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