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 1 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) 93 #if defined(__GNUC__) && __GNUC__ >= 3 94 #define yynoreturn __attribute__((__noreturn__)) 107 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 113 #define BEGIN (yy_start) = 1 + 2 * 119 #define YY_START (((yy_start) - 1) / 2) 120 #define YYSTATE YY_START 123 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 126 #define YY_NEW_FILE yyrestart(yyin ) 128 #define YY_END_OF_BUFFER_CHAR 0 137 #define YY_BUF_SIZE 32768 139 #define YY_BUF_SIZE 16384 145 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 147 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 148 #define YY_TYPEDEF_YY_BUFFER_STATE 152 #ifndef YY_TYPEDEF_YY_SIZE_T 153 #define YY_TYPEDEF_YY_SIZE_T 154 typedef size_t yy_size_t;
159 extern FILE *yyin, *yyout;
161 #define EOB_ACT_CONTINUE_SCAN 0 162 #define EOB_ACT_END_OF_FILE 1 163 #define EOB_ACT_LAST_MATCH 2 165 #define YY_LESS_LINENO(n) 166 #define YY_LINENO_REWIND_TO(ptr) 173 int yyless_macro_arg = (n); \ 174 YY_LESS_LINENO(yyless_macro_arg);\ 175 *yy_cp = (yy_hold_char); \ 176 YY_RESTORE_YY_MORE_OFFSET \ 177 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 178 YY_DO_BEFORE_ACTION; \ 182 #define unput(c) yyunput( c, (yytext_ptr) ) 184 #ifndef YY_STRUCT_YY_BUFFER_STATE 185 #define YY_STRUCT_YY_BUFFER_STATE 207 int yy_is_our_buffer;
214 int yy_is_interactive;
230 int yy_buffer_status;
232 #define YY_BUFFER_NEW 0 233 #define YY_BUFFER_NORMAL 1 244 #define YY_BUFFER_EOF_PENDING 2 260 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 261 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 267 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 270 static char yy_hold_char;
271 static int yy_n_chars;
275 static char *yy_c_buf_p = NULL;
276 static int yy_init = 0;
277 static int yy_start = 0;
282 static int yy_did_buffer_switch_on_eof;
284 void yyrestart (FILE *input_file );
290 void yypop_buffer_state (
void );
292 static void yyensure_buffer_stack (
void );
293 static void yy_load_buffer_state (
void );
296 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 302 void *yyalloc (yy_size_t );
303 void *yyrealloc (
void *,yy_size_t );
304 void yyfree (
void * );
306 #define yy_new_buffer yy_create_buffer 308 #define yy_set_interactive(is_interactive) \ 310 if ( ! YY_CURRENT_BUFFER ){ \ 311 yyensure_buffer_stack (); \ 312 YY_CURRENT_BUFFER_LVALUE = \ 313 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 315 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 318 #define yy_set_bol(at_bol) \ 320 if ( ! YY_CURRENT_BUFFER ){\ 321 yyensure_buffer_stack (); \ 322 YY_CURRENT_BUFFER_LVALUE = \ 323 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 325 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 328 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 333 #define YY_SKIP_YYWRAP 335 typedef unsigned char YY_CHAR;
337 FILE *yyin = NULL, *yyout = NULL;
339 typedef int yy_state_type;
349 #define yytext_ptr yytext 351 static yy_state_type yy_get_previous_state (
void );
352 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
353 static int yy_get_next_buffer (
void );
354 static void yynoreturn yy_fatal_error (yyconst
char* msg );
359 #define YY_DO_BEFORE_ACTION \ 360 (yytext_ptr) = yy_bp; \ 361 yyleng = (int) (yy_cp - yy_bp); \ 362 (yy_hold_char) = *yy_cp; \ 364 (yy_c_buf_p) = yy_cp; 366 #define YY_NUM_RULES 7 367 #define YY_END_OF_BUFFER 8 372 flex_int32_t yy_verify;
375 static yyconst flex_int16_t yy_accept[17] =
377 0, 0, 8, 6, 4, 2, 6, 1, 6, 5,
381 static yyconst YY_CHAR yy_ec[256] =
383 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 2, 1, 4, 5, 1, 1, 1, 6, 1,
387 1, 1, 1, 1, 7, 7, 7, 8, 8, 8,
388 8, 8, 8, 8, 8, 8, 8, 7, 1, 1,
389 1, 1, 1, 7, 9, 9, 9, 9, 9, 9,
390 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
391 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
392 1, 7, 1, 1, 7, 1, 10, 10, 10, 10,
394 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
395 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
396 10, 10, 1, 1, 1, 1, 1, 1, 1, 1,
397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 static yyconst YY_CHAR yy_meta[11] =
415 1, 1, 2, 1, 1, 1, 1, 1, 1, 1
418 static yyconst flex_uint16_t yy_base[20] =
420 0, 0, 15, 31, 31, 31, 8, 0, 10, 10,
421 18, 31, 0, 20, 0, 31, 26, 13, 28
424 static yyconst flex_int16_t yy_def[20] =
426 16, 1, 16, 16, 16, 16, 17, 18, 19, 16,
427 17, 16, 18, 19, 10, 0, 16, 16, 16
430 static yyconst flex_uint16_t yy_nxt[42] =
432 4, 5, 6, 7, 8, 9, 10, 10, 10, 10,
433 12, 12, 12, 13, 16, 12, 15, 15, 15, 15,
434 12, 12, 12, 16, 16, 12, 11, 11, 14, 14,
435 3, 16, 16, 16, 16, 16, 16, 16, 16, 16,
439 static yyconst flex_int16_t yy_chk[42] =
441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442 7, 7, 9, 18, 3, 9, 10, 10, 10, 10,
443 11, 11, 14, 0, 0, 14, 17, 17, 19, 19,
444 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
448 static yy_state_type yy_last_accepting_state;
449 static char *yy_last_accepting_cpos;
451 extern int yy_flex_debug;
452 int yy_flex_debug = 0;
457 #define REJECT reject_used_but_not_detected 458 #define yymore() yymore_used_but_not_detected 459 #define YY_MORE_ADJ 0 460 #define YY_RESTORE_YY_MORE_OFFSET 462 #line 1 "configfile.l" 498 #line 38 "configfile.l" 500 #include <sys/stat.h> 505 #include "configfile.h" 507 int evaluatetoken(
char *pcToken);
509 static int iLinenumber;
510 static int iOldLinenumber;
511 static char *pcPrevious;
512 static char *pcCurrent;
513 static char *pcFriendlyname;
514 static char *pcDevicename;
515 static char *pcLibpath;
516 static char *pcChannelid;
519 static int reader_list_size;
520 const char *ConfFile;
522 void tok_error(
char *pcToken_error);
524 #define YY_NO_INPUT 1 525 #line 526 "configfile.c" 529 #ifndef YY_NO_UNISTD_H 537 #ifndef YY_EXTRA_TYPE 538 #define YY_EXTRA_TYPE void * 541 static int yy_init_globals (
void );
546 int yylex_destroy (
void );
548 int yyget_debug (
void );
550 void yyset_debug (
int debug_flag );
552 YY_EXTRA_TYPE yyget_extra (
void );
554 void yyset_extra (YY_EXTRA_TYPE user_defined );
556 FILE *yyget_in (
void );
558 void yyset_in (FILE * _in_str );
560 FILE *yyget_out (
void );
562 void yyset_out (FILE * _out_str );
564 int yyget_leng (
void );
566 char *yyget_text (
void );
568 int yyget_lineno (
void );
570 void yyset_lineno (
int _line_number );
576 #ifndef YY_SKIP_YYWRAP 578 extern "C" int yywrap (
void );
580 extern int yywrap (
void );
589 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
592 #ifdef YY_NEED_STRLEN 593 static int yy_flex_strlen (yyconst
char * );
599 static int yyinput (
void );
601 static int input (
void );
607 #ifndef YY_READ_BUF_SIZE 610 #define YY_READ_BUF_SIZE 16384 612 #define YY_READ_BUF_SIZE 8192 621 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) 628 #define YY_INPUT(buf,result,max_size) \ 629 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 633 for ( n = 0; n < max_size && \ 634 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 637 buf[n++] = (char) c; \ 638 if ( c == EOF && ferror( yyin ) ) \ 639 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 645 while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 647 if( errno != EINTR) \ 649 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 665 #define yyterminate() return YY_NULL 669 #ifndef YY_START_STACK_INCR 670 #define YY_START_STACK_INCR 25 674 #ifndef YY_FATAL_ERROR 675 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 684 #define YY_DECL_IS_OURS 1 686 extern int yylex (
void);
688 #define YY_DECL int yylex (void) 694 #ifndef YY_USER_ACTION 695 #define YY_USER_ACTION 700 #define YY_BREAK break; 703 #define YY_RULE_SETUP \ 710 yy_state_type yy_current_state;
731 if ( ! YY_CURRENT_BUFFER ) {
732 yyensure_buffer_stack ();
733 YY_CURRENT_BUFFER_LVALUE =
734 yy_create_buffer(yyin,YY_BUF_SIZE );
737 yy_load_buffer_state( );
741 #line 69 "configfile.l" 744 #line 745 "configfile.c" 748 yy_cp = (yy_c_buf_p);
751 *yy_cp = (yy_hold_char);
758 yy_current_state = (yy_start);
762 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
763 if ( yy_accept[yy_current_state] )
765 (yy_last_accepting_state) = yy_current_state;
766 (yy_last_accepting_cpos) = yy_cp;
768 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
770 yy_current_state = (int) yy_def[yy_current_state];
771 if ( yy_current_state >= 17 )
772 yy_c = yy_meta[(
unsigned int) yy_c];
774 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
777 while ( yy_base[yy_current_state] != 31 );
780 yy_act = yy_accept[yy_current_state];
783 yy_cp = (yy_last_accepting_cpos);
784 yy_current_state = (yy_last_accepting_state);
785 yy_act = yy_accept[yy_current_state];
796 *yy_cp = (yy_hold_char);
797 yy_cp = (yy_last_accepting_cpos);
798 yy_current_state = (yy_last_accepting_state);
803 #line 71 "configfile.l" 809 #line 72 "configfile.l" 815 #line 73 "configfile.l" 816 { (void)evaluatetoken(yytext); }
820 #line 74 "configfile.l" 825 #line 75 "configfile.l" 826 { (void)evaluatetoken(yytext); }
830 #line 76 "configfile.l" 831 { iOldLinenumber = iLinenumber; tok_error(yytext); }
835 #line 77 "configfile.l" 838 #line 839 "configfile.c" 839 case YY_STATE_EOF(INITIAL):
842 case YY_END_OF_BUFFER:
845 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
848 *yy_cp = (yy_hold_char);
849 YY_RESTORE_YY_MORE_OFFSET
851 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
862 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
863 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
864 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
874 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
876 yy_state_type yy_next_state;
878 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
880 yy_current_state = yy_get_previous_state( );
891 yy_next_state = yy_try_NUL_trans( yy_current_state );
893 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
898 yy_cp = ++(yy_c_buf_p);
899 yy_current_state = yy_next_state;
905 yy_cp = (yy_c_buf_p);
910 else switch ( yy_get_next_buffer( ) )
912 case EOB_ACT_END_OF_FILE:
914 (yy_did_buffer_switch_on_eof) = 0;
927 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
929 yy_act = YY_STATE_EOF(YY_START);
935 if ( ! (yy_did_buffer_switch_on_eof) )
941 case EOB_ACT_CONTINUE_SCAN:
943 (yytext_ptr) + yy_amount_of_matched_text;
945 yy_current_state = yy_get_previous_state( );
947 yy_cp = (yy_c_buf_p);
948 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
951 case EOB_ACT_LAST_MATCH:
953 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
955 yy_current_state = yy_get_previous_state( );
957 yy_cp = (yy_c_buf_p);
958 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
966 "fatal flex scanner internal error--no action found" );
979 static int yy_get_next_buffer (
void)
981 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
982 char *source = (yytext_ptr);
983 int number_to_move, i;
986 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
988 "fatal flex scanner internal error--end of buffer missed" );
990 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
992 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
997 return EOB_ACT_END_OF_FILE;
1005 return EOB_ACT_LAST_MATCH;
1012 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1014 for ( i = 0; i < number_to_move; ++i )
1015 *(dest++) = *(source++);
1017 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1021 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1026 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1028 while ( num_to_read <= 0 )
1034 int yy_c_buf_p_offset =
1035 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1037 if ( b->yy_is_our_buffer )
1039 int new_size = b->yy_buf_size * 2;
1041 if ( new_size <= 0 )
1042 b->yy_buf_size += b->yy_buf_size / 8;
1044 b->yy_buf_size *= 2;
1046 b->yy_ch_buf = (
char *)
1048 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1052 b->yy_ch_buf = NULL;
1054 if ( ! b->yy_ch_buf )
1056 "fatal error - scanner input buffer overflow" );
1058 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1060 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1065 if ( num_to_read > YY_READ_BUF_SIZE )
1066 num_to_read = YY_READ_BUF_SIZE;
1069 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1070 (yy_n_chars), num_to_read );
1072 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1075 if ( (yy_n_chars) == 0 )
1077 if ( number_to_move == YY_MORE_ADJ )
1079 ret_val = EOB_ACT_END_OF_FILE;
1085 ret_val = EOB_ACT_LAST_MATCH;
1086 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1087 YY_BUFFER_EOF_PENDING;
1092 ret_val = EOB_ACT_CONTINUE_SCAN;
1094 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1096 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1097 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1098 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1099 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1102 (yy_n_chars) += number_to_move;
1103 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1104 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1106 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1113 static yy_state_type yy_get_previous_state (
void)
1115 yy_state_type yy_current_state;
1118 yy_current_state = (yy_start);
1120 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1122 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1123 if ( yy_accept[yy_current_state] )
1125 (yy_last_accepting_state) = yy_current_state;
1126 (yy_last_accepting_cpos) = yy_cp;
1128 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1130 yy_current_state = (int) yy_def[yy_current_state];
1131 if ( yy_current_state >= 17 )
1132 yy_c = yy_meta[(
unsigned int) yy_c];
1134 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1137 return yy_current_state;
1145 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1148 char *yy_cp = (yy_c_buf_p);
1151 if ( yy_accept[yy_current_state] )
1153 (yy_last_accepting_state) = yy_current_state;
1154 (yy_last_accepting_cpos) = yy_cp;
1156 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1158 yy_current_state = (int) yy_def[yy_current_state];
1159 if ( yy_current_state >= 17 )
1160 yy_c = yy_meta[(
unsigned int) yy_c];
1162 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1163 yy_is_jam = (yy_current_state == 16);
1165 return yy_is_jam ? 0 : yy_current_state;
1174 static int yyinput (
void)
1176 static int input (
void)
1182 *(yy_c_buf_p) = (yy_hold_char);
1184 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1190 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1192 *(yy_c_buf_p) =
'\0';
1196 int offset = (yy_c_buf_p) - (yytext_ptr);
1199 switch ( yy_get_next_buffer( ) )
1201 case EOB_ACT_LAST_MATCH:
1217 case EOB_ACT_END_OF_FILE:
1222 if ( ! (yy_did_buffer_switch_on_eof) )
1231 case EOB_ACT_CONTINUE_SCAN:
1232 (yy_c_buf_p) = (yytext_ptr) + offset;
1238 c = *(
unsigned char *) (yy_c_buf_p);
1239 *(yy_c_buf_p) =
'\0';
1240 (yy_hold_char) = *++(yy_c_buf_p);
1251 void yyrestart (FILE * input_file )
1254 if ( ! YY_CURRENT_BUFFER ){
1255 yyensure_buffer_stack ();
1256 YY_CURRENT_BUFFER_LVALUE =
1257 yy_create_buffer(yyin,YY_BUF_SIZE );
1260 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1261 yy_load_buffer_state( );
1276 yyensure_buffer_stack ();
1277 if ( YY_CURRENT_BUFFER == new_buffer )
1280 if ( YY_CURRENT_BUFFER )
1283 *(yy_c_buf_p) = (yy_hold_char);
1284 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1285 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1288 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1289 yy_load_buffer_state( );
1296 (yy_did_buffer_switch_on_eof) = 1;
1299 static void yy_load_buffer_state (
void)
1301 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1302 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1303 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1304 (yy_hold_char) = *(yy_c_buf_p);
1319 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1321 b->yy_buf_size = (yy_size_t)size;
1326 b->yy_ch_buf = (
char *) yyalloc(b->yy_buf_size + 2 );
1327 if ( ! b->yy_ch_buf )
1328 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1330 b->yy_is_our_buffer = 1;
1332 yy_init_buffer(b,file );
1347 if ( b == YY_CURRENT_BUFFER )
1350 if ( b->yy_is_our_buffer )
1351 yyfree((
void *) b->yy_ch_buf );
1353 yyfree((
void *) b );
1365 yy_flush_buffer(b );
1367 b->yy_input_file = file;
1368 b->yy_fill_buffer = 1;
1374 if (b != YY_CURRENT_BUFFER){
1379 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1399 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1400 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1402 b->yy_buf_pos = &b->yy_ch_buf[0];
1405 b->yy_buffer_status = YY_BUFFER_NEW;
1407 if ( b == YY_CURRENT_BUFFER )
1408 yy_load_buffer_state( );
1419 if (new_buffer == NULL)
1422 yyensure_buffer_stack();
1425 if ( YY_CURRENT_BUFFER )
1428 *(yy_c_buf_p) = (yy_hold_char);
1429 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1430 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1434 if (YY_CURRENT_BUFFER)
1436 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1439 yy_load_buffer_state( );
1440 (yy_did_buffer_switch_on_eof) = 1;
1447 void yypop_buffer_state (
void)
1449 if (!YY_CURRENT_BUFFER)
1452 yy_delete_buffer(YY_CURRENT_BUFFER );
1453 YY_CURRENT_BUFFER_LVALUE = NULL;
1457 if (YY_CURRENT_BUFFER) {
1458 yy_load_buffer_state( );
1459 (yy_did_buffer_switch_on_eof) = 1;
1466 static void yyensure_buffer_stack (
void)
1481 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1493 yy_size_t grow_size = 8 ;
1501 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1520 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1521 base[size-1] != YY_END_OF_BUFFER_CHAR )
1527 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1529 b->yy_buf_size = size - 2;
1530 b->yy_buf_pos = b->yy_ch_buf = base;
1531 b->yy_is_our_buffer = 0;
1532 b->yy_input_file = NULL;
1533 b->yy_n_chars = b->yy_buf_size;
1534 b->yy_is_interactive = 0;
1536 b->yy_fill_buffer = 0;
1537 b->yy_buffer_status = YY_BUFFER_NEW;
1539 yy_switch_to_buffer(b );
1555 return yy_scan_bytes(yystr,(
int) strlen(yystr) );
1565 YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes,
int _yybytes_len )
1573 n = (yy_size_t) (_yybytes_len + 2);
1574 buf = (
char *) yyalloc(n );
1576 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1578 for ( i = 0; i < _yybytes_len; ++i )
1579 buf[i] = yybytes[i];
1581 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1583 b = yy_scan_buffer(buf,n );
1585 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1590 b->yy_is_our_buffer = 1;
1595 #ifndef YY_EXIT_FAILURE 1596 #define YY_EXIT_FAILURE 2 1599 static void yynoreturn yy_fatal_error (yyconst
char* msg )
1601 (void) fprintf( stderr,
"%s\n", msg );
1602 exit( YY_EXIT_FAILURE );
1612 int yyless_macro_arg = (n); \ 1613 YY_LESS_LINENO(yyless_macro_arg);\ 1614 yytext[yyleng] = (yy_hold_char); \ 1615 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 1616 (yy_hold_char) = *(yy_c_buf_p); \ 1617 *(yy_c_buf_p) = '\0'; \ 1618 yyleng = yyless_macro_arg; \ 1627 int yyget_lineno (
void)
1636 FILE *yyget_in (
void)
1644 FILE *yyget_out (
void)
1652 int yyget_leng (
void)
1661 char *yyget_text (
void)
1670 void yyset_lineno (
int _line_number )
1673 yylineno = _line_number;
1682 void yyset_in (FILE * _in_str )
1687 void yyset_out (FILE * _out_str )
1692 int yyget_debug (
void)
1694 return yy_flex_debug;
1697 void yyset_debug (
int _bdebug )
1699 yy_flex_debug = _bdebug ;
1702 static int yy_init_globals (
void)
1711 (yy_c_buf_p) = NULL;
1731 int yylex_destroy (
void)
1735 while(YY_CURRENT_BUFFER){
1736 yy_delete_buffer(YY_CURRENT_BUFFER );
1737 YY_CURRENT_BUFFER_LVALUE = NULL;
1738 yypop_buffer_state();
1757 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n )
1761 for ( i = 0; i < n; ++i )
1766 #ifdef YY_NEED_STRLEN 1767 static int yy_flex_strlen (yyconst
char * s )
1770 for ( n = 0; s[n]; ++n )
1777 void *yyalloc (yy_size_t size )
1779 return malloc(size);
1782 void *yyrealloc (
void * ptr, yy_size_t size )
1792 return realloc(ptr, size);
1795 void yyfree (
void * ptr )
1797 free( (
char *) ptr );
1800 #define YYTABLES_NAME "yytables" 1802 #line 77 "configfile.l" 1818 int evaluatetoken(
char *pcToken)
1820 if (pcPrevious == NULL)
1822 pcPrevious = strdup(pcToken);
1823 iOldLinenumber = iLinenumber;
1828 if (iOldLinenumber != iLinenumber)
1830 tok_error(pcPrevious);
1831 pcPrevious = strdup(pcToken);
1832 iOldLinenumber = iLinenumber;
1836 pcCurrent = pcToken;
1837 if (strcmp(pcPrevious,
"FRIENDLYNAME") == 0)
1839 if (pcFriendlyname == NULL)
1843 pcFriendlyname = malloc(strlen(pcCurrent) + 1);
1844 for (n = 0, p = 0; n < strlen(pcCurrent); n++)
1846 if (pcCurrent[n] !=
'"')
1848 pcFriendlyname[p++] = pcCurrent[n];
1851 pcFriendlyname[p++] =
'\0';
1855 tok_error(pcPrevious);
1859 else if (strcmp(pcPrevious,
"DEVICENAME") == 0)
1861 if (pcDevicename == NULL)
1863 struct stat fStatBuf;
1865 pcDevicename = strdup(pcCurrent);
1866 if ((NULL == strchr(pcDevicename,
':'))
1867 && (stat(pcDevicename, &fStatBuf) != 0))
1869 Log3(PCSC_LOG_CRITICAL,
"Error with device %s: %s",
1870 pcDevicename, strerror(errno));
1871 Log1(PCSC_LOG_CRITICAL,
"You should remove the DEVICENAME line if your driver does not use this field");
1877 tok_error(pcPrevious);
1881 else if (strcmp(pcPrevious,
"LIBPATH") == 0)
1883 if (pcLibpath == NULL)
1885 struct stat fStatBuf;
1887 pcLibpath = strdup(pcCurrent);
1888 if (stat(pcLibpath, &fStatBuf) != 0)
1890 Log3(PCSC_LOG_CRITICAL,
"Error with library %s: %s",
1891 pcLibpath, strerror(errno));
1895 if (strstr(pcLibpath,
".bundle") != NULL)
1897 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1898 Log2(PCSC_LOG_ERROR,
"WARNING: USB drivers SHOULD NOT be declared in reader.conf: %s", pcLibpath);
1899 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1904 tok_error(pcPrevious);
1908 else if (strcmp(pcPrevious,
"CHANNELID") == 0)
1910 if (pcChannelid == NULL)
1911 pcChannelid = strdup(pcCurrent);
1914 tok_error(pcPrevious);
1920 tok_error(pcPrevious);
1931 if (pcFriendlyname && pcLibpath && badError != 1
1932 && (pcChannelid || pcDevicename))
1935 static char* defaultDeviceName = (
char *)
"";
1937 Log2(PCSC_LOG_DEBUG,
"Add reader: %s", pcFriendlyname);
1938 if (0 == reader_list_size)
1941 reader_list_size = 2;
1942 reader_list = malloc(reader_list_size *
sizeof(
SerialReader));
1947 reader_list = realloc(reader_list, reader_list_size *
1955 if (NULL == pcDevicename)
1956 pcDevicename = defaultDeviceName;
1959 channelId = strtoul(pcChannelid, NULL, 0);
1962 reader_list[reader_list_size-2].
pcFriendlyname = strdup(pcFriendlyname);
1963 reader_list[reader_list_size-2].
pcDevicename = strdup(pcDevicename);
1964 reader_list[reader_list_size-2].
pcLibpath = strdup(pcLibpath),
1965 reader_list[reader_list_size-2].
channelId = channelId;
1967 free(pcFriendlyname);
1968 pcFriendlyname = NULL;
1970 if (pcDevicename != defaultDeviceName)
1972 pcDevicename = NULL;
1985 void tok_error(
char *token_error)
1990 Log4(PCSC_LOG_ERROR,
"tok_error: invalid value line %d in %s: %s",
1991 iOldLinenumber, ConfFile, token_error);
1995 int DBGetReaderListDir(
const char *readerconf_dir,
2003 reader_list_size = 0;
2005 dir = opendir(readerconf_dir);
2009 struct dirent *direntry;
2011 Log2(PCSC_LOG_DEBUG,
"Parsing conf directory: %s", readerconf_dir);
2014 while ((direntry = readdir(dir)) != NULL)
2016 char filename[FILENAME_MAX];
2019 snprintf(filename,
sizeof(filename),
"%s/%s",
2020 readerconf_dir, direntry->d_name);
2023 #ifdef HAVE_STRUCT_DIRENT_D_TYPE 2024 if (direntry->d_type == DT_UNKNOWN)
2029 if (lstat(filename, &st) != 0)
2031 Log2(PCSC_LOG_DEBUG,
"Skipping non statable file: %s",
2036 if (!S_ISREG(st.st_mode))
2038 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2043 #ifdef HAVE_STRUCT_DIRENT_D_TYPE 2045 if (direntry->d_type != DT_REG)
2047 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2054 if (
'.' == direntry->d_name[0])
2056 Log2(PCSC_LOG_DEBUG,
"Skipping hidden file: %s",
2062 r = DBGetReaderList(filename, caller_reader_list);
2073 ret = DBGetReaderList(readerconf_dir, caller_reader_list);
2078 int DBGetReaderList(
const char *readerconf,
SerialReader **caller_reader_list)
2080 FILE *configFile = NULL;
2082 *caller_reader_list = NULL;
2085 ConfFile = readerconf;
2087 Log2(PCSC_LOG_DEBUG,
"Parsing conf file: %s", ConfFile);
2089 configFile = fopen(readerconf,
"r");
2091 if (configFile == NULL)
2098 iOldLinenumber = -1;
2099 pcFriendlyname = NULL;
2100 pcDevicename = NULL;
2111 while (!feof(configFile));
2114 (void)fclose(configFile);
2116 *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.