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