Annotation of src/usr.bin/lex/flex.skl, Revision 1.11
1.11 ! millert 1: /* $OpenBSD: flex.skl,v 1.10 2007/01/26 14:38:19 tsi Exp $ */
1.2 deraadt 2:
1.1 deraadt 3: /* A lexical scanner generated by flex */
4:
5: /* Scanner skeleton version:
1.11 ! millert 6: * $Header: /home/cvs/openbsd/src/usr.bin/lex/flex.skl,v 1.10 2007/01/26 14:38:19 tsi Exp $
1.1 deraadt 7: */
8:
9: #define FLEX_SCANNER
10: #define YY_FLEX_MAJOR_VERSION 2
11: #define YY_FLEX_MINOR_VERSION 5
12:
13: %-
14: #include <stdio.h>
1.6 millert 15: #include <errno.h>
1.8 espie 16: %+
17: #include <cerrno>
1.1 deraadt 18: %*
19:
20:
21: /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
22: #ifdef c_plusplus
23: #ifndef __cplusplus
24: #define __cplusplus
25: #endif
26: #endif
27:
28:
29: #ifdef __cplusplus
30:
31: #include <stdlib.h>
32: %+
1.7 espie 33: #include <iosfwd>
1.1 deraadt 34: %*
35: #include <unistd.h>
36:
37: /* Use prototypes in function declarations. */
38: #define YY_USE_PROTOS
39:
40: /* The "const" storage-class-modifier is valid. */
41: #define YY_USE_CONST
42:
43: #else /* ! __cplusplus */
44:
1.5 mickey 45: #ifdef __STDC__
1.1 deraadt 46:
47: #define YY_USE_PROTOS
48: #define YY_USE_CONST
49:
50: #endif /* __STDC__ */
51: #endif /* ! __cplusplus */
52:
53: #ifdef __TURBOC__
54: #pragma warn -rch
55: #pragma warn -use
56: #include <io.h>
57: #include <stdlib.h>
58: #define YY_USE_CONST
59: #define YY_USE_PROTOS
60: #endif
61:
62: #ifdef YY_USE_CONST
63: #define yyconst const
64: #else
65: #define yyconst
66: #endif
67:
68:
69: #ifdef YY_USE_PROTOS
70: #define YY_PROTO(proto) proto
71: #else
72: #define YY_PROTO(proto) ()
73: #endif
74:
75: /* Returned upon end-of-file. */
76: #define YY_NULL 0
77:
78: /* Promotes a possibly negative, possibly signed char to an unsigned
79: * integer for use as an array index. If the signed char is negative,
80: * we want to instead treat it as an 8-bit unsigned char, hence the
81: * double cast.
82: */
83: #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
84:
85: /* Enter a start condition. This macro really ought to take a parameter,
86: * but we do it the disgusting crufty way forced on us by the ()-less
87: * definition of BEGIN.
88: */
89: #define BEGIN yy_start = 1 + 2 *
90:
91: /* Translate the current start state into a value that can be later handed
92: * to BEGIN to return to the state. The YYSTATE alias is for lex
93: * compatibility.
94: */
95: #define YY_START ((yy_start - 1) / 2)
96: #define YYSTATE YY_START
97:
98: /* Action number for EOF rule of a given start state. */
99: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
100:
101: /* Special action meaning "start processing a new file". */
102: #define YY_NEW_FILE yyrestart( yyin )
103:
104: #define YY_END_OF_BUFFER_CHAR 0
105:
106: /* Size of default input buffer. */
107: #define YY_BUF_SIZE 16384
108:
109: typedef struct yy_buffer_state *YY_BUFFER_STATE;
110:
111: extern int yyleng;
112: %-
113: extern FILE *yyin, *yyout;
114: %*
115:
116: #define EOB_ACT_CONTINUE_SCAN 0
117: #define EOB_ACT_END_OF_FILE 1
118: #define EOB_ACT_LAST_MATCH 2
119:
120: /* The funky do-while in the following #define is used to turn the definition
121: * int a single C statement (which needs a semi-colon terminator). This
122: * avoids problems with code like:
123: *
124: * if ( condition_holds )
125: * yyless( 5 );
126: * else
127: * do_something_else();
128: *
129: * Prior to using the do-while the compiler would get upset at the
130: * "else" because it interpreted the "if" statement as being all
131: * done when it reached the ';' after the yyless() call.
132: */
133:
134: /* Return all but the first 'n' matched characters back to the input stream. */
135:
136: #define yyless(n) \
137: do \
138: { \
139: /* Undo effects of setting up yytext. */ \
140: *yy_cp = yy_hold_char; \
1.3 millert 141: YY_RESTORE_YY_MORE_OFFSET \
1.1 deraadt 142: yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
143: YY_DO_BEFORE_ACTION; /* set up yytext again */ \
144: } \
145: while ( 0 )
146:
147: #define unput(c) yyunput( c, yytext_ptr )
148:
149: /* The following is because we cannot portably get our hands on size_t
150: * (without autoconf's help, which isn't available because we want
151: * flex-generated scanners to compile on their own).
152: */
153: typedef unsigned int yy_size_t;
154:
155:
156: struct yy_buffer_state
157: {
158: %-
159: FILE *yy_input_file;
160: %+
1.7 espie 161: std::istream* yy_input_file;
1.1 deraadt 162: %*
163:
164: char *yy_ch_buf; /* input buffer */
165: char *yy_buf_pos; /* current position in input buffer */
166:
167: /* Size of input buffer in bytes, not including room for EOB
168: * characters.
169: */
170: yy_size_t yy_buf_size;
171:
172: /* Number of characters read into yy_ch_buf, not including EOB
173: * characters.
174: */
175: int yy_n_chars;
176:
177: /* Whether we "own" the buffer - i.e., we know we created it,
178: * and can realloc() it to grow it, and should free() it to
179: * delete it.
180: */
181: int yy_is_our_buffer;
182:
183: /* Whether this is an "interactive" input source; if so, and
184: * if we're using stdio for input, then we want to use getc()
185: * instead of fread(), to make sure we stop fetching input after
186: * each newline.
187: */
188: int yy_is_interactive;
189:
190: /* Whether we're considered to be at the beginning of a line.
191: * If so, '^' rules will be active on the next match, otherwise
192: * not.
193: */
194: int yy_at_bol;
195:
196: /* Whether to try to fill the input buffer when we reach the
197: * end of it.
198: */
199: int yy_fill_buffer;
200:
201: int yy_buffer_status;
202: #define YY_BUFFER_NEW 0
203: #define YY_BUFFER_NORMAL 1
204: /* When an EOF's been seen but there's still some text to process
205: * then we mark the buffer as YY_EOF_PENDING, to indicate that we
206: * shouldn't try reading from the input source any more. We might
207: * still have a bunch of tokens to match, though, because of
208: * possible backing-up.
209: *
210: * When we actually see the EOF, we change the status to "new"
211: * (via yyrestart()), so that the user can continue scanning by
212: * just pointing yyin at a new input file.
213: */
214: #define YY_BUFFER_EOF_PENDING 2
215: };
216:
217: %- Standard (non-C++) definition
218: static YY_BUFFER_STATE yy_current_buffer = 0;
219: %*
220:
221: /* We provide macros for accessing buffer states in case in the
222: * future we want to put the buffer states in a more general
223: * "scanner state".
224: */
225: #define YY_CURRENT_BUFFER yy_current_buffer
226:
227:
228: %- Standard (non-C++) definition
229: /* yy_hold_char holds the character lost when yytext is formed. */
230: static char yy_hold_char;
231:
232: static int yy_n_chars; /* number of characters read into yy_ch_buf */
233:
234:
235: int yyleng;
236:
237: /* Points to current character in buffer. */
238: static char *yy_c_buf_p = (char *) 0;
239: static int yy_init = 1; /* whether we need to initialize */
240: static int yy_start = 0; /* start state number */
241:
242: /* Flag which is used to allow yywrap()'s to do buffer switches
243: * instead of setting up a fresh yyin. A bit of a hack ...
244: */
245: static int yy_did_buffer_switch_on_eof;
246:
247: void yyrestart YY_PROTO(( FILE *input_file ));
248:
249: void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
250: void yy_load_buffer_state YY_PROTO(( void ));
251: YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
252: void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
253: void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
254: void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
255: #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
256:
257: YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
1.4 millert 258: YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
1.1 deraadt 259: YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
260: %*
261:
262: static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
263: static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
264: static void yy_flex_free YY_PROTO(( void * ));
265:
266: #define yy_new_buffer yy_create_buffer
267:
268: #define yy_set_interactive(is_interactive) \
269: { \
270: if ( ! yy_current_buffer ) \
271: yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
272: yy_current_buffer->yy_is_interactive = is_interactive; \
273: }
274:
275: #define yy_set_bol(at_bol) \
276: { \
277: if ( ! yy_current_buffer ) \
278: yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
279: yy_current_buffer->yy_at_bol = at_bol; \
280: }
281:
282: #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
283:
284: %% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
285:
286: %- Standard (non-C++) definition
287: static yy_state_type yy_get_previous_state YY_PROTO(( void ));
288: static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
289: static int yy_get_next_buffer YY_PROTO(( void ));
290: static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
291: %*
292:
293: /* Done after the current pattern has been matched and before the
294: * corresponding action - sets up yytext.
295: */
296: #define YY_DO_BEFORE_ACTION \
297: yytext_ptr = yy_bp; \
298: %% code to fiddle yytext and yyleng for yymore() goes here
299: yy_hold_char = *yy_cp; \
300: *yy_cp = '\0'; \
301: %% code to copy yytext_ptr to yytext[] goes here, if %array
302: yy_c_buf_p = yy_cp;
303:
304: %% data tables for the DFA and the user's section 1 definitions go here
305:
306: /* Macros after this point can all be overridden by user definitions in
307: * section 1.
308: */
309:
310: #ifndef YY_SKIP_YYWRAP
311: #ifdef __cplusplus
312: extern "C" int yywrap YY_PROTO(( void ));
313: #else
314: extern int yywrap YY_PROTO(( void ));
315: #endif
316: #endif
317:
318: %-
319: #ifndef YY_NO_UNPUT
320: static void yyunput YY_PROTO(( int c, char *buf_ptr ));
321: #endif
322: %*
323:
324: #ifndef yytext_ptr
325: static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
326: #endif
327:
1.3 millert 328: #ifdef YY_NEED_STRLEN
329: static int yy_flex_strlen YY_PROTO(( yyconst char * ));
330: #endif
331:
1.1 deraadt 332: #ifndef YY_NO_INPUT
333: %- Standard (non-C++) definition
334: #ifdef __cplusplus
335: static int yyinput YY_PROTO(( void ));
336: #else
337: static int input YY_PROTO(( void ));
338: #endif
339: %*
340: #endif
341:
1.10 tsi 342: #if defined(YY_STACK_USED) && YY_STACK_USED
1.1 deraadt 343: static int yy_start_stack_ptr = 0;
344: static int yy_start_stack_depth = 0;
345: static int *yy_start_stack = 0;
346: #ifndef YY_NO_PUSH_STATE
347: static void yy_push_state YY_PROTO(( int new_state ));
348: #endif
349: #ifndef YY_NO_POP_STATE
350: static void yy_pop_state YY_PROTO(( void ));
351: #endif
352: #ifndef YY_NO_TOP_STATE
353: static int yy_top_state YY_PROTO(( void ));
354: #endif
355:
356: #else
357: #define YY_NO_PUSH_STATE 1
358: #define YY_NO_POP_STATE 1
359: #define YY_NO_TOP_STATE 1
360: #endif
361:
362: #ifdef YY_MALLOC_DECL
363: YY_MALLOC_DECL
364: #else
1.5 mickey 365: #ifdef __STDC__
1.1 deraadt 366: #ifndef __cplusplus
367: #include <stdlib.h>
368: #endif
369: #else
370: /* Just try to get by without declaring the routines. This will fail
371: * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
372: * or sizeof(void*) != sizeof(int).
373: */
374: #endif
375: #endif
376:
377: /* Amount of stuff to slurp up with each read. */
378: #ifndef YY_READ_BUF_SIZE
379: #define YY_READ_BUF_SIZE 8192
380: #endif
381:
382: /* Copy whatever the last rule matched to the standard output. */
383:
384: #ifndef ECHO
385: %- Standard (non-C++) definition
386: /* This used to be an fputs(), but since the string might contain NUL's,
387: * we now use fwrite().
388: */
389: #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
390: %+ C++ definition
391: #define ECHO LexerOutput( yytext, yyleng )
392: %*
393: #endif
394:
395: /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
396: * is returned in "result".
397: */
398: #ifndef YY_INPUT
399: #define YY_INPUT(buf,result,max_size) \
400: %% fread()/read() definition of YY_INPUT goes here unless we're doing C++
401: %+ C++ definition
402: if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
403: YY_FATAL_ERROR( "input in flex scanner failed" );
404: %*
405: #endif
406:
407: /* No semi-colon after return; correct usage is to write "yyterminate();" -
408: * we don't want an extra ';' after the "return" because that will cause
409: * some compilers to complain about unreachable statements.
410: */
411: #ifndef yyterminate
412: #define yyterminate() return YY_NULL
413: #endif
414:
415: /* Number of entries by which start-condition stack grows. */
416: #ifndef YY_START_STACK_INCR
417: #define YY_START_STACK_INCR 25
418: #endif
419:
420: /* Report a fatal error. */
421: #ifndef YY_FATAL_ERROR
422: %-
423: #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
424: %+
425: #define YY_FATAL_ERROR(msg) LexerError( msg )
426: %*
427: #endif
428:
429: /* Default declaration of generated scanner - a define so the user can
430: * easily add parameters.
431: */
432: #ifndef YY_DECL
433: %- Standard (non-C++) definition
434: #define YY_DECL int yylex YY_PROTO(( void ))
435: %+ C++ definition
436: #define YY_DECL int yyFlexLexer::yylex()
437: %*
438: #endif
439:
440: /* Code executed at the beginning of each rule, after yytext and yyleng
441: * have been set up.
442: */
443: #ifndef YY_USER_ACTION
444: #define YY_USER_ACTION
445: #endif
446:
447: /* Code executed at the end of each rule. */
448: #ifndef YY_BREAK
449: #define YY_BREAK break;
450: #endif
451:
452: %% YY_RULE_SETUP definition goes here
453:
454: YY_DECL
455: {
456: register yy_state_type yy_current_state;
457: register char *yy_cp, *yy_bp;
458: register int yy_act;
459:
460: %% user's declarations go here
461:
462: if ( yy_init )
463: {
464: yy_init = 0;
465:
466: #ifdef YY_USER_INIT
467: YY_USER_INIT;
468: #endif
469:
470: if ( ! yy_start )
471: yy_start = 1; /* first start state */
472:
473: if ( ! yyin )
474: %-
475: yyin = stdin;
476: %+
1.7 espie 477: yyin = &std::cin;
1.1 deraadt 478: %*
479:
480: if ( ! yyout )
481: %-
482: yyout = stdout;
483: %+
1.7 espie 484: yyout = &std::cout;
1.1 deraadt 485: %*
486:
487: if ( ! yy_current_buffer )
488: yy_current_buffer =
489: yy_create_buffer( yyin, YY_BUF_SIZE );
490:
491: yy_load_buffer_state();
492: }
493:
494: while ( 1 ) /* loops until end-of-file is reached */
495: {
496: %% yymore()-related code goes here
497: yy_cp = yy_c_buf_p;
498:
499: /* Support of yytext. */
500: *yy_cp = yy_hold_char;
501:
502: /* yy_bp points to the position in yy_ch_buf of the start of
503: * the current run.
504: */
505: yy_bp = yy_cp;
506:
507: %% code to set up and find next match goes here
508:
509: yy_find_action:
510: %% code to find the action number goes here
511:
512: YY_DO_BEFORE_ACTION;
513:
514: %% code for yylineno update goes here
515:
516: do_action: /* This label is used only to access EOF actions. */
517:
518: %% debug code goes here
519:
520: switch ( yy_act )
521: { /* beginning of action switch */
522: %% actions go here
523:
524: case YY_END_OF_BUFFER:
525: {
526: /* Amount of text matched not including the EOB char. */
527: int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
528:
529: /* Undo the effects of YY_DO_BEFORE_ACTION. */
530: *yy_cp = yy_hold_char;
1.3 millert 531: YY_RESTORE_YY_MORE_OFFSET
1.1 deraadt 532:
533: if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
534: {
535: /* We're scanning a new file or input source. It's
536: * possible that this happened because the user
537: * just pointed yyin at a new source and called
538: * yylex(). If so, then we have to assure
539: * consistency between yy_current_buffer and our
540: * globals. Here is the right place to do so, because
541: * this is the first action (other than possibly a
542: * back-up) that will match for the new input source.
543: */
544: yy_n_chars = yy_current_buffer->yy_n_chars;
545: yy_current_buffer->yy_input_file = yyin;
546: yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
547: }
548:
549: /* Note that here we test for yy_c_buf_p "<=" to the position
550: * of the first EOB in the buffer, since yy_c_buf_p will
551: * already have been incremented past the NUL character
552: * (since all states make transitions on EOB to the
553: * end-of-buffer state). Contrast this with the test
554: * in input().
555: */
556: if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
557: { /* This was really a NUL. */
558: yy_state_type yy_next_state;
559:
560: yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
561:
562: yy_current_state = yy_get_previous_state();
563:
564: /* Okay, we're now positioned to make the NUL
565: * transition. We couldn't have
566: * yy_get_previous_state() go ahead and do it
567: * for us because it doesn't know how to deal
568: * with the possibility of jamming (and we don't
569: * want to build jamming into it because then it
570: * will run more slowly).
571: */
572:
573: yy_next_state = yy_try_NUL_trans( yy_current_state );
574:
575: yy_bp = yytext_ptr + YY_MORE_ADJ;
576:
577: if ( yy_next_state )
578: {
579: /* Consume the NUL. */
580: yy_cp = ++yy_c_buf_p;
581: yy_current_state = yy_next_state;
582: goto yy_match;
583: }
584:
585: else
586: {
587: %% code to do back-up for compressed tables and set up yy_cp goes here
588: goto yy_find_action;
589: }
590: }
591:
592: else switch ( yy_get_next_buffer() )
593: {
594: case EOB_ACT_END_OF_FILE:
595: {
596: yy_did_buffer_switch_on_eof = 0;
597:
598: if ( yywrap() )
599: {
600: /* Note: because we've taken care in
601: * yy_get_next_buffer() to have set up
602: * yytext, we can now set up
603: * yy_c_buf_p so that if some total
604: * hoser (like flex itself) wants to
605: * call the scanner after we return the
606: * YY_NULL, it'll still work - another
607: * YY_NULL will get returned.
608: */
609: yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
610:
611: yy_act = YY_STATE_EOF(YY_START);
612: goto do_action;
613: }
614:
615: else
616: {
617: if ( ! yy_did_buffer_switch_on_eof )
618: YY_NEW_FILE;
619: }
620: break;
621: }
622:
623: case EOB_ACT_CONTINUE_SCAN:
624: yy_c_buf_p =
625: yytext_ptr + yy_amount_of_matched_text;
626:
627: yy_current_state = yy_get_previous_state();
628:
629: yy_cp = yy_c_buf_p;
630: yy_bp = yytext_ptr + YY_MORE_ADJ;
631: goto yy_match;
632:
633: case EOB_ACT_LAST_MATCH:
634: yy_c_buf_p =
635: &yy_current_buffer->yy_ch_buf[yy_n_chars];
636:
637: yy_current_state = yy_get_previous_state();
638:
639: yy_cp = yy_c_buf_p;
640: yy_bp = yytext_ptr + YY_MORE_ADJ;
641: goto yy_find_action;
642: }
643: break;
644: }
645:
646: default:
647: YY_FATAL_ERROR(
648: "fatal flex scanner internal error--no action found" );
649: } /* end of action switch */
650: } /* end of scanning one token */
651: } /* end of yylex */
652:
653: %+
1.7 espie 654: yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1.1 deraadt 655: {
656: yyin = arg_yyin;
657: yyout = arg_yyout;
658: yy_c_buf_p = 0;
659: yy_init = 1;
660: yy_start = 0;
661: yy_flex_debug = 0;
662: yylineno = 1; // this will only get updated if %option yylineno
663:
664: yy_did_buffer_switch_on_eof = 0;
665:
666: yy_looking_for_trail_begin = 0;
667: yy_more_flag = 0;
668: yy_more_len = 0;
1.3 millert 669: yy_more_offset = yy_prev_more_offset = 0;
1.1 deraadt 670:
671: yy_start_stack_ptr = yy_start_stack_depth = 0;
672: yy_start_stack = 0;
673:
674: yy_current_buffer = 0;
675:
676: #ifdef YY_USES_REJECT
677: yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
678: #else
679: yy_state_buf = 0;
680: #endif
681: }
682:
683: yyFlexLexer::~yyFlexLexer()
684: {
685: delete yy_state_buf;
686: yy_delete_buffer( yy_current_buffer );
687: }
688:
1.7 espie 689: void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1.1 deraadt 690: {
691: if ( new_in )
692: {
693: yy_delete_buffer( yy_current_buffer );
694: yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
695: }
696:
697: if ( new_out )
698: yyout = new_out;
699: }
700:
701: #ifdef YY_INTERACTIVE
702: int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
703: #else
704: int yyFlexLexer::LexerInput( char* buf, int max_size )
705: #endif
706: {
707: if ( yyin->eof() || yyin->fail() )
708: return 0;
709:
710: #ifdef YY_INTERACTIVE
711: yyin->get( buf[0] );
712:
713: if ( yyin->eof() )
714: return 0;
715:
716: if ( yyin->bad() )
717: return -1;
718:
719: return 1;
720:
721: #else
722: (void) yyin->read( buf, max_size );
723:
724: if ( yyin->bad() )
725: return -1;
726: else
727: return yyin->gcount();
728: #endif
729: }
730:
731: void yyFlexLexer::LexerOutput( const char* buf, int size )
732: {
733: (void) yyout->write( buf, size );
734: }
735: %*
736:
737: /* yy_get_next_buffer - try to read in a new buffer
738: *
739: * Returns a code representing an action:
740: * EOB_ACT_LAST_MATCH -
741: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
742: * EOB_ACT_END_OF_FILE - end of file
743: */
744:
745: %-
746: static int yy_get_next_buffer()
747: %+
748: int yyFlexLexer::yy_get_next_buffer()
749: %*
750: {
751: register char *dest = yy_current_buffer->yy_ch_buf;
752: register char *source = yytext_ptr;
753: register int number_to_move, i;
754: int ret_val;
755:
756: if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
757: YY_FATAL_ERROR(
758: "fatal flex scanner internal error--end of buffer missed" );
759:
760: if ( yy_current_buffer->yy_fill_buffer == 0 )
761: { /* Don't try to fill the buffer, so this is an EOF. */
762: if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
763: {
1.3 millert 764: /* We matched a single character, the EOB, so
1.1 deraadt 765: * treat this as a final EOF.
766: */
767: return EOB_ACT_END_OF_FILE;
768: }
769:
770: else
771: {
772: /* We matched some text prior to the EOB, first
773: * process it.
774: */
775: return EOB_ACT_LAST_MATCH;
776: }
777: }
778:
779: /* Try to read more data. */
780:
781: /* First move last chars to start of buffer. */
782: number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
783:
784: for ( i = 0; i < number_to_move; ++i )
785: *(dest++) = *(source++);
786:
787: if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
788: /* don't do the read, it's not guaranteed to return an EOF,
789: * just force an EOF
790: */
1.4 millert 791: yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1.1 deraadt 792:
793: else
794: {
795: int num_to_read =
796: yy_current_buffer->yy_buf_size - number_to_move - 1;
797:
798: while ( num_to_read <= 0 )
799: { /* Not enough room in the buffer - grow it. */
800: #ifdef YY_USES_REJECT
801: YY_FATAL_ERROR(
802: "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
803: #else
804:
805: /* just a shorter name for the current buffer */
806: YY_BUFFER_STATE b = yy_current_buffer;
807:
808: int yy_c_buf_p_offset =
809: (int) (yy_c_buf_p - b->yy_ch_buf);
810:
811: if ( b->yy_is_our_buffer )
812: {
813: int new_size = b->yy_buf_size * 2;
814:
815: if ( new_size <= 0 )
816: b->yy_buf_size += b->yy_buf_size / 8;
817: else
818: b->yy_buf_size *= 2;
819:
820: b->yy_ch_buf = (char *)
821: /* Include room in for 2 EOB chars. */
822: yy_flex_realloc( (void *) b->yy_ch_buf,
823: b->yy_buf_size + 2 );
824: }
825: else
826: /* Can't grow it, we don't own it. */
827: b->yy_ch_buf = 0;
828:
829: if ( ! b->yy_ch_buf )
830: YY_FATAL_ERROR(
831: "fatal error - scanner input buffer overflow" );
832:
833: yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
834:
835: num_to_read = yy_current_buffer->yy_buf_size -
836: number_to_move - 1;
837: #endif
838: }
839:
840: if ( num_to_read > YY_READ_BUF_SIZE )
841: num_to_read = YY_READ_BUF_SIZE;
842:
843: /* Read in more data. */
844: YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
845: yy_n_chars, num_to_read );
1.4 millert 846:
847: yy_current_buffer->yy_n_chars = yy_n_chars;
1.1 deraadt 848: }
849:
850: if ( yy_n_chars == 0 )
851: {
852: if ( number_to_move == YY_MORE_ADJ )
853: {
854: ret_val = EOB_ACT_END_OF_FILE;
855: yyrestart( yyin );
856: }
857:
858: else
859: {
860: ret_val = EOB_ACT_LAST_MATCH;
861: yy_current_buffer->yy_buffer_status =
862: YY_BUFFER_EOF_PENDING;
863: }
864: }
865:
866: else
867: ret_val = EOB_ACT_CONTINUE_SCAN;
868:
869: yy_n_chars += number_to_move;
870: yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
871: yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
872:
873: yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
874:
875: return ret_val;
876: }
877:
878:
879: /* yy_get_previous_state - get the state just before the EOB char was reached */
880:
881: %-
882: static yy_state_type yy_get_previous_state()
883: %+
884: yy_state_type yyFlexLexer::yy_get_previous_state()
885: %*
886: {
887: register yy_state_type yy_current_state;
888: register char *yy_cp;
889:
890: %% code to get the start state into yy_current_state goes here
891:
892: for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
893: {
894: %% code to find the next state goes here
895: }
896:
897: return yy_current_state;
898: }
899:
900:
901: /* yy_try_NUL_trans - try to make a transition on the NUL character
902: *
903: * synopsis
904: * next_state = yy_try_NUL_trans( current_state );
905: */
906:
907: %-
908: #ifdef YY_USE_PROTOS
909: static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
910: #else
911: static yy_state_type yy_try_NUL_trans( yy_current_state )
912: yy_state_type yy_current_state;
913: #endif
914: %+
915: yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
916: %*
917: {
918: register int yy_is_jam;
919: %% code to find the next state, and perhaps do backing up, goes here
920:
921: return yy_is_jam ? 0 : yy_current_state;
922: }
923:
924:
925: %-
926: #ifndef YY_NO_UNPUT
927: #ifdef YY_USE_PROTOS
928: static void yyunput( int c, register char *yy_bp )
929: #else
930: static void yyunput( c, yy_bp )
931: int c;
932: register char *yy_bp;
933: #endif
934: %+
935: void yyFlexLexer::yyunput( int c, register char* yy_bp )
936: %*
937: {
938: register char *yy_cp = yy_c_buf_p;
939:
940: /* undo effects of setting up yytext */
941: *yy_cp = yy_hold_char;
942:
943: if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
944: { /* need to shift things up to make room */
945: /* +2 for EOB chars. */
946: register int number_to_move = yy_n_chars + 2;
947: register char *dest = &yy_current_buffer->yy_ch_buf[
948: yy_current_buffer->yy_buf_size + 2];
949: register char *source =
950: &yy_current_buffer->yy_ch_buf[number_to_move];
951:
952: while ( source > yy_current_buffer->yy_ch_buf )
953: *--dest = *--source;
954:
955: yy_cp += (int) (dest - source);
956: yy_bp += (int) (dest - source);
1.4 millert 957: yy_current_buffer->yy_n_chars =
958: yy_n_chars = yy_current_buffer->yy_buf_size;
1.1 deraadt 959:
960: if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
961: YY_FATAL_ERROR( "flex scanner push-back overflow" );
962: }
963:
964: *--yy_cp = (char) c;
965:
966: %% update yylineno here
967:
968: yytext_ptr = yy_bp;
969: yy_hold_char = *yy_cp;
970: yy_c_buf_p = yy_cp;
971: }
972: %-
973: #endif /* ifndef YY_NO_UNPUT */
974: %*
975:
976:
977: %-
1.11 ! millert 978: #ifndef YY_NO_INPUT
1.1 deraadt 979: #ifdef __cplusplus
980: static int yyinput()
981: #else
982: static int input()
983: #endif
984: %+
985: int yyFlexLexer::yyinput()
986: %*
987: {
988: int c;
989:
990: *yy_c_buf_p = yy_hold_char;
991:
992: if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
993: {
994: /* yy_c_buf_p now points to the character we want to return.
995: * If this occurs *before* the EOB characters, then it's a
996: * valid NUL; if not, then we've hit the end of the buffer.
997: */
998: if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
999: /* This was really a NUL. */
1000: *yy_c_buf_p = '\0';
1001:
1002: else
1003: { /* need more input */
1.3 millert 1004: int offset = yy_c_buf_p - yytext_ptr;
1.1 deraadt 1005: ++yy_c_buf_p;
1006:
1007: switch ( yy_get_next_buffer() )
1008: {
1.4 millert 1009: case EOB_ACT_LAST_MATCH:
1010: /* This happens because yy_g_n_b()
1011: * sees that we've accumulated a
1012: * token and flags that we need to
1013: * try matching the token before
1014: * proceeding. But for input(),
1015: * there's no matching to consider.
1016: * So convert the EOB_ACT_LAST_MATCH
1017: * to EOB_ACT_END_OF_FILE.
1018: */
1019:
1020: /* Reset buffer status. */
1021: yyrestart( yyin );
1022:
1023: /* fall through */
1024:
1.1 deraadt 1025: case EOB_ACT_END_OF_FILE:
1026: {
1027: if ( yywrap() )
1028: return EOF;
1029:
1030: if ( ! yy_did_buffer_switch_on_eof )
1031: YY_NEW_FILE;
1032: #ifdef __cplusplus
1033: return yyinput();
1034: #else
1035: return input();
1036: #endif
1037: }
1038:
1039: case EOB_ACT_CONTINUE_SCAN:
1.3 millert 1040: yy_c_buf_p = yytext_ptr + offset;
1.1 deraadt 1041: break;
1042: }
1043: }
1044: }
1045:
1046: c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1047: *yy_c_buf_p = '\0'; /* preserve yytext */
1048: yy_hold_char = *++yy_c_buf_p;
1049:
1050: %% update BOL and yylineno
1051:
1052: return c;
1053: }
1.11 ! millert 1054: %-
! 1055: #endif /* ifndef YY_NO_INPUT */
! 1056: %*
1.1 deraadt 1057:
1058:
1059: %-
1060: #ifdef YY_USE_PROTOS
1061: void yyrestart( FILE *input_file )
1062: #else
1063: void yyrestart( input_file )
1064: FILE *input_file;
1065: #endif
1066: %+
1.7 espie 1067: void yyFlexLexer::yyrestart( std::istream* input_file )
1.1 deraadt 1068: %*
1069: {
1070: if ( ! yy_current_buffer )
1071: yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1072:
1073: yy_init_buffer( yy_current_buffer, input_file );
1074: yy_load_buffer_state();
1075: }
1076:
1077:
1078: %-
1079: #ifdef YY_USE_PROTOS
1080: void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1081: #else
1082: void yy_switch_to_buffer( new_buffer )
1083: YY_BUFFER_STATE new_buffer;
1084: #endif
1085: %+
1086: void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1087: %*
1088: {
1089: if ( yy_current_buffer == new_buffer )
1090: return;
1091:
1092: if ( yy_current_buffer )
1093: {
1094: /* Flush out information for old buffer. */
1095: *yy_c_buf_p = yy_hold_char;
1096: yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1097: yy_current_buffer->yy_n_chars = yy_n_chars;
1098: }
1099:
1100: yy_current_buffer = new_buffer;
1101: yy_load_buffer_state();
1102:
1103: /* We don't actually know whether we did this switch during
1104: * EOF (yywrap()) processing, but the only time this flag
1105: * is looked at is after yywrap() is called, so it's safe
1106: * to go ahead and always set it.
1107: */
1108: yy_did_buffer_switch_on_eof = 1;
1109: }
1110:
1111:
1112: %-
1113: #ifdef YY_USE_PROTOS
1114: void yy_load_buffer_state( void )
1115: #else
1116: void yy_load_buffer_state()
1117: #endif
1118: %+
1119: void yyFlexLexer::yy_load_buffer_state()
1120: %*
1121: {
1122: yy_n_chars = yy_current_buffer->yy_n_chars;
1123: yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1124: yyin = yy_current_buffer->yy_input_file;
1125: yy_hold_char = *yy_c_buf_p;
1126: }
1127:
1128:
1129: %-
1130: #ifdef YY_USE_PROTOS
1131: YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1132: #else
1133: YY_BUFFER_STATE yy_create_buffer( file, size )
1134: FILE *file;
1135: int size;
1136: #endif
1137: %+
1.7 espie 1138: YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
1.1 deraadt 1139: %*
1140: {
1141: YY_BUFFER_STATE b;
1142:
1143: b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1144: if ( ! b )
1145: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1146:
1147: b->yy_buf_size = size;
1148:
1149: /* yy_ch_buf has to be 2 characters longer than the size given because
1150: * we need to put in 2 end-of-buffer characters.
1151: */
1152: b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1153: if ( ! b->yy_ch_buf )
1154: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1155:
1156: b->yy_is_our_buffer = 1;
1157:
1158: yy_init_buffer( b, file );
1159:
1160: return b;
1161: }
1162:
1163:
1164: %-
1165: #ifdef YY_USE_PROTOS
1166: void yy_delete_buffer( YY_BUFFER_STATE b )
1167: #else
1168: void yy_delete_buffer( b )
1169: YY_BUFFER_STATE b;
1170: #endif
1171: %+
1172: void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
1173: %*
1174: {
1175: if ( ! b )
1176: return;
1177:
1178: if ( b == yy_current_buffer )
1179: yy_current_buffer = (YY_BUFFER_STATE) 0;
1180:
1181: if ( b->yy_is_our_buffer )
1182: yy_flex_free( (void *) b->yy_ch_buf );
1183:
1184: yy_flex_free( (void *) b );
1185: }
1186:
1187:
1188: %-
1189: #ifndef YY_ALWAYS_INTERACTIVE
1190: #ifndef YY_NEVER_INTERACTIVE
1.7 espie 1191: #include <unistd.h>
1.1 deraadt 1192: #endif
1193: #endif
1194:
1195: #ifdef YY_USE_PROTOS
1196: void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1197: #else
1198: void yy_init_buffer( b, file )
1199: YY_BUFFER_STATE b;
1200: FILE *file;
1201: #endif
1202:
1203: %+
1204: extern "C" int isatty YY_PROTO(( int ));
1.7 espie 1205: void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
1.1 deraadt 1206: %*
1207:
1208: {
1.6 millert 1209: int oerrno = errno;
1210:
1.1 deraadt 1211: yy_flush_buffer( b );
1212:
1213: b->yy_input_file = file;
1214: b->yy_fill_buffer = 1;
1215:
1216: %-
1.10 tsi 1217: #if defined(YY_ALWAYS_INTERACTIVE) && YY_ALWAYS_INTERACTIVE
1.1 deraadt 1218: b->yy_is_interactive = 1;
1219: #else
1.10 tsi 1220: #if defined(YY_NEVER_INTERACTIVE) && YY_NEVER_INTERACTIVE
1.1 deraadt 1221: b->yy_is_interactive = 0;
1222: #else
1223: b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1224: #endif
1225: #endif
1226: %+
1227: b->yy_is_interactive = 0;
1228: %*
1.6 millert 1229: errno = oerrno;
1.1 deraadt 1230: }
1231:
1232:
1233: %-
1234: #ifdef YY_USE_PROTOS
1235: void yy_flush_buffer( YY_BUFFER_STATE b )
1236: #else
1237: void yy_flush_buffer( b )
1238: YY_BUFFER_STATE b;
1239: #endif
1240:
1241: %+
1242: void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
1243: %*
1244: {
1.4 millert 1245: if ( ! b )
1246: return;
1247:
1.1 deraadt 1248: b->yy_n_chars = 0;
1249:
1250: /* We always need two end-of-buffer characters. The first causes
1251: * a transition to the end-of-buffer state. The second causes
1252: * a jam in that state.
1253: */
1254: b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1255: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1256:
1257: b->yy_buf_pos = &b->yy_ch_buf[0];
1258:
1259: b->yy_at_bol = 1;
1260: b->yy_buffer_status = YY_BUFFER_NEW;
1261:
1262: if ( b == yy_current_buffer )
1263: yy_load_buffer_state();
1264: }
1265: %*
1266:
1267:
1268: #ifndef YY_NO_SCAN_BUFFER
1269: %-
1270: #ifdef YY_USE_PROTOS
1271: YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1272: #else
1273: YY_BUFFER_STATE yy_scan_buffer( base, size )
1274: char *base;
1275: yy_size_t size;
1276: #endif
1277: {
1278: YY_BUFFER_STATE b;
1279:
1280: if ( size < 2 ||
1281: base[size-2] != YY_END_OF_BUFFER_CHAR ||
1282: base[size-1] != YY_END_OF_BUFFER_CHAR )
1283: /* They forgot to leave room for the EOB's. */
1284: return 0;
1285:
1286: b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1287: if ( ! b )
1288: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1289:
1290: b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1291: b->yy_buf_pos = b->yy_ch_buf = base;
1292: b->yy_is_our_buffer = 0;
1293: b->yy_input_file = 0;
1294: b->yy_n_chars = b->yy_buf_size;
1295: b->yy_is_interactive = 0;
1296: b->yy_at_bol = 1;
1297: b->yy_fill_buffer = 0;
1298: b->yy_buffer_status = YY_BUFFER_NEW;
1299:
1300: yy_switch_to_buffer( b );
1301:
1302: return b;
1303: }
1304: %*
1305: #endif
1306:
1307:
1308: #ifndef YY_NO_SCAN_STRING
1309: %-
1310: #ifdef YY_USE_PROTOS
1.4 millert 1311: YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1.1 deraadt 1312: #else
1.4 millert 1313: YY_BUFFER_STATE yy_scan_string( yy_str )
1314: yyconst char *yy_str;
1.1 deraadt 1315: #endif
1316: {
1317: int len;
1.4 millert 1318: for ( len = 0; yy_str[len]; ++len )
1.1 deraadt 1319: ;
1320:
1.4 millert 1321: return yy_scan_bytes( yy_str, len );
1.1 deraadt 1322: }
1323: %*
1324: #endif
1325:
1326:
1327: #ifndef YY_NO_SCAN_BYTES
1328: %-
1329: #ifdef YY_USE_PROTOS
1330: YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1331: #else
1332: YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1333: yyconst char *bytes;
1334: int len;
1335: #endif
1336: {
1337: YY_BUFFER_STATE b;
1338: char *buf;
1339: yy_size_t n;
1340: int i;
1341:
1342: /* Get memory for full buffer, including space for trailing EOB's. */
1343: n = len + 2;
1344: buf = (char *) yy_flex_alloc( n );
1345: if ( ! buf )
1346: YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1347:
1348: for ( i = 0; i < len; ++i )
1349: buf[i] = bytes[i];
1350:
1351: buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1352:
1353: b = yy_scan_buffer( buf, n );
1354: if ( ! b )
1355: YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1356:
1357: /* It's okay to grow etc. this buffer, and we should throw it
1358: * away when we're done.
1359: */
1360: b->yy_is_our_buffer = 1;
1361:
1362: return b;
1363: }
1364: %*
1365: #endif
1366:
1367:
1368: #ifndef YY_NO_PUSH_STATE
1369: %-
1370: #ifdef YY_USE_PROTOS
1371: static void yy_push_state( int new_state )
1372: #else
1373: static void yy_push_state( new_state )
1374: int new_state;
1375: #endif
1376: %+
1377: void yyFlexLexer::yy_push_state( int new_state )
1378: %*
1379: {
1380: if ( yy_start_stack_ptr >= yy_start_stack_depth )
1381: {
1382: yy_size_t new_size;
1383:
1384: yy_start_stack_depth += YY_START_STACK_INCR;
1385: new_size = yy_start_stack_depth * sizeof( int );
1386:
1387: if ( ! yy_start_stack )
1388: yy_start_stack = (int *) yy_flex_alloc( new_size );
1389:
1390: else
1391: yy_start_stack = (int *) yy_flex_realloc(
1392: (void *) yy_start_stack, new_size );
1393:
1394: if ( ! yy_start_stack )
1395: YY_FATAL_ERROR(
1396: "out of memory expanding start-condition stack" );
1397: }
1398:
1399: yy_start_stack[yy_start_stack_ptr++] = YY_START;
1400:
1401: BEGIN(new_state);
1402: }
1403: #endif
1404:
1405:
1406: #ifndef YY_NO_POP_STATE
1407: %-
1408: static void yy_pop_state()
1409: %+
1410: void yyFlexLexer::yy_pop_state()
1411: %*
1412: {
1413: if ( --yy_start_stack_ptr < 0 )
1414: YY_FATAL_ERROR( "start-condition stack underflow" );
1415:
1416: BEGIN(yy_start_stack[yy_start_stack_ptr]);
1417: }
1418: #endif
1419:
1420:
1421: #ifndef YY_NO_TOP_STATE
1422: %-
1423: static int yy_top_state()
1424: %+
1425: int yyFlexLexer::yy_top_state()
1426: %*
1427: {
1428: return yy_start_stack[yy_start_stack_ptr - 1];
1429: }
1430: #endif
1431:
1432: #ifndef YY_EXIT_FAILURE
1433: #define YY_EXIT_FAILURE 2
1434: #endif
1435:
1436: %-
1437: #ifdef YY_USE_PROTOS
1438: static void yy_fatal_error( yyconst char msg[] )
1439: #else
1440: static void yy_fatal_error( msg )
1441: char msg[];
1442: #endif
1443: {
1444: (void) fprintf( stderr, "%s\n", msg );
1445: exit( YY_EXIT_FAILURE );
1446: }
1447:
1448: %+
1449:
1450: void yyFlexLexer::LexerError( yyconst char msg[] )
1451: {
1.7 espie 1452: std::cerr << msg << '\n';
1.1 deraadt 1453: exit( YY_EXIT_FAILURE );
1454: }
1455: %*
1456:
1457:
1458: /* Redefine yyless() so it works in section 3 code. */
1459:
1460: #undef yyless
1461: #define yyless(n) \
1462: do \
1463: { \
1464: /* Undo effects of setting up yytext. */ \
1465: yytext[yyleng] = yy_hold_char; \
1.3 millert 1466: yy_c_buf_p = yytext + n; \
1.1 deraadt 1467: yy_hold_char = *yy_c_buf_p; \
1468: *yy_c_buf_p = '\0'; \
1469: yyleng = n; \
1470: } \
1471: while ( 0 )
1472:
1473:
1474: /* Internal utility routines. */
1475:
1476: #ifndef yytext_ptr
1477: #ifdef YY_USE_PROTOS
1478: static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1479: #else
1480: static void yy_flex_strncpy( s1, s2, n )
1481: char *s1;
1482: yyconst char *s2;
1483: int n;
1484: #endif
1485: {
1486: register int i;
1487: for ( i = 0; i < n; ++i )
1488: s1[i] = s2[i];
1.3 millert 1489: }
1490: #endif
1491:
1492: #ifdef YY_NEED_STRLEN
1493: #ifdef YY_USE_PROTOS
1494: static int yy_flex_strlen( yyconst char *s )
1495: #else
1496: static int yy_flex_strlen( s )
1497: yyconst char *s;
1498: #endif
1499: {
1500: register int n;
1501: for ( n = 0; s[n]; ++n )
1502: ;
1503:
1504: return n;
1.1 deraadt 1505: }
1506: #endif
1507:
1508:
1509: #ifdef YY_USE_PROTOS
1510: static void *yy_flex_alloc( yy_size_t size )
1511: #else
1512: static void *yy_flex_alloc( size )
1513: yy_size_t size;
1514: #endif
1515: {
1516: return (void *) malloc( size );
1517: }
1518:
1519: #ifdef YY_USE_PROTOS
1520: static void *yy_flex_realloc( void *ptr, yy_size_t size )
1521: #else
1522: static void *yy_flex_realloc( ptr, size )
1523: void *ptr;
1524: yy_size_t size;
1525: #endif
1526: {
1527: /* The cast to (char *) in the following accommodates both
1528: * implementations that use char* generic pointers, and those
1529: * that use void* generic pointers. It works with the latter
1530: * because both ANSI C and C++ allow castless assignment from
1531: * any pointer type to void*, and deal with argument conversions
1532: * as though doing an assignment.
1533: */
1534: return (void *) realloc( (char *) ptr, size );
1535: }
1536:
1537: #ifdef YY_USE_PROTOS
1538: static void yy_flex_free( void *ptr )
1539: #else
1540: static void yy_flex_free( ptr )
1541: void *ptr;
1542: #endif
1543: {
1544: free( ptr );
1545: }
1546:
1.10 tsi 1547: #if defined(YY_MAIN) && YY_MAIN
1.1 deraadt 1548: int main()
1549: {
1550: yylex();
1551: return 0;
1552: }
1553: #endif