1
2 #line 3 "pam_conv_l.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 4
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 /* Feature test macros. Flex uses functions that require a minimum set of
20 * macros defined. As defining some macros may hide function declarations that
21 * user code might use, be conservative and respect user's definitions as much
22 * as possible. In glibc, feature test macros may not be all set up until one
23 * of the libc header (that includes <features.h>) is included. This creates
24 * a circular dependency when we check the macros. <assert.h> is the safest
25 * header we can include and does not declare too many functions we don't need.
26 */
27 #if !defined(__GNU_LIBRARY__) && defined(__STDC__)
28 #include <assert.h>
29 #endif
30 #if !(defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE) || \
31 defined(_POSIX_SOURCE))
32 # define _POSIX_C_SOURCE 1 /* Required for fileno() */
33 # define _POSIX_SOURCE 1
34 #endif
35 #include <stdio.h>
36 #include <string.h>
37 #include <errno.h>
38 #include <stdlib.h>
39
40 /* end standard C headers. */
41
42 /* begin standard C++ headers. */
43
44 /* flex integer type definitions */
45
46 #ifndef YYFLEX_INTTYPES_DEFINED
47 #define YYFLEX_INTTYPES_DEFINED
48
49 /* Prefer C99 integer types if available. */
50 # if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
51 /* Include <inttypes.h> and not <stdint.h> because Solaris 2.6 has the former
52 * and not the latter.
53 */
54 #include <inttypes.h>
55 # define YYFLEX_USE_STDINT
56 # else
57 # if defined(_MSC_VER) && _MSC_VER >= 1600
58 /* Visual C++ 2010 does not define __STDC_VERSION__ and has <stdint.h> but not
59 * <inttypes.h>.
60 */
61 #include <stdint.h>
62 # define YYFLEX_USE_STDINT
63 # endif
64 # endif
65 # ifdef YYFLEX_USE_STDINT
66 typedef int8_t flex_int8_t;
67 typedef uint8_t flex_uint8_t;
68 typedef int16_t flex_int16_t;
69 typedef uint16_t flex_uint16_t;
70 typedef int32_t flex_int32_t;
71 typedef uint32_t flex_uint32_t;
72 # else
73 typedef unsigned char flex_uint8_t;
74 typedef short int flex_int16_t;
75 typedef unsigned short int flex_uint16_t;
76 # ifdef __STDC__
77 typedef signed char flex_int8_t;
78 /* ISO C only requires at least 16 bits for int. */
79 #include <limits.h>
80 # if UINT_MAX >= 4294967295
81 # define YYFLEX_INT32_DEFINED
82 typedef int flex_int32_t;
83 typedef unsigned int flex_uint32_t;
84 # endif
85 # else
86 typedef char flex_int8_t;
87 # endif
88 # ifndef YYFLEX_INT32_DEFINED
89 typedef long int flex_int32_t;
90 typedef unsigned long int flex_uint32_t;
91 # endif
92 # endif
93 #endif /* YYFLEX_INTTYPES_DEFINED */
94
95 /* TODO: this is always defined, so inline it */
96 #define yyconst const
97
98 #if defined(__GNUC__) && __GNUC__ >= 3
99 #define yynoreturn __attribute__((__noreturn__))
100 #define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
101 #else
102 #define yynoreturn
103 #define YY_ATTRIBUTE_UNUSED /* __attribute__ ((__unused__)) */
104 #endif
105
106 /* Returned upon end-of-file. */
107 #define YY_NULL 0
108
109 /* Promotes a possibly negative, possibly signed char to an
110 * integer in range [0..255] for use as an array index.
111 */
112 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
113
114 /* Enter a start condition. This macro really ought to take a parameter,
115 * but we do it the disgusting crufty way forced on us by the ()-less
116 * definition of BEGIN.
117 */
118 #define BEGIN (yy_start) = 1 + 2 *
119 /* Translate the current start state into a value that can be later handed
120 * to BEGIN to return to the state. The YYSTATE alias is for lex
121 * compatibility.
122 */
123 #define YY_START (((yy_start) - 1) / 2)
124 #define YYSTATE YY_START
125 /* Action number for EOF rule of a given start state. */
126 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
127 /* Special action meaning "start processing a new file". */
128 #define YY_NEW_FILE yyrestart( yyin )
129 #define YY_END_OF_BUFFER_CHAR 0
130
131 /* Size of default input buffer. */
132 #ifndef YY_BUF_SIZE
133 #ifdef __ia64__
134 /* On IA-64, the buffer size is 16k, not 8k.
135 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
136 * Ditto for the __ia64__ case accordingly.
137 */
138 #define YY_BUF_SIZE 32768
139 #else
140 #define YY_BUF_SIZE 16384
141 #endif /* __ia64__ */
142 #endif
143
144 /* The state buf must be large enough to hold one state per character in the main buffer.
145 */
146 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
147
148 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
149 #define YY_TYPEDEF_YY_BUFFER_STATE
150 typedef struct yy_buffer_state *YY_BUFFER_STATE;
151 #endif
152
153 #ifndef YY_TYPEDEF_YY_SIZE_T
154 #define YY_TYPEDEF_YY_SIZE_T
155 typedef size_t yy_size_t;
156 #endif
157
158 extern int yyleng;
159
160 extern FILE *yyin, *yyout;
161
162 #define EOB_ACT_CONTINUE_SCAN 0
163 #define EOB_ACT_END_OF_FILE 1
164 #define EOB_ACT_LAST_MATCH 2
165
166 #define YY_LESS_LINENO(n)
167 #define YY_LINENO_REWIND_TO(ptr)
168
169 /* Return all but the first "n" matched characters back to the input stream. */
170 #define yyless(n) \
171 do \
172 { \
173 /* Undo effects of setting up yytext. */ \
174 int yyless_macro_arg = (n); \
175 YY_LESS_LINENO(yyless_macro_arg);\
176 *yy_cp = (yy_hold_char); \
177 YY_RESTORE_YY_MORE_OFFSET \
178 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
179 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
180 } \
181 while ( 0 )
182 #define unput(c) yyunput( c, (yytext_ptr) )
183
184 #ifndef YY_STRUCT_YY_BUFFER_STATE
185 #define YY_STRUCT_YY_BUFFER_STATE
186 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
222 int yy_bs_lineno; /**< The line count. */
223 int yy_bs_column; /**< The column count. */
224
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; /**< index of top of stack. */
251 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
252 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
253
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 /* Same as previous macro, but useful when we know that the buffer stack is not
264 * NULL or when we need an lvalue. For internal use only.
265 */
266 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
267
268 /* yy_hold_char holds the character lost when yytext is formed. */
269 static char yy_hold_char;
270 static int yy_n_chars; /* number of characters read into yy_ch_buf */
271 int yyleng;
272
273 /* Points to current character in buffer. */
274 static char *yy_c_buf_p = NULL;
275 static int yy_init = 0; /* whether we need to initialize */
276 static int yy_start = 0; /* start state number */
277
278 /* Flag which is used to allow yywrap()'s to do buffer switches
279 * instead of setting up a fresh yyin. A bit of a hack ...
280 */
281 static int yy_did_buffer_switch_on_eof;
282
283 void yyrestart ( FILE *input_file );
284 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
285 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
286 void yy_delete_buffer ( YY_BUFFER_STATE b );
287 void yy_flush_buffer ( YY_BUFFER_STATE b );
288 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
289 void yypop_buffer_state ( void );
290
291 static void yyensure_buffer_stack ( void );
292 static void yy_load_buffer_state ( void );
293 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
294 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
295
296 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
297 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
298 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
299
300 void *yyalloc ( yy_size_t );
301 void *yyrealloc ( void *, yy_size_t );
302 void yyfree ( void * );
303
304 #define yy_new_buffer yy_create_buffer
305 #define yy_set_interactive(is_interactive) \
306 { \
307 if ( ! YY_CURRENT_BUFFER ){ \
308 yyensure_buffer_stack (); \
309 YY_CURRENT_BUFFER_LVALUE = \
310 yy_create_buffer( yyin, YY_BUF_SIZE ); \
311 } \
312 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
313 }
314 #define yy_set_bol(at_bol) \
315 { \
316 if ( ! YY_CURRENT_BUFFER ){\
317 yyensure_buffer_stack (); \
318 YY_CURRENT_BUFFER_LVALUE = \
319 yy_create_buffer( yyin, YY_BUF_SIZE ); \
320 } \
321 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
322 }
323 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
324
325 /* Begin user sect3 */
326
327 #define yywrap() (/*CONSTCOND*/1)
328 #define YY_SKIP_YYWRAP
329 typedef flex_uint8_t YY_CHAR;
330
331 FILE *yyin = NULL, *yyout = NULL;
332
333 typedef int yy_state_type;
334
335 extern int yylineno;
336 int yylineno = 1;
337
338 extern char *yytext;
339 #ifdef yytext_ptr
340 #undef yytext_ptr
341 #endif
342 #define yytext_ptr yytext
343
344 static yy_state_type yy_get_previous_state ( void );
345 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
346 static int yy_get_next_buffer ( void );
347 static void yynoreturn yy_fatal_error ( const char* msg );
348
349 /* Done after the current pattern has been matched and before the
350 * corresponding action - sets up yytext.
351 */
352 #define YY_DO_BEFORE_ACTION \
353 (yytext_ptr) = yy_bp; \
354 yyleng = (int) (yy_cp - yy_bp); \
355 (yy_hold_char) = *yy_cp; \
356 *yy_cp = '\0'; \
357 (yy_c_buf_p) = yy_cp;
358 #define YY_NUM_RULES 6
359 #define YY_END_OF_BUFFER 7
360 /* This struct is not used in this scanner,
361 but its presence is necessary. */
362 struct yy_trans_info
363 {
364 flex_int32_t yy_verify;
365 flex_int32_t yy_nxt;
366 };
367 static const flex_int16_t yy_accept[21] =
368 { 0,
369 0, 0, 7, 3, 4, 5, 1, 3, 3, 3,
370 4, 1, 1, 1, 3, 2, 3, 1, 1, 0
371 } ;
372
373 static const YY_CHAR yy_ec[256] =
374 { 0,
375 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
376 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
377 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
378 1, 2, 1, 1, 4, 1, 1, 1, 1, 1,
379 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
380 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384 1, 5, 1, 1, 1, 1, 1, 1, 1, 1,
385
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
389 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
391 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396
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
403 } ;
404
405 static const YY_CHAR yy_meta[6] =
406 { 0,
407 1, 2, 3, 1, 1
408 } ;
409
410 static const flex_int16_t yy_base[24] =
411 { 0,
412 0, 0, 26, 20, 0, 27, 5, 10, 19, 20,
413 0, 0, 0, 15, 0, 27, 0, 0, 0, 27,
414 17, 6, 20
415 } ;
416
417 static const flex_int16_t yy_def[24] =
418 { 0,
419 20, 1, 20, 21, 22, 20, 20, 20, 21, 8,
420 22, 7, 23, 20, 9, 20, 10, 7, 14, 0,
421 20, 20, 20
422 } ;
423
424 static const flex_int16_t yy_nxt[33] =
425 { 0,
426 4, 5, 6, 7, 8, 12, 13, 11, 12, 14,
427 15, 9, 16, 15, 17, 18, 12, 9, 18, 19,
428 13, 13, 20, 10, 10, 20, 3, 20, 20, 20,
429 20, 20
430 } ;
431
432 static const flex_int16_t yy_chk[33] =
433 { 0,
434 1, 1, 1, 1, 1, 7, 7, 22, 7, 7,
435 8, 8, 8, 8, 8, 14, 14, 21, 14, 14,
436 23, 23, 10, 9, 4, 3, 20, 20, 20, 20,
437 20, 20
438 } ;
439
440 static yy_state_type yy_last_accepting_state;
441 static char *yy_last_accepting_cpos;
442
443 extern int yy_flex_debug;
444 int yy_flex_debug = 0;
445
446 /* The intent behind this definition is that it'll catch
447 * any uses of REJECT which flex missed.
448 */
449 #define REJECT reject_used_but_not_detected
450 #define yymore() yymore_used_but_not_detected
451 #define YY_MORE_ADJ 0
452 #define YY_RESTORE_YY_MORE_OFFSET
453 char *yytext;
454 #line 1 "pam_conv_l.l"
455 #line 3 "pam_conv_l.l"
456 /*
457 * $Id$
458 *
459 * Copyright (c) Andrew G. Morgan 1997 <morgan@parc.power.net>
460 *
461 * This file is covered by the Linux-PAM License (which should be
462 * distributed with this file.)
463 */
464
465 #ifdef HAVE_CONFIG_H
466 # include <config.h>
467 #endif
468
469 #include <stdio.h>
470
471 #include "pam_conv_y.h"
472
473 extern int current_line;
474 #line 475 "pam_conv_l.c"
475 #line 476 "pam_conv_l.c"
476
477 #define INITIAL 0
478
479 #ifndef YY_NO_UNISTD_H
480 /* Special case for "unistd.h", since it is non-ANSI. We include it way
481 * down here because we want the user's section 1 to have been scanned first.
482 * The user has a chance to override it with an option.
483 */
484 #include <unistd.h>
485 #endif
486
487 #ifndef YY_EXTRA_TYPE
488 #define YY_EXTRA_TYPE void *
489 #endif
490
491 static int yy_init_globals ( void );
492
493 /* Accessor methods to globals.
494 These are made visible to non-reentrant scanners for convenience. */
495
496 int yylex_destroy ( void );
497
498 int yyget_debug ( void );
499
500 void yyset_debug ( int debug_flag );
501
502 YY_EXTRA_TYPE yyget_extra ( void );
503
504 void yyset_extra ( YY_EXTRA_TYPE user_defined );
505
506 FILE *yyget_in ( void );
507
508 void yyset_in ( FILE * _in_str );
509
510 FILE *yyget_out ( void );
511
512 void yyset_out ( FILE * _out_str );
513
514 int yyget_leng ( void );
515
516 char *yyget_text ( void );
517
518 int yyget_lineno ( void );
519
520 void yyset_lineno ( int _line_number );
521
522 /* Macros after this point can all be overridden by user definitions in
523 * section 1.
524 */
525
526 #ifndef YY_SKIP_YYWRAP
527 #ifdef __cplusplus
528 extern "C" int yywrap ( void );
529 #else
530 extern int yywrap ( void );
531 #endif
532 #endif
533
534 #ifndef YY_NO_UNPUT
535
536 static void yyunput ( int c, char *buf_ptr );
537
538 #endif
539
540 #ifndef yytext_ptr
541 static void yy_flex_strncpy ( char *, const char *, int );
542 #endif
543
544 #ifdef YY_NEED_STRLEN
545 static int yy_flex_strlen ( const char * );
546 #endif
547
548 #ifndef YY_NO_INPUT
549 #ifdef __cplusplus
550 static int yyinput ( void );
551 #else
552 static int input ( void );
553 #endif
554
555 #endif
556
557 /* Amount of stuff to slurp up with each read. */
558 #ifndef YY_READ_BUF_SIZE
559 #ifdef __ia64__
560 /* On IA-64, the buffer size is 16k, not 8k */
561 #define YY_READ_BUF_SIZE 16384
562 #else
563 #define YY_READ_BUF_SIZE 8192
564 #endif /* __ia64__ */
565 #endif
566
567 /* Copy whatever the last rule matched to the standard output. */
568 #ifndef ECHO
569 /* This used to be an fputs(), but since the string might contain NUL's,
570 * we now use fwrite().
571 */
572 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
573 #endif
574
575 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
576 * is returned in "result".
577 */
578 #ifndef YY_INPUT
579 #define YY_INPUT(buf,result,max_size) \
580 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
581 { \
582 int c = '*'; \
583 int n; \
584 for ( n = 0; n < max_size && \
585 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
586 buf[n] = (char) c; \
587 if ( c == '\n' ) \
588 buf[n++] = (char) c; \
589 if ( c == EOF && ferror( yyin ) ) \
590 YY_FATAL_ERROR( "input in flex scanner failed" ); \
591 result = n; \
592 } \
593 else \
594 { \
595 errno=0; \
596 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
597 { \
598 if( errno != EINTR) \
599 { \
600 YY_FATAL_ERROR( "input in flex scanner failed" ); \
601 break; \
602 } \
603 errno=0; \
604 clearerr(yyin); \
605 } \
606 }\
607 \
608
609 #endif
610
611 /* No semi-colon after return; correct usage is to write "yyterminate();" -
612 * we don't want an extra ';' after the "return" because that will cause
613 * some compilers to complain about unreachable statements.
614 */
615 #ifndef yyterminate
616 #define yyterminate() return YY_NULL
617 #endif
618
619 /* Number of entries by which start-condition stack grows. */
620 #ifndef YY_START_STACK_INCR
621 #define YY_START_STACK_INCR 25
622 #endif
623
624 /* Report a fatal error. */
625 #ifndef YY_FATAL_ERROR
626 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
627 #endif
628
629 /* end tables serialization structures and prototypes */
630
631 /* Default declaration of generated scanner - a define so the user can
632 * easily add parameters.
633 */
634 #ifndef YY_DECL
635 #define YY_DECL_IS_OURS 1
636
637 extern int yylex (void);
638
639 #define YY_DECL int yylex (void)
640 #endif /* !YY_DECL */
641
642 /* Code executed at the beginning of each rule, after yytext and yyleng
643 * have been set up.
644 */
645 #ifndef YY_USER_ACTION
646 #define YY_USER_ACTION
647 #endif
648
649 /* Code executed at the end of each rule. */
650 #ifndef YY_BREAK
651 #define YY_BREAK /*LINTED*/break;
652 #endif
653
654 #define YY_RULE_SETUP \
655 YY_USER_ACTION
656
657 /** The main scanner function which does all the work.
658 */
659 YY_DECL
660 {
661 yy_state_type yy_current_state;
662 char *yy_cp, *yy_bp;
663 int yy_act;
664
665 if ( !(yy_init) )
666 {
667 (yy_init) = 1;
668
669 #ifdef YY_USER_INIT
670 YY_USER_INIT;
671 #endif
672
673 if ( ! (yy_start) )
674 (yy_start) = 1; /* first start state */
675
676 if ( ! yyin )
677 yyin = stdin;
678
679 if ( ! yyout )
680 yyout = stdout;
681
682 if ( ! YY_CURRENT_BUFFER ) {
683 yyensure_buffer_stack ();
684 YY_CURRENT_BUFFER_LVALUE =
685 yy_create_buffer( yyin, YY_BUF_SIZE );
686 }
687
688 yy_load_buffer_state( );
689 }
690
691 {
692 #line 24 "pam_conv_l.l"
693
694
695 #line 696 "pam_conv_l.c"
696
697 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
698 {
699 yy_cp = (yy_c_buf_p);
700
701 /* Support of yytext. */
702 *yy_cp = (yy_hold_char);
703
704 /* yy_bp points to the position in yy_ch_buf of the start of
705 * the current run.
706 */
707 yy_bp = yy_cp;
708
709 yy_current_state = (yy_start);
710 yy_match:
711 do
712 {
713 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
714 if ( yy_accept[yy_current_state] )
715 {
716 (yy_last_accepting_state) = yy_current_state;
717 (yy_last_accepting_cpos) = yy_cp;
718 }
719 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
720 {
721 yy_current_state = (int) yy_def[yy_current_state];
722 if ( yy_current_state >= 21 )
723 yy_c = yy_meta[yy_c];
724 }
725 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
726 ++yy_cp;
727 }
728 while ( yy_base[yy_current_state] != 27 );
729
730 yy_find_action:
731 yy_act = yy_accept[yy_current_state];
732 if ( yy_act == 0 )
733 { /* have to back up */
734 yy_cp = (yy_last_accepting_cpos);
735 yy_current_state = (yy_last_accepting_state);
736 yy_act = yy_accept[yy_current_state];
737 }
738
739 YY_DO_BEFORE_ACTION;
740
741 do_action: /* This label is used only to access EOF actions. */
742
743 switch ( yy_act )
744 { /* beginning of action switch */
745 case 0: /* must back up */
746 /* undo the effects of YY_DO_BEFORE_ACTION */
747 *yy_cp = (yy_hold_char);
748 yy_cp = (yy_last_accepting_cpos);
749 yy_current_state = (yy_last_accepting_state);
750 goto yy_find_action;
751
752 case 1:
753 YY_RULE_SETUP
754 #line 26 "pam_conv_l.l"
755 ; /* skip comments (sorry) */
756 YY_BREAK
757 case 2:
758 /* rule 2 can match eol */
759 YY_RULE_SETUP
760 #line 28 "pam_conv_l.l"
761 {
762 ++current_line;
763 }
764 YY_BREAK
765 case 3:
766 YY_RULE_SETUP
767 #line 32 "pam_conv_l.l"
768 {
769 return TOK;
770 }
771 YY_BREAK
772 case 4:
773 YY_RULE_SETUP
774 #line 36 "pam_conv_l.l"
775 ; /* Ignore */
776 YY_BREAK
777 case YY_STATE_EOF(INITIAL):
778 #line 38 "pam_conv_l.l"
779 {
780 return EOFILE;
781 }
782 YY_BREAK
783 case 5:
784 /* rule 5 can match eol */
785 YY_RULE_SETUP
786 #line 42 "pam_conv_l.l"
787 {
788 ++current_line;
789 return NL;
790 }
791 YY_BREAK
792 case 6:
793 YY_RULE_SETUP
794 #line 47 "pam_conv_l.l"
795 ECHO;
796 YY_BREAK
797 #line 798 "pam_conv_l.c"
798
799 case YY_END_OF_BUFFER:
800 {
801 /* Amount of text matched not including the EOB char. */
802 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
803
804 /* Undo the effects of YY_DO_BEFORE_ACTION. */
805 *yy_cp = (yy_hold_char);
806 YY_RESTORE_YY_MORE_OFFSET
807
808 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
809 {
810 /* We're scanning a new file or input source. It's
811 * possible that this happened because the user
812 * just pointed yyin at a new source and called
813 * yylex(). If so, then we have to assure
814 * consistency between YY_CURRENT_BUFFER and our
815 * globals. Here is the right place to do so, because
816 * this is the first action (other than possibly a
817 * back-up) that will match for the new input source.
818 */
819 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
820 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
821 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
822 }
823
824 /* Note that here we test for yy_c_buf_p "<=" to the position
825 * of the first EOB in the buffer, since yy_c_buf_p will
826 * already have been incremented past the NUL character
827 * (since all states make transitions on EOB to the
828 * end-of-buffer state). Contrast this with the test
829 * in input().
830 */
831 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
832 { /* This was really a NUL. */
833 yy_state_type yy_next_state;
834
835 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
836
837 yy_current_state = yy_get_previous_state( );
838
839 /* Okay, we're now positioned to make the NUL
840 * transition. We couldn't have
841 * yy_get_previous_state() go ahead and do it
842 * for us because it doesn't know how to deal
843 * with the possibility of jamming (and we don't
844 * want to build jamming into it because then it
845 * will run more slowly).
846 */
847
848 yy_next_state = yy_try_NUL_trans( yy_current_state );
849
850 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
851
852 if ( yy_next_state )
853 {
854 /* Consume the NUL. */
855 yy_cp = ++(yy_c_buf_p);
856 yy_current_state = yy_next_state;
857 goto yy_match;
858 }
859
860 else
861 {
862 yy_cp = (yy_c_buf_p);
863 goto yy_find_action;
864 }
865 }
866
867 else switch ( yy_get_next_buffer( ) )
868 {
869 case EOB_ACT_END_OF_FILE:
870 {
871 (yy_did_buffer_switch_on_eof) = 0;
872
873 if ( yywrap( ) )
874 {
875 /* Note: because we've taken care in
876 * yy_get_next_buffer() to have set up
877 * yytext, we can now set up
878 * yy_c_buf_p so that if some total
879 * hoser (like flex itself) wants to
880 * call the scanner after we return the
881 * YY_NULL, it'll still work - another
882 * YY_NULL will get returned.
883 */
884 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
885
886 yy_act = YY_STATE_EOF(YY_START);
887 goto do_action;
888 }
889
890 else
891 {
892 if ( ! (yy_did_buffer_switch_on_eof) )
893 YY_NEW_FILE;
894 }
895 break;
896 }
897
898 case EOB_ACT_CONTINUE_SCAN:
899 (yy_c_buf_p) =
900 (yytext_ptr) + yy_amount_of_matched_text;
901
902 yy_current_state = yy_get_previous_state( );
903
904 yy_cp = (yy_c_buf_p);
905 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
906 goto yy_match;
907
908 case EOB_ACT_LAST_MATCH:
909 (yy_c_buf_p) =
910 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
911
912 yy_current_state = yy_get_previous_state( );
913
914 yy_cp = (yy_c_buf_p);
915 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
916 goto yy_find_action;
917 }
918 break;
919 }
920
921 default:
922 YY_FATAL_ERROR(
923 "fatal flex scanner internal error--no action found" );
924 } /* end of action switch */
925 } /* end of scanning one token */
926 } /* end of user's declarations */
927 } /* end of yylex */
928
929 /* yy_get_next_buffer - try to read in a new buffer
930 *
931 * Returns a code representing an action:
932 * EOB_ACT_LAST_MATCH -
933 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
934 * EOB_ACT_END_OF_FILE - end of file
935 */
936 static int yy_get_next_buffer (void)
937 {
938 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
939 char *source = (yytext_ptr);
940 int number_to_move, i;
941 int ret_val;
942
943 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
944 YY_FATAL_ERROR(
945 "fatal flex scanner internal error--end of buffer missed" );
946
947 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
948 { /* Don't try to fill the buffer, so this is an EOF. */
949 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
950 {
951 /* We matched a single character, the EOB, so
952 * treat this as a final EOF.
953 */
954 return EOB_ACT_END_OF_FILE;
955 }
956
957 else
958 {
959 /* We matched some text prior to the EOB, first
960 * process it.
961 */
962 return EOB_ACT_LAST_MATCH;
963 }
964 }
965
966 /* Try to read more data. */
967
968 /* First move last chars to start of buffer. */
969 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
970
971 for ( i = 0; i < number_to_move; ++i )
972 *(dest++) = *(source++);
973
974 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
975 /* don't do the read, it's not guaranteed to return an EOF,
976 * just force an EOF
977 */
978 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
979
980 else
981 {
982 int num_to_read =
983 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
984
985 while ( num_to_read <= 0 )
986 { /* Not enough room in the buffer - grow it. */
987
988 /* just a shorter name for the current buffer */
989 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
990
991 int yy_c_buf_p_offset =
992 (int) ((yy_c_buf_p) - b->yy_ch_buf);
993
994 if ( b->yy_is_our_buffer )
995 {
996 int new_size = b->yy_buf_size * 2;
997
998 if ( new_size <= 0 )
999 b->yy_buf_size += b->yy_buf_size / 8;
1000 else
1001 b->yy_buf_size *= 2;
1002
1003 b->yy_ch_buf = (char *)
1004 /* Include room in for 2 EOB chars. */
1005 yyrealloc( (void *) b->yy_ch_buf,
1006 (yy_size_t) (b->yy_buf_size + 2) );
1007 }
1008 else
1009 /* Can't grow it, we don't own it. */
1010 b->yy_ch_buf = NULL;
1011
1012 if ( ! b->yy_ch_buf )
1013 YY_FATAL_ERROR(
1014 "fatal error - scanner input buffer overflow" );
1015
1016 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1017
1018 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1019 number_to_move - 1;
1020
1021 }
1022
1023 if ( num_to_read > YY_READ_BUF_SIZE )
1024 num_to_read = YY_READ_BUF_SIZE;
1025
1026 /* Read in more data. */
1027 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1028 (yy_n_chars), num_to_read );
1029
1030 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1031 }
1032
1033 if ( (yy_n_chars) == 0 )
1034 {
1035 if ( number_to_move == YY_MORE_ADJ )
1036 {
1037 ret_val = EOB_ACT_END_OF_FILE;
1038 yyrestart( yyin );
1039 }
1040
1041 else
1042 {
1043 ret_val = EOB_ACT_LAST_MATCH;
1044 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1045 YY_BUFFER_EOF_PENDING;
1046 }
1047 }
1048
1049 else
1050 ret_val = EOB_ACT_CONTINUE_SCAN;
1051
1052 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1053 /* Extend the array by 50%, plus the number we really need. */
1054 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1055 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1056 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1057 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1058 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1059 /* "- 2" to take care of EOB's */
1060 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1061 }
1062
1063 (yy_n_chars) += number_to_move;
1064 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1065 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1066
1067 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1068
1069 return ret_val;
1070 }
1071
1072 /* yy_get_previous_state - get the state just before the EOB char was reached */
1073
1074 static yy_state_type yy_get_previous_state (void)
1075 {
1076 yy_state_type yy_current_state;
1077 char *yy_cp;
1078
1079 yy_current_state = (yy_start);
1080
1081 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1082 {
1083 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1084 if ( yy_accept[yy_current_state] )
1085 {
1086 (yy_last_accepting_state) = yy_current_state;
1087 (yy_last_accepting_cpos) = yy_cp;
1088 }
1089 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1090 {
1091 yy_current_state = (int) yy_def[yy_current_state];
1092 if ( yy_current_state >= 21 )
1093 yy_c = yy_meta[yy_c];
1094 }
1095 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1096 }
1097
1098 return yy_current_state;
1099 }
1100
1101 /* yy_try_NUL_trans - try to make a transition on the NUL character
1102 *
1103 * synopsis
1104 * next_state = yy_try_NUL_trans( current_state );
1105 */
1106 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1107 {
1108 int yy_is_jam;
1109 char *yy_cp = (yy_c_buf_p);
1110
1111 YY_CHAR yy_c = 1;
1112 if ( yy_accept[yy_current_state] )
1113 {
1114 (yy_last_accepting_state) = yy_current_state;
1115 (yy_last_accepting_cpos) = yy_cp;
1116 }
1117 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1118 {
1119 yy_current_state = (int) yy_def[yy_current_state];
1120 if ( yy_current_state >= 21 )
1121 yy_c = yy_meta[yy_c];
1122 }
1123 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1124 yy_is_jam = (yy_current_state == 20);
1125
1126 return yy_is_jam ? 0 : yy_current_state;
1127 }
1128
1129 #ifndef YY_NO_UNPUT
1130
1131 static void yyunput (int c, char * yy_bp )
1132 {
1133 char *yy_cp;
1134
1135 yy_cp = (yy_c_buf_p);
1136
1137 /* undo effects of setting up yytext */
1138 *yy_cp = (yy_hold_char);
1139
1140 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1141 { /* need to shift things up to make room */
1142 /* +2 for EOB chars. */
1143 int number_to_move = (yy_n_chars) + 2;
1144 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1145 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1146 char *source =
1147 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1148
1149 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1150 *--dest = *--source;
1151
1152 yy_cp += (int) (dest - source);
1153 yy_bp += (int) (dest - source);
1154 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1155 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1156
1157 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1158 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1159 }
1160
1161 *--yy_cp = (char) c;
1162
1163 (yytext_ptr) = yy_bp;
1164 (yy_hold_char) = *yy_cp;
1165 (yy_c_buf_p) = yy_cp;
1166 }
1167
1168 #endif
1169
1170 #ifndef YY_NO_INPUT
1171 #ifdef __cplusplus
1172 static int yyinput (void)
1173 #else
1174 static int input (void)
1175 #endif
1176
1177 {
1178 int c;
1179
1180 *(yy_c_buf_p) = (yy_hold_char);
1181
1182 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1183 {
1184 /* yy_c_buf_p now points to the character we want to return.
1185 * If this occurs *before* the EOB characters, then it's a
1186 * valid NUL; if not, then we've hit the end of the buffer.
1187 */
1188 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1189 /* This was really a NUL. */
1190 *(yy_c_buf_p) = '\0';
1191
1192 else
1193 { /* need more input */
1194 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1195 ++(yy_c_buf_p);
1196
1197 switch ( yy_get_next_buffer( ) )
1198 {
1199 case EOB_ACT_LAST_MATCH:
1200 /* This happens because yy_g_n_b()
1201 * sees that we've accumulated a
1202 * token and flags that we need to
1203 * try matching the token before
1204 * proceeding. But for input(),
1205 * there's no matching to consider.
1206 * So convert the EOB_ACT_LAST_MATCH
1207 * to EOB_ACT_END_OF_FILE.
1208 */
1209
1210 /* Reset buffer status. */
1211 yyrestart( yyin );
1212
1213 /*FALLTHROUGH*/
1214
1215 case EOB_ACT_END_OF_FILE:
1216 {
1217 if ( yywrap( ) )
1218 return 0;
1219
1220 if ( ! (yy_did_buffer_switch_on_eof) )
1221 YY_NEW_FILE;
1222 #ifdef __cplusplus
1223 return yyinput();
1224 #else
1225 return input();
1226 #endif
1227 }
1228
1229 case EOB_ACT_CONTINUE_SCAN:
1230 (yy_c_buf_p) = (yytext_ptr) + offset;
1231 break;
1232 }
1233 }
1234 }
1235
1236 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1237 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1238 (yy_hold_char) = *++(yy_c_buf_p);
1239
1240 return c;
1241 }
1242 #endif /* ifndef YY_NO_INPUT */
1243
1244 /** Immediately switch to a different input stream.
1245 * @param input_file A readable stream.
1246 *
1247 * @note This function does not reset the start condition to @c INITIAL .
1248 */
1249 void yyrestart (FILE * input_file )
1250 {
1251
1252 if ( ! YY_CURRENT_BUFFER ){
1253 yyensure_buffer_stack ();
1254 YY_CURRENT_BUFFER_LVALUE =
1255 yy_create_buffer( yyin, YY_BUF_SIZE );
1256 }
1257
1258 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1259 yy_load_buffer_state( );
1260 }
1261
1262 /** Switch to a different input buffer.
1263 * @param new_buffer The new input buffer.
1264 *
1265 */
1266 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1267 {
1268
1269 /* TODO. We should be able to replace this entire function body
1270 * with
1271 * yypop_buffer_state();
1272 * yypush_buffer_state(new_buffer);
1273 */
1274 yyensure_buffer_stack ();
1275 if ( YY_CURRENT_BUFFER == new_buffer )
1276 return;
1277
1278 if ( YY_CURRENT_BUFFER )
1279 {
1280 /* Flush out information for old buffer. */
1281 *(yy_c_buf_p) = (yy_hold_char);
1282 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1283 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1284 }
1285
1286 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1287 yy_load_buffer_state( );
1288
1289 /* We don't actually know whether we did this switch during
1290 * EOF (yywrap()) processing, but the only time this flag
1291 * is looked at is after yywrap() is called, so it's safe
1292 * to go ahead and always set it.
1293 */
1294 (yy_did_buffer_switch_on_eof) = 1;
1295 }
1296
1297 static void yy_load_buffer_state (void)
1298 {
1299 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1300 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1301 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1302 (yy_hold_char) = *(yy_c_buf_p);
1303 }
1304
1305 /** Allocate and initialize an input buffer state.
1306 * @param file A readable stream.
1307 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1308 *
1309 * @return the allocated buffer state.
1310 */
1311 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1312 {
1313 YY_BUFFER_STATE b;
1314
1315 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1316 if ( ! b )
1317 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1318
1319 b->yy_buf_size = size;
1320
1321 /* yy_ch_buf has to be 2 characters longer than the size given because
1322 * we need to put in 2 end-of-buffer characters.
1323 */
1324 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1325 if ( ! b->yy_ch_buf )
1326 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1327
1328 b->yy_is_our_buffer = 1;
1329
1330 yy_init_buffer( b, file );
1331
1332 return b;
1333 }
1334
1335 /** Destroy the buffer.
1336 * @param b a buffer created with yy_create_buffer()
1337 *
1338 */
1339 void yy_delete_buffer (YY_BUFFER_STATE b )
1340 {
1341
1342 if ( ! b )
1343 return;
1344
1345 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1346 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1347
1348 if ( b->yy_is_our_buffer )
1349 yyfree( (void *) b->yy_ch_buf );
1350
1351 yyfree( (void *) b );
1352 }
1353
1354 /* Initializes or reinitializes a buffer.
1355 * This function is sometimes called more than once on the same buffer,
1356 * such as during a yyrestart() or at EOF.
1357 */
1358 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1359
1360 {
1361 int oerrno = errno;
1362
1363 yy_flush_buffer( b );
1364
1365 b->yy_input_file = file;
1366 b->yy_fill_buffer = 1;
1367
1368 /* If b is the current buffer, then yy_init_buffer was _probably_
1369 * called from yyrestart() or through yy_get_next_buffer.
1370 * In that case, we don't want to reset the lineno or column.
1371 */
1372 if (b != YY_CURRENT_BUFFER){
1373 b->yy_bs_lineno = 1;
1374 b->yy_bs_column = 0;
1375 }
1376
1377 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1378
1379 errno = oerrno;
1380 }
1381
1382 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1383 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1384 *
1385 */
1386 void yy_flush_buffer (YY_BUFFER_STATE b )
1387 {
1388 if ( ! b )
1389 return;
1390
1391 b->yy_n_chars = 0;
1392
1393 /* We always need two end-of-buffer characters. The first causes
1394 * a transition to the end-of-buffer state. The second causes
1395 * a jam in that state.
1396 */
1397 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1398 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1399
1400 b->yy_buf_pos = &b->yy_ch_buf[0];
1401
1402 b->yy_at_bol = 1;
1403 b->yy_buffer_status = YY_BUFFER_NEW;
1404
1405 if ( b == YY_CURRENT_BUFFER )
1406 yy_load_buffer_state( );
1407 }
1408
1409 /** Pushes the new state onto the stack. The new state becomes
1410 * the current state. This function will allocate the stack
1411 * if necessary.
1412 * @param new_buffer The new state.
1413 *
1414 */
1415 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1416 {
1417 if (new_buffer == NULL)
1418 return;
1419
1420 yyensure_buffer_stack();
1421
1422 /* This block is copied from yy_switch_to_buffer. */
1423 if ( YY_CURRENT_BUFFER )
1424 {
1425 /* Flush out information for old buffer. */
1426 *(yy_c_buf_p) = (yy_hold_char);
1427 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1428 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1429 }
1430
1431 /* Only push if top exists. Otherwise, replace top. */
1432 if (YY_CURRENT_BUFFER)
1433 (yy_buffer_stack_top)++;
1434 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1435
1436 /* copied from yy_switch_to_buffer. */
1437 yy_load_buffer_state( );
1438 (yy_did_buffer_switch_on_eof) = 1;
1439 }
1440
1441 /** Removes and deletes the top of the stack, if present.
1442 * The next element becomes the new top.
1443 *
1444 */
1445 void yypop_buffer_state (void)
1446 {
1447 if (!YY_CURRENT_BUFFER)
1448 return;
1449
1450 yy_delete_buffer(YY_CURRENT_BUFFER );
1451 YY_CURRENT_BUFFER_LVALUE = NULL;
1452 if ((yy_buffer_stack_top) > 0)
1453 --(yy_buffer_stack_top);
1454
1455 if (YY_CURRENT_BUFFER) {
1456 yy_load_buffer_state( );
1457 (yy_did_buffer_switch_on_eof) = 1;
1458 }
1459 }
1460
1461 /* Allocates the stack if it does not exist.
1462 * Guarantees space for at least one push.
1463 */
1464 static void yyensure_buffer_stack (void)
1465 {
1466 yy_size_t num_to_alloc;
1467
1468 if (!(yy_buffer_stack)) {
1469
1470 /* First allocation is just for 2 elements, since we don't know if this
1471 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1472 * immediate realloc on the next call.
1473 */
1474 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1475 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1476 (num_to_alloc * sizeof(struct yy_buffer_state*)
1477 );
1478 if ( ! (yy_buffer_stack) )
1479 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1480
1481 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1482
1483 (yy_buffer_stack_max) = num_to_alloc;
1484 (yy_buffer_stack_top) = 0;
1485 return;
1486 }
1487
1488 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1489
1490 /* Increase the buffer to prepare for a possible push. */
1491 yy_size_t grow_size = 8 /* arbitrary grow size */;
1492
1493 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1494 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1495 ((yy_buffer_stack),
1496 num_to_alloc * sizeof(struct yy_buffer_state*)
1497 );
1498 if ( ! (yy_buffer_stack) )
1499 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1500
1501 /* zero only the new slots.*/
1502 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1503 (yy_buffer_stack_max) = num_to_alloc;
1504 }
1505 }
1506
1507 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1508 * @param base the character buffer
1509 * @param size the size in bytes of the character buffer
1510 *
1511 * @return the newly allocated buffer state object.
1512 */
1513 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1514 {
1515 YY_BUFFER_STATE b;
1516
1517 if ( size < 2 ||
1518 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1519 base[size-1] != YY_END_OF_BUFFER_CHAR )
1520 /* They forgot to leave room for the EOB's. */
1521 return NULL;
1522
1523 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1524 if ( ! b )
1525 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1526
1527 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1528 b->yy_buf_pos = b->yy_ch_buf = base;
1529 b->yy_is_our_buffer = 0;
1530 b->yy_input_file = NULL;
1531 b->yy_n_chars = b->yy_buf_size;
1532 b->yy_is_interactive = 0;
1533 b->yy_at_bol = 1;
1534 b->yy_fill_buffer = 0;
1535 b->yy_buffer_status = YY_BUFFER_NEW;
1536
1537 yy_switch_to_buffer( b );
1538
1539 return b;
1540 }
1541
1542 /** Setup the input buffer state to scan a string. The next call to yylex() will
1543 * scan from a @e copy of @a str.
1544 * @param yystr a NUL-terminated string to scan
1545 *
1546 * @return the newly allocated buffer state object.
1547 * @note If you want to scan bytes that may contain NUL values, then use
1548 * yy_scan_bytes() instead.
1549 */
1550 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1551 {
1552
1553 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1554 }
1555
1556 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1557 * scan from a @e copy of @a bytes.
1558 * @param yybytes the byte buffer to scan
1559 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1560 *
1561 * @return the newly allocated buffer state object.
1562 */
1563 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1564 {
1565 YY_BUFFER_STATE b;
1566 char *buf;
1567 yy_size_t n;
1568 int i;
1569
1570 /* Get memory for full buffer, including space for trailing EOB's. */
1571 n = (yy_size_t) (_yybytes_len + 2);
1572 buf = (char *) yyalloc( n );
1573 if ( ! buf )
1574 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1575
1576 for ( i = 0; i < _yybytes_len; ++i )
1577 buf[i] = yybytes[i];
1578
1579 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1580
1581 b = yy_scan_buffer( buf, n );
1582 if ( ! b )
1583 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1584
1585 /* It's okay to grow etc. this buffer, and we should throw it
1586 * away when we're done.
1587 */
1588 b->yy_is_our_buffer = 1;
1589
1590 return b;
1591 }
1592
1593 #ifndef YY_EXIT_FAILURE
1594 #define YY_EXIT_FAILURE 2
1595 #endif
1596
1597 static void yynoreturn yy_fatal_error (const char* msg YY_ATTRIBUTE_UNUSED)
1598 {
1599 fprintf( stderr, "%s\n", msg );
1600 exit( YY_EXIT_FAILURE );
1601 }
1602
1603 /* Redefine yyless() so it works in section 3 code. */
1604
1605 #undef yyless
1606 #define yyless(n) \
1607 do \
1608 { \
1609 /* Undo effects of setting up yytext. */ \
1610 int yyless_macro_arg = (n); \
1611 YY_LESS_LINENO(yyless_macro_arg);\
1612 yytext[yyleng] = (yy_hold_char); \
1613 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1614 (yy_hold_char) = *(yy_c_buf_p); \
1615 *(yy_c_buf_p) = '\0'; \
1616 yyleng = yyless_macro_arg; \
1617 } \
1618 while ( 0 )
1619
1620 /* Accessor methods (get/set functions) to struct members. */
1621
1622 /** Get the current line number.
1623 *
1624 */
1625 int yyget_lineno (void)
1626 {
1627
1628 return yylineno;
1629 }
1630
1631 /** Get the input stream.
1632 *
1633 */
1634 FILE *yyget_in (void)
1635 {
1636 return yyin;
1637 }
1638
1639 /** Get the output stream.
1640 *
1641 */
1642 FILE *yyget_out (void)
1643 {
1644 return yyout;
1645 }
1646
1647 /** Get the length of the current token.
1648 *
1649 */
1650 int yyget_leng (void)
1651 {
1652 return yyleng;
1653 }
1654
1655 /** Get the current token.
1656 *
1657 */
1658
1659 char *yyget_text (void)
1660 {
1661 return yytext;
1662 }
1663
1664 /** Set the current line number.
1665 * @param _line_number line number
1666 *
1667 */
1668 void yyset_lineno (int _line_number )
1669 {
1670
1671 yylineno = _line_number;
1672 }
1673
1674 /** Set the input stream. This does not discard the current
1675 * input buffer.
1676 * @param _in_str A readable stream.
1677 *
1678 * @see yy_switch_to_buffer
1679 */
1680 void yyset_in (FILE * _in_str )
1681 {
1682 yyin = _in_str ;
1683 }
1684
1685 void yyset_out (FILE * _out_str )
1686 {
1687 yyout = _out_str ;
1688 }
1689
1690 int yyget_debug (void)
1691 {
1692 return yy_flex_debug;
1693 }
1694
1695 void yyset_debug (int _bdebug )
1696 {
1697 yy_flex_debug = _bdebug ;
1698 }
1699
1700 static int yy_init_globals (void)
1701 {
1702 /* Initialization is the same as for the non-reentrant scanner.
1703 * This function is called from yylex_destroy(), so don't allocate here.
1704 */
1705
1706 (yy_buffer_stack) = NULL;
1707 (yy_buffer_stack_top) = 0;
1708 (yy_buffer_stack_max) = 0;
1709 (yy_c_buf_p) = NULL;
1710 (yy_init) = 0;
1711 (yy_start) = 0;
1712
1713 /* Defined in main.c */
1714 #ifdef YY_STDINIT
1715 yyin = stdin;
1716 yyout = stdout;
1717 #else
1718 yyin = NULL;
1719 yyout = NULL;
1720 #endif
1721
1722 /* For future reference: Set errno on error, since we are called by
1723 * yylex_init()
1724 */
1725 return 0;
1726 }
1727
1728 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1729 int yylex_destroy (void)
1730 {
1731
1732 /* Pop the buffer stack, destroying each element. */
1733 while(YY_CURRENT_BUFFER){
1734 yy_delete_buffer( YY_CURRENT_BUFFER );
1735 YY_CURRENT_BUFFER_LVALUE = NULL;
1736 yypop_buffer_state();
1737 }
1738
1739 /* Destroy the stack itself. */
1740 yyfree((yy_buffer_stack) );
1741 (yy_buffer_stack) = NULL;
1742
1743 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1744 * yylex() is called, initialization will occur. */
1745 yy_init_globals( );
1746
1747 return 0;
1748 }
1749
1750 /*
1751 * Internal utility routines.
1752 */
1753
1754 #ifndef yytext_ptr
1755 static void yy_flex_strncpy (char* s1, const char * s2, int n YY_ATTRIBUTE_UNUSED)
1756 {
1757 int i;
1758 for ( i = 0; i < n; ++i )
1759 s1[i] = s2[i];
1760 }
1761 #endif
1762
1763 #ifdef YY_NEED_STRLEN
1764 static int yy_flex_strlen (const char * s YY_ATTRIBUTE_UNUSED)
1765 {
1766 int n;
1767 for ( n = 0; s[n]; ++n )
1768 ;
1769
1770 return n;
1771 }
1772 #endif
1773
1774 void *yyalloc (yy_size_t size YY_ATTRIBUTE_UNUSED)
1775 {
1776 return malloc(size);
1777 }
1778
1779 void *yyrealloc (void * ptr, yy_size_t size YY_ATTRIBUTE_UNUSED)
1780 {
1781 /* The cast to (char *) in the following accommodates both
1782 * implementations that use char* generic pointers, and those
1783 * that use void* generic pointers. It works with the latter
1784 * because both ANSI C and C++ allow castless assignment from
1785 * any pointer type to void*, and deal with argument conversions
1786 * as though doing an assignment.
1787 */
1788 return realloc(ptr, size);
1789 }
1790
1791 void yyfree (void * ptr YY_ATTRIBUTE_UNUSED)
1792 {
1793 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1794 }
1795
1796 #line 47 "pam_conv_l.l"
1797
1798