source: rtems-libbsd/ipsec-tools/src/libipsec/policy_token.c @ ff36f5e

5-freebsd-12
Last change on this file since ff36f5e was ff36f5e, checked in by Christian Mauderer <christian.mauderer@…>, on May 30, 2018 at 12:27:35 PM

Import ipsec-tools 0.8.2.

Import unchanged ipsec-tools sources in the release version 0.8.2. The
homepage of ipsec-tools is http://ipsec-tools.sourceforge.net/. The
sources can be obtained from there.

  • Property mode set to 100644
File size: 56.0 KB
Line 
1#line 2 "policy_token.c"
2
3#line 4 "policy_token.c"
4
5#define  YY_INT_ALIGNED short int
6
7/* A lexical scanner generated by flex */
8
9#define yy_create_buffer __libipsec_create_buffer
10#define yy_delete_buffer __libipsec_delete_buffer
11#define yy_flex_debug __libipsec_flex_debug
12#define yy_init_buffer __libipsec_init_buffer
13#define yy_flush_buffer __libipsec_flush_buffer
14#define yy_load_buffer_state __libipsec_load_buffer_state
15#define yy_switch_to_buffer __libipsec_switch_to_buffer
16#define yyin __libipsecin
17#define yyleng __libipsecleng
18#define yylex __libipseclex
19#define yylineno __libipseclineno
20#define yyout __libipsecout
21#define yyrestart __libipsecrestart
22#define yytext __libipsectext
23#define yywrap __libipsecwrap
24#define yyalloc __libipsecalloc
25#define yyrealloc __libipsecrealloc
26#define yyfree __libipsecfree
27
28#define FLEX_SCANNER
29#define YY_FLEX_MAJOR_VERSION 2
30#define YY_FLEX_MINOR_VERSION 5
31#define YY_FLEX_SUBMINOR_VERSION 37
32#if YY_FLEX_SUBMINOR_VERSION > 0
33#define FLEX_BETA
34#endif
35
36/* First, we deal with  platform-specific or compiler-specific issues. */
37
38/* begin standard C headers. */
39#include <stdio.h>
40#include <string.h>
41#include <errno.h>
42#include <stdlib.h>
43
44/* end standard C headers. */
45
46/* flex integer type definitions */
47
48#ifndef FLEXINT_H
49#define FLEXINT_H
50
51/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52
53#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54
55/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56 * if you want the limit (max/min) macros for int types.
57 */
58#ifndef __STDC_LIMIT_MACROS
59#define __STDC_LIMIT_MACROS 1
60#endif
61
62#include <inttypes.h>
63typedef int8_t flex_int8_t;
64typedef uint8_t flex_uint8_t;
65typedef int16_t flex_int16_t;
66typedef uint16_t flex_uint16_t;
67typedef int32_t flex_int32_t;
68typedef uint32_t flex_uint32_t;
69#else
70typedef signed char flex_int8_t;
71typedef short int flex_int16_t;
72typedef int flex_int32_t;
73typedef unsigned char flex_uint8_t; 
74typedef unsigned short int flex_uint16_t;
75typedef unsigned int flex_uint32_t;
76
77/* Limits of integral types. */
78#ifndef INT8_MIN
79#define INT8_MIN               (-128)
80#endif
81#ifndef INT16_MIN
82#define INT16_MIN              (-32767-1)
83#endif
84#ifndef INT32_MIN
85#define INT32_MIN              (-2147483647-1)
86#endif
87#ifndef INT8_MAX
88#define INT8_MAX               (127)
89#endif
90#ifndef INT16_MAX
91#define INT16_MAX              (32767)
92#endif
93#ifndef INT32_MAX
94#define INT32_MAX              (2147483647)
95#endif
96#ifndef UINT8_MAX
97#define UINT8_MAX              (255U)
98#endif
99#ifndef UINT16_MAX
100#define UINT16_MAX             (65535U)
101#endif
102#ifndef UINT32_MAX
103#define UINT32_MAX             (4294967295U)
104#endif
105
106#endif /* ! C99 */
107
108#endif /* ! FLEXINT_H */
109
110#ifdef __cplusplus
111
112/* The "const" storage-class-modifier is valid. */
113#define YY_USE_CONST
114
115#else   /* ! __cplusplus */
116
117/* C99 requires __STDC__ to be defined as 1. */
118#if defined (__STDC__)
119
120#define YY_USE_CONST
121
122#endif  /* defined (__STDC__) */
123#endif  /* ! __cplusplus */
124
125#ifdef YY_USE_CONST
126#define yyconst const
127#else
128#define yyconst
129#endif
130
131/* Returned upon end-of-file. */
132#define YY_NULL 0
133
134/* Promotes a possibly negative, possibly signed char to an unsigned
135 * integer for use as an array index.  If the signed char is negative,
136 * we want to instead treat it as an 8-bit unsigned char, hence the
137 * double cast.
138 */
139#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140
141/* Enter a start condition.  This macro really ought to take a parameter,
142 * but we do it the disgusting crufty way forced on us by the ()-less
143 * definition of BEGIN.
144 */
145#define BEGIN (yy_start) = 1 + 2 *
146
147/* Translate the current start state into a value that can be later handed
148 * to BEGIN to return to the state.  The YYSTATE alias is for lex
149 * compatibility.
150 */
151#define YY_START (((yy_start) - 1) / 2)
152#define YYSTATE YY_START
153
154/* Action number for EOF rule of a given start state. */
155#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156
157/* Special action meaning "start processing a new file". */
158#define YY_NEW_FILE __libipsecrestart(__libipsecin  )
159
160#define YY_END_OF_BUFFER_CHAR 0
161
162/* Size of default input buffer. */
163#ifndef YY_BUF_SIZE
164#define YY_BUF_SIZE 16384
165#endif
166
167/* The state buf must be large enough to hold one state per character in the main buffer.
168 */
169#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170
171#ifndef YY_TYPEDEF_YY_BUFFER_STATE
172#define YY_TYPEDEF_YY_BUFFER_STATE
173typedef struct yy_buffer_state *YY_BUFFER_STATE;
174#endif
175
176#ifndef YY_TYPEDEF_YY_SIZE_T
177#define YY_TYPEDEF_YY_SIZE_T
178typedef size_t yy_size_t;
179#endif
180
181extern yy_size_t __libipsecleng;
182
183extern FILE *__libipsecin, *__libipsecout;
184
185#define EOB_ACT_CONTINUE_SCAN 0
186#define EOB_ACT_END_OF_FILE 1
187#define EOB_ACT_LAST_MATCH 2
188
189    #define YY_LESS_LINENO(n)
190   
191/* Return all but the first "n" matched characters back to the input stream. */
192#define yyless(n) \
193        do \
194                { \
195                /* Undo effects of setting up __libipsectext. */ \
196        int yyless_macro_arg = (n); \
197        YY_LESS_LINENO(yyless_macro_arg);\
198                *yy_cp = (yy_hold_char); \
199                YY_RESTORE_YY_MORE_OFFSET \
200                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
201                YY_DO_BEFORE_ACTION; /* set up __libipsectext again */ \
202                } \
203        while ( 0 )
204
205#define unput(c) yyunput( c, (yytext_ptr)  )
206
207#ifndef YY_STRUCT_YY_BUFFER_STATE
208#define YY_STRUCT_YY_BUFFER_STATE
209struct yy_buffer_state
210        {
211        FILE *yy_input_file;
212
213        char *yy_ch_buf;                /* input buffer */
214        char *yy_buf_pos;               /* current position in input buffer */
215
216        /* Size of input buffer in bytes, not including room for EOB
217         * characters.
218         */
219        yy_size_t yy_buf_size;
220
221        /* Number of characters read into yy_ch_buf, not including EOB
222         * characters.
223         */
224        yy_size_t yy_n_chars;
225
226        /* Whether we "own" the buffer - i.e., we know we created it,
227         * and can realloc() it to grow it, and should free() it to
228         * delete it.
229         */
230        int yy_is_our_buffer;
231
232        /* Whether this is an "interactive" input source; if so, and
233         * if we're using stdio for input, then we want to use getc()
234         * instead of fread(), to make sure we stop fetching input after
235         * each newline.
236         */
237        int yy_is_interactive;
238
239        /* Whether we're considered to be at the beginning of a line.
240         * If so, '^' rules will be active on the next match, otherwise
241         * not.
242         */
243        int yy_at_bol;
244
245    int yy_bs_lineno; /**< The line count. */
246    int yy_bs_column; /**< The column count. */
247   
248        /* Whether to try to fill the input buffer when we reach the
249         * end of it.
250         */
251        int yy_fill_buffer;
252
253        int yy_buffer_status;
254
255#define YY_BUFFER_NEW 0
256#define YY_BUFFER_NORMAL 1
257        /* When an EOF's been seen but there's still some text to process
258         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259         * shouldn't try reading from the input source any more.  We might
260         * still have a bunch of tokens to match, though, because of
261         * possible backing-up.
262         *
263         * When we actually see the EOF, we change the status to "new"
264         * (via __libipsecrestart()), so that the user can continue scanning by
265         * just pointing __libipsecin at a new input file.
266         */
267#define YY_BUFFER_EOF_PENDING 2
268
269        };
270#endif /* !YY_STRUCT_YY_BUFFER_STATE */
271
272/* Stack of input buffers. */
273static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
274static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
275static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
276
277/* We provide macros for accessing buffer states in case in the
278 * future we want to put the buffer states in a more general
279 * "scanner state".
280 *
281 * Returns the top of the stack, or NULL.
282 */
283#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
284                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
285                          : NULL)
286
287/* Same as previous macro, but useful when we know that the buffer stack is not
288 * NULL or when we need an lvalue. For internal use only.
289 */
290#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291
292/* yy_hold_char holds the character lost when __libipsectext is formed. */
293static char yy_hold_char;
294static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
295yy_size_t __libipsecleng;
296
297/* Points to current character in buffer. */
298static char *yy_c_buf_p = (char *) 0;
299static int yy_init = 0;         /* whether we need to initialize */
300static int yy_start = 0;        /* start state number */
301
302/* Flag which is used to allow __libipsecwrap()'s to do buffer switches
303 * instead of setting up a fresh __libipsecin.  A bit of a hack ...
304 */
305static int yy_did_buffer_switch_on_eof;
306
307void __libipsecrestart (FILE *input_file  );
308void __libipsec_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
309YY_BUFFER_STATE __libipsec_create_buffer (FILE *file,int size  );
310void __libipsec_delete_buffer (YY_BUFFER_STATE b  );
311void __libipsec_flush_buffer (YY_BUFFER_STATE b  );
312void __libipsecpush_buffer_state (YY_BUFFER_STATE new_buffer  );
313void __libipsecpop_buffer_state (void );
314
315static void __libipsecensure_buffer_stack (void );
316static void __libipsec_load_buffer_state (void );
317static void __libipsec_init_buffer (YY_BUFFER_STATE b,FILE *file  );
318
319#define YY_FLUSH_BUFFER __libipsec_flush_buffer(YY_CURRENT_BUFFER )
320
321YY_BUFFER_STATE __libipsec_scan_buffer (char *base,yy_size_t size  );
322YY_BUFFER_STATE __libipsec_scan_string (yyconst char *yy_str  );
323YY_BUFFER_STATE __libipsec_scan_bytes (yyconst char *bytes,yy_size_t len  );
324
325void *__libipsecalloc (yy_size_t  );
326void *__libipsecrealloc (void *,yy_size_t  );
327void __libipsecfree (void *  );
328
329#define yy_new_buffer __libipsec_create_buffer
330
331#define yy_set_interactive(is_interactive) \
332        { \
333        if ( ! YY_CURRENT_BUFFER ){ \
334        __libipsecensure_buffer_stack (); \
335                YY_CURRENT_BUFFER_LVALUE =    \
336            __libipsec_create_buffer(__libipsecin,YY_BUF_SIZE ); \
337        } \
338        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
339        }
340
341#define yy_set_bol(at_bol) \
342        { \
343        if ( ! YY_CURRENT_BUFFER ){\
344        __libipsecensure_buffer_stack (); \
345                YY_CURRENT_BUFFER_LVALUE =    \
346            __libipsec_create_buffer(__libipsecin,YY_BUF_SIZE ); \
347        } \
348        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
349        }
350
351#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352
353/* Begin user sect3 */
354
355#define __libipsecwrap() 1
356#define YY_SKIP_YYWRAP
357
358typedef unsigned char YY_CHAR;
359
360FILE *__libipsecin = (FILE *) 0, *__libipsecout = (FILE *) 0;
361
362typedef int yy_state_type;
363
364extern int __libipseclineno;
365
366int __libipseclineno = 1;
367
368extern char *__libipsectext;
369#define yytext_ptr __libipsectext
370
371static yy_state_type yy_get_previous_state (void );
372static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
373static int yy_get_next_buffer (void );
374static void yy_fatal_error (yyconst char msg[]  );
375
376/* Done after the current pattern has been matched and before the
377 * corresponding action - sets up __libipsectext.
378 */
379#define YY_DO_BEFORE_ACTION \
380        (yytext_ptr) = yy_bp; \
381        __libipsecleng = (size_t) (yy_cp - yy_bp); \
382        (yy_hold_char) = *yy_cp; \
383        *yy_cp = '\0'; \
384        (yy_c_buf_p) = yy_cp;
385
386#define YY_NUM_RULES 34
387#define YY_END_OF_BUFFER 35
388/* This struct is not used in this scanner,
389   but its presence is necessary. */
390struct yy_trans_info
391        {
392        flex_int32_t yy_verify;
393        flex_int32_t yy_nxt;
394        };
395static yyconst flex_int16_t yy_accept[121] =
396    {   0,
397        0,    0,   35,   34,   32,   33,    9,   30,   29,   28,
398       10,   34,   29,   29,   29,   29,   29,   29,   29,   29,
399       29,   29,   29,   29,   29,   29,   29,   32,    0,   29,
400       10,    0,   17,   29,   29,   29,   29,   29,   29,   29,
401       29,    1,   29,   29,   21,   29,   29,   29,   29,   29,
402       29,   29,   29,   29,   31,   22,   29,    7,   29,   29,
403       16,    3,   29,   29,   29,    6,   29,    2,   29,   29,
404       29,   29,   29,   24,   29,   29,   29,   29,    8,   29,
405       29,   12,    5,   29,   29,   29,   29,   29,   29,   29,
406       29,   29,   13,   29,   29,   29,   29,   29,   14,   29,
407
408       29,   29,   18,   29,   29,   29,   20,   27,   23,   11,
409       15,   29,   25,   29,   29,    4,   29,   26,   19,    0
410    } ;
411
412static yyconst flex_int32_t yy_ec[256] =
413    {   0,
414        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
415        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
416        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
417        1,    2,    1,    1,    1,    1,    4,    1,    1,    1,
418        1,    1,    5,    1,    6,    7,    8,    9,    9,    9,
419        9,    9,    9,    9,    9,    9,    9,   10,    1,    1,
420        1,    1,    1,    1,   11,   11,   11,   11,   11,   11,
421       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
422       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
423       12,    1,   13,    1,    7,    1,   14,   15,   16,   17,
424
425       18,   19,   20,   21,   22,   11,   11,   23,   24,   25,
426       26,   27,   28,   29,   30,   31,   32,   11,   33,   11,
427       34,   11,    1,    1,    1,    1,    1,    1,    1,    1,
428        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
429        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
430        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
431        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
432        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
433        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
434        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
435
436        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
437        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
438        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
439        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
440        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
441        1,    1,    1,    1,    1
442    } ;
443
444static yyconst flex_int32_t yy_meta[35] =
445    {   0,
446        1,    1,    1,    2,    1,    1,    2,    1,    3,    2,
447        3,    1,    1,    3,    3,    3,    3,    3,    3,    3,
448        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
449        3,    3,    3,    3
450    } ;
451
452static yyconst flex_int16_t yy_base[123] =
453    {   0,
454        0,    0,  235,  236,  232,  236,  236,  236,  229,  236,
455       31,  223,   32,   33,   34,   35,   37,   39,   41,   38,
456       40,   43,   42,   44,   45,   46,   47,  229,    0,  226,
457       50,   67,  225,   51,   67,   77,   58,   75,   78,   80,
458       79,  224,   82,   83,  223,   85,   86,   87,   91,   88,
459       89,   96,   97,    0,  236,  222,   99,  107,  104,  100,
460      221,  220,  103,  118,  119,  219,  121,  218,  122,  123,
461      124,  126,  128,  217,  127,  129,  131,  130,  216,  134,
462      136,  215,  137,  132,  138,  142,  139,  143,  146,  149,
463      155,  159,  214,  160,  161,  166,  168,  163,  213,  170,
464
465      171,  172,  212,  173,  176,  179,  211,  185,  206,  204,
466      202,  175,  196,  183,  188,  195,  180,  198,  194,  236,
467      211,  193
468    } ;
469
470static yyconst flex_int16_t yy_def[123] =
471    {   0,
472      120,    1,  120,  120,  120,  120,  120,  120,  121,  120,
473      121,  120,  121,  121,  121,  121,  121,  121,  121,  121,
474      121,  121,  121,  121,  121,  121,  121,  120,  122,  121,
475      121,  120,  121,  121,  121,  121,  121,  121,  121,  121,
476      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
477      121,  121,  121,  122,  120,  121,  121,  121,  121,  121,
478      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
479      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
480      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
481      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
482
483      121,  121,  121,  121,  121,  121,  121,  121,  121,  121,
484      121,  121,  121,  121,  121,  121,  121,  121,  121,    0,
485      120,  120
486    } ;
487
488static yyconst flex_int16_t yy_nxt[271] =
489    {   0,
490        4,    5,    6,    4,    7,    8,    9,   10,   11,    9,
491        9,   12,    4,   13,   14,    9,   15,   16,   17,    9,
492       18,   19,   20,   21,   22,   23,   24,    9,   25,    9,
493       26,   27,    9,    9,   29,   29,   29,   29,   29,   31,
494       29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
495       29,   36,   33,   29,   29,   37,   34,   45,   31,   38,
496       41,   29,   49,   44,   39,   42,   35,   43,   46,   40,
497       29,   52,   48,   47,   50,   32,   53,   51,   29,   55,
498       29,   29,   29,   29,   56,   29,   29,   59,   29,   29,
499       29,   29,   29,   57,   29,   58,   62,   64,   63,   29,
500
501       29,   71,   29,   29,   61,   60,   29,   29,   69,   67,
502       29,   65,   75,   72,   74,   66,   68,   73,   70,   77,
503       76,   29,   29,   79,   29,   29,   29,   29,   78,   29,
504       29,   29,   29,   29,   29,   29,   81,   29,   82,   29,
505       29,   29,   29,   80,   90,   29,   29,   83,   85,   29,
506       86,   93,   29,   95,   84,   87,   88,   92,   29,   97,
507       89,   91,   29,   29,   29,   94,   29,   96,  100,   29,
508       98,   29,   99,   29,   29,   29,   29,  101,   29,   29,
509      108,  104,   29,   29,  102,  103,   29,  110,   29,  105,
510      107,   29,  106,  113,  115,   54,  118,   29,   29,   29,
511
512      109,   29,  111,  112,  114,   29,  118,   29,  116,   29,
513      119,  117,   30,   30,   29,   29,   29,   29,   29,   29,
514       29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
515       28,   32,   29,   28,  120,    3,  120,  120,  120,  120,
516      120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
517      120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
518      120,  120,  120,  120,  120,  120,  120,  120,  120,  120
519    } ;
520
521static yyconst flex_int16_t yy_chk[271] =
522    {   0,
523        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
524        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
525        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
526        1,    1,    1,    1,   11,   13,   14,   15,   16,   11,
527       17,   20,   18,   21,   19,   23,   22,   24,   25,   26,
528       27,   15,   13,   31,   34,   15,   13,   21,   31,   16,
529       18,   37,   25,   20,   16,   19,   14,   19,   22,   17,
530       35,   27,   24,   23,   26,   32,   27,   26,   38,   32,
531       36,   39,   41,   40,   34,   43,   44,   37,   46,   47,
532       48,   50,   51,   35,   49,   36,   40,   43,   41,   52,
533
534       53,   50,   57,   60,   39,   38,   63,   59,   48,   46,
535       58,   43,   57,   51,   53,   44,   47,   52,   49,   59,
536       58,   64,   65,   63,   67,   69,   70,   71,   60,   72,
537       75,   73,   76,   78,   77,   84,   65,   80,   67,   81,
538       83,   85,   87,   64,   77,   86,   88,   69,   71,   89,
539       72,   81,   90,   84,   70,   73,   75,   80,   91,   86,
540       76,   78,   92,   94,   95,   83,   98,   85,   89,   96,
541       87,   97,   88,  100,  101,  102,  104,   90,  112,  105,
542       98,   94,  106,  117,   91,   92,  114,  101,  108,   95,
543       97,  115,   96,  105,  108,  122,  115,  119,  116,  113,
544
545      100,  118,  102,  104,  106,  111,  118,  110,  112,  109,
546      117,  114,  121,  121,  107,  103,   99,   93,   82,   79,
547       74,   68,   66,   62,   61,   56,   45,   42,   33,   30,
548       28,   12,    9,    5,    3,  120,  120,  120,  120,  120,
549      120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
550      120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
551      120,  120,  120,  120,  120,  120,  120,  120,  120,  120
552    } ;
553
554static yy_state_type yy_last_accepting_state;
555static char *yy_last_accepting_cpos;
556
557extern int __libipsec_flex_debug;
558int __libipsec_flex_debug = 0;
559
560/* The intent behind this definition is that it'll catch
561 * any uses of REJECT which flex missed.
562 */
563#define REJECT reject_used_but_not_detected
564#define yymore() yymore_used_but_not_detected
565#define YY_MORE_ADJ 0
566#define YY_RESTORE_YY_MORE_OFFSET
567char *__libipsectext;
568#line 1 "policy_token.l"
569/*      $NetBSD: policy_token.l,v 1.7 2007/07/18 12:07:50 vanhu Exp $   */
570/* Id: policy_token.l,v 1.12 2005/05/05 12:32:18 manubsd Exp */
571/*
572 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
573 * All rights reserved.
574 *
575 * Redistribution and use in source and binary forms, with or without
576 * modification, are permitted provided that the following conditions
577 * are met:
578 * 1. Redistributions of source code must retain the above copyright
579 *    notice, this list of conditions and the following disclaimer.
580 * 2. Redistributions in binary form must reproduce the above copyright
581 *    notice, this list of conditions and the following disclaimer in the
582 *    documentation and/or other materials provided with the distribution.
583 * 3. Neither the name of the project nor the names of its contributors
584 *    may be used to endorse or promote products derived from this software
585 *    without specific prior written permission.
586 *
587 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
588 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
589 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
590 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
591 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
592 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
593 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
594 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
595 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
596 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
597 * SUCH DAMAGE.
598 */
599#line 35 "policy_token.l"
600#ifdef HAVE_CONFIG_H
601#include "config.h"
602#endif
603
604#include <sys/types.h>
605#include <sys/param.h>
606#include <sys/socket.h>
607#include <net/pfkeyv2.h>
608#include <netinet/in.h>
609#include PATH_IPSEC_H
610
611#include <stdlib.h>
612#include <limits.h>
613#include <string.h>
614#include <unistd.h>
615#include <errno.h>
616
617#include "libpfkey.h"
618
619#if !defined(__NetBSD__) && !defined(__FreeBSD__) && !defined(__linux__)  && \
620!defined(__APPLE__) && !defined(__MACH__)
621#include "y.tab.h"
622#else
623#include "policy_parse.h"
624#endif
625#define yylval __libipseclval   /* XXX */
626
627int __libipseclex __P((void));
628/* common section */
629#line 630 "policy_token.c"
630
631#define INITIAL 0
632
633#ifndef YY_NO_UNISTD_H
634/* Special case for "unistd.h", since it is non-ANSI. We include it way
635 * down here because we want the user's section 1 to have been scanned first.
636 * The user has a chance to override it with an option.
637 */
638#include <unistd.h>
639#endif
640
641#ifndef YY_EXTRA_TYPE
642#define YY_EXTRA_TYPE void *
643#endif
644
645static int yy_init_globals (void );
646
647/* Accessor methods to globals.
648   These are made visible to non-reentrant scanners for convenience. */
649
650int __libipseclex_destroy (void );
651
652int __libipsecget_debug (void );
653
654void __libipsecset_debug (int debug_flag  );
655
656YY_EXTRA_TYPE __libipsecget_extra (void );
657
658void __libipsecset_extra (YY_EXTRA_TYPE user_defined  );
659
660FILE *__libipsecget_in (void );
661
662void __libipsecset_in  (FILE * in_str  );
663
664FILE *__libipsecget_out (void );
665
666void __libipsecset_out  (FILE * out_str  );
667
668yy_size_t __libipsecget_leng (void );
669
670char *__libipsecget_text (void );
671
672int __libipsecget_lineno (void );
673
674void __libipsecset_lineno (int line_number  );
675
676/* Macros after this point can all be overridden by user definitions in
677 * section 1.
678 */
679
680#ifndef YY_SKIP_YYWRAP
681#ifdef __cplusplus
682extern "C" int __libipsecwrap (void );
683#else
684extern int __libipsecwrap (void );
685#endif
686#endif
687
688#ifndef yytext_ptr
689static void yy_flex_strncpy (char *,yyconst char *,int );
690#endif
691
692#ifdef YY_NEED_STRLEN
693static int yy_flex_strlen (yyconst char * );
694#endif
695
696#ifndef YY_NO_INPUT
697
698#ifdef __cplusplus
699static int yyinput (void );
700#else
701static int input (void );
702#endif
703
704#endif
705
706/* Amount of stuff to slurp up with each read. */
707#ifndef YY_READ_BUF_SIZE
708#define YY_READ_BUF_SIZE 8192
709#endif
710
711/* Copy whatever the last rule matched to the standard output. */
712#ifndef ECHO
713/* This used to be an fputs(), but since the string might contain NUL's,
714 * we now use fwrite().
715 */
716#define ECHO do { if (fwrite( __libipsectext, __libipsecleng, 1, __libipsecout )) {} } while (0)
717#endif
718
719/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
720 * is returned in "result".
721 */
722#ifndef YY_INPUT
723#define YY_INPUT(buf,result,max_size) \
724        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
725                { \
726                int c = '*'; \
727                size_t n; \
728                for ( n = 0; n < max_size && \
729                             (c = getc( __libipsecin )) != EOF && c != '\n'; ++n ) \
730                        buf[n] = (char) c; \
731                if ( c == '\n' ) \
732                        buf[n++] = (char) c; \
733                if ( c == EOF && ferror( __libipsecin ) ) \
734                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
735                result = n; \
736                } \
737        else \
738                { \
739                errno=0; \
740                while ( (result = fread(buf, 1, max_size, __libipsecin))==0 && ferror(__libipsecin)) \
741                        { \
742                        if( errno != EINTR) \
743                                { \
744                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
745                                break; \
746                                } \
747                        errno=0; \
748                        clearerr(__libipsecin); \
749                        } \
750                }\
751\
752
753#endif
754
755/* No semi-colon after return; correct usage is to write "yyterminate();" -
756 * we don't want an extra ';' after the "return" because that will cause
757 * some compilers to complain about unreachable statements.
758 */
759#ifndef yyterminate
760#define yyterminate() return YY_NULL
761#endif
762
763/* Number of entries by which start-condition stack grows. */
764#ifndef YY_START_STACK_INCR
765#define YY_START_STACK_INCR 25
766#endif
767
768/* Report a fatal error. */
769#ifndef YY_FATAL_ERROR
770#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
771#endif
772
773/* end tables serialization structures and prototypes */
774
775/* Default declaration of generated scanner - a define so the user can
776 * easily add parameters.
777 */
778#ifndef YY_DECL
779#define YY_DECL_IS_OURS 1
780
781extern int __libipseclex (void);
782
783#define YY_DECL int __libipseclex (void)
784#endif /* !YY_DECL */
785
786/* Code executed at the beginning of each rule, after __libipsectext and __libipsecleng
787 * have been set up.
788 */
789#ifndef YY_USER_ACTION
790#define YY_USER_ACTION
791#endif
792
793/* Code executed at the end of each rule. */
794#ifndef YY_BREAK
795#define YY_BREAK break;
796#endif
797
798#define YY_RULE_SETUP \
799        YY_USER_ACTION
800
801/** The main scanner function which does all the work.
802 */
803YY_DECL
804{
805        register yy_state_type yy_current_state;
806        register char *yy_cp, *yy_bp;
807        register int yy_act;
808   
809#line 97 "policy_token.l"
810
811
812#line 813 "policy_token.c"
813
814        if ( !(yy_init) )
815                {
816                (yy_init) = 1;
817
818#ifdef YY_USER_INIT
819                YY_USER_INIT;
820#endif
821
822                if ( ! (yy_start) )
823                        (yy_start) = 1; /* first start state */
824
825                if ( ! __libipsecin )
826                        __libipsecin = stdin;
827
828                if ( ! __libipsecout )
829                        __libipsecout = stdout;
830
831                if ( ! YY_CURRENT_BUFFER ) {
832                        __libipsecensure_buffer_stack ();
833                        YY_CURRENT_BUFFER_LVALUE =
834                                __libipsec_create_buffer(__libipsecin,YY_BUF_SIZE );
835                }
836
837                __libipsec_load_buffer_state( );
838                }
839
840        while ( 1 )             /* loops until end-of-file is reached */
841                {
842                yy_cp = (yy_c_buf_p);
843
844                /* Support of __libipsectext. */
845                *yy_cp = (yy_hold_char);
846
847                /* yy_bp points to the position in yy_ch_buf of the start of
848                 * the current run.
849                 */
850                yy_bp = yy_cp;
851
852                yy_current_state = (yy_start);
853yy_match:
854                do
855                        {
856                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
857                        if ( yy_accept[yy_current_state] )
858                                {
859                                (yy_last_accepting_state) = yy_current_state;
860                                (yy_last_accepting_cpos) = yy_cp;
861                                }
862                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
863                                {
864                                yy_current_state = (int) yy_def[yy_current_state];
865                                if ( yy_current_state >= 121 )
866                                        yy_c = yy_meta[(unsigned int) yy_c];
867                                }
868                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
869                        ++yy_cp;
870                        }
871                while ( yy_base[yy_current_state] != 236 );
872
873yy_find_action:
874                yy_act = yy_accept[yy_current_state];
875                if ( yy_act == 0 )
876                        { /* have to back up */
877                        yy_cp = (yy_last_accepting_cpos);
878                        yy_current_state = (yy_last_accepting_state);
879                        yy_act = yy_accept[yy_current_state];
880                        }
881
882                YY_DO_BEFORE_ACTION;
883
884do_action:      /* This label is used only to access EOF actions. */
885
886                switch ( yy_act )
887        { /* beginning of action switch */
888                        case 0: /* must back up */
889                        /* undo the effects of YY_DO_BEFORE_ACTION */
890                        *yy_cp = (yy_hold_char);
891                        yy_cp = (yy_last_accepting_cpos);
892                        yy_current_state = (yy_last_accepting_state);
893                        goto yy_find_action;
894
895case 1:
896YY_RULE_SETUP
897#line 99 "policy_token.l"
898{ yylval.num = IPSEC_DIR_INBOUND; return(DIR); }
899        YY_BREAK
900case 2:
901YY_RULE_SETUP
902#line 100 "policy_token.l"
903{ yylval.num = IPSEC_DIR_OUTBOUND; return(DIR); }
904        YY_BREAK
905case 3:
906YY_RULE_SETUP
907#line 101 "policy_token.l"
908{ 
909#ifdef HAVE_POLICY_FWD
910                  yylval.num = IPSEC_DIR_FWD; return(DIR); 
911#else
912                  yylval.num = IPSEC_DIR_INBOUND; return(DIR); 
913#endif
914                }
915        YY_BREAK
916case 4:
917YY_RULE_SETUP
918#line 109 "policy_token.l"
919{ return(PRIORITY); }
920        YY_BREAK
921case 5:
922YY_RULE_SETUP
923#line 110 "policy_token.l"
924{ return(PRIORITY); }
925        YY_BREAK
926case 6:
927YY_RULE_SETUP
928#line 111 "policy_token.l"
929{ yylval.num32 = PRIORITY_LOW; return(PRIO_BASE); }
930        YY_BREAK
931case 7:
932YY_RULE_SETUP
933#line 112 "policy_token.l"
934{ yylval.num32 = PRIORITY_DEFAULT; return(PRIO_BASE); }
935        YY_BREAK
936case 8:
937YY_RULE_SETUP
938#line 113 "policy_token.l"
939{ yylval.num32 = PRIORITY_HIGH; return(PRIO_BASE); }
940        YY_BREAK
941case 9:
942YY_RULE_SETUP
943#line 114 "policy_token.l"
944{ return(PLUS); }
945        YY_BREAK
946case 10:
947YY_RULE_SETUP
948#line 115 "policy_token.l"
949{
950                        yylval.val.len = strlen(__libipsectext);
951                        yylval.val.buf = __libipsectext;
952                        return(PRIO_OFFSET);
953}
954        YY_BREAK
955case 11:
956YY_RULE_SETUP
957#line 121 "policy_token.l"
958{ yylval.num = IPSEC_POLICY_DISCARD; return(ACTION); }
959        YY_BREAK
960case 12:
961YY_RULE_SETUP
962#line 122 "policy_token.l"
963{ yylval.num = IPSEC_POLICY_NONE; return(ACTION); }
964        YY_BREAK
965case 13:
966YY_RULE_SETUP
967#line 123 "policy_token.l"
968{ yylval.num = IPSEC_POLICY_IPSEC; return(ACTION); }
969        YY_BREAK
970case 14:
971YY_RULE_SETUP
972#line 124 "policy_token.l"
973{ yylval.num = IPSEC_POLICY_BYPASS; return(ACTION); }
974        YY_BREAK
975case 15:
976YY_RULE_SETUP
977#line 125 "policy_token.l"
978{ yylval.num = IPSEC_POLICY_ENTRUST; return(ACTION); }
979        YY_BREAK
980case 16:
981YY_RULE_SETUP
982#line 127 "policy_token.l"
983{ yylval.num = IPPROTO_ESP; return(PROTOCOL); }
984        YY_BREAK
985case 17:
986YY_RULE_SETUP
987#line 128 "policy_token.l"
988{ yylval.num = IPPROTO_AH; return(PROTOCOL); }
989        YY_BREAK
990case 18:
991YY_RULE_SETUP
992#line 129 "policy_token.l"
993{ yylval.num = IPPROTO_IPCOMP; return(PROTOCOL); }
994        YY_BREAK
995case 19:
996YY_RULE_SETUP
997#line 131 "policy_token.l"
998{ yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
999        YY_BREAK
1000case 20:
1001YY_RULE_SETUP
1002#line 132 "policy_token.l"
1003{ yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
1004        YY_BREAK
1005case 21:
1006YY_RULE_SETUP
1007#line 134 "policy_token.l"
1008{ return(ME); }
1009        YY_BREAK
1010case 22:
1011YY_RULE_SETUP
1012#line 135 "policy_token.l"
1013{ return(ANY); }
1014        YY_BREAK
1015case 23:
1016YY_RULE_SETUP
1017#line 137 "policy_token.l"
1018{ yylval.num = IPSEC_LEVEL_DEFAULT; return(LEVEL); }
1019        YY_BREAK
1020case 24:
1021YY_RULE_SETUP
1022#line 138 "policy_token.l"
1023{ yylval.num = IPSEC_LEVEL_USE; return(LEVEL); }
1024        YY_BREAK
1025case 25:
1026YY_RULE_SETUP
1027#line 139 "policy_token.l"
1028{ yylval.num = IPSEC_LEVEL_REQUIRE; return(LEVEL); }
1029        YY_BREAK
1030case 26:
1031YY_RULE_SETUP
1032#line 140 "policy_token.l"
1033{
1034                        yylval.val.len = strlen(__libipsectext + 7);
1035                        yylval.val.buf = __libipsectext + 7;
1036                        return(LEVEL_SPECIFY);
1037                }
1038        YY_BREAK
1039case 27:
1040YY_RULE_SETUP
1041#line 145 "policy_token.l"
1042{ yylval.num = IPSEC_LEVEL_UNIQUE; return(LEVEL); }
1043        YY_BREAK
1044case 28:
1045YY_RULE_SETUP
1046#line 146 "policy_token.l"
1047{ return(SLASH); }
1048        YY_BREAK
1049case 29:
1050YY_RULE_SETUP
1051#line 148 "policy_token.l"
1052{
1053                        yylval.val.len = strlen(__libipsectext);
1054                        yylval.val.buf = __libipsectext;
1055                        return(IPADDRESS);
1056                }
1057        YY_BREAK
1058case 30:
1059YY_RULE_SETUP
1060#line 154 "policy_token.l"
1061{ return(HYPHEN); }
1062        YY_BREAK
1063case 31:
1064YY_RULE_SETUP
1065#line 156 "policy_token.l"
1066{
1067                        /* Remove leading '[' and trailing ']' */
1068                        yylval.val.buf = __libipsectext + 1;
1069                        yylval.val.len = strlen(__libipsectext) - 2;
1070
1071                        return(PORT);
1072                }
1073        YY_BREAK
1074case 32:
1075YY_RULE_SETUP
1076#line 164 "policy_token.l"
1077{ ; }
1078        YY_BREAK
1079case 33:
1080/* rule 33 can match eol */
1081YY_RULE_SETUP
1082#line 165 "policy_token.l"
1083{ ; }
1084        YY_BREAK
1085case 34:
1086YY_RULE_SETUP
1087#line 167 "policy_token.l"
1088ECHO;
1089        YY_BREAK
1090#line 1091 "policy_token.c"
1091case YY_STATE_EOF(INITIAL):
1092        yyterminate();
1093
1094        case YY_END_OF_BUFFER:
1095                {
1096                /* Amount of text matched not including the EOB char. */
1097                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1098
1099                /* Undo the effects of YY_DO_BEFORE_ACTION. */
1100                *yy_cp = (yy_hold_char);
1101                YY_RESTORE_YY_MORE_OFFSET
1102
1103                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1104                        {
1105                        /* We're scanning a new file or input source.  It's
1106                         * possible that this happened because the user
1107                         * just pointed __libipsecin at a new source and called
1108                         * __libipseclex().  If so, then we have to assure
1109                         * consistency between YY_CURRENT_BUFFER and our
1110                         * globals.  Here is the right place to do so, because
1111                         * this is the first action (other than possibly a
1112                         * back-up) that will match for the new input source.
1113                         */
1114                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1115                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = __libipsecin;
1116                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1117                        }
1118
1119                /* Note that here we test for yy_c_buf_p "<=" to the position
1120                 * of the first EOB in the buffer, since yy_c_buf_p will
1121                 * already have been incremented past the NUL character
1122                 * (since all states make transitions on EOB to the
1123                 * end-of-buffer state).  Contrast this with the test
1124                 * in input().
1125                 */
1126                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1127                        { /* This was really a NUL. */
1128                        yy_state_type yy_next_state;
1129
1130                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1131
1132                        yy_current_state = yy_get_previous_state(  );
1133
1134                        /* Okay, we're now positioned to make the NUL
1135                         * transition.  We couldn't have
1136                         * yy_get_previous_state() go ahead and do it
1137                         * for us because it doesn't know how to deal
1138                         * with the possibility of jamming (and we don't
1139                         * want to build jamming into it because then it
1140                         * will run more slowly).
1141                         */
1142
1143                        yy_next_state = yy_try_NUL_trans( yy_current_state );
1144
1145                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1146
1147                        if ( yy_next_state )
1148                                {
1149                                /* Consume the NUL. */
1150                                yy_cp = ++(yy_c_buf_p);
1151                                yy_current_state = yy_next_state;
1152                                goto yy_match;
1153                                }
1154
1155                        else
1156                                {
1157                                yy_cp = (yy_c_buf_p);
1158                                goto yy_find_action;
1159                                }
1160                        }
1161
1162                else switch ( yy_get_next_buffer(  ) )
1163                        {
1164                        case EOB_ACT_END_OF_FILE:
1165                                {
1166                                (yy_did_buffer_switch_on_eof) = 0;
1167
1168                                if ( __libipsecwrap( ) )
1169                                        {
1170                                        /* Note: because we've taken care in
1171                                         * yy_get_next_buffer() to have set up
1172                                         * __libipsectext, we can now set up
1173                                         * yy_c_buf_p so that if some total
1174                                         * hoser (like flex itself) wants to
1175                                         * call the scanner after we return the
1176                                         * YY_NULL, it'll still work - another
1177                                         * YY_NULL will get returned.
1178                                         */
1179                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1180
1181                                        yy_act = YY_STATE_EOF(YY_START);
1182                                        goto do_action;
1183                                        }
1184
1185                                else
1186                                        {
1187                                        if ( ! (yy_did_buffer_switch_on_eof) )
1188                                                YY_NEW_FILE;
1189                                        }
1190                                break;
1191                                }
1192
1193                        case EOB_ACT_CONTINUE_SCAN:
1194                                (yy_c_buf_p) =
1195                                        (yytext_ptr) + yy_amount_of_matched_text;
1196
1197                                yy_current_state = yy_get_previous_state(  );
1198
1199                                yy_cp = (yy_c_buf_p);
1200                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1201                                goto yy_match;
1202
1203                        case EOB_ACT_LAST_MATCH:
1204                                (yy_c_buf_p) =
1205                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1206
1207                                yy_current_state = yy_get_previous_state(  );
1208
1209                                yy_cp = (yy_c_buf_p);
1210                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1211                                goto yy_find_action;
1212                        }
1213                break;
1214                }
1215
1216        default:
1217                YY_FATAL_ERROR(
1218                        "fatal flex scanner internal error--no action found" );
1219        } /* end of action switch */
1220                } /* end of scanning one token */
1221} /* end of __libipseclex */
1222
1223/* yy_get_next_buffer - try to read in a new buffer
1224 *
1225 * Returns a code representing an action:
1226 *      EOB_ACT_LAST_MATCH -
1227 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1228 *      EOB_ACT_END_OF_FILE - end of file
1229 */
1230static int yy_get_next_buffer (void)
1231{
1232        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1233        register char *source = (yytext_ptr);
1234        register int number_to_move, i;
1235        int ret_val;
1236
1237        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1238                YY_FATAL_ERROR(
1239                "fatal flex scanner internal error--end of buffer missed" );
1240
1241        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1242                { /* Don't try to fill the buffer, so this is an EOF. */
1243                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1244                        {
1245                        /* We matched a single character, the EOB, so
1246                         * treat this as a final EOF.
1247                         */
1248                        return EOB_ACT_END_OF_FILE;
1249                        }
1250
1251                else
1252                        {
1253                        /* We matched some text prior to the EOB, first
1254                         * process it.
1255                         */
1256                        return EOB_ACT_LAST_MATCH;
1257                        }
1258                }
1259
1260        /* Try to read more data. */
1261
1262        /* First move last chars to start of buffer. */
1263        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1264
1265        for ( i = 0; i < number_to_move; ++i )
1266                *(dest++) = *(source++);
1267
1268        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1269                /* don't do the read, it's not guaranteed to return an EOF,
1270                 * just force an EOF
1271                 */
1272                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1273
1274        else
1275                {
1276                        yy_size_t num_to_read =
1277                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1278
1279                while ( num_to_read <= 0 )
1280                        { /* Not enough room in the buffer - grow it. */
1281
1282                        /* just a shorter name for the current buffer */
1283                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1284
1285                        int yy_c_buf_p_offset =
1286                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1287
1288                        if ( b->yy_is_our_buffer )
1289                                {
1290                                yy_size_t new_size = b->yy_buf_size * 2;
1291
1292                                if ( new_size <= 0 )
1293                                        b->yy_buf_size += b->yy_buf_size / 8;
1294                                else
1295                                        b->yy_buf_size *= 2;
1296
1297                                b->yy_ch_buf = (char *)
1298                                        /* Include room in for 2 EOB chars. */
1299                                        __libipsecrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1300                                }
1301                        else
1302                                /* Can't grow it, we don't own it. */
1303                                b->yy_ch_buf = 0;
1304
1305                        if ( ! b->yy_ch_buf )
1306                                YY_FATAL_ERROR(
1307                                "fatal error - scanner input buffer overflow" );
1308
1309                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1310
1311                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1312                                                number_to_move - 1;
1313
1314                        }
1315
1316                if ( num_to_read > YY_READ_BUF_SIZE )
1317                        num_to_read = YY_READ_BUF_SIZE;
1318
1319                /* Read in more data. */
1320                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1321                        (yy_n_chars), num_to_read );
1322
1323                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1324                }
1325
1326        if ( (yy_n_chars) == 0 )
1327                {
1328                if ( number_to_move == YY_MORE_ADJ )
1329                        {
1330                        ret_val = EOB_ACT_END_OF_FILE;
1331                        __libipsecrestart(__libipsecin  );
1332                        }
1333
1334                else
1335                        {
1336                        ret_val = EOB_ACT_LAST_MATCH;
1337                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1338                                YY_BUFFER_EOF_PENDING;
1339                        }
1340                }
1341
1342        else
1343                ret_val = EOB_ACT_CONTINUE_SCAN;
1344
1345        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1346                /* Extend the array by 50%, plus the number we really need. */
1347                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1348                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) __libipsecrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1349                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1350                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1351        }
1352
1353        (yy_n_chars) += number_to_move;
1354        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1355        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1356
1357        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1358
1359        return ret_val;
1360}
1361
1362/* yy_get_previous_state - get the state just before the EOB char was reached */
1363
1364    static yy_state_type yy_get_previous_state (void)
1365{
1366        register yy_state_type yy_current_state;
1367        register char *yy_cp;
1368   
1369        yy_current_state = (yy_start);
1370
1371        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1372                {
1373                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1374                if ( yy_accept[yy_current_state] )
1375                        {
1376                        (yy_last_accepting_state) = yy_current_state;
1377                        (yy_last_accepting_cpos) = yy_cp;
1378                        }
1379                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1380                        {
1381                        yy_current_state = (int) yy_def[yy_current_state];
1382                        if ( yy_current_state >= 121 )
1383                                yy_c = yy_meta[(unsigned int) yy_c];
1384                        }
1385                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1386                }
1387
1388        return yy_current_state;
1389}
1390
1391/* yy_try_NUL_trans - try to make a transition on the NUL character
1392 *
1393 * synopsis
1394 *      next_state = yy_try_NUL_trans( current_state );
1395 */
1396    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1397{
1398        register int yy_is_jam;
1399        register char *yy_cp = (yy_c_buf_p);
1400
1401        register YY_CHAR yy_c = 1;
1402        if ( yy_accept[yy_current_state] )
1403                {
1404                (yy_last_accepting_state) = yy_current_state;
1405                (yy_last_accepting_cpos) = yy_cp;
1406                }
1407        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1408                {
1409                yy_current_state = (int) yy_def[yy_current_state];
1410                if ( yy_current_state >= 121 )
1411                        yy_c = yy_meta[(unsigned int) yy_c];
1412                }
1413        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1414        yy_is_jam = (yy_current_state == 120);
1415
1416                return yy_is_jam ? 0 : yy_current_state;
1417}
1418
1419#ifndef YY_NO_INPUT
1420#ifdef __cplusplus
1421    static int yyinput (void)
1422#else
1423    static int input  (void)
1424#endif
1425
1426{
1427        int c;
1428   
1429        *(yy_c_buf_p) = (yy_hold_char);
1430
1431        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1432                {
1433                /* yy_c_buf_p now points to the character we want to return.
1434                 * If this occurs *before* the EOB characters, then it's a
1435                 * valid NUL; if not, then we've hit the end of the buffer.
1436                 */
1437                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1438                        /* This was really a NUL. */
1439                        *(yy_c_buf_p) = '\0';
1440
1441                else
1442                        { /* need more input */
1443                        yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1444                        ++(yy_c_buf_p);
1445
1446                        switch ( yy_get_next_buffer(  ) )
1447                                {
1448                                case EOB_ACT_LAST_MATCH:
1449                                        /* This happens because yy_g_n_b()
1450                                         * sees that we've accumulated a
1451                                         * token and flags that we need to
1452                                         * try matching the token before
1453                                         * proceeding.  But for input(),
1454                                         * there's no matching to consider.
1455                                         * So convert the EOB_ACT_LAST_MATCH
1456                                         * to EOB_ACT_END_OF_FILE.
1457                                         */
1458
1459                                        /* Reset buffer status. */
1460                                        __libipsecrestart(__libipsecin );
1461
1462                                        /*FALLTHROUGH*/
1463
1464                                case EOB_ACT_END_OF_FILE:
1465                                        {
1466                                        if ( __libipsecwrap( ) )
1467                                                return EOF;
1468
1469                                        if ( ! (yy_did_buffer_switch_on_eof) )
1470                                                YY_NEW_FILE;
1471#ifdef __cplusplus
1472                                        return yyinput();
1473#else
1474                                        return input();
1475#endif
1476                                        }
1477
1478                                case EOB_ACT_CONTINUE_SCAN:
1479                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1480                                        break;
1481                                }
1482                        }
1483                }
1484
1485        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1486        *(yy_c_buf_p) = '\0';   /* preserve __libipsectext */
1487        (yy_hold_char) = *++(yy_c_buf_p);
1488
1489        return c;
1490}
1491#endif  /* ifndef YY_NO_INPUT */
1492
1493/** Immediately switch to a different input stream.
1494 * @param input_file A readable stream.
1495 *
1496 * @note This function does not reset the start condition to @c INITIAL .
1497 */
1498    void __libipsecrestart  (FILE * input_file )
1499{
1500   
1501        if ( ! YY_CURRENT_BUFFER ){
1502        __libipsecensure_buffer_stack ();
1503                YY_CURRENT_BUFFER_LVALUE =
1504            __libipsec_create_buffer(__libipsecin,YY_BUF_SIZE );
1505        }
1506
1507        __libipsec_init_buffer(YY_CURRENT_BUFFER,input_file );
1508        __libipsec_load_buffer_state( );
1509}
1510
1511/** Switch to a different input buffer.
1512 * @param new_buffer The new input buffer.
1513 *
1514 */
1515    void __libipsec_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1516{
1517   
1518        /* TODO. We should be able to replace this entire function body
1519         * with
1520         *              __libipsecpop_buffer_state();
1521         *              __libipsecpush_buffer_state(new_buffer);
1522     */
1523        __libipsecensure_buffer_stack ();
1524        if ( YY_CURRENT_BUFFER == new_buffer )
1525                return;
1526
1527        if ( YY_CURRENT_BUFFER )
1528                {
1529                /* Flush out information for old buffer. */
1530                *(yy_c_buf_p) = (yy_hold_char);
1531                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1532                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1533                }
1534
1535        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1536        __libipsec_load_buffer_state( );
1537
1538        /* We don't actually know whether we did this switch during
1539         * EOF (__libipsecwrap()) processing, but the only time this flag
1540         * is looked at is after __libipsecwrap() is called, so it's safe
1541         * to go ahead and always set it.
1542         */
1543        (yy_did_buffer_switch_on_eof) = 1;
1544}
1545
1546static void __libipsec_load_buffer_state  (void)
1547{
1548        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1549        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1550        __libipsecin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1551        (yy_hold_char) = *(yy_c_buf_p);
1552}
1553
1554/** Allocate and initialize an input buffer state.
1555 * @param file A readable stream.
1556 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1557 *
1558 * @return the allocated buffer state.
1559 */
1560    YY_BUFFER_STATE __libipsec_create_buffer  (FILE * file, int  size )
1561{
1562        YY_BUFFER_STATE b;
1563   
1564        b = (YY_BUFFER_STATE) __libipsecalloc(sizeof( struct yy_buffer_state )  );
1565        if ( ! b )
1566                YY_FATAL_ERROR( "out of dynamic memory in __libipsec_create_buffer()" );
1567
1568        b->yy_buf_size = size;
1569
1570        /* yy_ch_buf has to be 2 characters longer than the size given because
1571         * we need to put in 2 end-of-buffer characters.
1572         */
1573        b->yy_ch_buf = (char *) __libipsecalloc(b->yy_buf_size + 2  );
1574        if ( ! b->yy_ch_buf )
1575                YY_FATAL_ERROR( "out of dynamic memory in __libipsec_create_buffer()" );
1576
1577        b->yy_is_our_buffer = 1;
1578
1579        __libipsec_init_buffer(b,file );
1580
1581        return b;
1582}
1583
1584/** Destroy the buffer.
1585 * @param b a buffer created with __libipsec_create_buffer()
1586 *
1587 */
1588    void __libipsec_delete_buffer (YY_BUFFER_STATE  b )
1589{
1590   
1591        if ( ! b )
1592                return;
1593
1594        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1595                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1596
1597        if ( b->yy_is_our_buffer )
1598                __libipsecfree((void *) b->yy_ch_buf  );
1599
1600        __libipsecfree((void *) b  );
1601}
1602
1603/* Initializes or reinitializes a buffer.
1604 * This function is sometimes called more than once on the same buffer,
1605 * such as during a __libipsecrestart() or at EOF.
1606 */
1607    static void __libipsec_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1608
1609{
1610        int oerrno = errno;
1611   
1612        __libipsec_flush_buffer(b );
1613
1614        b->yy_input_file = file;
1615        b->yy_fill_buffer = 1;
1616
1617    /* If b is the current buffer, then __libipsec_init_buffer was _probably_
1618     * called from __libipsecrestart() or through yy_get_next_buffer.
1619     * In that case, we don't want to reset the lineno or column.
1620     */
1621    if (b != YY_CURRENT_BUFFER){
1622        b->yy_bs_lineno = 1;
1623        b->yy_bs_column = 0;
1624    }
1625
1626        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1627   
1628        errno = oerrno;
1629}
1630
1631/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1632 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1633 *
1634 */
1635    void __libipsec_flush_buffer (YY_BUFFER_STATE  b )
1636{
1637        if ( ! b )
1638                return;
1639
1640        b->yy_n_chars = 0;
1641
1642        /* We always need two end-of-buffer characters.  The first causes
1643         * a transition to the end-of-buffer state.  The second causes
1644         * a jam in that state.
1645         */
1646        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1647        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1648
1649        b->yy_buf_pos = &b->yy_ch_buf[0];
1650
1651        b->yy_at_bol = 1;
1652        b->yy_buffer_status = YY_BUFFER_NEW;
1653
1654        if ( b == YY_CURRENT_BUFFER )
1655                __libipsec_load_buffer_state( );
1656}
1657
1658/** Pushes the new state onto the stack. The new state becomes
1659 *  the current state. This function will allocate the stack
1660 *  if necessary.
1661 *  @param new_buffer The new state.
1662 * 
1663 */
1664void __libipsecpush_buffer_state (YY_BUFFER_STATE new_buffer )
1665{
1666        if (new_buffer == NULL)
1667                return;
1668
1669        __libipsecensure_buffer_stack();
1670
1671        /* This block is copied from __libipsec_switch_to_buffer. */
1672        if ( YY_CURRENT_BUFFER )
1673                {
1674                /* Flush out information for old buffer. */
1675                *(yy_c_buf_p) = (yy_hold_char);
1676                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1677                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1678                }
1679
1680        /* Only push if top exists. Otherwise, replace top. */
1681        if (YY_CURRENT_BUFFER)
1682                (yy_buffer_stack_top)++;
1683        YY_CURRENT_BUFFER_LVALUE = new_buffer;
1684
1685        /* copied from __libipsec_switch_to_buffer. */
1686        __libipsec_load_buffer_state( );
1687        (yy_did_buffer_switch_on_eof) = 1;
1688}
1689
1690/** Removes and deletes the top of the stack, if present.
1691 *  The next element becomes the new top.
1692 * 
1693 */
1694void __libipsecpop_buffer_state (void)
1695{
1696        if (!YY_CURRENT_BUFFER)
1697                return;
1698
1699        __libipsec_delete_buffer(YY_CURRENT_BUFFER );
1700        YY_CURRENT_BUFFER_LVALUE = NULL;
1701        if ((yy_buffer_stack_top) > 0)
1702                --(yy_buffer_stack_top);
1703
1704        if (YY_CURRENT_BUFFER) {
1705                __libipsec_load_buffer_state( );
1706                (yy_did_buffer_switch_on_eof) = 1;
1707        }
1708}
1709
1710/* Allocates the stack if it does not exist.
1711 *  Guarantees space for at least one push.
1712 */
1713static void __libipsecensure_buffer_stack (void)
1714{
1715        yy_size_t num_to_alloc;
1716   
1717        if (!(yy_buffer_stack)) {
1718
1719                /* First allocation is just for 2 elements, since we don't know if this
1720                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1721                 * immediate realloc on the next call.
1722         */
1723                num_to_alloc = 1;
1724                (yy_buffer_stack) = (struct yy_buffer_state**)__libipsecalloc
1725                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1726                                                                );
1727                if ( ! (yy_buffer_stack) )
1728                        YY_FATAL_ERROR( "out of dynamic memory in __libipsecensure_buffer_stack()" );
1729                                                                 
1730                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1731                               
1732                (yy_buffer_stack_max) = num_to_alloc;
1733                (yy_buffer_stack_top) = 0;
1734                return;
1735        }
1736
1737        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1738
1739                /* Increase the buffer to prepare for a possible push. */
1740                int grow_size = 8 /* arbitrary grow size */;
1741
1742                num_to_alloc = (yy_buffer_stack_max) + grow_size;
1743                (yy_buffer_stack) = (struct yy_buffer_state**)__libipsecrealloc
1744                                                                ((yy_buffer_stack),
1745                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
1746                                                                );
1747                if ( ! (yy_buffer_stack) )
1748                        YY_FATAL_ERROR( "out of dynamic memory in __libipsecensure_buffer_stack()" );
1749
1750                /* zero only the new slots.*/
1751                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1752                (yy_buffer_stack_max) = num_to_alloc;
1753        }
1754}
1755
1756/** Setup the input buffer state to scan directly from a user-specified character buffer.
1757 * @param base the character buffer
1758 * @param size the size in bytes of the character buffer
1759 *
1760 * @return the newly allocated buffer state object.
1761 */
1762YY_BUFFER_STATE __libipsec_scan_buffer  (char * base, yy_size_t  size )
1763{
1764        YY_BUFFER_STATE b;
1765   
1766        if ( size < 2 ||
1767             base[size-2] != YY_END_OF_BUFFER_CHAR ||
1768             base[size-1] != YY_END_OF_BUFFER_CHAR )
1769                /* They forgot to leave room for the EOB's. */
1770                return 0;
1771
1772        b = (YY_BUFFER_STATE) __libipsecalloc(sizeof( struct yy_buffer_state )  );
1773        if ( ! b )
1774                YY_FATAL_ERROR( "out of dynamic memory in __libipsec_scan_buffer()" );
1775
1776        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1777        b->yy_buf_pos = b->yy_ch_buf = base;
1778        b->yy_is_our_buffer = 0;
1779        b->yy_input_file = 0;
1780        b->yy_n_chars = b->yy_buf_size;
1781        b->yy_is_interactive = 0;
1782        b->yy_at_bol = 1;
1783        b->yy_fill_buffer = 0;
1784        b->yy_buffer_status = YY_BUFFER_NEW;
1785
1786        __libipsec_switch_to_buffer();
1787
1788        return b;
1789}
1790
1791/** Setup the input buffer state to scan a string. The next call to __libipseclex() will
1792 * scan from a @e copy of @a str.
1793 * @param yystr a NUL-terminated string to scan
1794 *
1795 * @return the newly allocated buffer state object.
1796 * @note If you want to scan bytes that may contain NUL values, then use
1797 *       __libipsec_scan_bytes() instead.
1798 */
1799YY_BUFFER_STATE __libipsec_scan_string (yyconst char * yystr )
1800{
1801   
1802        return __libipsec_scan_bytes(yystr,strlen(yystr) );
1803}
1804
1805/** Setup the input buffer state to scan the given bytes. The next call to __libipseclex() will
1806 * scan from a @e copy of @a bytes.
1807 * @param yybytes the byte buffer to scan
1808 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1809 *
1810 * @return the newly allocated buffer state object.
1811 */
1812YY_BUFFER_STATE __libipsec_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
1813{
1814        YY_BUFFER_STATE b;
1815        char *buf;
1816        yy_size_t n;
1817        int i;
1818   
1819        /* Get memory for full buffer, including space for trailing EOB's. */
1820        n = _yybytes_len + 2;
1821        buf = (char *) __libipsecalloc();
1822        if ( ! buf )
1823                YY_FATAL_ERROR( "out of dynamic memory in __libipsec_scan_bytes()" );
1824
1825        for ( i = 0; i < _yybytes_len; ++i )
1826                buf[i] = yybytes[i];
1827
1828        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1829
1830        b = __libipsec_scan_buffer(buf,n );
1831        if ( ! b )
1832                YY_FATAL_ERROR( "bad buffer in __libipsec_scan_bytes()" );
1833
1834        /* It's okay to grow etc. this buffer, and we should throw it
1835         * away when we're done.
1836         */
1837        b->yy_is_our_buffer = 1;
1838
1839        return b;
1840}
1841
1842#ifndef YY_EXIT_FAILURE
1843#define YY_EXIT_FAILURE 2
1844#endif
1845
1846static void yy_fatal_error (yyconst char* msg )
1847{
1848        (void) fprintf( stderr, "%s\n", msg );
1849        exit( YY_EXIT_FAILURE );
1850}
1851
1852/* Redefine yyless() so it works in section 3 code. */
1853
1854#undef yyless
1855#define yyless(n) \
1856        do \
1857                { \
1858                /* Undo effects of setting up __libipsectext. */ \
1859        int yyless_macro_arg = (n); \
1860        YY_LESS_LINENO(yyless_macro_arg);\
1861                __libipsectext[__libipsecleng] = (yy_hold_char); \
1862                (yy_c_buf_p) = __libipsectext + yyless_macro_arg; \
1863                (yy_hold_char) = *(yy_c_buf_p); \
1864                *(yy_c_buf_p) = '\0'; \
1865                __libipsecleng = yyless_macro_arg; \
1866                } \
1867        while ( 0 )
1868
1869/* Accessor  methods (get/set functions) to struct members. */
1870
1871/** Get the current line number.
1872 *
1873 */
1874int __libipsecget_lineno  (void)
1875{
1876       
1877    return __libipseclineno;
1878}
1879
1880/** Get the input stream.
1881 *
1882 */
1883FILE *__libipsecget_in  (void)
1884{
1885        return __libipsecin;
1886}
1887
1888/** Get the output stream.
1889 *
1890 */
1891FILE *__libipsecget_out  (void)
1892{
1893        return __libipsecout;
1894}
1895
1896/** Get the length of the current token.
1897 *
1898 */
1899yy_size_t __libipsecget_leng  (void)
1900{
1901        return __libipsecleng;
1902}
1903
1904/** Get the current token.
1905 *
1906 */
1907
1908char *__libipsecget_text  (void)
1909{
1910        return __libipsectext;
1911}
1912
1913/** Set the current line number.
1914 * @param line_number
1915 *
1916 */
1917void __libipsecset_lineno (int  line_number )
1918{
1919   
1920    __libipseclineno = line_number;
1921}
1922
1923/** Set the input stream. This does not discard the current
1924 * input buffer.
1925 * @param in_str A readable stream.
1926 *
1927 * @see __libipsec_switch_to_buffer
1928 */
1929void __libipsecset_in (FILE *  in_str )
1930{
1931        __libipsecin = in_str ;
1932}
1933
1934void __libipsecset_out (FILE *  out_str )
1935{
1936        __libipsecout = out_str ;
1937}
1938
1939int __libipsecget_debug  (void)
1940{
1941        return __libipsec_flex_debug;
1942}
1943
1944void __libipsecset_debug (int  bdebug )
1945{
1946        __libipsec_flex_debug = bdebug ;
1947}
1948
1949static int yy_init_globals (void)
1950{
1951        /* Initialization is the same as for the non-reentrant scanner.
1952     * This function is called from __libipseclex_destroy(), so don't allocate here.
1953     */
1954
1955    (yy_buffer_stack) = 0;
1956    (yy_buffer_stack_top) = 0;
1957    (yy_buffer_stack_max) = 0;
1958    (yy_c_buf_p) = (char *) 0;
1959    (yy_init) = 0;
1960    (yy_start) = 0;
1961
1962/* Defined in main.c */
1963#ifdef YY_STDINIT
1964    __libipsecin = stdin;
1965    __libipsecout = stdout;
1966#else
1967    __libipsecin = (FILE *) 0;
1968    __libipsecout = (FILE *) 0;
1969#endif
1970
1971    /* For future reference: Set errno on error, since we are called by
1972     * __libipseclex_init()
1973     */
1974    return 0;
1975}
1976
1977/* __libipseclex_destroy is for both reentrant and non-reentrant scanners. */
1978int __libipseclex_destroy  (void)
1979{
1980   
1981    /* Pop the buffer stack, destroying each element. */
1982        while(YY_CURRENT_BUFFER){
1983                __libipsec_delete_buffer(YY_CURRENT_BUFFER  );
1984                YY_CURRENT_BUFFER_LVALUE = NULL;
1985                __libipsecpop_buffer_state();
1986        }
1987
1988        /* Destroy the stack itself. */
1989        __libipsecfree((yy_buffer_stack) );
1990        (yy_buffer_stack) = NULL;
1991
1992    /* Reset the globals. This is important in a non-reentrant scanner so the next time
1993     * __libipseclex() is called, initialization will occur. */
1994    yy_init_globals( );
1995
1996    return 0;
1997}
1998
1999/*
2000 * Internal utility routines.
2001 */
2002
2003#ifndef yytext_ptr
2004static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2005{
2006        register int i;
2007        for ( i = 0; i < n; ++i )
2008                s1[i] = s2[i];
2009}
2010#endif
2011
2012#ifdef YY_NEED_STRLEN
2013static int yy_flex_strlen (yyconst char * s )
2014{
2015        register int n;
2016        for ( n = 0; s[n]; ++n )
2017                ;
2018
2019        return n;
2020}
2021#endif
2022
2023void *__libipsecalloc (yy_size_t  size )
2024{
2025        return (void *) malloc( size );
2026}
2027
2028void *__libipsecrealloc  (void * ptr, yy_size_t  size )
2029{
2030        /* The cast to (char *) in the following accommodates both
2031         * implementations that use char* generic pointers, and those
2032         * that use void* generic pointers.  It works with the latter
2033         * because both ANSI C and C++ allow castless assignment from
2034         * any pointer type to void*, and deal with argument conversions
2035         * as though doing an assignment.
2036         */
2037        return (void *) realloc( (char *) ptr, size );
2038}
2039
2040void __libipsecfree (void * ptr )
2041{
2042        free( (char *) ptr );   /* see __libipsecrealloc() for (char *) cast */
2043}
2044
2045#define YYTABLES_NAME "yytables"
2046
2047#line 167 "policy_token.l"
2048
2049
2050
2051void __policy__strbuffer__init__ __P((char *));
2052void __policy__strbuffer__free__ __P((void));
2053
2054static YY_BUFFER_STATE strbuffer;
2055
2056void
2057__policy__strbuffer__init__(msg)
2058        char *msg;
2059{
2060        if (YY_CURRENT_BUFFER)
2061                __libipsec_delete_buffer(YY_CURRENT_BUFFER);
2062        strbuffer = (YY_BUFFER_STATE)__libipsec_scan_string(msg);
2063        __libipsec_switch_to_buffer(strbuffer);
2064
2065        return;
2066}
2067
2068void
2069__policy__strbuffer__free__()
2070{
2071        __libipsec_delete_buffer(strbuffer);
2072
2073        return;
2074}
2075
Note: See TracBrowser for help on using the repository browser.