2 #line 3 "tokenparser.c"
4 #define YY_INT_ALIGNED short int
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
18 #define yylineno tplineno
20 #define yyrestart tprestart
23 #define yyalloc tpalloc
24 #define yyrealloc tprealloc
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
52 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
57 #ifndef __STDC_LIMIT_MACROS
58 #define __STDC_LIMIT_MACROS 1
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;
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;
78 #define INT8_MIN (-128)
81 #define INT16_MIN (-32767-1)
84 #define INT32_MIN (-2147483647-1)
87 #define INT8_MAX (127)
90 #define INT16_MAX (32767)
93 #define INT32_MAX (2147483647)
96 #define UINT8_MAX (255U)
99 #define UINT16_MAX (65535U)
102 #define UINT32_MAX (4294967295U)
117 #if defined (__STDC__)
125 #define yyconst const
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
144 #define BEGIN (yy_start) = 1 + 2 *
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
157 #define YY_NEW_FILE tprestart(tpin )
159 #define YY_END_OF_BUFFER_CHAR 0
168 #define YY_BUF_SIZE 32768
170 #define YY_BUF_SIZE 16384
176 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
178 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
179 #define YY_TYPEDEF_YY_BUFFER_STATE
183 #ifndef YY_TYPEDEF_YY_SIZE_T
184 #define YY_TYPEDEF_YY_SIZE_T
185 typedef size_t yy_size_t;
188 extern yy_size_t tpleng;
190 extern FILE *tpin, *tpout;
192 #define EOB_ACT_CONTINUE_SCAN 0
193 #define EOB_ACT_END_OF_FILE 1
194 #define EOB_ACT_LAST_MATCH 2
196 #define YY_LESS_LINENO(n)
197 #define YY_LINENO_REWIND_TO(ptr)
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; \
213 #define unput(c) yyunput( c, (yytext_ptr) )
215 #ifndef YY_STRUCT_YY_BUFFER_STATE
216 #define YY_STRUCT_YY_BUFFER_STATE
227 yy_size_t yy_buf_size;
232 yy_size_t yy_n_chars;
238 int yy_is_our_buffer;
245 int yy_is_interactive;
261 int yy_buffer_status;
263 #define YY_BUFFER_NEW 0
264 #define YY_BUFFER_NORMAL 1
275 #define YY_BUFFER_EOF_PENDING 2
291 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
292 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
298 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
301 static char yy_hold_char;
302 static yy_size_t yy_n_chars;
306 static char *yy_c_buf_p = (
char *) 0;
307 static int yy_init = 0;
308 static int yy_start = 0;
313 static int yy_did_buffer_switch_on_eof;
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 );
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 );
327 #define YY_FLUSH_BUFFER tp_flush_buffer(YY_CURRENT_BUFFER )
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 );
333 void *tpalloc (yy_size_t );
334 void *tprealloc (
void *,yy_size_t );
335 void tpfree (
void * );
337 #define yy_new_buffer tp_create_buffer
339 #define yy_set_interactive(is_interactive) \
341 if ( ! YY_CURRENT_BUFFER ){ \
342 tpensure_buffer_stack (); \
343 YY_CURRENT_BUFFER_LVALUE = \
344 tp_create_buffer(tpin,YY_BUF_SIZE ); \
346 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
349 #define yy_set_bol(at_bol) \
351 if ( ! YY_CURRENT_BUFFER ){\
352 tpensure_buffer_stack (); \
353 YY_CURRENT_BUFFER_LVALUE = \
354 tp_create_buffer(tpin,YY_BUF_SIZE ); \
356 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
359 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
364 #define YY_SKIP_YYWRAP
366 typedef unsigned char YY_CHAR;
368 FILE *tpin = (FILE *) 0, *tpout = (FILE *) 0;
370 typedef int yy_state_type;
377 #define yytext_ptr tptext
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[] );
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; \
392 (yy_c_buf_p) = yy_cp;
394 #define YY_NUM_RULES 7
395 #define YY_END_OF_BUFFER 8
400 flex_int32_t yy_verify;
403 static yyconst flex_int16_t yy_accept[39] =
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
411 static yyconst flex_int32_t yy_ec[256] =
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,
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,
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,
443 static yyconst flex_int32_t yy_meta[21] =
445 1, 2, 3, 4, 4, 4, 2, 1, 1, 2,
446 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
449 static yyconst flex_int16_t yy_base[43] =
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,
458 static yyconst flex_int16_t yy_def[43] =
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,
467 static yyconst flex_int16_t yy_nxt[71] =
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
478 static yyconst flex_int16_t yy_chk[71] =
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
489 static yy_state_type yy_last_accepting_state;
490 static char *yy_last_accepting_cpos;
492 extern int tp_flex_debug;
493 int tp_flex_debug = 0;
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
503 #line 1 "tokenparser.l"
544 #line 44 "tokenparser.l"
553 #include "simclist.h"
558 static void eval_key(
char *pcToken,
list_t *list_key);
559 static void eval_value(
char *pcToken,
list_t *list_values);
560 void tperrorCheck (
char *pcToken_error);
563 static list_t *ListValues;
565 #define YY_NO_INPUT 1
566 #line 567 "tokenparser.c"
570 #ifndef YY_NO_UNISTD_H
578 #ifndef YY_EXTRA_TYPE
579 #define YY_EXTRA_TYPE void *
582 static int yy_init_globals (
void );
587 int tplex_destroy (
void );
589 int tpget_debug (
void );
591 void tpset_debug (
int debug_flag );
593 YY_EXTRA_TYPE tpget_extra (
void );
595 void tpset_extra (YY_EXTRA_TYPE user_defined );
597 FILE *tpget_in (
void );
599 void tpset_in (FILE * in_str );
601 FILE *tpget_out (
void );
603 void tpset_out (FILE * out_str );
605 yy_size_t tpget_leng (
void );
607 char *tpget_text (
void );
609 int tpget_lineno (
void );
611 void tpset_lineno (
int line_number );
617 #ifndef YY_SKIP_YYWRAP
619 extern "C" int tpwrap (
void );
621 extern int tpwrap (
void );
626 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
629 #ifdef YY_NEED_STRLEN
630 static int yy_flex_strlen (yyconst
char * );
636 static int yyinput (
void );
638 static int input (
void );
644 #ifndef YY_READ_BUF_SIZE
647 #define YY_READ_BUF_SIZE 16384
649 #define YY_READ_BUF_SIZE 8192
658 #define ECHO do { if (fwrite( tptext, tpleng, 1, tpout )) {} } while (0)
665 #define YY_INPUT(buf,result,max_size) \
666 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
670 for ( n = 0; n < max_size && \
671 (c = getc( tpin )) != EOF && c != '\n'; ++n ) \
674 buf[n++] = (char) c; \
675 if ( c == EOF && ferror( tpin ) ) \
676 YY_FATAL_ERROR( "input in flex scanner failed" ); \
682 while ( (result = fread(buf, 1, max_size, tpin))==0 && ferror(tpin)) \
684 if( errno != EINTR) \
686 YY_FATAL_ERROR( "input in flex scanner failed" ); \
702 #define yyterminate() return YY_NULL
706 #ifndef YY_START_STACK_INCR
707 #define YY_START_STACK_INCR 25
711 #ifndef YY_FATAL_ERROR
712 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
721 #define YY_DECL_IS_OURS 1
723 extern int tplex (
void);
725 #define YY_DECL int tplex (void)
731 #ifndef YY_USER_ACTION
732 #define YY_USER_ACTION
737 #define YY_BREAK break;
740 #define YY_RULE_SETUP \
747 register yy_state_type yy_current_state;
748 register char *yy_cp, *yy_bp;
768 if ( ! YY_CURRENT_BUFFER ) {
769 tpensure_buffer_stack ();
770 YY_CURRENT_BUFFER_LVALUE =
771 tp_create_buffer(tpin,YY_BUF_SIZE );
774 tp_load_buffer_state( );
778 #line 70 "tokenparser.l"
781 #line 782 "tokenparser.c"
785 yy_cp = (yy_c_buf_p);
788 *yy_cp = (yy_hold_char);
795 yy_current_state = (yy_start);
799 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
800 if ( yy_accept[yy_current_state] )
802 (yy_last_accepting_state) = yy_current_state;
803 (yy_last_accepting_cpos) = yy_cp;
805 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
807 yy_current_state = (int) yy_def[yy_current_state];
808 if ( yy_current_state >= 39 )
809 yy_c = yy_meta[(
unsigned int) yy_c];
811 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
814 while ( yy_base[yy_current_state] != 50 );
817 yy_act = yy_accept[yy_current_state];
820 yy_cp = (yy_last_accepting_cpos);
821 yy_current_state = (yy_last_accepting_state);
822 yy_act = yy_accept[yy_current_state];
833 *yy_cp = (yy_hold_char);
834 yy_cp = (yy_last_accepting_cpos);
835 yy_current_state = (yy_last_accepting_state);
840 #line 72 "tokenparser.l"
846 #line 73 "tokenparser.l"
851 #line 74 "tokenparser.l"
852 { eval_key(tptext, ListKeys); }
856 #line 75 "tokenparser.l"
861 #line 76 "tokenparser.l"
862 { eval_value(tptext, ListValues); }
866 #line 77 "tokenparser.l"
867 { tperrorCheck(tptext); }
871 #line 78 "tokenparser.l"
874 #line 875 "tokenparser.c"
875 case YY_STATE_EOF(INITIAL):
878 case YY_END_OF_BUFFER:
881 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
884 *yy_cp = (yy_hold_char);
885 YY_RESTORE_YY_MORE_OFFSET
887 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
898 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
899 YY_CURRENT_BUFFER_LVALUE->yy_input_file = tpin;
900 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
910 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
912 yy_state_type yy_next_state;
914 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
916 yy_current_state = yy_get_previous_state( );
927 yy_next_state = yy_try_NUL_trans( yy_current_state );
929 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
934 yy_cp = ++(yy_c_buf_p);
935 yy_current_state = yy_next_state;
941 yy_cp = (yy_c_buf_p);
946 else switch ( yy_get_next_buffer( ) )
948 case EOB_ACT_END_OF_FILE:
950 (yy_did_buffer_switch_on_eof) = 0;
963 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
965 yy_act = YY_STATE_EOF(YY_START);
971 if ( ! (yy_did_buffer_switch_on_eof) )
977 case EOB_ACT_CONTINUE_SCAN:
979 (yytext_ptr) + yy_amount_of_matched_text;
981 yy_current_state = yy_get_previous_state( );
983 yy_cp = (yy_c_buf_p);
984 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
987 case EOB_ACT_LAST_MATCH:
989 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
991 yy_current_state = yy_get_previous_state( );
993 yy_cp = (yy_c_buf_p);
994 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1002 "fatal flex scanner internal error--no action found" );
1015 static int yy_get_next_buffer (
void)
1017 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1018 register char *source = (yytext_ptr);
1019 register int number_to_move, i;
1022 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1024 "fatal flex scanner internal error--end of buffer missed" );
1026 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1028 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1033 return EOB_ACT_END_OF_FILE;
1041 return EOB_ACT_LAST_MATCH;
1048 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1050 for ( i = 0; i < number_to_move; ++i )
1051 *(dest++) = *(source++);
1053 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1057 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1061 yy_size_t num_to_read =
1062 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1064 while ( num_to_read <= 0 )
1068 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1070 int yy_c_buf_p_offset =
1071 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1073 if ( b->yy_is_our_buffer )
1075 yy_size_t new_size = b->yy_buf_size * 2;
1077 if ( new_size <= 0 )
1078 b->yy_buf_size += b->yy_buf_size / 8;
1080 b->yy_buf_size *= 2;
1082 b->yy_ch_buf = (
char *)
1084 tprealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1090 if ( ! b->yy_ch_buf )
1092 "fatal error - scanner input buffer overflow" );
1094 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1096 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1101 if ( num_to_read > YY_READ_BUF_SIZE )
1102 num_to_read = YY_READ_BUF_SIZE;
1105 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1106 (yy_n_chars), num_to_read );
1108 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1111 if ( (yy_n_chars) == 0 )
1113 if ( number_to_move == YY_MORE_ADJ )
1115 ret_val = EOB_ACT_END_OF_FILE;
1121 ret_val = EOB_ACT_LAST_MATCH;
1122 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1123 YY_BUFFER_EOF_PENDING;
1128 ret_val = EOB_ACT_CONTINUE_SCAN;
1130 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1132 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1133 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) tprealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1134 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1135 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1138 (yy_n_chars) += number_to_move;
1139 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1140 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1142 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1149 static yy_state_type yy_get_previous_state (
void)
1151 register yy_state_type yy_current_state;
1152 register char *yy_cp;
1154 yy_current_state = (yy_start);
1156 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1158 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1159 if ( yy_accept[yy_current_state] )
1161 (yy_last_accepting_state) = yy_current_state;
1162 (yy_last_accepting_cpos) = yy_cp;
1164 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1166 yy_current_state = (int) yy_def[yy_current_state];
1167 if ( yy_current_state >= 39 )
1168 yy_c = yy_meta[(
unsigned int) yy_c];
1170 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1173 return yy_current_state;
1181 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1183 register int yy_is_jam;
1184 register char *yy_cp = (yy_c_buf_p);
1186 register YY_CHAR yy_c = 1;
1187 if ( yy_accept[yy_current_state] )
1189 (yy_last_accepting_state) = yy_current_state;
1190 (yy_last_accepting_cpos) = yy_cp;
1192 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1194 yy_current_state = (int) yy_def[yy_current_state];
1195 if ( yy_current_state >= 39 )
1196 yy_c = yy_meta[(
unsigned int) yy_c];
1198 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1199 yy_is_jam = (yy_current_state == 38);
1201 return yy_is_jam ? 0 : yy_current_state;
1206 static int yyinput (
void)
1208 static int input (
void)
1214 *(yy_c_buf_p) = (yy_hold_char);
1216 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1222 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1224 *(yy_c_buf_p) =
'\0';
1228 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1231 switch ( yy_get_next_buffer( ) )
1233 case EOB_ACT_LAST_MATCH:
1249 case EOB_ACT_END_OF_FILE:
1254 if ( ! (yy_did_buffer_switch_on_eof) )
1263 case EOB_ACT_CONTINUE_SCAN:
1264 (yy_c_buf_p) = (yytext_ptr) + offset;
1270 c = *(
unsigned char *) (yy_c_buf_p);
1271 *(yy_c_buf_p) =
'\0';
1272 (yy_hold_char) = *++(yy_c_buf_p);
1283 void tprestart (FILE * input_file )
1286 if ( ! YY_CURRENT_BUFFER ){
1287 tpensure_buffer_stack ();
1288 YY_CURRENT_BUFFER_LVALUE =
1289 tp_create_buffer(tpin,YY_BUF_SIZE );
1292 tp_init_buffer(YY_CURRENT_BUFFER,input_file );
1293 tp_load_buffer_state( );
1300 void tp_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1308 tpensure_buffer_stack ();
1309 if ( YY_CURRENT_BUFFER == new_buffer )
1312 if ( YY_CURRENT_BUFFER )
1315 *(yy_c_buf_p) = (yy_hold_char);
1316 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1317 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1320 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1321 tp_load_buffer_state( );
1328 (yy_did_buffer_switch_on_eof) = 1;
1331 static void tp_load_buffer_state (
void)
1333 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1334 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1335 tpin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1336 (yy_hold_char) = *(yy_c_buf_p);
1345 YY_BUFFER_STATE tp_create_buffer (FILE * file,
int size )
1351 YY_FATAL_ERROR(
"out of dynamic memory in tp_create_buffer()" );
1353 b->yy_buf_size = size;
1358 b->yy_ch_buf = (
char *) tpalloc(b->yy_buf_size + 2 );
1359 if ( ! b->yy_ch_buf )
1360 YY_FATAL_ERROR(
"out of dynamic memory in tp_create_buffer()" );
1362 b->yy_is_our_buffer = 1;
1364 tp_init_buffer(b,file );
1373 void tp_delete_buffer (YY_BUFFER_STATE b )
1379 if ( b == YY_CURRENT_BUFFER )
1380 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1382 if ( b->yy_is_our_buffer )
1383 tpfree((
void *) b->yy_ch_buf );
1385 tpfree((
void *) b );
1392 static void tp_init_buffer (YY_BUFFER_STATE b, FILE * file )
1397 tp_flush_buffer(b );
1399 b->yy_input_file = file;
1400 b->yy_fill_buffer = 1;
1406 if (b != YY_CURRENT_BUFFER){
1411 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1420 void tp_flush_buffer (YY_BUFFER_STATE b )
1431 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1432 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1434 b->yy_buf_pos = &b->yy_ch_buf[0];
1437 b->yy_buffer_status = YY_BUFFER_NEW;
1439 if ( b == YY_CURRENT_BUFFER )
1440 tp_load_buffer_state( );
1449 void tppush_buffer_state (YY_BUFFER_STATE new_buffer )
1451 if (new_buffer == NULL)
1454 tpensure_buffer_stack();
1457 if ( YY_CURRENT_BUFFER )
1460 *(yy_c_buf_p) = (yy_hold_char);
1461 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1462 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1466 if (YY_CURRENT_BUFFER)
1468 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1471 tp_load_buffer_state( );
1472 (yy_did_buffer_switch_on_eof) = 1;
1479 void tppop_buffer_state (
void)
1481 if (!YY_CURRENT_BUFFER)
1484 tp_delete_buffer(YY_CURRENT_BUFFER );
1485 YY_CURRENT_BUFFER_LVALUE = NULL;
1489 if (YY_CURRENT_BUFFER) {
1490 tp_load_buffer_state( );
1491 (yy_did_buffer_switch_on_eof) = 1;
1498 static void tpensure_buffer_stack (
void)
1500 yy_size_t num_to_alloc;
1502 if (!(yy_buffer_stack)) {
1512 if ( ! (yy_buffer_stack) )
1513 YY_FATAL_ERROR(
"out of dynamic memory in tpensure_buffer_stack()" );
1515 memset((yy_buffer_stack), 0, num_to_alloc *
sizeof(
struct yy_buffer_state*));
1532 if ( ! (yy_buffer_stack) )
1533 YY_FATAL_ERROR(
"out of dynamic memory in tpensure_buffer_stack()" );
1547 YY_BUFFER_STATE tp_scan_buffer (
char * base, yy_size_t size )
1552 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1553 base[size-1] != YY_END_OF_BUFFER_CHAR )
1559 YY_FATAL_ERROR(
"out of dynamic memory in tp_scan_buffer()" );
1561 b->yy_buf_size = size - 2;
1562 b->yy_buf_pos = b->yy_ch_buf = base;
1563 b->yy_is_our_buffer = 0;
1564 b->yy_input_file = 0;
1565 b->yy_n_chars = b->yy_buf_size;
1566 b->yy_is_interactive = 0;
1568 b->yy_fill_buffer = 0;
1569 b->yy_buffer_status = YY_BUFFER_NEW;
1571 tp_switch_to_buffer(b );
1584 YY_BUFFER_STATE tp_scan_string (yyconst
char * yystr )
1587 return tp_scan_bytes(yystr,strlen(yystr) );
1597 YY_BUFFER_STATE tp_scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len )
1605 n = _yybytes_len + 2;
1606 buf = (
char *) tpalloc(n );
1608 YY_FATAL_ERROR(
"out of dynamic memory in tp_scan_bytes()" );
1610 for ( i = 0; i < _yybytes_len; ++i )
1611 buf[i] = yybytes[i];
1613 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1615 b = tp_scan_buffer(buf,n );
1617 YY_FATAL_ERROR(
"bad buffer in tp_scan_bytes()" );
1622 b->yy_is_our_buffer = 1;
1627 #ifndef YY_EXIT_FAILURE
1628 #define YY_EXIT_FAILURE 2
1631 static void yy_fatal_error (yyconst
char* msg )
1633 (void) fprintf( stderr,
"%s\n", msg );
1634 exit( YY_EXIT_FAILURE );
1644 int yyless_macro_arg = (n); \
1645 YY_LESS_LINENO(yyless_macro_arg);\
1646 tptext[tpleng] = (yy_hold_char); \
1647 (yy_c_buf_p) = tptext + yyless_macro_arg; \
1648 (yy_hold_char) = *(yy_c_buf_p); \
1649 *(yy_c_buf_p) = '\0'; \
1650 tpleng = yyless_macro_arg; \
1659 int tpget_lineno (
void)
1668 FILE *tpget_in (
void)
1676 FILE *tpget_out (
void)
1684 yy_size_t tpget_leng (
void)
1693 char *tpget_text (
void)
1702 void tpset_lineno (
int line_number )
1705 tplineno = line_number;
1714 void tpset_in (FILE * in_str )
1719 void tpset_out (FILE * out_str )
1724 int tpget_debug (
void)
1726 return tp_flex_debug;
1729 void tpset_debug (
int bdebug )
1731 tp_flex_debug = bdebug ;
1734 static int yy_init_globals (
void)
1743 (yy_c_buf_p) = (
char *) 0;
1763 int tplex_destroy (
void)
1767 while(YY_CURRENT_BUFFER){
1768 tp_delete_buffer(YY_CURRENT_BUFFER );
1769 YY_CURRENT_BUFFER_LVALUE = NULL;
1770 tppop_buffer_state();
1774 tpfree((yy_buffer_stack) );
1789 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n )
1792 for ( i = 0; i < n; ++i )
1797 #ifdef YY_NEED_STRLEN
1798 static int yy_flex_strlen (yyconst
char * s )
1801 for ( n = 0; s[n]; ++n )
1808 void *tpalloc (yy_size_t size )
1810 return (
void *) malloc( size );
1813 void *tprealloc (
void * ptr, yy_size_t size )
1822 return (
void *) realloc( (
char *) ptr, size );
1825 void tpfree (
void * ptr )
1827 free( (
char *) ptr );
1830 #define YYTABLES_NAME "yytables"
1832 #line 77 "tokenparser.l"
1837 static void eval_key(
char *pcToken,
list_t *list_key)
1844 elt = malloc(
sizeof(*elt));
1851 for (len=0; pcToken[len+5] !=
'<'; len++)
1855 elt->key = malloc(len);
1856 (void)strlcpy(elt->key, &pcToken[5], len);
1858 r = list_init(&elt->values);
1863 list_append(list_key, elt);
1866 ListValues = &elt->values;
1869 static void eval_value(
char *pcToken,
list_t *list_values)
1880 for (len=0; pcToken[len+8] !=
'<'; len++)
1884 value = malloc(len);
1887 (void)strlcpy(value, &pcToken[8], len);
1891 while ((amp = strstr(amp,
"&")) != NULL)
1896 for (p = amp+1; *(p+4); p++)
1907 r = list_append(list_values, value);
1912 void tperrorCheck (
char *token_error)
1927 int LTPBundleFindValueWithKey(
list_t *l,
const char *key,
list_t **values)
1932 for (i=0; i < list_size(l); i++)
1936 elt = list_get_at(l, i);
1939 if (0 == strcmp(elt->key, key))
1941 *values = &elt->values;
1958 int bundleParse(
const char *fileName,
list_t *l)
1966 file = fopen(fileName,
"r");
1969 Log3(PCSC_LOG_CRITICAL,
"Could not open bundle file %s: %s",
1970 fileName, strerror(errno));
1984 }
while (!feof(file));
1990 printf(
"size: %d\n", list_size(l));
1991 for (i=0; i < list_size(l); i++)
1996 elt = list_get_at(l, i);
1998 printf(
"Key: %s\n", elt->key);
2000 for (j=0; j<list_size(&elt->values); j++)
2002 char *v = list_get_at(&elt->values, j);
2003 printf(
" value: %s\n", v);
2016 void bundleRelease(
list_t *l)
2020 for (i=0; i < list_size(l); i++)
2025 elt = list_get_at(l, i);
2029 for (j=0; j<list_size(&elt->values); j++)
2030 free(list_get_at(&elt->values, j));
2031 list_destroy(&elt->values);
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
int yy_bs_column
The column count.
Reads lexical config files and updates database.
prototypes of strlcpy()/strlcat() imported from OpenBSD
static size_t yy_buffer_stack_max
capacity of stack.
YY_DECL
The main scanner function which does all the work.
static size_t yy_buffer_stack_top
index of top of stack.
int yy_bs_lineno
The line count.