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"
509 #line 40 "configfile.l"
511 #include <sys/stat.h>
516 #include "configfile.h"
518 int evaluatetoken(
char *pcToken);
520 static int iLinenumber;
521 static int iOldLinenumber;
522 static char *pcPrevious;
523 static char *pcCurrent;
524 static char *pcFriendlyname;
525 static char *pcDevicename;
526 static char *pcLibpath;
527 static char *pcChannelid;
530 static int reader_list_size;
531 const char *ConfFile;
533 void tok_error(
char *pcToken_error);
535 #define YY_NO_INPUT 1
536 #line 537 "configfile.c"
540 #ifndef YY_NO_UNISTD_H
548 #ifndef YY_EXTRA_TYPE
549 #define YY_EXTRA_TYPE void *
552 static int yy_init_globals (
void );
557 int yylex_destroy (
void );
559 int yyget_debug (
void );
561 void yyset_debug (
int debug_flag );
563 YY_EXTRA_TYPE yyget_extra (
void );
565 void yyset_extra (YY_EXTRA_TYPE user_defined );
567 FILE *yyget_in (
void );
569 void yyset_in (FILE * in_str );
571 FILE *yyget_out (
void );
573 void yyset_out (FILE * out_str );
575 yy_size_t yyget_leng (
void );
577 char *yyget_text (
void );
579 int yyget_lineno (
void );
581 void yyset_lineno (
int line_number );
587 #ifndef YY_SKIP_YYWRAP
589 extern "C" int yywrap (
void );
591 extern int yywrap (
void );
596 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
599 #ifdef YY_NEED_STRLEN
600 static int yy_flex_strlen (yyconst
char * );
606 static int yyinput (
void );
608 static int input (
void );
614 #ifndef YY_READ_BUF_SIZE
617 #define YY_READ_BUF_SIZE 16384
619 #define YY_READ_BUF_SIZE 8192
628 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
635 #define YY_INPUT(buf,result,max_size) \
636 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
640 for ( n = 0; n < max_size && \
641 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
644 buf[n++] = (char) c; \
645 if ( c == EOF && ferror( yyin ) ) \
646 YY_FATAL_ERROR( "input in flex scanner failed" ); \
652 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
654 if( errno != EINTR) \
656 YY_FATAL_ERROR( "input in flex scanner failed" ); \
672 #define yyterminate() return YY_NULL
676 #ifndef YY_START_STACK_INCR
677 #define YY_START_STACK_INCR 25
681 #ifndef YY_FATAL_ERROR
682 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
691 #define YY_DECL_IS_OURS 1
693 extern int yylex (
void);
695 #define YY_DECL int yylex (void)
701 #ifndef YY_USER_ACTION
702 #define YY_USER_ACTION
707 #define YY_BREAK break;
710 #define YY_RULE_SETUP \
717 register yy_state_type yy_current_state;
718 register char *yy_cp, *yy_bp;
738 if ( ! YY_CURRENT_BUFFER ) {
739 yyensure_buffer_stack ();
740 YY_CURRENT_BUFFER_LVALUE =
741 yy_create_buffer(yyin,YY_BUF_SIZE );
744 yy_load_buffer_state( );
748 #line 71 "configfile.l"
751 #line 752 "configfile.c"
755 yy_cp = (yy_c_buf_p);
758 *yy_cp = (yy_hold_char);
765 yy_current_state = (yy_start);
769 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
770 if ( yy_accept[yy_current_state] )
772 (yy_last_accepting_state) = yy_current_state;
773 (yy_last_accepting_cpos) = yy_cp;
775 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
777 yy_current_state = (int) yy_def[yy_current_state];
778 if ( yy_current_state >= 17 )
779 yy_c = yy_meta[(
unsigned int) yy_c];
781 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
784 while ( yy_base[yy_current_state] != 31 );
787 yy_act = yy_accept[yy_current_state];
790 yy_cp = (yy_last_accepting_cpos);
791 yy_current_state = (yy_last_accepting_state);
792 yy_act = yy_accept[yy_current_state];
803 *yy_cp = (yy_hold_char);
804 yy_cp = (yy_last_accepting_cpos);
805 yy_current_state = (yy_last_accepting_state);
810 #line 73 "configfile.l"
816 #line 74 "configfile.l"
822 #line 75 "configfile.l"
823 { (void)evaluatetoken(yytext); }
827 #line 76 "configfile.l"
832 #line 77 "configfile.l"
833 { (void)evaluatetoken(yytext); }
837 #line 78 "configfile.l"
838 { iOldLinenumber = iLinenumber; tok_error(yytext); }
842 #line 79 "configfile.l"
845 #line 846 "configfile.c"
846 case YY_STATE_EOF(INITIAL):
849 case YY_END_OF_BUFFER:
852 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
855 *yy_cp = (yy_hold_char);
856 YY_RESTORE_YY_MORE_OFFSET
858 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
869 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
870 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
871 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
881 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
883 yy_state_type yy_next_state;
885 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
887 yy_current_state = yy_get_previous_state( );
898 yy_next_state = yy_try_NUL_trans( yy_current_state );
900 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
905 yy_cp = ++(yy_c_buf_p);
906 yy_current_state = yy_next_state;
912 yy_cp = (yy_c_buf_p);
917 else switch ( yy_get_next_buffer( ) )
919 case EOB_ACT_END_OF_FILE:
921 (yy_did_buffer_switch_on_eof) = 0;
934 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
936 yy_act = YY_STATE_EOF(YY_START);
942 if ( ! (yy_did_buffer_switch_on_eof) )
948 case EOB_ACT_CONTINUE_SCAN:
950 (yytext_ptr) + yy_amount_of_matched_text;
952 yy_current_state = yy_get_previous_state( );
954 yy_cp = (yy_c_buf_p);
955 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
958 case EOB_ACT_LAST_MATCH:
960 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
962 yy_current_state = yy_get_previous_state( );
964 yy_cp = (yy_c_buf_p);
965 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
973 "fatal flex scanner internal error--no action found" );
986 static int yy_get_next_buffer (
void)
988 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
989 register char *source = (yytext_ptr);
990 register int number_to_move, i;
993 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
995 "fatal flex scanner internal error--end of buffer missed" );
997 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
999 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1004 return EOB_ACT_END_OF_FILE;
1012 return EOB_ACT_LAST_MATCH;
1019 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1021 for ( i = 0; i < number_to_move; ++i )
1022 *(dest++) = *(source++);
1024 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1028 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1032 yy_size_t num_to_read =
1033 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1035 while ( num_to_read <= 0 )
1039 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1041 int yy_c_buf_p_offset =
1042 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1044 if ( b->yy_is_our_buffer )
1046 yy_size_t new_size = b->yy_buf_size * 2;
1048 if ( new_size <= 0 )
1049 b->yy_buf_size += b->yy_buf_size / 8;
1051 b->yy_buf_size *= 2;
1053 b->yy_ch_buf = (
char *)
1055 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1061 if ( ! b->yy_ch_buf )
1063 "fatal error - scanner input buffer overflow" );
1065 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1067 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1072 if ( num_to_read > YY_READ_BUF_SIZE )
1073 num_to_read = YY_READ_BUF_SIZE;
1076 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1077 (yy_n_chars), num_to_read );
1079 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1082 if ( (yy_n_chars) == 0 )
1084 if ( number_to_move == YY_MORE_ADJ )
1086 ret_val = EOB_ACT_END_OF_FILE;
1092 ret_val = EOB_ACT_LAST_MATCH;
1093 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1094 YY_BUFFER_EOF_PENDING;
1099 ret_val = EOB_ACT_CONTINUE_SCAN;
1101 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1103 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1104 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1105 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1106 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1109 (yy_n_chars) += number_to_move;
1110 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1111 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1113 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1120 static yy_state_type yy_get_previous_state (
void)
1122 register yy_state_type yy_current_state;
1123 register char *yy_cp;
1125 yy_current_state = (yy_start);
1127 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1129 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1130 if ( yy_accept[yy_current_state] )
1132 (yy_last_accepting_state) = yy_current_state;
1133 (yy_last_accepting_cpos) = yy_cp;
1135 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1137 yy_current_state = (int) yy_def[yy_current_state];
1138 if ( yy_current_state >= 17 )
1139 yy_c = yy_meta[(
unsigned int) yy_c];
1141 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1144 return yy_current_state;
1152 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1154 register int yy_is_jam;
1155 register char *yy_cp = (yy_c_buf_p);
1157 register YY_CHAR yy_c = 1;
1158 if ( yy_accept[yy_current_state] )
1160 (yy_last_accepting_state) = yy_current_state;
1161 (yy_last_accepting_cpos) = yy_cp;
1163 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1165 yy_current_state = (int) yy_def[yy_current_state];
1166 if ( yy_current_state >= 17 )
1167 yy_c = yy_meta[(
unsigned int) yy_c];
1169 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1170 yy_is_jam = (yy_current_state == 16);
1172 return yy_is_jam ? 0 : yy_current_state;
1177 static int yyinput (
void)
1179 static int input (
void)
1185 *(yy_c_buf_p) = (yy_hold_char);
1187 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1193 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1195 *(yy_c_buf_p) =
'\0';
1199 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1202 switch ( yy_get_next_buffer( ) )
1204 case EOB_ACT_LAST_MATCH:
1220 case EOB_ACT_END_OF_FILE:
1225 if ( ! (yy_did_buffer_switch_on_eof) )
1234 case EOB_ACT_CONTINUE_SCAN:
1235 (yy_c_buf_p) = (yytext_ptr) + offset;
1241 c = *(
unsigned char *) (yy_c_buf_p);
1242 *(yy_c_buf_p) =
'\0';
1243 (yy_hold_char) = *++(yy_c_buf_p);
1254 void yyrestart (FILE * input_file )
1257 if ( ! YY_CURRENT_BUFFER ){
1258 yyensure_buffer_stack ();
1259 YY_CURRENT_BUFFER_LVALUE =
1260 yy_create_buffer(yyin,YY_BUF_SIZE );
1263 yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1264 yy_load_buffer_state( );
1271 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1279 yyensure_buffer_stack ();
1280 if ( YY_CURRENT_BUFFER == new_buffer )
1283 if ( YY_CURRENT_BUFFER )
1286 *(yy_c_buf_p) = (yy_hold_char);
1287 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1288 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1291 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1292 yy_load_buffer_state( );
1299 (yy_did_buffer_switch_on_eof) = 1;
1302 static void yy_load_buffer_state (
void)
1304 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1305 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1306 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1307 (yy_hold_char) = *(yy_c_buf_p);
1316 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size )
1322 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1324 b->yy_buf_size = size;
1329 b->yy_ch_buf = (
char *) yyalloc(b->yy_buf_size + 2 );
1330 if ( ! b->yy_ch_buf )
1331 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1333 b->yy_is_our_buffer = 1;
1335 yy_init_buffer(b,file );
1344 void yy_delete_buffer (YY_BUFFER_STATE b )
1350 if ( b == YY_CURRENT_BUFFER )
1351 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1353 if ( b->yy_is_our_buffer )
1354 yyfree((
void *) b->yy_ch_buf );
1356 yyfree((
void *) b );
1363 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1368 yy_flush_buffer(b );
1370 b->yy_input_file = file;
1371 b->yy_fill_buffer = 1;
1377 if (b != YY_CURRENT_BUFFER){
1382 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1391 void yy_flush_buffer (YY_BUFFER_STATE b )
1402 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1403 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1405 b->yy_buf_pos = &b->yy_ch_buf[0];
1408 b->yy_buffer_status = YY_BUFFER_NEW;
1410 if ( b == YY_CURRENT_BUFFER )
1411 yy_load_buffer_state( );
1420 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1422 if (new_buffer == NULL)
1425 yyensure_buffer_stack();
1428 if ( YY_CURRENT_BUFFER )
1431 *(yy_c_buf_p) = (yy_hold_char);
1432 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1433 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1437 if (YY_CURRENT_BUFFER)
1439 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1442 yy_load_buffer_state( );
1443 (yy_did_buffer_switch_on_eof) = 1;
1450 void yypop_buffer_state (
void)
1452 if (!YY_CURRENT_BUFFER)
1455 yy_delete_buffer(YY_CURRENT_BUFFER );
1456 YY_CURRENT_BUFFER_LVALUE = NULL;
1460 if (YY_CURRENT_BUFFER) {
1461 yy_load_buffer_state( );
1462 (yy_did_buffer_switch_on_eof) = 1;
1469 static void yyensure_buffer_stack (
void)
1471 yy_size_t num_to_alloc;
1473 if (!(yy_buffer_stack)) {
1483 if ( ! (yy_buffer_stack) )
1484 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1486 memset((yy_buffer_stack), 0, num_to_alloc *
sizeof(
struct yy_buffer_state*));
1503 if ( ! (yy_buffer_stack) )
1504 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1518 YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size )
1523 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1524 base[size-1] != YY_END_OF_BUFFER_CHAR )
1530 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1532 b->yy_buf_size = size - 2;
1533 b->yy_buf_pos = b->yy_ch_buf = base;
1534 b->yy_is_our_buffer = 0;
1535 b->yy_input_file = 0;
1536 b->yy_n_chars = b->yy_buf_size;
1537 b->yy_is_interactive = 0;
1539 b->yy_fill_buffer = 0;
1540 b->yy_buffer_status = YY_BUFFER_NEW;
1542 yy_switch_to_buffer(b );
1555 YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr )
1558 return yy_scan_bytes(yystr,strlen(yystr) );
1568 YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes, yy_size_t _yybytes_len )
1576 n = _yybytes_len + 2;
1577 buf = (
char *) yyalloc(n );
1579 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1581 for ( i = 0; i < _yybytes_len; ++i )
1582 buf[i] = yybytes[i];
1584 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1586 b = yy_scan_buffer(buf,n );
1588 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1593 b->yy_is_our_buffer = 1;
1598 #ifndef YY_EXIT_FAILURE
1599 #define YY_EXIT_FAILURE 2
1602 static void yy_fatal_error (yyconst
char* msg )
1604 (void) fprintf( stderr,
"%s\n", msg );
1605 exit( YY_EXIT_FAILURE );
1615 int yyless_macro_arg = (n); \
1616 YY_LESS_LINENO(yyless_macro_arg);\
1617 yytext[yyleng] = (yy_hold_char); \
1618 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1619 (yy_hold_char) = *(yy_c_buf_p); \
1620 *(yy_c_buf_p) = '\0'; \
1621 yyleng = yyless_macro_arg; \
1630 int yyget_lineno (
void)
1639 FILE *yyget_in (
void)
1647 FILE *yyget_out (
void)
1655 yy_size_t yyget_leng (
void)
1664 char *yyget_text (
void)
1673 void yyset_lineno (
int line_number )
1676 yylineno = line_number;
1685 void yyset_in (FILE * in_str )
1690 void yyset_out (FILE * out_str )
1695 int yyget_debug (
void)
1697 return yy_flex_debug;
1700 void yyset_debug (
int bdebug )
1702 yy_flex_debug = bdebug ;
1705 static int yy_init_globals (
void)
1714 (yy_c_buf_p) = (
char *) 0;
1734 int yylex_destroy (
void)
1738 while(YY_CURRENT_BUFFER){
1739 yy_delete_buffer(YY_CURRENT_BUFFER );
1740 YY_CURRENT_BUFFER_LVALUE = NULL;
1741 yypop_buffer_state();
1745 yyfree((yy_buffer_stack) );
1760 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n )
1763 for ( i = 0; i < n; ++i )
1768 #ifdef YY_NEED_STRLEN
1769 static int yy_flex_strlen (yyconst
char * s )
1772 for ( n = 0; s[n]; ++n )
1779 void *yyalloc (yy_size_t size )
1781 return (
void *) malloc( size );
1784 void *yyrealloc (
void * ptr, yy_size_t size )
1793 return (
void *) realloc( (
char *) ptr, size );
1796 void yyfree (
void * ptr )
1798 free( (
char *) ptr );
1801 #define YYTABLES_NAME "yytables"
1803 #line 78 "configfile.l"
1819 int evaluatetoken(
char *pcToken)
1821 if (pcPrevious == NULL)
1823 pcPrevious = strdup(pcToken);
1824 iOldLinenumber = iLinenumber;
1829 if (iOldLinenumber != iLinenumber)
1831 tok_error(pcPrevious);
1832 pcPrevious = strdup(pcToken);
1833 iOldLinenumber = iLinenumber;
1837 pcCurrent = pcToken;
1838 if (strcmp(pcPrevious,
"FRIENDLYNAME") == 0)
1840 if (pcFriendlyname == NULL)
1844 pcFriendlyname = malloc(strlen(pcCurrent) + 1);
1845 for (n = 0, p = 0; n < strlen(pcCurrent); n++)
1847 if (pcCurrent[n] !=
'"')
1849 pcFriendlyname[p++] = pcCurrent[n];
1852 pcFriendlyname[p++] =
'\0';
1856 tok_error(pcPrevious);
1860 else if (strcmp(pcPrevious,
"DEVICENAME") == 0)
1862 if (pcDevicename == NULL)
1864 struct stat fStatBuf;
1866 pcDevicename = strdup(pcCurrent);
1867 if ((NULL == strchr(pcDevicename,
':'))
1868 && (stat(pcDevicename, &fStatBuf) != 0))
1870 Log3(PCSC_LOG_CRITICAL,
"Error with device %s: %s",
1871 pcDevicename, strerror(errno));
1872 Log1(PCSC_LOG_CRITICAL,
"You should remove the DEVICENAME line if your driver does not use this field");
1878 tok_error(pcPrevious);
1882 else if (strcmp(pcPrevious,
"LIBPATH") == 0)
1884 if (pcLibpath == NULL)
1886 struct stat fStatBuf;
1888 pcLibpath = strdup(pcCurrent);
1889 if (stat(pcLibpath, &fStatBuf) != 0)
1891 Log3(PCSC_LOG_CRITICAL,
"Error with library %s: %s",
1892 pcLibpath, strerror(errno));
1896 if (strstr(pcLibpath,
".bundle") != NULL)
1898 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1899 Log2(PCSC_LOG_ERROR,
"WARNING: USB drivers SHOULD NOT be declared in reader.conf: %s", pcLibpath);
1900 Log1(PCSC_LOG_ERROR,
"WARNING *************************************");
1905 tok_error(pcPrevious);
1909 else if (strcmp(pcPrevious,
"CHANNELID") == 0)
1911 if (pcChannelid == NULL)
1912 pcChannelid = strdup(pcCurrent);
1915 tok_error(pcPrevious);
1921 tok_error(pcPrevious);
1932 if (pcFriendlyname && pcLibpath && badError != 1
1933 && (pcChannelid || pcDevicename))
1936 static char* defaultDeviceName = (
char *)
"";
1938 Log2(PCSC_LOG_DEBUG,
"Add reader: %s", pcFriendlyname);
1939 if (0 == reader_list_size)
1942 reader_list_size = 2;
1943 reader_list = malloc(reader_list_size *
sizeof(
SerialReader));
1948 reader_list = realloc(reader_list, reader_list_size *
1956 if (NULL == pcDevicename)
1957 pcDevicename = defaultDeviceName;
1960 channelId = strtoul(pcChannelid, NULL, 0);
1963 reader_list[reader_list_size-2].
pcFriendlyname = strdup(pcFriendlyname);
1964 reader_list[reader_list_size-2].
pcDevicename = strdup(pcDevicename);
1965 reader_list[reader_list_size-2].
pcLibpath = strdup(pcLibpath),
1966 reader_list[reader_list_size-2].
channelId = channelId;
1968 free(pcFriendlyname);
1969 pcFriendlyname = NULL;
1971 if (pcDevicename != defaultDeviceName)
1973 pcDevicename = NULL;
1986 void tok_error(
char *token_error)
1988 Log4(PCSC_LOG_ERROR,
"tok_error: invalid value line %d in %s: %s",
1989 iOldLinenumber, ConfFile, token_error);
1993 int DBGetReaderListDir(
const char *readerconf_dir,
2001 reader_list_size = 0;
2003 dir = opendir(readerconf_dir);
2007 struct dirent *direntry;
2009 Log2(PCSC_LOG_DEBUG,
"Parsing conf directory: %s", readerconf_dir);
2012 while ((direntry = readdir(dir)) != NULL)
2014 char filename[FILENAME_MAX];
2017 snprintf(filename,
sizeof(filename),
"%s/%s",
2018 readerconf_dir, direntry->d_name);
2021 if (direntry->d_type == DT_UNKNOWN)
2025 if (lstat(filename, &st) != 0)
2027 Log2(PCSC_LOG_DEBUG,
"Skipping non statable file: %s",
2032 if (!S_ISREG(st.st_mode))
2034 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2040 if (direntry->d_type != DT_REG)
2042 Log2(PCSC_LOG_DEBUG,
"Skipping non regular file: %s",
2048 if (
'.' == direntry->d_name[0])
2050 Log2(PCSC_LOG_DEBUG,
"Skipping hidden file: %s",
2056 r = DBGetReaderList(filename, caller_reader_list);
2067 ret = DBGetReaderList(readerconf_dir, caller_reader_list);
2072 int DBGetReaderList(
const char *readerconf,
SerialReader **caller_reader_list)
2074 FILE *configFile = NULL;
2076 *caller_reader_list = NULL;
2079 ConfFile = readerconf;
2081 Log2(PCSC_LOG_DEBUG,
"Parsing conf file: %s", ConfFile);
2083 configFile = fopen(readerconf,
"r");
2085 if (configFile == NULL)
2092 iOldLinenumber = -1;
2093 pcFriendlyname = NULL;
2094 pcDevicename = NULL;
2105 while (!feof(configFile));
2108 (void)fclose(configFile);
2110 *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.