4 #define YY_INT_ALIGNED short int
9 #define YY_FLEX_MAJOR_VERSION 2
10 #define YY_FLEX_MINOR_VERSION 5
11 #define YY_FLEX_SUBMINOR_VERSION 39
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;
213 yy_size_t yy_n_chars;
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 yy_size_t 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;
358 #define yytext_ptr yytext
360 static yy_state_type yy_get_previous_state (
void );
361 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
362 static int yy_get_next_buffer (
void );
363 static void yy_fatal_error (yyconst
char msg[] );
368 #define YY_DO_BEFORE_ACTION \
369 (yytext_ptr) = yy_bp; \
370 yyleng = (size_t) (yy_cp - yy_bp); \
371 (yy_hold_char) = *yy_cp; \
373 (yy_c_buf_p) = yy_cp;
375 #define YY_NUM_RULES 7
376 #define YY_END_OF_BUFFER 8
381 flex_int32_t yy_verify;
384 static yyconst flex_int16_t yy_accept[17] =
386 0, 0, 8, 6, 4, 2, 6, 1, 6, 5,
390 static yyconst flex_int32_t yy_ec[256] =
392 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 1, 2, 1, 4, 5, 1, 1, 1, 6, 1,
396 1, 1, 1, 1, 7, 7, 7, 8, 8, 8,
397 8, 8, 8, 8, 8, 8, 8, 7, 1, 1,
398 1, 1, 1, 7, 9, 9, 9, 9, 9, 9,
399 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
400 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
401 1, 7, 1, 1, 7, 1, 10, 10, 10, 10,
403 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
404 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
405 10, 10, 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,
410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
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,
422 static yyconst flex_int32_t yy_meta[11] =
424 1, 1, 2, 1, 1, 1, 1, 1, 1, 1
427 static yyconst flex_int16_t yy_base[20] =
429 0, 0, 15, 31, 31, 31, 8, 0, 10, 10,
430 18, 31, 0, 20, 0, 31, 26, 13, 28
433 static yyconst flex_int16_t yy_def[20] =
435 16, 1, 16, 16, 16, 16, 17, 18, 19, 16,
436 17, 16, 18, 19, 10, 0, 16, 16, 16
439 static yyconst flex_int16_t yy_nxt[42] =
441 4, 5, 6, 7, 8, 9, 10, 10, 10, 10,
442 12, 12, 12, 13, 16, 12, 15, 15, 15, 15,
443 12, 12, 12, 16, 16, 12, 11, 11, 14, 14,
444 3, 16, 16, 16, 16, 16, 16, 16, 16, 16,
448 static yyconst flex_int16_t yy_chk[42] =
450 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
451 7, 7, 9, 18, 3, 9, 10, 10, 10, 10,
452 11, 11, 14, 0, 0, 14, 17, 17, 19, 19,
453 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
457 static yy_state_type yy_last_accepting_state;
458 static char *yy_last_accepting_cpos;
460 extern int yy_flex_debug;
461 int yy_flex_debug = 0;
466 #define REJECT reject_used_but_not_detected
467 #define yymore() yymore_used_but_not_detected
468 #define YY_MORE_ADJ 0
469 #define YY_RESTORE_YY_MORE_OFFSET
471 #line 1 "configfile.l"
507 #line 38 "configfile.l"
509 #include <sys/stat.h>
514 #include "configfile.h"
516 int evaluatetoken(
char *pcToken);
518 static int iLinenumber;
519 static int iOldLinenumber;
520 static char *pcPrevious;
521 static char *pcCurrent;
522 static char *pcFriendlyname;
523 static char *pcDevicename;
524 static char *pcLibpath;
525 static char *pcChannelid;
528 static int reader_list_size;
529 const char *ConfFile;
531 void tok_error(
char *pcToken_error);
533 #define YY_NO_INPUT 1
534 #line 535 "configfile.c"
538 #ifndef YY_NO_UNISTD_H
546 #ifndef YY_EXTRA_TYPE
547 #define YY_EXTRA_TYPE void *
550 static int yy_init_globals (
void );
555 int yylex_destroy (
void );
557 int yyget_debug (
void );
559 void yyset_debug (
int debug_flag );
561 YY_EXTRA_TYPE yyget_extra (
void );
563 void yyset_extra (YY_EXTRA_TYPE user_defined );
565 FILE *yyget_in (
void );
567 void yyset_in (FILE * in_str );
569 FILE *yyget_out (
void );
571 void yyset_out (FILE * out_str );
573 yy_size_t yyget_leng (
void );
575 char *yyget_text (
void );
577 int yyget_lineno (
void );
579 void yyset_lineno (
int line_number );
585 #ifndef YY_SKIP_YYWRAP
587 extern "C" int yywrap (
void );
589 extern int yywrap (
void );
594 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
597 #ifdef YY_NEED_STRLEN
598 static int yy_flex_strlen (yyconst
char * );
604 static int yyinput (
void );
606 static int input (
void );
612 #ifndef YY_READ_BUF_SIZE
615 #define YY_READ_BUF_SIZE 16384
617 #define YY_READ_BUF_SIZE 8192
626 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
633 #define YY_INPUT(buf,result,max_size) \
634 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
638 for ( n = 0; n < max_size && \
639 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
642 buf[n++] = (char) c; \
643 if ( c == EOF && ferror( yyin ) ) \
644 YY_FATAL_ERROR( "input in flex scanner failed" ); \
650 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
652 if( errno != EINTR) \
654 YY_FATAL_ERROR( "input in flex scanner failed" ); \
670 #define yyterminate() return YY_NULL
674 #ifndef YY_START_STACK_INCR
675 #define YY_START_STACK_INCR 25
679 #ifndef YY_FATAL_ERROR
680 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
689 #define YY_DECL_IS_OURS 1
691 extern int yylex (
void);
693 #define YY_DECL int yylex (void)
699 #ifndef YY_USER_ACTION
700 #define YY_USER_ACTION
705 #define YY_BREAK break;
708 #define YY_RULE_SETUP \
715 register yy_state_type yy_current_state;
716 register char *yy_cp, *yy_bp;
736 if ( ! YY_CURRENT_BUFFER ) {
737 yyensure_buffer_stack ();
738 YY_CURRENT_BUFFER_LVALUE =
739 yy_create_buffer(yyin,YY_BUF_SIZE );
742 yy_load_buffer_state( );
746 #line 69 "configfile.l"
749 #line 750 "configfile.c"
753 yy_cp = (yy_c_buf_p);
756 *yy_cp = (yy_hold_char);
763 yy_current_state = (yy_start);
767 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
768 if ( yy_accept[yy_current_state] )
770 (yy_last_accepting_state) = yy_current_state;
771 (yy_last_accepting_cpos) = yy_cp;
773 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
775 yy_current_state = (int) yy_def[yy_current_state];
776 if ( yy_current_state >= 17 )
777 yy_c = yy_meta[(
unsigned int) yy_c];
779 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
782 while ( yy_base[yy_current_state] != 31 );
785 yy_act = yy_accept[yy_current_state];
788 yy_cp = (yy_last_accepting_cpos);
789 yy_current_state = (yy_last_accepting_state);
790 yy_act = yy_accept[yy_current_state];
801 *yy_cp = (yy_hold_char);
802 yy_cp = (yy_last_accepting_cpos);
803 yy_current_state = (yy_last_accepting_state);
808 #line 71 "configfile.l"
814 #line 72 "configfile.l"
820 #line 73 "configfile.l"
821 { (void)evaluatetoken(yytext); }
825 #line 74 "configfile.l"
830 #line 75 "configfile.l"
831 { (void)evaluatetoken(yytext); }
835 #line 76 "configfile.l"
836 { iOldLinenumber = iLinenumber; tok_error(yytext); }
840 #line 77 "configfile.l"
843 #line 844 "configfile.c"
844 case YY_STATE_EOF(INITIAL):
847 case YY_END_OF_BUFFER:
850 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
853 *yy_cp = (yy_hold_char);
854 YY_RESTORE_YY_MORE_OFFSET
856 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
867 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
868 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
869 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
879 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
881 yy_state_type yy_next_state;
883 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
885 yy_current_state = yy_get_previous_state( );
896 yy_next_state = yy_try_NUL_trans( yy_current_state );
898 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
903 yy_cp = ++(yy_c_buf_p);
904 yy_current_state = yy_next_state;
910 yy_cp = (yy_c_buf_p);
915 else switch ( yy_get_next_buffer( ) )
917 case EOB_ACT_END_OF_FILE:
919 (yy_did_buffer_switch_on_eof) = 0;
932 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
934 yy_act = YY_STATE_EOF(YY_START);
940 if ( ! (yy_did_buffer_switch_on_eof) )
946 case EOB_ACT_CONTINUE_SCAN:
948 (yytext_ptr) + yy_amount_of_matched_text;
950 yy_current_state = yy_get_previous_state( );
952 yy_cp = (yy_c_buf_p);
953 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
956 case EOB_ACT_LAST_MATCH:
958 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
960 yy_current_state = yy_get_previous_state( );
962 yy_cp = (yy_c_buf_p);
963 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
971 "fatal flex scanner internal error--no action found" );
984 static int yy_get_next_buffer (
void)
986 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
987 register char *source = (yytext_ptr);
988 register int number_to_move, i;
991 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
993 "fatal flex scanner internal error--end of buffer missed" );
995 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
997 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1002 return EOB_ACT_END_OF_FILE;
1010 return EOB_ACT_LAST_MATCH;
1017 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1019 for ( i = 0; i < number_to_move; ++i )
1020 *(dest++) = *(source++);
1022 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1026 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1030 yy_size_t num_to_read =
1031 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1033 while ( num_to_read <= 0 )
1037 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1039 int yy_c_buf_p_offset =
1040 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1042 if ( b->yy_is_our_buffer )
1044 yy_size_t new_size = b->yy_buf_size * 2;
1046 if ( new_size <= 0 )
1047 b->yy_buf_size += b->yy_buf_size / 8;
1049 b->yy_buf_size *= 2;
1051 b->yy_ch_buf = (
char *)
1053 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1059 if ( ! b->yy_ch_buf )
1061 "fatal error - scanner input buffer overflow" );
1063 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1065 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1070 if ( num_to_read > YY_READ_BUF_SIZE )
1071 num_to_read = YY_READ_BUF_SIZE;
1074 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1075 (yy_n_chars), num_to_read );
1077 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1080 if ( (yy_n_chars) == 0 )
1082 if ( number_to_move == YY_MORE_ADJ )
1084 ret_val = EOB_ACT_END_OF_FILE;
1090 ret_val = EOB_ACT_LAST_MATCH;
1091 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1092 YY_BUFFER_EOF_PENDING;
1097 ret_val = EOB_ACT_CONTINUE_SCAN;
1099 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1101 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1102 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1103 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1104 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1107 (yy_n_chars) += number_to_move;
1108 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1109 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1111 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1118 static yy_state_type yy_get_previous_state (
void)
1120 register yy_state_type yy_current_state;
1121 register char *yy_cp;
1123 yy_current_state = (yy_start);
1125 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1127 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1128 if ( yy_accept[yy_current_state] )
1130 (yy_last_accepting_state) = yy_current_state;
1131 (yy_last_accepting_cpos) = yy_cp;
1133 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1135 yy_current_state = (int) yy_def[yy_current_state];
1136 if ( yy_current_state >= 17 )
1137 yy_c = yy_meta[(
unsigned int) yy_c];
1139 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1142 return yy_current_state;
1150 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1152 register int yy_is_jam;
1153 register char *yy_cp = (yy_c_buf_p);
1155 register YY_CHAR yy_c = 1;
1156 if ( yy_accept[yy_current_state] )
1158 (yy_last_accepting_state) = yy_current_state;
1159 (yy_last_accepting_cpos) = yy_cp;
1161 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1163 yy_current_state = (int) yy_def[yy_current_state];
1164 if ( yy_current_state >= 17 )
1165 yy_c = yy_meta[(
unsigned int) yy_c];
1167 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1168 yy_is_jam = (yy_current_state == 16);
1170 return yy_is_jam ? 0 : yy_current_state;
1175 static int yyinput (
void)
1177 static int input (
void)
1183 *(yy_c_buf_p) = (yy_hold_char);
1185 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1191 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1193 *(yy_c_buf_p) =
'\0';
1197 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1200 switch ( yy_get_next_buffer( ) )
1202 case EOB_ACT_LAST_MATCH:
1218 case EOB_ACT_END_OF_FILE:
1223 if ( ! (yy_did_buffer_switch_on_eof) )
1232 case EOB_ACT_CONTINUE_SCAN:
1233 (yy_c_buf_p) = (yytext_ptr) + offset;
1239 c = *(
unsigned char *) (yy_c_buf_p);
1240 *(yy_c_buf_p) =
'\0';
1241 (yy_hold_char) = *++(yy_c_buf_p);
1252 void yyrestart (FILE * input_file )
1255 if ( ! YY_CURRENT_BUFFER ){
1256 yyensure_buffer_stack ();
1257 YY_CURRENT_BUFFER_LVALUE =
1258 yy_create_buffer(yyin,YY_BUF_SIZE );
1261 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1262 yy_load_buffer_state( );
1269 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1277 yyensure_buffer_stack ();
1278 if ( YY_CURRENT_BUFFER == new_buffer )
1281 if ( YY_CURRENT_BUFFER )
1284 *(yy_c_buf_p) = (yy_hold_char);
1285 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1286 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1289 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1290 yy_load_buffer_state( );
1297 (yy_did_buffer_switch_on_eof) = 1;
1300 static void yy_load_buffer_state (
void)
1302 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1303 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1304 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1305 (yy_hold_char) = *(yy_c_buf_p);
1314 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size )
1320 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1322 b->yy_buf_size = size;
1327 b->yy_ch_buf = (
char *) yyalloc(b->yy_buf_size + 2 );
1328 if ( ! b->yy_ch_buf )
1329 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1331 b->yy_is_our_buffer = 1;
1333 yy_init_buffer(b,file );
1342 void yy_delete_buffer (YY_BUFFER_STATE b )
1348 if ( b == YY_CURRENT_BUFFER )
1349 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1351 if ( b->yy_is_our_buffer )
1352 yyfree((
void *) b->yy_ch_buf );
1354 yyfree((
void *) b );
1361 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1366 yy_flush_buffer(b );
1368 b->yy_input_file = file;
1369 b->yy_fill_buffer = 1;
1375 if (b != YY_CURRENT_BUFFER){
1380 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1389 void yy_flush_buffer (YY_BUFFER_STATE b )
1400 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1401 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1403 b->yy_buf_pos = &b->yy_ch_buf[0];
1406 b->yy_buffer_status = YY_BUFFER_NEW;
1408 if ( b == YY_CURRENT_BUFFER )
1409 yy_load_buffer_state( );
1418 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1420 if (new_buffer == NULL)
1423 yyensure_buffer_stack();
1426 if ( YY_CURRENT_BUFFER )
1429 *(yy_c_buf_p) = (yy_hold_char);
1430 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1431 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1435 if (YY_CURRENT_BUFFER)
1437 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1440 yy_load_buffer_state( );
1441 (yy_did_buffer_switch_on_eof) = 1;
1448 void yypop_buffer_state (
void)
1450 if (!YY_CURRENT_BUFFER)
1453 yy_delete_buffer(YY_CURRENT_BUFFER );
1454 YY_CURRENT_BUFFER_LVALUE = NULL;
1458 if (YY_CURRENT_BUFFER) {
1459 yy_load_buffer_state( );
1460 (yy_did_buffer_switch_on_eof) = 1;
1467 static void yyensure_buffer_stack (
void)
1469 yy_size_t num_to_alloc;
1471 if (!(yy_buffer_stack)) {
1481 if ( ! (yy_buffer_stack) )
1482 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1484 memset((yy_buffer_stack), 0, num_to_alloc *
sizeof(
struct yy_buffer_state*));
1501 if ( ! (yy_buffer_stack) )
1502 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1516 YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size )
1521 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1522 base[size-1] != YY_END_OF_BUFFER_CHAR )
1528 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1530 b->yy_buf_size = size - 2;
1531 b->yy_buf_pos = b->yy_ch_buf = base;
1532 b->yy_is_our_buffer = 0;
1533 b->yy_input_file = 0;
1534 b->yy_n_chars = b->yy_buf_size;
1535 b->yy_is_interactive = 0;
1537 b->yy_fill_buffer = 0;
1538 b->yy_buffer_status = YY_BUFFER_NEW;
1540 yy_switch_to_buffer(b );
1553 YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr )
1556 return yy_scan_bytes(yystr,strlen(yystr) );
1566 YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len )
1574 n = _yybytes_len + 2;
1575 buf = (
char *) yyalloc(n );
1577 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1579 for ( i = 0; i < _yybytes_len; ++i )
1580 buf[i] = yybytes[i];
1582 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1584 b = yy_scan_buffer(buf,n );
1586 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1591 b->yy_is_our_buffer = 1;
1596 #ifndef YY_EXIT_FAILURE
1597 #define YY_EXIT_FAILURE 2
1600 static void yy_fatal_error (yyconst
char* msg )
1602 (void) fprintf( stderr,
"%s\n", msg );
1603 exit( YY_EXIT_FAILURE );
1613 int yyless_macro_arg = (n); \
1614 YY_LESS_LINENO(yyless_macro_arg);\
1615 yytext[yyleng] = (yy_hold_char); \
1616 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1617 (yy_hold_char) = *(yy_c_buf_p); \
1618 *(yy_c_buf_p) = '\0'; \
1619 yyleng = yyless_macro_arg; \
1628 int yyget_lineno (
void)
1637 FILE *yyget_in (
void)
1645 FILE *yyget_out (
void)
1653 yy_size_t yyget_leng (
void)
1662 char *yyget_text (
void)
1671 void yyset_lineno (
int line_number )
1674 yylineno = line_number;
1683 void yyset_in (FILE * in_str )
1688 void yyset_out (FILE * out_str )
1693 int yyget_debug (
void)
1695 return yy_flex_debug;
1698 void yyset_debug (
int bdebug )
1700 yy_flex_debug = bdebug ;
1703 static int yy_init_globals (
void)
1712 (yy_c_buf_p) = (
char *) 0;
1732 int yylex_destroy (
void)
1736 while(YY_CURRENT_BUFFER){
1737 yy_delete_buffer(YY_CURRENT_BUFFER );
1738 YY_CURRENT_BUFFER_LVALUE = NULL;
1739 yypop_buffer_state();
1743 yyfree((yy_buffer_stack) );
1758 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 (
void *) malloc( size );
1782 void *yyrealloc (
void * ptr, yy_size_t size )
1791 return (
void *) realloc( (
char *) ptr, size );
1794 void yyfree (
void * ptr )
1796 free( (
char *) ptr );
1799 #define YYTABLES_NAME "yytables"
1801 #line 76 "configfile.l"
1817 int evaluatetoken(
char *pcToken)
1819 if (pcPrevious == NULL)
1821 pcPrevious = strdup(pcToken);
1822 iOldLinenumber = iLinenumber;
1827 if (iOldLinenumber != iLinenumber)
1829 tok_error(pcPrevious);
1830 pcPrevious = strdup(pcToken);
1831 iOldLinenumber = iLinenumber;
1835 pcCurrent = pcToken;
1836 if (strcmp(pcPrevious,
"FRIENDLYNAME") == 0)
1838 if (pcFriendlyname == NULL)
1842 pcFriendlyname = malloc(strlen(pcCurrent) + 1);
1843 for (n = 0, p = 0; n < strlen(pcCurrent); n++)
1845 if (pcCurrent[n] !=
'"')
1847 pcFriendlyname[p++] = pcCurrent[n];
1850 pcFriendlyname[p++] =
'\0';
1854 tok_error(pcPrevious);
1858 else if (strcmp(pcPrevious,
"DEVICENAME") == 0)
1860 if (pcDevicename == NULL)
1862 struct stat fStatBuf;
1864 pcDevicename = strdup(pcCurrent);
1865 if ((NULL == strchr(pcDevicename,
':'))
1866 && (stat(pcDevicename, &fStatBuf) != 0))
1868 Log3(PCSC_LOG_CRITICAL,
"Error with device %s: %s",
1869 pcDevicename, strerror(errno));
1870 Log1(PCSC_LOG_CRITICAL,
"You should remove the DEVICENAME line if your driver does not use this field");
1876 tok_error(pcPrevious);
1880 else if (strcmp(pcPrevious,
"LIBPATH") == 0)
1882 if (pcLibpath == NULL)
1884 struct stat fStatBuf;
1886 pcLibpath = strdup(pcCurrent);
1887 if (stat(pcLibpath, &fStatBuf) != 0)
1889 Log3(PCSC_LOG_CRITICAL,
"Error with library %s: %s",
1890 pcLibpath, strerror(errno));
1894 if (strstr(pcLibpath,
".bundle") != NULL)
1896 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1897 Log2(PCSC_LOG_ERROR,
"WARNING: USB drivers SHOULD NOT be declared in reader.conf: %s", pcLibpath);
1898 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1903 tok_error(pcPrevious);
1907 else if (strcmp(pcPrevious,
"CHANNELID") == 0)
1909 if (pcChannelid == NULL)
1910 pcChannelid = strdup(pcCurrent);
1913 tok_error(pcPrevious);
1919 tok_error(pcPrevious);
1930 if (pcFriendlyname && pcLibpath && badError != 1
1931 && (pcChannelid || pcDevicename))
1934 static char* defaultDeviceName = (
char *)
"";
1936 Log2(PCSC_LOG_DEBUG,
"Add reader: %s", pcFriendlyname);
1937 if (0 == reader_list_size)
1940 reader_list_size = 2;
1941 reader_list = malloc(reader_list_size *
sizeof(
SerialReader));
1946 reader_list = realloc(reader_list, reader_list_size *
1954 if (NULL == pcDevicename)
1955 pcDevicename = defaultDeviceName;
1958 channelId = strtoul(pcChannelid, NULL, 0);
1961 reader_list[reader_list_size-2].
pcFriendlyname = strdup(pcFriendlyname);
1962 reader_list[reader_list_size-2].
pcDevicename = strdup(pcDevicename);
1963 reader_list[reader_list_size-2].
pcLibpath = strdup(pcLibpath),
1964 reader_list[reader_list_size-2].
channelId = channelId;
1966 free(pcFriendlyname);
1967 pcFriendlyname = NULL;
1969 if (pcDevicename != defaultDeviceName)
1971 pcDevicename = NULL;
1984 void tok_error(
char *token_error)
1986 Log4(PCSC_LOG_ERROR,
"tok_error: invalid value line %d in %s: %s",
1987 iOldLinenumber, ConfFile, token_error);
1991 int DBGetReaderListDir(
const char *readerconf_dir,
1999 reader_list_size = 0;
2001 dir = opendir(readerconf_dir);
2005 struct dirent *direntry;
2007 Log2(PCSC_LOG_DEBUG,
"Parsing conf directory: %s", readerconf_dir);
2010 while ((direntry = readdir(dir)) != NULL)
2012 char filename[FILENAME_MAX];
2015 snprintf(filename,
sizeof(filename),
"%s/%s",
2016 readerconf_dir, direntry->d_name);
2019 if (direntry->d_type == DT_UNKNOWN)
2023 if (lstat(filename, &st) != 0)
2025 Log2(PCSC_LOG_DEBUG,
"Skipping non statable file: %s",
2030 if (!S_ISREG(st.st_mode))
2032 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2038 if (direntry->d_type != DT_REG)
2040 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2046 if (
'.' == direntry->d_name[0])
2048 Log2(PCSC_LOG_DEBUG,
"Skipping hidden file: %s",
2054 r = DBGetReaderList(filename, caller_reader_list);
2065 ret = DBGetReaderList(readerconf_dir, caller_reader_list);
2070 int DBGetReaderList(
const char *readerconf,
SerialReader **caller_reader_list)
2072 FILE *configFile = NULL;
2074 *caller_reader_list = NULL;
2077 ConfFile = readerconf;
2079 Log2(PCSC_LOG_DEBUG,
"Parsing conf file: %s", ConfFile);
2081 configFile = fopen(readerconf,
"r");
2083 if (configFile == NULL)
2090 iOldLinenumber = -1;
2091 pcFriendlyname = NULL;
2092 pcDevicename = NULL;
2103 while (!feof(configFile));
2106 (void)fclose(configFile);
2108 *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.