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