pcsc-lite  1.8.13
configfile.c
1 
2 #line 3 "configfile.c"
3 
4 #define YY_INT_ALIGNED short int
5 
6 /* A lexical scanner generated by flex */
7 
8 #define FLEX_SCANNER
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
13 #define FLEX_BETA
14 #endif
15 
16 /* First, we deal with platform-specific or compiler-specific issues. */
17 
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23 
24 /* end standard C headers. */
25 
26 /* flex integer type definitions */
27 
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30 
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32 
33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34 
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36  * if you want the limit (max/min) macros for int types.
37  */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41 
42 #include <inttypes.h>
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;
49 #else
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;
56 
57 /* Limits of integral types. */
58 #ifndef INT8_MIN
59 #define INT8_MIN (-128)
60 #endif
61 #ifndef INT16_MIN
62 #define INT16_MIN (-32767-1)
63 #endif
64 #ifndef INT32_MIN
65 #define INT32_MIN (-2147483647-1)
66 #endif
67 #ifndef INT8_MAX
68 #define INT8_MAX (127)
69 #endif
70 #ifndef INT16_MAX
71 #define INT16_MAX (32767)
72 #endif
73 #ifndef INT32_MAX
74 #define INT32_MAX (2147483647)
75 #endif
76 #ifndef UINT8_MAX
77 #define UINT8_MAX (255U)
78 #endif
79 #ifndef UINT16_MAX
80 #define UINT16_MAX (65535U)
81 #endif
82 #ifndef UINT32_MAX
83 #define UINT32_MAX (4294967295U)
84 #endif
85 
86 #endif /* ! C99 */
87 
88 #endif /* ! FLEXINT_H */
89 
90 #ifdef __cplusplus
91 
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94 
95 #else /* ! __cplusplus */
96 
97 /* C99 requires __STDC__ to be defined as 1. */
98 #if defined (__STDC__)
99 
100 #define YY_USE_CONST
101 
102 #endif /* defined (__STDC__) */
103 #endif /* ! __cplusplus */
104 
105 #ifdef YY_USE_CONST
106 #define yyconst const
107 #else
108 #define yyconst
109 #endif
110 
111 /* Returned upon end-of-file. */
112 #define YY_NULL 0
113 
114 /* Promotes a possibly negative, possibly signed char to an unsigned
115  * integer for use as an array index. If the signed char is negative,
116  * we want to instead treat it as an 8-bit unsigned char, hence the
117  * double cast.
118  */
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120 
121 /* Enter a start condition. This macro really ought to take a parameter,
122  * but we do it the disgusting crufty way forced on us by the ()-less
123  * definition of BEGIN.
124  */
125 #define BEGIN (yy_start) = 1 + 2 *
126 
127 /* Translate the current start state into a value that can be later handed
128  * to BEGIN to return to the state. The YYSTATE alias is for lex
129  * compatibility.
130  */
131 #define YY_START (((yy_start) - 1) / 2)
132 #define YYSTATE YY_START
133 
134 /* Action number for EOF rule of a given start state. */
135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136 
137 /* Special action meaning "start processing a new file". */
138 #define YY_NEW_FILE yyrestart(yyin )
139 
140 #define YY_END_OF_BUFFER_CHAR 0
141 
142 /* Size of default input buffer. */
143 #ifndef YY_BUF_SIZE
144 #ifdef __ia64__
145 /* On IA-64, the buffer size is 16k, not 8k.
146  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
147  * Ditto for the __ia64__ case accordingly.
148  */
149 #define YY_BUF_SIZE 32768
150 #else
151 #define YY_BUF_SIZE 16384
152 #endif /* __ia64__ */
153 #endif
154 
155 /* The state buf must be large enough to hold one state per character in the main buffer.
156  */
157 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
158 
159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
160 #define YY_TYPEDEF_YY_BUFFER_STATE
161 typedef struct yy_buffer_state *YY_BUFFER_STATE;
162 #endif
163 
164 #ifndef YY_TYPEDEF_YY_SIZE_T
165 #define YY_TYPEDEF_YY_SIZE_T
166 typedef size_t yy_size_t;
167 #endif
168 
169 extern yy_size_t yyleng;
170 
171 extern FILE *yyin, *yyout;
172 
173 #define EOB_ACT_CONTINUE_SCAN 0
174 #define EOB_ACT_END_OF_FILE 1
175 #define EOB_ACT_LAST_MATCH 2
176 
177  #define YY_LESS_LINENO(n)
178  #define YY_LINENO_REWIND_TO(ptr)
179 
180 /* Return all but the first "n" matched characters back to the input stream. */
181 #define yyless(n) \
182  do \
183  { \
184  /* Undo effects of setting up yytext. */ \
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; /* set up yytext again */ \
191  } \
192  while ( 0 )
193 
194 #define unput(c) yyunput( c, (yytext_ptr) )
195 
196 #ifndef YY_STRUCT_YY_BUFFER_STATE
197 #define YY_STRUCT_YY_BUFFER_STATE
199  {
200  FILE *yy_input_file;
201 
202  char *yy_ch_buf; /* input buffer */
203  char *yy_buf_pos; /* current position in input buffer */
204 
205  /* Size of input buffer in bytes, not including room for EOB
206  * characters.
207  */
208  yy_size_t yy_buf_size;
209 
210  /* Number of characters read into yy_ch_buf, not including EOB
211  * characters.
212  */
213  yy_size_t yy_n_chars;
214 
215  /* Whether we "own" the buffer - i.e., we know we created it,
216  * and can realloc() it to grow it, and should free() it to
217  * delete it.
218  */
219  int yy_is_our_buffer;
220 
221  /* Whether this is an "interactive" input source; if so, and
222  * if we're using stdio for input, then we want to use getc()
223  * instead of fread(), to make sure we stop fetching input after
224  * each newline.
225  */
226  int yy_is_interactive;
227 
228  /* Whether we're considered to be at the beginning of a line.
229  * If so, '^' rules will be active on the next match, otherwise
230  * not.
231  */
232  int yy_at_bol;
233 
237  /* Whether to try to fill the input buffer when we reach the
238  * end of it.
239  */
240  int yy_fill_buffer;
241 
242  int yy_buffer_status;
243 
244 #define YY_BUFFER_NEW 0
245 #define YY_BUFFER_NORMAL 1
246  /* When an EOF's been seen but there's still some text to process
247  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
248  * shouldn't try reading from the input source any more. We might
249  * still have a bunch of tokens to match, though, because of
250  * possible backing-up.
251  *
252  * When we actually see the EOF, we change the status to "new"
253  * (via yyrestart()), so that the user can continue scanning by
254  * just pointing yyin at a new input file.
255  */
256 #define YY_BUFFER_EOF_PENDING 2
257 
258  };
259 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
260 
261 /* Stack of input buffers. */
262 static size_t yy_buffer_stack_top = 0;
263 static size_t yy_buffer_stack_max = 0;
264 static YY_BUFFER_STATE * yy_buffer_stack = 0;
266 /* We provide macros for accessing buffer states in case in the
267  * future we want to put the buffer states in a more general
268  * "scanner state".
269  *
270  * Returns the top of the stack, or NULL.
271  */
272 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
273  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
274  : NULL)
275 
276 /* Same as previous macro, but useful when we know that the buffer stack is not
277  * NULL or when we need an lvalue. For internal use only.
278  */
279 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
280 
281 /* yy_hold_char holds the character lost when yytext is formed. */
282 static char yy_hold_char;
283 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
284 yy_size_t yyleng;
285 
286 /* Points to current character in buffer. */
287 static char *yy_c_buf_p = (char *) 0;
288 static int yy_init = 0; /* whether we need to initialize */
289 static int yy_start = 0; /* start state number */
290 
291 /* Flag which is used to allow yywrap()'s to do buffer switches
292  * instead of setting up a fresh yyin. A bit of a hack ...
293  */
294 static int yy_did_buffer_switch_on_eof;
295 
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 );
303 
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 );
307 
308 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
309 
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 );
313 
314 void *yyalloc (yy_size_t );
315 void *yyrealloc (void *,yy_size_t );
316 void yyfree (void * );
317 
318 #define yy_new_buffer yy_create_buffer
319 
320 #define yy_set_interactive(is_interactive) \
321  { \
322  if ( ! YY_CURRENT_BUFFER ){ \
323  yyensure_buffer_stack (); \
324  YY_CURRENT_BUFFER_LVALUE = \
325  yy_create_buffer(yyin,YY_BUF_SIZE ); \
326  } \
327  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
328  }
329 
330 #define yy_set_bol(at_bol) \
331  { \
332  if ( ! YY_CURRENT_BUFFER ){\
333  yyensure_buffer_stack (); \
334  YY_CURRENT_BUFFER_LVALUE = \
335  yy_create_buffer(yyin,YY_BUF_SIZE ); \
336  } \
337  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
338  }
339 
340 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
341 
342 /* Begin user sect3 */
343 
344 #define yywrap() 1
345 #define YY_SKIP_YYWRAP
346 
347 typedef unsigned char YY_CHAR;
348 
349 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
350 
351 typedef int yy_state_type;
352 
353 extern int yylineno;
354 
355 int yylineno = 1;
356 
357 extern char *yytext;
358 #define yytext_ptr yytext
359 
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[] );
364 
365 /* Done after the current pattern has been matched and before the
366  * corresponding action - sets up yytext.
367  */
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; \
372  *yy_cp = '\0'; \
373  (yy_c_buf_p) = yy_cp;
374 
375 #define YY_NUM_RULES 7
376 #define YY_END_OF_BUFFER 8
377 /* This struct is not used in this scanner,
378  but its presence is necessary. */
380  {
381  flex_int32_t yy_verify;
382  flex_int32_t yy_nxt;
383  };
384 static yyconst flex_int16_t yy_accept[17] =
385  { 0,
386  0, 0, 8, 6, 4, 2, 6, 1, 6, 5,
387  0, 3, 1, 0, 5, 0
388  } ;
389 
390 static yyconst flex_int32_t yy_ec[256] =
391  { 0,
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,
402 
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,
413 
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,
419  1, 1, 1, 1, 1
420  } ;
421 
422 static yyconst flex_int32_t yy_meta[11] =
423  { 0,
424  1, 1, 2, 1, 1, 1, 1, 1, 1, 1
425  } ;
426 
427 static yyconst flex_int16_t yy_base[20] =
428  { 0,
429  0, 0, 15, 31, 31, 31, 8, 0, 10, 10,
430  18, 31, 0, 20, 0, 31, 26, 13, 28
431  } ;
432 
433 static yyconst flex_int16_t yy_def[20] =
434  { 0,
435  16, 1, 16, 16, 16, 16, 17, 18, 19, 16,
436  17, 16, 18, 19, 10, 0, 16, 16, 16
437  } ;
438 
439 static yyconst flex_int16_t yy_nxt[42] =
440  { 0,
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,
445  16
446  } ;
447 
448 static yyconst flex_int16_t yy_chk[42] =
449  { 0,
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,
454  16
455  } ;
456 
457 static yy_state_type yy_last_accepting_state;
458 static char *yy_last_accepting_cpos;
459 
460 extern int yy_flex_debug;
461 int yy_flex_debug = 0;
462 
463 /* The intent behind this definition is that it'll catch
464  * any uses of REJECT which flex missed.
465  */
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
470 char *yytext;
471 #line 1 "configfile.l"
472 /*
473  * Reads lexical config files and updates database.
474  *
475  * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
476  *
477  * Copyright (C) 1999-2002
478  * David Corcoran <corcoran@musclecard.com>
479  * Copyright (C) 2004
480  * Damien Sauveron <damien.sauveron@labri.fr>
481  * Copyright (C) 2004-2010
482  * Ludovic Rousseau <ludovic.rousseau@free.fr>
483  *
484 Redistribution and use in source and binary forms, with or without
485 modification, are permitted provided that the following conditions
486 are met:
487 
488 1. Redistributions of source code must retain the above copyright
489  notice, this list of conditions and the following disclaimer.
490 2. Redistributions in binary form must reproduce the above copyright
491  notice, this list of conditions and the following disclaimer in the
492  documentation and/or other materials provided with the distribution.
493 3. The name of the author may not be used to endorse or promote products
494  derived from this software without specific prior written permission.
495 
496 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
497 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
498 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
499 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
500 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
501 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
502 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
503 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
504 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
505 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
506  *
507  * $Id: configfile.l 7004 2014-10-02 09:26:36Z rousseau $
508  */
509 #line 40 "configfile.l"
510 #include <dirent.h>
511 #include <sys/stat.h>
512 
513 #include "wintypes.h"
514 #include "pcscd.h"
515 #include "readerfactory.h"
516 #include "configfile.h"
517 
518 int evaluatetoken(char *pcToken);
519 
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;
528 static int badError;
529 static SerialReader *reader_list;
530 static int reader_list_size;
531 const char *ConfFile;
532 
533 void tok_error(char *pcToken_error);
534 
535 #define YY_NO_INPUT 1
536 #line 537 "configfile.c"
537 
538 #define INITIAL 0
539 
540 #ifndef YY_NO_UNISTD_H
541 /* Special case for "unistd.h", since it is non-ANSI. We include it way
542  * down here because we want the user's section 1 to have been scanned first.
543  * The user has a chance to override it with an option.
544  */
545 #include <unistd.h>
546 #endif
547 
548 #ifndef YY_EXTRA_TYPE
549 #define YY_EXTRA_TYPE void *
550 #endif
551 
552 static int yy_init_globals (void );
553 
554 /* Accessor methods to globals.
555  These are made visible to non-reentrant scanners for convenience. */
556 
557 int yylex_destroy (void );
558 
559 int yyget_debug (void );
560 
561 void yyset_debug (int debug_flag );
562 
563 YY_EXTRA_TYPE yyget_extra (void );
564 
565 void yyset_extra (YY_EXTRA_TYPE user_defined );
566 
567 FILE *yyget_in (void );
568 
569 void yyset_in (FILE * in_str );
570 
571 FILE *yyget_out (void );
572 
573 void yyset_out (FILE * out_str );
574 
575 yy_size_t yyget_leng (void );
576 
577 char *yyget_text (void );
578 
579 int yyget_lineno (void );
580 
581 void yyset_lineno (int line_number );
582 
583 /* Macros after this point can all be overridden by user definitions in
584  * section 1.
585  */
586 
587 #ifndef YY_SKIP_YYWRAP
588 #ifdef __cplusplus
589 extern "C" int yywrap (void );
590 #else
591 extern int yywrap (void );
592 #endif
593 #endif
594 
595 #ifndef yytext_ptr
596 static void yy_flex_strncpy (char *,yyconst char *,int );
597 #endif
598 
599 #ifdef YY_NEED_STRLEN
600 static int yy_flex_strlen (yyconst char * );
601 #endif
602 
603 #ifndef YY_NO_INPUT
604 
605 #ifdef __cplusplus
606 static int yyinput (void );
607 #else
608 static int input (void );
609 #endif
610 
611 #endif
612 
613 /* Amount of stuff to slurp up with each read. */
614 #ifndef YY_READ_BUF_SIZE
615 #ifdef __ia64__
616 /* On IA-64, the buffer size is 16k, not 8k */
617 #define YY_READ_BUF_SIZE 16384
618 #else
619 #define YY_READ_BUF_SIZE 8192
620 #endif /* __ia64__ */
621 #endif
622 
623 /* Copy whatever the last rule matched to the standard output. */
624 #ifndef ECHO
625 /* This used to be an fputs(), but since the string might contain NUL's,
626  * we now use fwrite().
627  */
628 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
629 #endif
630 
631 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
632  * is returned in "result".
633  */
634 #ifndef YY_INPUT
635 #define YY_INPUT(buf,result,max_size) \
636  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
637  { \
638  int c = '*'; \
639  size_t n; \
640  for ( n = 0; n < max_size && \
641  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
642  buf[n] = (char) c; \
643  if ( c == '\n' ) \
644  buf[n++] = (char) c; \
645  if ( c == EOF && ferror( yyin ) ) \
646  YY_FATAL_ERROR( "input in flex scanner failed" ); \
647  result = n; \
648  } \
649  else \
650  { \
651  errno=0; \
652  while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
653  { \
654  if( errno != EINTR) \
655  { \
656  YY_FATAL_ERROR( "input in flex scanner failed" ); \
657  break; \
658  } \
659  errno=0; \
660  clearerr(yyin); \
661  } \
662  }\
663 \
664 
665 #endif
666 
667 /* No semi-colon after return; correct usage is to write "yyterminate();" -
668  * we don't want an extra ';' after the "return" because that will cause
669  * some compilers to complain about unreachable statements.
670  */
671 #ifndef yyterminate
672 #define yyterminate() return YY_NULL
673 #endif
674 
675 /* Number of entries by which start-condition stack grows. */
676 #ifndef YY_START_STACK_INCR
677 #define YY_START_STACK_INCR 25
678 #endif
679 
680 /* Report a fatal error. */
681 #ifndef YY_FATAL_ERROR
682 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
683 #endif
684 
685 /* end tables serialization structures and prototypes */
686 
687 /* Default declaration of generated scanner - a define so the user can
688  * easily add parameters.
689  */
690 #ifndef YY_DECL
691 #define YY_DECL_IS_OURS 1
692 
693 extern int yylex (void);
694 
695 #define YY_DECL int yylex (void)
696 #endif /* !YY_DECL */
697 
698 /* Code executed at the beginning of each rule, after yytext and yyleng
699  * have been set up.
700  */
701 #ifndef YY_USER_ACTION
702 #define YY_USER_ACTION
703 #endif
704 
705 /* Code executed at the end of each rule. */
706 #ifndef YY_BREAK
707 #define YY_BREAK break;
708 #endif
709 
710 #define YY_RULE_SETUP \
711  YY_USER_ACTION
712 
715 YY_DECL
716 {
717  register yy_state_type yy_current_state;
718  register char *yy_cp, *yy_bp;
719  register int yy_act;
720 
721  if ( !(yy_init) )
722  {
723  (yy_init) = 1;
724 
725 #ifdef YY_USER_INIT
726  YY_USER_INIT;
727 #endif
728 
729  if ( ! (yy_start) )
730  (yy_start) = 1; /* first start state */
731 
732  if ( ! yyin )
733  yyin = stdin;
734 
735  if ( ! yyout )
736  yyout = stdout;
737 
738  if ( ! YY_CURRENT_BUFFER ) {
739  yyensure_buffer_stack ();
740  YY_CURRENT_BUFFER_LVALUE =
741  yy_create_buffer(yyin,YY_BUF_SIZE );
742  }
743 
744  yy_load_buffer_state( );
745  }
746 
747  {
748 #line 71 "configfile.l"
749 
750 
751 #line 752 "configfile.c"
752 
753  while ( 1 ) /* loops until end-of-file is reached */
754  {
755  yy_cp = (yy_c_buf_p);
756 
757  /* Support of yytext. */
758  *yy_cp = (yy_hold_char);
759 
760  /* yy_bp points to the position in yy_ch_buf of the start of
761  * the current run.
762  */
763  yy_bp = yy_cp;
764 
765  yy_current_state = (yy_start);
766 yy_match:
767  do
768  {
769  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
770  if ( yy_accept[yy_current_state] )
771  {
772  (yy_last_accepting_state) = yy_current_state;
773  (yy_last_accepting_cpos) = yy_cp;
774  }
775  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
776  {
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];
780  }
781  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
782  ++yy_cp;
783  }
784  while ( yy_base[yy_current_state] != 31 );
785 
786 yy_find_action:
787  yy_act = yy_accept[yy_current_state];
788  if ( yy_act == 0 )
789  { /* have to back up */
790  yy_cp = (yy_last_accepting_cpos);
791  yy_current_state = (yy_last_accepting_state);
792  yy_act = yy_accept[yy_current_state];
793  }
794 
795  YY_DO_BEFORE_ACTION;
796 
797 do_action: /* This label is used only to access EOF actions. */
798 
799  switch ( yy_act )
800  { /* beginning of action switch */
801  case 0: /* must back up */
802  /* undo the effects of YY_DO_BEFORE_ACTION */
803  *yy_cp = (yy_hold_char);
804  yy_cp = (yy_last_accepting_cpos);
805  yy_current_state = (yy_last_accepting_state);
806  goto yy_find_action;
807 
808 case 1:
809 YY_RULE_SETUP
810 #line 73 "configfile.l"
811 {}
812  YY_BREAK
813 case 2:
814 /* rule 2 can match eol */
815 YY_RULE_SETUP
816 #line 74 "configfile.l"
817 { iLinenumber++; }
818  YY_BREAK
819 case 3:
820 /* rule 3 can match eol */
821 YY_RULE_SETUP
822 #line 75 "configfile.l"
823 { (void)evaluatetoken(yytext); }
824  YY_BREAK
825 case 4:
826 YY_RULE_SETUP
827 #line 76 "configfile.l"
828 {}
829  YY_BREAK
830 case 5:
831 YY_RULE_SETUP
832 #line 77 "configfile.l"
833 { (void)evaluatetoken(yytext); }
834  YY_BREAK
835 case 6:
836 YY_RULE_SETUP
837 #line 78 "configfile.l"
838 { iOldLinenumber = iLinenumber; tok_error(yytext); }
839  YY_BREAK
840 case 7:
841 YY_RULE_SETUP
842 #line 79 "configfile.l"
843 ECHO;
844  YY_BREAK
845 #line 846 "configfile.c"
846 case YY_STATE_EOF(INITIAL):
847  yyterminate();
848 
849  case YY_END_OF_BUFFER:
850  {
851  /* Amount of text matched not including the EOB char. */
852  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
853 
854  /* Undo the effects of YY_DO_BEFORE_ACTION. */
855  *yy_cp = (yy_hold_char);
856  YY_RESTORE_YY_MORE_OFFSET
857 
858  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
859  {
860  /* We're scanning a new file or input source. It's
861  * possible that this happened because the user
862  * just pointed yyin at a new source and called
863  * yylex(). If so, then we have to assure
864  * consistency between YY_CURRENT_BUFFER and our
865  * globals. Here is the right place to do so, because
866  * this is the first action (other than possibly a
867  * back-up) that will match for the new input source.
868  */
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;
872  }
873 
874  /* Note that here we test for yy_c_buf_p "<=" to the position
875  * of the first EOB in the buffer, since yy_c_buf_p will
876  * already have been incremented past the NUL character
877  * (since all states make transitions on EOB to the
878  * end-of-buffer state). Contrast this with the test
879  * in input().
880  */
881  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
882  { /* This was really a NUL. */
883  yy_state_type yy_next_state;
884 
885  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
886 
887  yy_current_state = yy_get_previous_state( );
888 
889  /* Okay, we're now positioned to make the NUL
890  * transition. We couldn't have
891  * yy_get_previous_state() go ahead and do it
892  * for us because it doesn't know how to deal
893  * with the possibility of jamming (and we don't
894  * want to build jamming into it because then it
895  * will run more slowly).
896  */
897 
898  yy_next_state = yy_try_NUL_trans( yy_current_state );
899 
900  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
901 
902  if ( yy_next_state )
903  {
904  /* Consume the NUL. */
905  yy_cp = ++(yy_c_buf_p);
906  yy_current_state = yy_next_state;
907  goto yy_match;
908  }
909 
910  else
911  {
912  yy_cp = (yy_c_buf_p);
913  goto yy_find_action;
914  }
915  }
916 
917  else switch ( yy_get_next_buffer( ) )
918  {
919  case EOB_ACT_END_OF_FILE:
920  {
921  (yy_did_buffer_switch_on_eof) = 0;
922 
923  if ( yywrap( ) )
924  {
925  /* Note: because we've taken care in
926  * yy_get_next_buffer() to have set up
927  * yytext, we can now set up
928  * yy_c_buf_p so that if some total
929  * hoser (like flex itself) wants to
930  * call the scanner after we return the
931  * YY_NULL, it'll still work - another
932  * YY_NULL will get returned.
933  */
934  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
935 
936  yy_act = YY_STATE_EOF(YY_START);
937  goto do_action;
938  }
939 
940  else
941  {
942  if ( ! (yy_did_buffer_switch_on_eof) )
943  YY_NEW_FILE;
944  }
945  break;
946  }
947 
948  case EOB_ACT_CONTINUE_SCAN:
949  (yy_c_buf_p) =
950  (yytext_ptr) + yy_amount_of_matched_text;
951 
952  yy_current_state = yy_get_previous_state( );
953 
954  yy_cp = (yy_c_buf_p);
955  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
956  goto yy_match;
957 
958  case EOB_ACT_LAST_MATCH:
959  (yy_c_buf_p) =
960  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
961 
962  yy_current_state = yy_get_previous_state( );
963 
964  yy_cp = (yy_c_buf_p);
965  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
966  goto yy_find_action;
967  }
968  break;
969  }
970 
971  default:
972  YY_FATAL_ERROR(
973  "fatal flex scanner internal error--no action found" );
974  } /* end of action switch */
975  } /* end of scanning one token */
976  } /* end of user's declarations */
977 } /* end of yylex */
978 
979 /* yy_get_next_buffer - try to read in a new buffer
980  *
981  * Returns a code representing an action:
982  * EOB_ACT_LAST_MATCH -
983  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
984  * EOB_ACT_END_OF_FILE - end of file
985  */
986 static int yy_get_next_buffer (void)
987 {
988  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
989  register char *source = (yytext_ptr);
990  register int number_to_move, i;
991  int ret_val;
992 
993  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
994  YY_FATAL_ERROR(
995  "fatal flex scanner internal error--end of buffer missed" );
996 
997  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
998  { /* Don't try to fill the buffer, so this is an EOF. */
999  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1000  {
1001  /* We matched a single character, the EOB, so
1002  * treat this as a final EOF.
1003  */
1004  return EOB_ACT_END_OF_FILE;
1005  }
1006 
1007  else
1008  {
1009  /* We matched some text prior to the EOB, first
1010  * process it.
1011  */
1012  return EOB_ACT_LAST_MATCH;
1013  }
1014  }
1015 
1016  /* Try to read more data. */
1017 
1018  /* First move last chars to start of buffer. */
1019  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1020 
1021  for ( i = 0; i < number_to_move; ++i )
1022  *(dest++) = *(source++);
1023 
1024  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1025  /* don't do the read, it's not guaranteed to return an EOF,
1026  * just force an EOF
1027  */
1028  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1029 
1030  else
1031  {
1032  yy_size_t num_to_read =
1033  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1034 
1035  while ( num_to_read <= 0 )
1036  { /* Not enough room in the buffer - grow it. */
1037 
1038  /* just a shorter name for the current buffer */
1039  YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1040 
1041  int yy_c_buf_p_offset =
1042  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1043 
1044  if ( b->yy_is_our_buffer )
1045  {
1046  yy_size_t new_size = b->yy_buf_size * 2;
1047 
1048  if ( new_size <= 0 )
1049  b->yy_buf_size += b->yy_buf_size / 8;
1050  else
1051  b->yy_buf_size *= 2;
1052 
1053  b->yy_ch_buf = (char *)
1054  /* Include room in for 2 EOB chars. */
1055  yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1056  }
1057  else
1058  /* Can't grow it, we don't own it. */
1059  b->yy_ch_buf = 0;
1060 
1061  if ( ! b->yy_ch_buf )
1062  YY_FATAL_ERROR(
1063  "fatal error - scanner input buffer overflow" );
1064 
1065  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1066 
1067  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1068  number_to_move - 1;
1069 
1070  }
1071 
1072  if ( num_to_read > YY_READ_BUF_SIZE )
1073  num_to_read = YY_READ_BUF_SIZE;
1074 
1075  /* Read in more data. */
1076  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1077  (yy_n_chars), num_to_read );
1078 
1079  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1080  }
1081 
1082  if ( (yy_n_chars) == 0 )
1083  {
1084  if ( number_to_move == YY_MORE_ADJ )
1085  {
1086  ret_val = EOB_ACT_END_OF_FILE;
1087  yyrestart(yyin );
1088  }
1089 
1090  else
1091  {
1092  ret_val = EOB_ACT_LAST_MATCH;
1093  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1094  YY_BUFFER_EOF_PENDING;
1095  }
1096  }
1097 
1098  else
1099  ret_val = EOB_ACT_CONTINUE_SCAN;
1100 
1101  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1102  /* Extend the array by 50%, plus the number we really need. */
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()" );
1107  }
1108 
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;
1112 
1113  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1114 
1115  return ret_val;
1116 }
1117 
1118 /* yy_get_previous_state - get the state just before the EOB char was reached */
1119 
1120  static yy_state_type yy_get_previous_state (void)
1121 {
1122  register yy_state_type yy_current_state;
1123  register char *yy_cp;
1124 
1125  yy_current_state = (yy_start);
1126 
1127  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1128  {
1129  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1130  if ( yy_accept[yy_current_state] )
1131  {
1132  (yy_last_accepting_state) = yy_current_state;
1133  (yy_last_accepting_cpos) = yy_cp;
1134  }
1135  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1136  {
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];
1140  }
1141  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1142  }
1143 
1144  return yy_current_state;
1145 }
1146 
1147 /* yy_try_NUL_trans - try to make a transition on the NUL character
1148  *
1149  * synopsis
1150  * next_state = yy_try_NUL_trans( current_state );
1151  */
1152  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1153 {
1154  register int yy_is_jam;
1155  register char *yy_cp = (yy_c_buf_p);
1156 
1157  register YY_CHAR yy_c = 1;
1158  if ( yy_accept[yy_current_state] )
1159  {
1160  (yy_last_accepting_state) = yy_current_state;
1161  (yy_last_accepting_cpos) = yy_cp;
1162  }
1163  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1164  {
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];
1168  }
1169  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1170  yy_is_jam = (yy_current_state == 16);
1171 
1172  return yy_is_jam ? 0 : yy_current_state;
1173 }
1174 
1175 #ifndef YY_NO_INPUT
1176 #ifdef __cplusplus
1177  static int yyinput (void)
1178 #else
1179  static int input (void)
1180 #endif
1181 
1182 {
1183  int c;
1184 
1185  *(yy_c_buf_p) = (yy_hold_char);
1186 
1187  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1188  {
1189  /* yy_c_buf_p now points to the character we want to return.
1190  * If this occurs *before* the EOB characters, then it's a
1191  * valid NUL; if not, then we've hit the end of the buffer.
1192  */
1193  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1194  /* This was really a NUL. */
1195  *(yy_c_buf_p) = '\0';
1196 
1197  else
1198  { /* need more input */
1199  yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1200  ++(yy_c_buf_p);
1201 
1202  switch ( yy_get_next_buffer( ) )
1203  {
1204  case EOB_ACT_LAST_MATCH:
1205  /* This happens because yy_g_n_b()
1206  * sees that we've accumulated a
1207  * token and flags that we need to
1208  * try matching the token before
1209  * proceeding. But for input(),
1210  * there's no matching to consider.
1211  * So convert the EOB_ACT_LAST_MATCH
1212  * to EOB_ACT_END_OF_FILE.
1213  */
1214 
1215  /* Reset buffer status. */
1216  yyrestart(yyin );
1217 
1218  /*FALLTHROUGH*/
1219 
1220  case EOB_ACT_END_OF_FILE:
1221  {
1222  if ( yywrap( ) )
1223  return EOF;
1224 
1225  if ( ! (yy_did_buffer_switch_on_eof) )
1226  YY_NEW_FILE;
1227 #ifdef __cplusplus
1228  return yyinput();
1229 #else
1230  return input();
1231 #endif
1232  }
1233 
1234  case EOB_ACT_CONTINUE_SCAN:
1235  (yy_c_buf_p) = (yytext_ptr) + offset;
1236  break;
1237  }
1238  }
1239  }
1240 
1241  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1242  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1243  (yy_hold_char) = *++(yy_c_buf_p);
1244 
1245  return c;
1246 }
1247 #endif /* ifndef YY_NO_INPUT */
1248 
1254  void yyrestart (FILE * input_file )
1255 {
1256 
1257  if ( ! YY_CURRENT_BUFFER ){
1258  yyensure_buffer_stack ();
1259  YY_CURRENT_BUFFER_LVALUE =
1260  yy_create_buffer(yyin,YY_BUF_SIZE );
1261  }
1262 
1263  yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1264  yy_load_buffer_state( );
1265 }
1266 
1271  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1272 {
1273 
1274  /* TODO. We should be able to replace this entire function body
1275  * with
1276  * yypop_buffer_state();
1277  * yypush_buffer_state(new_buffer);
1278  */
1279  yyensure_buffer_stack ();
1280  if ( YY_CURRENT_BUFFER == new_buffer )
1281  return;
1282 
1283  if ( YY_CURRENT_BUFFER )
1284  {
1285  /* Flush out information for old 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);
1289  }
1290 
1291  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1292  yy_load_buffer_state( );
1293 
1294  /* We don't actually know whether we did this switch during
1295  * EOF (yywrap()) processing, but the only time this flag
1296  * is looked at is after yywrap() is called, so it's safe
1297  * to go ahead and always set it.
1298  */
1299  (yy_did_buffer_switch_on_eof) = 1;
1300 }
1301 
1302 static void yy_load_buffer_state (void)
1303 {
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);
1308 }
1309 
1316  YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1317 {
1318  YY_BUFFER_STATE b;
1319 
1320  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1321  if ( ! b )
1322  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1323 
1324  b->yy_buf_size = size;
1325 
1326  /* yy_ch_buf has to be 2 characters longer than the size given because
1327  * we need to put in 2 end-of-buffer characters.
1328  */
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()" );
1332 
1333  b->yy_is_our_buffer = 1;
1334 
1335  yy_init_buffer(b,file );
1336 
1337  return b;
1338 }
1339 
1344  void yy_delete_buffer (YY_BUFFER_STATE b )
1345 {
1346 
1347  if ( ! b )
1348  return;
1349 
1350  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1351  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1352 
1353  if ( b->yy_is_our_buffer )
1354  yyfree((void *) b->yy_ch_buf );
1355 
1356  yyfree((void *) b );
1357 }
1358 
1359 /* Initializes or reinitializes a buffer.
1360  * This function is sometimes called more than once on the same buffer,
1361  * such as during a yyrestart() or at EOF.
1362  */
1363  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1364 
1365 {
1366  int oerrno = errno;
1367 
1368  yy_flush_buffer(b );
1369 
1370  b->yy_input_file = file;
1371  b->yy_fill_buffer = 1;
1372 
1373  /* If b is the current buffer, then yy_init_buffer was _probably_
1374  * called from yyrestart() or through yy_get_next_buffer.
1375  * In that case, we don't want to reset the lineno or column.
1376  */
1377  if (b != YY_CURRENT_BUFFER){
1378  b->yy_bs_lineno = 1;
1379  b->yy_bs_column = 0;
1380  }
1381 
1382  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1383 
1384  errno = oerrno;
1385 }
1386 
1391  void yy_flush_buffer (YY_BUFFER_STATE b )
1392 {
1393  if ( ! b )
1394  return;
1395 
1396  b->yy_n_chars = 0;
1397 
1398  /* We always need two end-of-buffer characters. The first causes
1399  * a transition to the end-of-buffer state. The second causes
1400  * a jam in that state.
1401  */
1402  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1403  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1404 
1405  b->yy_buf_pos = &b->yy_ch_buf[0];
1406 
1407  b->yy_at_bol = 1;
1408  b->yy_buffer_status = YY_BUFFER_NEW;
1409 
1410  if ( b == YY_CURRENT_BUFFER )
1411  yy_load_buffer_state( );
1412 }
1413 
1420 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1421 {
1422  if (new_buffer == NULL)
1423  return;
1424 
1425  yyensure_buffer_stack();
1426 
1427  /* This block is copied from yy_switch_to_buffer. */
1428  if ( YY_CURRENT_BUFFER )
1429  {
1430  /* Flush out information for old 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);
1434  }
1435 
1436  /* Only push if top exists. Otherwise, replace top. */
1437  if (YY_CURRENT_BUFFER)
1438  (yy_buffer_stack_top)++;
1439  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1440 
1441  /* copied from yy_switch_to_buffer. */
1442  yy_load_buffer_state( );
1443  (yy_did_buffer_switch_on_eof) = 1;
1444 }
1445 
1450 void yypop_buffer_state (void)
1451 {
1452  if (!YY_CURRENT_BUFFER)
1453  return;
1454 
1455  yy_delete_buffer(YY_CURRENT_BUFFER );
1456  YY_CURRENT_BUFFER_LVALUE = NULL;
1457  if ((yy_buffer_stack_top) > 0)
1458  --(yy_buffer_stack_top);
1459 
1460  if (YY_CURRENT_BUFFER) {
1461  yy_load_buffer_state( );
1462  (yy_did_buffer_switch_on_eof) = 1;
1463  }
1464 }
1465 
1466 /* Allocates the stack if it does not exist.
1467  * Guarantees space for at least one push.
1468  */
1469 static void yyensure_buffer_stack (void)
1470 {
1471  yy_size_t num_to_alloc;
1472 
1473  if (!(yy_buffer_stack)) {
1474 
1475  /* First allocation is just for 2 elements, since we don't know if this
1476  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1477  * immediate realloc on the next call.
1478  */
1479  num_to_alloc = 1;
1480  (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1481  (num_to_alloc * sizeof(struct yy_buffer_state*)
1482  );
1483  if ( ! (yy_buffer_stack) )
1484  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1485 
1486  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1487 
1488  (yy_buffer_stack_max) = num_to_alloc;
1489  (yy_buffer_stack_top) = 0;
1490  return;
1491  }
1492 
1493  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1494 
1495  /* Increase the buffer to prepare for a possible push. */
1496  int grow_size = 8 /* arbitrary grow size */;
1497 
1498  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1499  (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1500  ((yy_buffer_stack),
1501  num_to_alloc * sizeof(struct yy_buffer_state*)
1502  );
1503  if ( ! (yy_buffer_stack) )
1504  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1505 
1506  /* zero only the new slots.*/
1507  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1508  (yy_buffer_stack_max) = num_to_alloc;
1509  }
1510 }
1511 
1518 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1519 {
1520  YY_BUFFER_STATE b;
1521 
1522  if ( size < 2 ||
1523  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1524  base[size-1] != YY_END_OF_BUFFER_CHAR )
1525  /* They forgot to leave room for the EOB's. */
1526  return 0;
1527 
1528  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1529  if ( ! b )
1530  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1531 
1532  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
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;
1538  b->yy_at_bol = 1;
1539  b->yy_fill_buffer = 0;
1540  b->yy_buffer_status = YY_BUFFER_NEW;
1541 
1542  yy_switch_to_buffer(b );
1543 
1544  return b;
1545 }
1546 
1555 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1556 {
1557 
1558  return yy_scan_bytes(yystr,strlen(yystr) );
1559 }
1560 
1568 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1569 {
1570  YY_BUFFER_STATE b;
1571  char *buf;
1572  yy_size_t n;
1573  yy_size_t i;
1574 
1575  /* Get memory for full buffer, including space for trailing EOB's. */
1576  n = _yybytes_len + 2;
1577  buf = (char *) yyalloc(n );
1578  if ( ! buf )
1579  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1580 
1581  for ( i = 0; i < _yybytes_len; ++i )
1582  buf[i] = yybytes[i];
1583 
1584  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1585 
1586  b = yy_scan_buffer(buf,n );
1587  if ( ! b )
1588  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1589 
1590  /* It's okay to grow etc. this buffer, and we should throw it
1591  * away when we're done.
1592  */
1593  b->yy_is_our_buffer = 1;
1594 
1595  return b;
1596 }
1597 
1598 #ifndef YY_EXIT_FAILURE
1599 #define YY_EXIT_FAILURE 2
1600 #endif
1601 
1602 static void yy_fatal_error (yyconst char* msg )
1603 {
1604  (void) fprintf( stderr, "%s\n", msg );
1605  exit( YY_EXIT_FAILURE );
1606 }
1607 
1608 /* Redefine yyless() so it works in section 3 code. */
1609 
1610 #undef yyless
1611 #define yyless(n) \
1612  do \
1613  { \
1614  /* Undo effects of setting up yytext. */ \
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; \
1622  } \
1623  while ( 0 )
1624 
1625 /* Accessor methods (get/set functions) to struct members. */
1626 
1630 int yyget_lineno (void)
1631 {
1632 
1633  return yylineno;
1634 }
1635 
1639 FILE *yyget_in (void)
1640 {
1641  return yyin;
1642 }
1643 
1647 FILE *yyget_out (void)
1648 {
1649  return yyout;
1650 }
1651 
1655 yy_size_t yyget_leng (void)
1656 {
1657  return yyleng;
1658 }
1659 
1664 char *yyget_text (void)
1665 {
1666  return yytext;
1667 }
1668 
1673 void yyset_lineno (int line_number )
1674 {
1675 
1676  yylineno = line_number;
1677 }
1678 
1685 void yyset_in (FILE * in_str )
1686 {
1687  yyin = in_str ;
1688 }
1689 
1690 void yyset_out (FILE * out_str )
1691 {
1692  yyout = out_str ;
1693 }
1694 
1695 int yyget_debug (void)
1696 {
1697  return yy_flex_debug;
1698 }
1699 
1700 void yyset_debug (int bdebug )
1701 {
1702  yy_flex_debug = bdebug ;
1703 }
1704 
1705 static int yy_init_globals (void)
1706 {
1707  /* Initialization is the same as for the non-reentrant scanner.
1708  * This function is called from yylex_destroy(), so don't allocate here.
1709  */
1710 
1711  (yy_buffer_stack) = 0;
1712  (yy_buffer_stack_top) = 0;
1713  (yy_buffer_stack_max) = 0;
1714  (yy_c_buf_p) = (char *) 0;
1715  (yy_init) = 0;
1716  (yy_start) = 0;
1717 
1718 /* Defined in main.c */
1719 #ifdef YY_STDINIT
1720  yyin = stdin;
1721  yyout = stdout;
1722 #else
1723  yyin = (FILE *) 0;
1724  yyout = (FILE *) 0;
1725 #endif
1726 
1727  /* For future reference: Set errno on error, since we are called by
1728  * yylex_init()
1729  */
1730  return 0;
1731 }
1732 
1733 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1734 int yylex_destroy (void)
1735 {
1736 
1737  /* Pop the buffer stack, destroying each element. */
1738  while(YY_CURRENT_BUFFER){
1739  yy_delete_buffer(YY_CURRENT_BUFFER );
1740  YY_CURRENT_BUFFER_LVALUE = NULL;
1741  yypop_buffer_state();
1742  }
1743 
1744  /* Destroy the stack itself. */
1745  yyfree((yy_buffer_stack) );
1746  (yy_buffer_stack) = NULL;
1747 
1748  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1749  * yylex() is called, initialization will occur. */
1750  yy_init_globals( );
1751 
1752  return 0;
1753 }
1754 
1755 /*
1756  * Internal utility routines.
1757  */
1758 
1759 #ifndef yytext_ptr
1760 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1761 {
1762  register int i;
1763  for ( i = 0; i < n; ++i )
1764  s1[i] = s2[i];
1765 }
1766 #endif
1767 
1768 #ifdef YY_NEED_STRLEN
1769 static int yy_flex_strlen (yyconst char * s )
1770 {
1771  register int n;
1772  for ( n = 0; s[n]; ++n )
1773  ;
1774 
1775  return n;
1776 }
1777 #endif
1778 
1779 void *yyalloc (yy_size_t size )
1780 {
1781  return (void *) malloc( size );
1782 }
1783 
1784 void *yyrealloc (void * ptr, yy_size_t size )
1785 {
1786  /* The cast to (char *) in the following accommodates both
1787  * implementations that use char* generic pointers, and those
1788  * that use void* generic pointers. It works with the latter
1789  * because both ANSI C and C++ allow castless assignment from
1790  * any pointer type to void*, and deal with argument conversions
1791  * as though doing an assignment.
1792  */
1793  return (void *) realloc( (char *) ptr, size );
1794 }
1795 
1796 void yyfree (void * ptr )
1797 {
1798  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1799 }
1800 
1801 #define YYTABLES_NAME "yytables"
1802 
1803 #line 78 "configfile.l"
1804 
1805 
1806 
1807 #include <stdio.h>
1808 #include <string.h>
1809 #include <errno.h>
1810 
1811 #include "config.h"
1812 #include "misc.h"
1813 #include "pcsclite.h"
1814 #include "pcscd.h"
1815 #include "debuglog.h"
1816 #include "sys_generic.h"
1817 #include "readerfactory.h"
1818 
1819 int evaluatetoken(char *pcToken)
1820 {
1821  if (pcPrevious == NULL)
1822  { /* This is the key */
1823  pcPrevious = strdup(pcToken);
1824  iOldLinenumber = iLinenumber;
1825  }
1826  else
1827  {
1828  /* first and second tokens are not on the same line */
1829  if (iOldLinenumber != iLinenumber)
1830  {
1831  tok_error(pcPrevious);
1832  pcPrevious = strdup(pcToken);
1833  iOldLinenumber = iLinenumber;
1834  return 1;
1835  }
1836 
1837  pcCurrent = pcToken;
1838  if (strcmp(pcPrevious, "FRIENDLYNAME") == 0)
1839  {
1840  if (pcFriendlyname == NULL)
1841  {
1842  size_t n, p;
1843 
1844  pcFriendlyname = malloc(strlen(pcCurrent) + 1);
1845  for (n = 0, p = 0; n < strlen(pcCurrent); n++)
1846  {
1847  if (pcCurrent[n] != '"')
1848  { /* Strip off the quotes */
1849  pcFriendlyname[p++] = pcCurrent[n];
1850  }
1851  }
1852  pcFriendlyname[p++] = '\0';
1853  }
1854  else
1855  {
1856  tok_error(pcPrevious);
1857  return 1;
1858  }
1859  }
1860  else if (strcmp(pcPrevious, "DEVICENAME") == 0)
1861  {
1862  if (pcDevicename == NULL)
1863  {
1864  struct stat fStatBuf;
1865 
1866  pcDevicename = strdup(pcCurrent);
1867  if ((NULL == strchr(pcDevicename, ':'))
1868  && (stat(pcDevicename, &fStatBuf) != 0))
1869  {
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");
1873  badError = 1;
1874  }
1875  }
1876  else
1877  {
1878  tok_error(pcPrevious);
1879  return 1;
1880  }
1881  }
1882  else if (strcmp(pcPrevious, "LIBPATH") == 0)
1883  {
1884  if (pcLibpath == NULL)
1885  {
1886  struct stat fStatBuf;
1887 
1888  pcLibpath = strdup(pcCurrent);
1889  if (stat(pcLibpath, &fStatBuf) != 0)
1890  {
1891  Log3(PCSC_LOG_CRITICAL, "Error with library %s: %s",
1892  pcLibpath, strerror(errno));
1893  badError = 1;
1894  }
1895 
1896  if (strstr(pcLibpath, ".bundle") != NULL)
1897  {
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 *************************************");
1901  }
1902  }
1903  else
1904  {
1905  tok_error(pcPrevious);
1906  return 1;
1907  }
1908  }
1909  else if (strcmp(pcPrevious, "CHANNELID") == 0)
1910  {
1911  if (pcChannelid == NULL)
1912  pcChannelid = strdup(pcCurrent);
1913  else
1914  {
1915  tok_error(pcPrevious);
1916  return 1;
1917  }
1918  }
1919  else
1920  {
1921  tok_error(pcPrevious);
1922  free(pcPrevious);
1923  pcPrevious = NULL;
1924  return 1;
1925  }
1926 
1927  free(pcPrevious);
1928  pcPrevious = NULL;
1929  }
1930 
1931  /* CHANNELID and DEVICENAME are both optional but not at the same time */
1932  if (pcFriendlyname && pcLibpath && badError != 1
1933  && (pcChannelid || pcDevicename))
1934  {
1935  int channelId;
1936  static char* defaultDeviceName = (char *)"";
1937 
1938  Log2(PCSC_LOG_DEBUG, "Add reader: %s", pcFriendlyname);
1939  if (0 == reader_list_size)
1940  {
1941  /* one real reader and one end marker */
1942  reader_list_size = 2;
1943  reader_list = malloc(reader_list_size * sizeof(SerialReader));
1944  }
1945  else
1946  {
1947  reader_list_size++;
1948  reader_list = realloc(reader_list, reader_list_size *
1949  sizeof(SerialReader));
1950  }
1951 
1952  /* end marker */
1953  reader_list[reader_list_size-1].pcFriendlyname = NULL;
1954 
1955  /* the DEVICENAME parameter is optional */
1956  if (NULL == pcDevicename)
1957  pcDevicename = defaultDeviceName;
1958 
1959  if (pcChannelid)
1960  channelId = strtoul(pcChannelid, NULL, 0);
1961  else
1962  channelId = 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;
1967 
1968  free(pcFriendlyname);
1969  pcFriendlyname = NULL;
1970 
1971  if (pcDevicename != defaultDeviceName)
1972  free(pcDevicename);
1973  pcDevicename = NULL;
1974 
1975  free(pcLibpath);
1976  pcLibpath = NULL;
1977 
1978  if (pcChannelid)
1979  free(pcChannelid);
1980  pcChannelid = NULL;
1981  }
1982 
1983  return 0;
1984 }
1985 
1986 void tok_error(char *token_error)
1987 {
1988  Log4(PCSC_LOG_ERROR, "tok_error: invalid value line %d in %s: %s",
1989  iOldLinenumber, ConfFile, token_error);
1990  badError = 1;
1991 }
1992 
1993 int DBGetReaderListDir(const char *readerconf_dir,
1994  SerialReader **caller_reader_list)
1995 {
1996  DIR *dir;
1997  int ret = 0;
1998 
1999  /* (re)start with an empty list */
2000  reader_list = NULL;
2001  reader_list_size = 0;
2002 
2003  dir = opendir(readerconf_dir);
2004  if (dir)
2005  {
2006  /* the configuration file is a directory */
2007  struct dirent *direntry;
2008 
2009  Log2(PCSC_LOG_DEBUG, "Parsing conf directory: %s", readerconf_dir);
2010 
2011  /* for each configuration file */
2012  while ((direntry = readdir(dir)) != NULL)
2013  {
2014  char filename[FILENAME_MAX];
2015  int r;
2016 
2017  snprintf(filename, sizeof(filename), "%s/%s",
2018  readerconf_dir, direntry->d_name);
2019 
2020  /* skip non regular files */
2021  if (direntry->d_type == DT_UNKNOWN)
2022  {
2023  struct stat st;
2024 
2025  if (lstat(filename, &st) != 0)
2026  {
2027  Log2(PCSC_LOG_DEBUG, "Skipping non statable file: %s",
2028  direntry->d_name);
2029  continue;
2030  }
2031 
2032  if (!S_ISREG(st.st_mode))
2033  {
2034  Log2(PCSC_LOG_DEBUG, "Skipping non regular file: %s",
2035  direntry->d_name);
2036  continue;
2037  }
2038  }
2039  else
2040  if (direntry->d_type != DT_REG)
2041  {
2042  Log2(PCSC_LOG_DEBUG, "Skipping non regular file: %s",
2043  direntry->d_name);
2044  continue;
2045  }
2046 
2047  /* skip files starting with . like ., .., .svn, etc */
2048  if ('.' == direntry->d_name[0])
2049  {
2050  Log2(PCSC_LOG_DEBUG, "Skipping hidden file: %s",
2051  direntry->d_name);
2052  continue;
2053  }
2054 
2055  /* each call to DBGetReaderList() will append to the list */
2056  r = DBGetReaderList(filename, caller_reader_list);
2057 
2058  /* set the global return value to the latest error */
2059  if (r)
2060  ret = r;
2061  }
2062 
2063  closedir(dir);
2064  }
2065  else
2066  /* the configuration file is really a file */
2067  ret = DBGetReaderList(readerconf_dir, caller_reader_list);
2068 
2069  return ret;
2070 }
2071 
2072 int DBGetReaderList(const char *readerconf, SerialReader **caller_reader_list)
2073 {
2074  FILE *configFile = NULL;
2075 
2076  *caller_reader_list = NULL; /* no list by default */
2077 
2078  /* used by tok_error() */
2079  ConfFile = readerconf;
2080 
2081  Log2(PCSC_LOG_DEBUG, "Parsing conf file: %s", ConfFile);
2082 
2083  configFile = fopen(readerconf, "r");
2084 
2085  if (configFile == NULL)
2086  return 1;
2087 
2088  yyin = configFile;
2089 
2090  /* (re)start with a clean state */
2091  iLinenumber = 1;
2092  iOldLinenumber = -1;
2093  pcFriendlyname = NULL;
2094  pcDevicename = NULL;
2095  pcLibpath = NULL;
2096  pcChannelid = NULL;
2097  pcPrevious = NULL;
2098  pcCurrent = NULL;
2099  badError = 0;
2100 
2101  do
2102  {
2103  (void)yylex();
2104  }
2105  while (!feof(configFile));
2106  yylex_destroy();
2107 
2108  (void)fclose(configFile);
2109 
2110  *caller_reader_list = reader_list;
2111 
2112  if (badError == 1)
2113  return -1;
2114  else
2115  return 0;
2116 } /* End of configfile.c */
2117 
2118 
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition: tokenparser.c:283
int yy_bs_column
The column count.
Definition: configfile.c:235
This handles abstract system level calls.
char * pcLibpath
LIBPATH.
Definition: readerfactory.h:54
static size_t yy_buffer_stack_max
capacity of stack.
Definition: tokenparser.c:282
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.
Definition: tokenparser.c:746
int channelId
CHANNELID.
Definition: readerfactory.h:55
This keeps track of a list of currently available reader structures.
static size_t yy_buffer_stack_top
index of top of stack.
Definition: tokenparser.c:281
char * pcDevicename
DEVICENAME.
Definition: readerfactory.h:53
char * pcFriendlyname
FRIENDLYNAME.
Definition: readerfactory.h:52
This handles debugging.
int yy_bs_lineno
The line count.
Definition: configfile.c:234