4 #define YY_INT_ALIGNED short int 9 #define YY_FLEX_MAJOR_VERSION 2 10 #define YY_FLEX_MINOR_VERSION 6 11 #define YY_FLEX_SUBMINOR_VERSION 0 12 #if YY_FLEX_SUBMINOR_VERSION > 0 33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 38 #ifndef __STDC_LIMIT_MACROS 39 #define __STDC_LIMIT_MACROS 1 43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t;
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
59 #define INT8_MIN (-128) 62 #define INT16_MIN (-32767-1) 65 #define INT32_MIN (-2147483647-1) 68 #define INT8_MAX (127) 71 #define INT16_MAX (32767) 74 #define INT32_MAX (2147483647) 77 #define UINT8_MAX (255U) 80 #define UINT16_MAX (65535U) 83 #define UINT32_MAX (4294967295U) 98 #if defined (__STDC__) 106 #define yyconst const 119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 125 #define BEGIN (yy_start) = 1 + 2 * 131 #define YY_START (((yy_start) - 1) / 2) 132 #define YYSTATE YY_START 135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 138 #define YY_NEW_FILE yyrestart(yyin ) 140 #define YY_END_OF_BUFFER_CHAR 0 149 #define YY_BUF_SIZE 32768 151 #define YY_BUF_SIZE 16384 157 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 160 #define YY_TYPEDEF_YY_BUFFER_STATE 164 #ifndef YY_TYPEDEF_YY_SIZE_T 165 #define YY_TYPEDEF_YY_SIZE_T 166 typedef size_t yy_size_t;
169 extern yy_size_t yyleng;
171 extern FILE *yyin, *yyout;
173 #define EOB_ACT_CONTINUE_SCAN 0 174 #define EOB_ACT_END_OF_FILE 1 175 #define EOB_ACT_LAST_MATCH 2 177 #define YY_LESS_LINENO(n) 178 #define YY_LINENO_REWIND_TO(ptr) 185 int yyless_macro_arg = (n); \ 186 YY_LESS_LINENO(yyless_macro_arg);\ 187 *yy_cp = (yy_hold_char); \ 188 YY_RESTORE_YY_MORE_OFFSET \ 189 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 190 YY_DO_BEFORE_ACTION; \ 194 #define unput(c) yyunput( c, (yytext_ptr) ) 196 #ifndef YY_STRUCT_YY_BUFFER_STATE 197 #define YY_STRUCT_YY_BUFFER_STATE 208 yy_size_t yy_buf_size;
219 int yy_is_our_buffer;
226 int yy_is_interactive;
242 int yy_buffer_status;
244 #define YY_BUFFER_NEW 0 245 #define YY_BUFFER_NORMAL 1 256 #define YY_BUFFER_EOF_PENDING 2 272 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 273 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 279 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 282 static char yy_hold_char;
283 static int yy_n_chars;
287 static char *yy_c_buf_p = (
char *) 0;
288 static int yy_init = 0;
289 static int yy_start = 0;
294 static int yy_did_buffer_switch_on_eof;
296 void yyrestart (FILE *input_file );
297 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
298 YY_BUFFER_STATE yy_create_buffer (FILE *file,
int size );
299 void yy_delete_buffer (YY_BUFFER_STATE b );
300 void yy_flush_buffer (YY_BUFFER_STATE b );
301 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
302 void yypop_buffer_state (
void );
304 static void yyensure_buffer_stack (
void );
305 static void yy_load_buffer_state (
void );
306 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
308 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 310 YY_BUFFER_STATE yy_scan_buffer (
char *base,yy_size_t size );
311 YY_BUFFER_STATE yy_scan_string (yyconst
char *yy_str );
312 YY_BUFFER_STATE yy_scan_bytes (yyconst
char *bytes,yy_size_t len );
314 void *yyalloc (yy_size_t );
315 void *yyrealloc (
void *,yy_size_t );
316 void yyfree (
void * );
318 #define yy_new_buffer yy_create_buffer 320 #define yy_set_interactive(is_interactive) \ 322 if ( ! YY_CURRENT_BUFFER ){ \ 323 yyensure_buffer_stack (); \ 324 YY_CURRENT_BUFFER_LVALUE = \ 325 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 327 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 330 #define yy_set_bol(at_bol) \ 332 if ( ! YY_CURRENT_BUFFER ){\ 333 yyensure_buffer_stack (); \ 334 YY_CURRENT_BUFFER_LVALUE = \ 335 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 337 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 340 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 345 #define YY_SKIP_YYWRAP 347 typedef unsigned char YY_CHAR;
349 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
351 typedef int yy_state_type;
361 #define yytext_ptr yytext 363 static yy_state_type yy_get_previous_state (
void );
364 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
365 static int yy_get_next_buffer (
void );
366 #if defined(__GNUC__) && __GNUC__ >= 3 367 __attribute__((__noreturn__))
369 static void yy_fatal_error (yyconst
char msg[] );
374 #define YY_DO_BEFORE_ACTION \ 375 (yytext_ptr) = yy_bp; \ 376 yyleng = (size_t) (yy_cp - yy_bp); \ 377 (yy_hold_char) = *yy_cp; \ 379 (yy_c_buf_p) = yy_cp; 381 #define YY_NUM_RULES 7 382 #define YY_END_OF_BUFFER 8 387 flex_int32_t yy_verify;
390 static yyconst flex_int16_t yy_accept[17] =
392 0, 0, 8, 6, 4, 2, 6, 1, 6, 5,
396 static yyconst YY_CHAR yy_ec[256] =
398 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 2, 1, 4, 5, 1, 1, 1, 6, 1,
402 1, 1, 1, 1, 7, 7, 7, 8, 8, 8,
403 8, 8, 8, 8, 8, 8, 8, 7, 1, 1,
404 1, 1, 1, 7, 9, 9, 9, 9, 9, 9,
405 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
406 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
407 1, 7, 1, 1, 7, 1, 10, 10, 10, 10,
409 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
410 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
411 10, 10, 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, 1, 1, 1, 1, 1,
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428 static yyconst YY_CHAR yy_meta[11] =
430 1, 1, 2, 1, 1, 1, 1, 1, 1, 1
433 static yyconst flex_uint16_t yy_base[20] =
435 0, 0, 15, 31, 31, 31, 8, 0, 10, 10,
436 18, 31, 0, 20, 0, 31, 26, 13, 28
439 static yyconst flex_int16_t yy_def[20] =
441 16, 1, 16, 16, 16, 16, 17, 18, 19, 16,
442 17, 16, 18, 19, 10, 0, 16, 16, 16
445 static yyconst flex_uint16_t yy_nxt[42] =
447 4, 5, 6, 7, 8, 9, 10, 10, 10, 10,
448 12, 12, 12, 13, 16, 12, 15, 15, 15, 15,
449 12, 12, 12, 16, 16, 12, 11, 11, 14, 14,
450 3, 16, 16, 16, 16, 16, 16, 16, 16, 16,
454 static yyconst flex_int16_t yy_chk[42] =
456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 7, 7, 9, 18, 3, 9, 10, 10, 10, 10,
458 11, 11, 14, 0, 0, 14, 17, 17, 19, 19,
459 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
463 static yy_state_type yy_last_accepting_state;
464 static char *yy_last_accepting_cpos;
466 extern int yy_flex_debug;
467 int yy_flex_debug = 0;
472 #define REJECT reject_used_but_not_detected 473 #define yymore() yymore_used_but_not_detected 474 #define YY_MORE_ADJ 0 475 #define YY_RESTORE_YY_MORE_OFFSET 477 #line 1 "configfile.l" 513 #line 38 "configfile.l" 515 #include <sys/stat.h> 520 #include "configfile.h" 522 int evaluatetoken(
char *pcToken);
524 static int iLinenumber;
525 static int iOldLinenumber;
526 static char *pcPrevious;
527 static char *pcCurrent;
528 static char *pcFriendlyname;
529 static char *pcDevicename;
530 static char *pcLibpath;
531 static char *pcChannelid;
534 static int reader_list_size;
535 const char *ConfFile;
537 void tok_error(
char *pcToken_error);
539 #define YY_NO_INPUT 1 540 #line 541 "configfile.c" 544 #ifndef YY_NO_UNISTD_H 552 #ifndef YY_EXTRA_TYPE 553 #define YY_EXTRA_TYPE void * 556 static int yy_init_globals (
void );
561 int yylex_destroy (
void );
563 int yyget_debug (
void );
565 void yyset_debug (
int debug_flag );
567 YY_EXTRA_TYPE yyget_extra (
void );
569 void yyset_extra (YY_EXTRA_TYPE user_defined );
571 FILE *yyget_in (
void );
573 void yyset_in (FILE * _in_str );
575 FILE *yyget_out (
void );
577 void yyset_out (FILE * _out_str );
579 yy_size_t yyget_leng (
void );
581 char *yyget_text (
void );
583 int yyget_lineno (
void );
585 void yyset_lineno (
int _line_number );
591 #ifndef YY_SKIP_YYWRAP 593 extern "C" int yywrap (
void );
595 extern int yywrap (
void );
604 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
607 #ifdef YY_NEED_STRLEN 608 static int yy_flex_strlen (yyconst
char * );
614 static int yyinput (
void );
616 static int input (
void );
622 #ifndef YY_READ_BUF_SIZE 625 #define YY_READ_BUF_SIZE 16384 627 #define YY_READ_BUF_SIZE 8192 636 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 643 #define YY_INPUT(buf,result,max_size) \ 644 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 648 for ( n = 0; n < max_size && \ 649 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 652 buf[n++] = (char) c; \ 653 if ( c == EOF && ferror( yyin ) ) \ 654 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 660 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 662 if( errno != EINTR) \ 664 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 680 #define yyterminate() return YY_NULL 684 #ifndef YY_START_STACK_INCR 685 #define YY_START_STACK_INCR 25 689 #ifndef YY_FATAL_ERROR 690 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 699 #define YY_DECL_IS_OURS 1 701 extern int yylex (
void);
703 #define YY_DECL int yylex (void) 709 #ifndef YY_USER_ACTION 710 #define YY_USER_ACTION 715 #define YY_BREAK break; 718 #define YY_RULE_SETUP \ 725 yy_state_type yy_current_state;
746 if ( ! YY_CURRENT_BUFFER ) {
747 yyensure_buffer_stack ();
748 YY_CURRENT_BUFFER_LVALUE =
749 yy_create_buffer(yyin,YY_BUF_SIZE );
752 yy_load_buffer_state( );
756 #line 69 "configfile.l" 759 #line 760 "configfile.c" 763 yy_cp = (yy_c_buf_p);
766 *yy_cp = (yy_hold_char);
773 yy_current_state = (yy_start);
777 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
778 if ( yy_accept[yy_current_state] )
780 (yy_last_accepting_state) = yy_current_state;
781 (yy_last_accepting_cpos) = yy_cp;
783 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
785 yy_current_state = (int) yy_def[yy_current_state];
786 if ( yy_current_state >= 17 )
787 yy_c = yy_meta[(
unsigned int) yy_c];
789 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
792 while ( yy_base[yy_current_state] != 31 );
795 yy_act = yy_accept[yy_current_state];
798 yy_cp = (yy_last_accepting_cpos);
799 yy_current_state = (yy_last_accepting_state);
800 yy_act = yy_accept[yy_current_state];
811 *yy_cp = (yy_hold_char);
812 yy_cp = (yy_last_accepting_cpos);
813 yy_current_state = (yy_last_accepting_state);
818 #line 71 "configfile.l" 824 #line 72 "configfile.l" 830 #line 73 "configfile.l" 831 { (void)evaluatetoken(yytext); }
835 #line 74 "configfile.l" 840 #line 75 "configfile.l" 841 { (void)evaluatetoken(yytext); }
845 #line 76 "configfile.l" 846 { iOldLinenumber = iLinenumber; tok_error(yytext); }
850 #line 77 "configfile.l" 853 #line 854 "configfile.c" 854 case YY_STATE_EOF(INITIAL):
857 case YY_END_OF_BUFFER:
860 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
863 *yy_cp = (yy_hold_char);
864 YY_RESTORE_YY_MORE_OFFSET
866 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
877 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
878 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
879 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
889 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
891 yy_state_type yy_next_state;
893 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
895 yy_current_state = yy_get_previous_state( );
906 yy_next_state = yy_try_NUL_trans( yy_current_state );
908 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
913 yy_cp = ++(yy_c_buf_p);
914 yy_current_state = yy_next_state;
920 yy_cp = (yy_c_buf_p);
925 else switch ( yy_get_next_buffer( ) )
927 case EOB_ACT_END_OF_FILE:
929 (yy_did_buffer_switch_on_eof) = 0;
942 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
944 yy_act = YY_STATE_EOF(YY_START);
950 if ( ! (yy_did_buffer_switch_on_eof) )
956 case EOB_ACT_CONTINUE_SCAN:
958 (yytext_ptr) + yy_amount_of_matched_text;
960 yy_current_state = yy_get_previous_state( );
962 yy_cp = (yy_c_buf_p);
963 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
966 case EOB_ACT_LAST_MATCH:
968 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
970 yy_current_state = yy_get_previous_state( );
972 yy_cp = (yy_c_buf_p);
973 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
981 "fatal flex scanner internal error--no action found" );
994 static int yy_get_next_buffer (
void)
996 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
997 char *source = (yytext_ptr);
998 yy_size_t number_to_move, i;
1001 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1003 "fatal flex scanner internal error--end of buffer missed" );
1005 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1007 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1012 return EOB_ACT_END_OF_FILE;
1020 return EOB_ACT_LAST_MATCH;
1027 number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1029 for ( i = 0; i < number_to_move; ++i )
1030 *(dest++) = *(source++);
1032 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1036 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1040 yy_size_t num_to_read =
1041 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1043 while ( num_to_read <= 0 )
1047 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1049 int yy_c_buf_p_offset =
1050 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1052 if ( b->yy_is_our_buffer )
1054 yy_size_t new_size = b->yy_buf_size * 2;
1056 if ( new_size <= 0 )
1057 b->yy_buf_size += b->yy_buf_size / 8;
1059 b->yy_buf_size *= 2;
1061 b->yy_ch_buf = (
char *)
1063 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1069 if ( ! b->yy_ch_buf )
1071 "fatal error - scanner input buffer overflow" );
1073 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1075 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1080 if ( num_to_read > YY_READ_BUF_SIZE )
1081 num_to_read = YY_READ_BUF_SIZE;
1084 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1085 (yy_n_chars), num_to_read );
1087 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1090 if ( (yy_n_chars) == 0 )
1092 if ( number_to_move == YY_MORE_ADJ )
1094 ret_val = EOB_ACT_END_OF_FILE;
1100 ret_val = EOB_ACT_LAST_MATCH;
1101 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1102 YY_BUFFER_EOF_PENDING;
1107 ret_val = EOB_ACT_CONTINUE_SCAN;
1109 if ((
int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1111 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1112 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1113 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1114 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1117 (yy_n_chars) += number_to_move;
1118 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1119 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1121 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1128 static yy_state_type yy_get_previous_state (
void)
1130 yy_state_type yy_current_state;
1133 yy_current_state = (yy_start);
1135 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1137 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1138 if ( yy_accept[yy_current_state] )
1140 (yy_last_accepting_state) = yy_current_state;
1141 (yy_last_accepting_cpos) = yy_cp;
1143 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1145 yy_current_state = (int) yy_def[yy_current_state];
1146 if ( yy_current_state >= 17 )
1147 yy_c = yy_meta[(
unsigned int) yy_c];
1149 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1152 return yy_current_state;
1160 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1163 char *yy_cp = (yy_c_buf_p);
1166 if ( yy_accept[yy_current_state] )
1168 (yy_last_accepting_state) = yy_current_state;
1169 (yy_last_accepting_cpos) = yy_cp;
1171 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1173 yy_current_state = (int) yy_def[yy_current_state];
1174 if ( yy_current_state >= 17 )
1175 yy_c = yy_meta[(
unsigned int) yy_c];
1177 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1178 yy_is_jam = (yy_current_state == 16);
1180 return yy_is_jam ? 0 : yy_current_state;
1189 static int yyinput (
void)
1191 static int input (
void)
1197 *(yy_c_buf_p) = (yy_hold_char);
1199 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1205 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1207 *(yy_c_buf_p) =
'\0';
1211 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1214 switch ( yy_get_next_buffer( ) )
1216 case EOB_ACT_LAST_MATCH:
1232 case EOB_ACT_END_OF_FILE:
1237 if ( ! (yy_did_buffer_switch_on_eof) )
1246 case EOB_ACT_CONTINUE_SCAN:
1247 (yy_c_buf_p) = (yytext_ptr) + offset;
1253 c = *(
unsigned char *) (yy_c_buf_p);
1254 *(yy_c_buf_p) =
'\0';
1255 (yy_hold_char) = *++(yy_c_buf_p);
1266 void yyrestart (FILE * input_file )
1269 if ( ! YY_CURRENT_BUFFER ){
1270 yyensure_buffer_stack ();
1271 YY_CURRENT_BUFFER_LVALUE =
1272 yy_create_buffer(yyin,YY_BUF_SIZE );
1275 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1276 yy_load_buffer_state( );
1283 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1291 yyensure_buffer_stack ();
1292 if ( YY_CURRENT_BUFFER == new_buffer )
1295 if ( YY_CURRENT_BUFFER )
1298 *(yy_c_buf_p) = (yy_hold_char);
1299 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1300 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1303 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1304 yy_load_buffer_state( );
1311 (yy_did_buffer_switch_on_eof) = 1;
1314 static void yy_load_buffer_state (
void)
1316 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1317 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1318 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1319 (yy_hold_char) = *(yy_c_buf_p);
1328 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size )
1334 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1336 b->yy_buf_size = (yy_size_t)size;
1341 b->yy_ch_buf = (
char *) yyalloc(b->yy_buf_size + 2 );
1342 if ( ! b->yy_ch_buf )
1343 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1345 b->yy_is_our_buffer = 1;
1347 yy_init_buffer(b,file );
1356 void yy_delete_buffer (YY_BUFFER_STATE b )
1362 if ( b == YY_CURRENT_BUFFER )
1363 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1365 if ( b->yy_is_our_buffer )
1366 yyfree((
void *) b->yy_ch_buf );
1368 yyfree((
void *) b );
1375 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1380 yy_flush_buffer(b );
1382 b->yy_input_file = file;
1383 b->yy_fill_buffer = 1;
1389 if (b != YY_CURRENT_BUFFER){
1394 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1403 void yy_flush_buffer (YY_BUFFER_STATE b )
1414 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1415 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1417 b->yy_buf_pos = &b->yy_ch_buf[0];
1420 b->yy_buffer_status = YY_BUFFER_NEW;
1422 if ( b == YY_CURRENT_BUFFER )
1423 yy_load_buffer_state( );
1432 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1434 if (new_buffer == NULL)
1437 yyensure_buffer_stack();
1440 if ( YY_CURRENT_BUFFER )
1443 *(yy_c_buf_p) = (yy_hold_char);
1444 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1445 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1449 if (YY_CURRENT_BUFFER)
1451 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1454 yy_load_buffer_state( );
1455 (yy_did_buffer_switch_on_eof) = 1;
1462 void yypop_buffer_state (
void)
1464 if (!YY_CURRENT_BUFFER)
1467 yy_delete_buffer(YY_CURRENT_BUFFER );
1468 YY_CURRENT_BUFFER_LVALUE = NULL;
1472 if (YY_CURRENT_BUFFER) {
1473 yy_load_buffer_state( );
1474 (yy_did_buffer_switch_on_eof) = 1;
1481 static void yyensure_buffer_stack (
void)
1483 yy_size_t num_to_alloc;
1485 if (!(yy_buffer_stack)) {
1495 if ( ! (yy_buffer_stack) )
1496 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1498 memset((yy_buffer_stack), 0, num_to_alloc *
sizeof(
struct yy_buffer_state*));
1508 yy_size_t grow_size = 8 ;
1515 if ( ! (yy_buffer_stack) )
1516 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1530 YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size )
1535 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1536 base[size-1] != YY_END_OF_BUFFER_CHAR )
1542 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1544 b->yy_buf_size = size - 2;
1545 b->yy_buf_pos = b->yy_ch_buf = base;
1546 b->yy_is_our_buffer = 0;
1547 b->yy_input_file = 0;
1548 b->yy_n_chars = b->yy_buf_size;
1549 b->yy_is_interactive = 0;
1551 b->yy_fill_buffer = 0;
1552 b->yy_buffer_status = YY_BUFFER_NEW;
1554 yy_switch_to_buffer(b );
1567 YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr )
1570 return yy_scan_bytes(yystr,strlen(yystr) );
1580 YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len )
1588 n = _yybytes_len + 2;
1589 buf = (
char *) yyalloc(n );
1591 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1593 for ( i = 0; i < _yybytes_len; ++i )
1594 buf[i] = yybytes[i];
1596 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1598 b = yy_scan_buffer(buf,n );
1600 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1605 b->yy_is_our_buffer = 1;
1610 #ifndef YY_EXIT_FAILURE 1611 #define YY_EXIT_FAILURE 2 1614 static void yy_fatal_error (yyconst
char* msg )
1616 (void) fprintf( stderr,
"%s\n", msg );
1617 exit( YY_EXIT_FAILURE );
1627 int yyless_macro_arg = (n); \ 1628 YY_LESS_LINENO(yyless_macro_arg);\ 1629 yytext[yyleng] = (yy_hold_char); \ 1630 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 1631 (yy_hold_char) = *(yy_c_buf_p); \ 1632 *(yy_c_buf_p) = '\0'; \ 1633 yyleng = yyless_macro_arg; \ 1642 int yyget_lineno (
void)
1651 FILE *yyget_in (
void)
1659 FILE *yyget_out (
void)
1667 yy_size_t yyget_leng (
void)
1676 char *yyget_text (
void)
1685 void yyset_lineno (
int _line_number )
1688 yylineno = _line_number;
1697 void yyset_in (FILE * _in_str )
1702 void yyset_out (FILE * _out_str )
1707 int yyget_debug (
void)
1709 return yy_flex_debug;
1712 void yyset_debug (
int _bdebug )
1714 yy_flex_debug = _bdebug ;
1717 static int yy_init_globals (
void)
1726 (yy_c_buf_p) = (
char *) 0;
1746 int yylex_destroy (
void)
1750 while(YY_CURRENT_BUFFER){
1751 yy_delete_buffer(YY_CURRENT_BUFFER );
1752 YY_CURRENT_BUFFER_LVALUE = NULL;
1753 yypop_buffer_state();
1757 yyfree((yy_buffer_stack) );
1772 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n )
1776 for ( i = 0; i < n; ++i )
1781 #ifdef YY_NEED_STRLEN 1782 static int yy_flex_strlen (yyconst
char * s )
1785 for ( n = 0; s[n]; ++n )
1792 void *yyalloc (yy_size_t size )
1794 return (
void *) malloc( size );
1797 void *yyrealloc (
void * ptr, yy_size_t size )
1807 return (
void *) realloc( (
char *) ptr, size );
1810 void yyfree (
void * ptr )
1812 free( (
char *) ptr );
1815 #define YYTABLES_NAME "yytables" 1817 #line 77 "configfile.l" 1833 int evaluatetoken(
char *pcToken)
1835 if (pcPrevious == NULL)
1837 pcPrevious = strdup(pcToken);
1838 iOldLinenumber = iLinenumber;
1843 if (iOldLinenumber != iLinenumber)
1845 tok_error(pcPrevious);
1846 pcPrevious = strdup(pcToken);
1847 iOldLinenumber = iLinenumber;
1851 pcCurrent = pcToken;
1852 if (strcmp(pcPrevious,
"FRIENDLYNAME") == 0)
1854 if (pcFriendlyname == NULL)
1858 pcFriendlyname = malloc(strlen(pcCurrent) + 1);
1859 for (n = 0, p = 0; n < strlen(pcCurrent); n++)
1861 if (pcCurrent[n] !=
'"')
1863 pcFriendlyname[p++] = pcCurrent[n];
1866 pcFriendlyname[p++] =
'\0';
1870 tok_error(pcPrevious);
1874 else if (strcmp(pcPrevious,
"DEVICENAME") == 0)
1876 if (pcDevicename == NULL)
1878 struct stat fStatBuf;
1880 pcDevicename = strdup(pcCurrent);
1881 if ((NULL == strchr(pcDevicename,
':'))
1882 && (stat(pcDevicename, &fStatBuf) != 0))
1884 Log3(PCSC_LOG_CRITICAL,
"Error with device %s: %s",
1885 pcDevicename, strerror(errno));
1886 Log1(PCSC_LOG_CRITICAL,
"You should remove the DEVICENAME line if your driver does not use this field");
1892 tok_error(pcPrevious);
1896 else if (strcmp(pcPrevious,
"LIBPATH") == 0)
1898 if (pcLibpath == NULL)
1900 struct stat fStatBuf;
1902 pcLibpath = strdup(pcCurrent);
1903 if (stat(pcLibpath, &fStatBuf) != 0)
1905 Log3(PCSC_LOG_CRITICAL,
"Error with library %s: %s",
1906 pcLibpath, strerror(errno));
1910 if (strstr(pcLibpath,
".bundle") != NULL)
1912 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1913 Log2(PCSC_LOG_ERROR,
"WARNING: USB drivers SHOULD NOT be declared in reader.conf: %s", pcLibpath);
1914 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1919 tok_error(pcPrevious);
1923 else if (strcmp(pcPrevious,
"CHANNELID") == 0)
1925 if (pcChannelid == NULL)
1926 pcChannelid = strdup(pcCurrent);
1929 tok_error(pcPrevious);
1935 tok_error(pcPrevious);
1946 if (pcFriendlyname && pcLibpath && badError != 1
1947 && (pcChannelid || pcDevicename))
1950 static char* defaultDeviceName = (
char *)
"";
1952 Log2(PCSC_LOG_DEBUG,
"Add reader: %s", pcFriendlyname);
1953 if (0 == reader_list_size)
1956 reader_list_size = 2;
1957 reader_list = malloc(reader_list_size *
sizeof(
SerialReader));
1962 reader_list = realloc(reader_list, reader_list_size *
1970 if (NULL == pcDevicename)
1971 pcDevicename = defaultDeviceName;
1974 channelId = strtoul(pcChannelid, NULL, 0);
1977 reader_list[reader_list_size-2].
pcFriendlyname = strdup(pcFriendlyname);
1978 reader_list[reader_list_size-2].
pcDevicename = strdup(pcDevicename);
1979 reader_list[reader_list_size-2].
pcLibpath = strdup(pcLibpath),
1980 reader_list[reader_list_size-2].
channelId = channelId;
1982 free(pcFriendlyname);
1983 pcFriendlyname = NULL;
1985 if (pcDevicename != defaultDeviceName)
1987 pcDevicename = NULL;
2000 void tok_error(
char *token_error)
2002 Log4(PCSC_LOG_ERROR,
"tok_error: invalid value line %d in %s: %s",
2003 iOldLinenumber, ConfFile, token_error);
2007 int DBGetReaderListDir(
const char *readerconf_dir,
2015 reader_list_size = 0;
2017 dir = opendir(readerconf_dir);
2021 struct dirent *direntry;
2023 Log2(PCSC_LOG_DEBUG,
"Parsing conf directory: %s", readerconf_dir);
2026 while ((direntry = readdir(dir)) != NULL)
2028 char filename[FILENAME_MAX];
2031 snprintf(filename,
sizeof(filename),
"%s/%s",
2032 readerconf_dir, direntry->d_name);
2035 #ifdef HAVE_STRUCT_DIRENT_D_TYPE 2036 if (direntry->d_type == DT_UNKNOWN)
2041 if (lstat(filename, &st) != 0)
2043 Log2(PCSC_LOG_DEBUG,
"Skipping non statable file: %s",
2048 if (!S_ISREG(st.st_mode))
2050 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2055 #ifdef HAVE_STRUCT_DIRENT_D_TYPE 2057 if (direntry->d_type != DT_REG)
2059 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2066 if (
'.' == direntry->d_name[0])
2068 Log2(PCSC_LOG_DEBUG,
"Skipping hidden file: %s",
2074 r = DBGetReaderList(filename, caller_reader_list);
2085 ret = DBGetReaderList(readerconf_dir, caller_reader_list);
2090 int DBGetReaderList(
const char *readerconf,
SerialReader **caller_reader_list)
2092 FILE *configFile = NULL;
2094 *caller_reader_list = NULL;
2097 ConfFile = readerconf;
2099 Log2(PCSC_LOG_DEBUG,
"Parsing conf file: %s", ConfFile);
2101 configFile = fopen(readerconf,
"r");
2103 if (configFile == NULL)
2110 iOldLinenumber = -1;
2111 pcFriendlyname = NULL;
2112 pcDevicename = NULL;
2123 while (!feof(configFile));
2126 (void)fclose(configFile);
2128 *caller_reader_list = reader_list;
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
int yy_bs_column
The column count.
This handles abstract system level calls.
static size_t yy_buffer_stack_max
capacity of stack.
This keeps a list of defines for pcsc-lite.
This keeps a list of Windows(R) types.
This keeps a list of defines for pcsc-lite.
YY_DECL
The main scanner function which does all the work.
This keeps track of a list of currently available reader structures.
static size_t yy_buffer_stack_top
index of top of stack.
char * pcDevicename
DEVICENAME.
char * pcFriendlyname
FRIENDLYNAME.
int yy_bs_lineno
The line count.