![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.skel CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex|
Return to lex.skel CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / lex |
1.1 root 1: /* A lexical scanner generated by flex */
2:
3: /* scanner skeleton version:
4: *
5: * $Header: flex/RCS/flex.skel,v 2.13 90/05/26 17:24:13 vern Exp $
6: *
7: * @(#)lex.skel 5.2 (Berkeley) 6/18/90
8: */
9:
10: #define FLEX_SCANNER
11:
12: #include <stdio.h>
13:
14: #ifdef __STDC__
15:
16: #ifndef DONT_HAVE_STDLIB_H
17: #include <stdlib.h>
18: #else
19: void *malloc( unsigned );
20: void free( void* );
21: #endif
22:
23: #define YY_USE_PROTOS
24: #define YY_USE_CONST
25: #endif
26:
27:
28: /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
29: #ifdef c_plusplus
30: #ifndef __cplusplus
31: #define __cplusplus
32: #endif
33: #endif
34:
35:
36: #ifdef __cplusplus
37:
38: #ifndef __STDC__
39: #include <stdlib.h>
40: #endif
41:
42: #include <osfcn.h>
43:
44: /* use prototypes in function declarations */
45: #define YY_USE_PROTOS
46:
47: /* the "const" storage-class-modifier is valid */
48: #define YY_USE_CONST
49:
50: #endif
51:
52:
53: #ifdef __TURBOC__
54: #define YY_USE_CONST
55: #endif
56:
57:
58: #ifndef YY_USE_CONST
59: #define const
60: #endif
61:
62:
63: #ifdef YY_USE_PROTOS
64: #define YY_PROTO(proto) proto
65: #else
66: #define YY_PROTO(proto) ()
67: /* there's no standard place to get these definitions */
68: char *malloc();
69: int free();
70: int read();
71: #endif
72:
73:
74: /* amount of stuff to slurp up with each read */
75: #ifndef YY_READ_BUF_SIZE
76: #define YY_READ_BUF_SIZE 8192
77: #endif
78:
79: /* returned upon end-of-file */
80: #define YY_END_TOK 0
81:
82: /* copy whatever the last rule matched to the standard output */
83:
84: /* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
85: /* this used to be an fputs(), but since the string might contain NUL's,
86: * we now use fwrite()
87: */
88: #define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
89:
90: /* gets input and stuffs it into "buf". number of characters read, or YY_NULL,
91: * is returned in "result".
92: */
93: #define YY_INPUT(buf,result,max_size) \
94: if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
95: YY_FATAL_ERROR( "read() in flex scanner failed" );
96: #define YY_NULL 0
97:
98: /* no semi-colon after return; correct usage is to write "yyterminate();" -
99: * we don't want an extra ';' after the "return" because that will cause
100: * some compilers to complain about unreachable statements.
101: */
102: #define yyterminate() return ( YY_NULL )
103:
104: /* report a fatal error */
105:
106: /* The funky do-while is used to turn this macro definition into
107: * a single C statement (which needs a semi-colon terminator).
108: * This avoids problems with code like:
109: *
110: * if ( something_happens )
111: * YY_FATAL_ERROR( "oops, the something happened" );
112: * else
113: * everything_okay();
114: *
115: * Prior to using the do-while the compiler would get upset at the
116: * "else" because it interpreted the "if" statement as being all
117: * done when it reached the ';' after the YY_FATAL_ERROR() call.
118: */
119:
120: #define YY_FATAL_ERROR(msg) \
121: do \
122: { \
123: (void) fputs( msg, stderr ); \
124: (void) putc( '\n', stderr ); \
125: exit( 1 ); \
126: } \
127: while ( 0 )
128:
129: /* default yywrap function - always treat EOF as an EOF */
130: #define yywrap() 1
131:
132: /* enter a start condition. This macro really ought to take a parameter,
133: * but we do it the disgusting crufty way forced on us by the ()-less
134: * definition of BEGIN
135: */
136: #define BEGIN yy_start = 1 + 2 *
137:
138: /* action number for EOF rule of a given start state */
139: #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
140:
141: /* special action meaning "start processing a new file" */
142: #define YY_NEW_FILE \
143: do \
144: { \
145: yy_init_buffer( yy_current_buffer, yyin ); \
146: yy_load_buffer_state(); \
147: } \
148: while ( 0 )
149:
150: /* default declaration of generated scanner - a define so the user can
151: * easily add parameters
152: */
153: #define YY_DECL int yylex YY_PROTO(( void ))
154:
155: /* code executed at the end of each rule */
156: #define YY_BREAK break;
157:
158: #define YY_END_OF_BUFFER_CHAR 0
159:
160: #ifndef YY_BUF_SIZE
161: #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
162: #endif
163:
164: typedef struct yy_buffer_state *YY_BUFFER_STATE;
165:
166: %% section 1 definitions go here
167:
168: /* done after the current pattern has been matched and before the
169: * corresponding action - sets up yytext
170: */
171: #define YY_DO_BEFORE_ACTION \
172: yytext = yy_bp; \
173: %% code to fiddle yytext and yyleng for yymore() goes here
174: yy_hold_char = *yy_cp; \
175: *yy_cp = '\0'; \
176: yy_c_buf_p = yy_cp;
177:
178: #define EOB_ACT_CONTINUE_SCAN 0
179: #define EOB_ACT_END_OF_FILE 1
180: #define EOB_ACT_LAST_MATCH 2
181:
182: /* return all but the first 'n' matched characters back to the input stream */
183: #define yyless(n) \
184: do \
185: { \
186: /* undo effects of setting up yytext */ \
187: *yy_cp = yy_hold_char; \
188: yy_c_buf_p = yy_cp = yy_bp + n; \
189: YY_DO_BEFORE_ACTION; /* set up yytext again */ \
190: } \
191: while ( 0 )
192:
193: #define unput(c) yyunput( c, yytext )
194:
195:
196: struct yy_buffer_state
197: {
198: FILE *yy_input_file;
199:
200: YY_CHAR *yy_ch_buf; /* input buffer */
201: YY_CHAR *yy_buf_pos; /* current position in input buffer */
202:
203: /* size of input buffer in bytes, not including room for EOB characters*/
204: int yy_buf_size;
205:
206: /* number of characters read into yy_ch_buf, not including EOB characters */
207: int yy_n_chars;
208:
209: int yy_eof_status; /* whether we've seen an EOF on this buffer */
210: #define EOF_NOT_SEEN 0
211: /* "pending" happens when the EOF has been seen but there's still
212: * some text process
213: */
214: #define EOF_PENDING 1
215: #define EOF_DONE 2
216: };
217:
218: static YY_BUFFER_STATE yy_current_buffer;
219:
220: /* we provide macros for accessing buffer states in case in the
221: * future we want to put the buffer states in a more general
222: * "scanner state"
223: */
224: #define YY_CURRENT_BUFFER yy_current_buffer
225:
226:
227: /* yy_hold_char holds the character lost when yytext is formed */
228: static YY_CHAR yy_hold_char;
229:
230: static int yy_n_chars; /* number of characters read into yy_ch_buf */
231:
232:
233:
234: #ifndef YY_USER_ACTION
235: #define YY_USER_ACTION
236: #endif
237:
238: #ifndef YY_USER_INIT
239: #define YY_USER_INIT
240: #endif
241:
242: extern YY_CHAR *yytext;
243: extern int yyleng;
244: extern FILE *yyin, *yyout;
245:
246: YY_CHAR *yytext;
247: int yyleng;
248:
249: FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
250:
251: %% data tables for the DFA go here
252:
253: /* these variables are all declared out here so that section 3 code can
254: * manipulate them
255: */
256: /* points to current character in buffer */
257: static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
258: static int yy_init = 1; /* whether we need to initialize */
259: static int yy_start = 0; /* start state number */
260:
261: /* flag which is used to allow yywrap()'s to do buffer switches
262: * instead of setting up a fresh yyin. A bit of a hack ...
263: */
264: static int yy_did_buffer_switch_on_eof;
265:
266: static yy_state_type yy_get_previous_state YY_PROTO(( void ));
267: static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
268: static int yy_get_next_buffer YY_PROTO(( void ));
269: static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
270: void yyrestart YY_PROTO(( FILE *input_file ));
271: void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
272: void yy_load_buffer_state YY_PROTO(( void ));
273: YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
274: void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
275: void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
276:
277: #define yy_new_buffer yy_create_buffer
278:
279: #ifdef __cplusplus
280: static int yyinput YY_PROTO(( void ));
281: #else
282: static int input YY_PROTO(( void ));
283: #endif
284:
285: YY_DECL
286: {
287: register yy_state_type yy_current_state;
288: register YY_CHAR *yy_cp, *yy_bp;
289: register int yy_act;
290:
291: %% user's declarations go here
292:
293: if ( yy_init )
294: {
295: YY_USER_INIT;
296:
297: if ( ! yy_start )
298: yy_start = 1; /* first start state */
299:
300: if ( ! yyin )
301: yyin = stdin;
302:
303: if ( ! yyout )
304: yyout = stdout;
305:
306: if ( yy_current_buffer )
307: yy_init_buffer( yy_current_buffer, yyin );
308: else
309: yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
310:
311: yy_load_buffer_state();
312:
313: yy_init = 0;
314: }
315:
316: while ( 1 ) /* loops until end-of-file is reached */
317: {
318: %% yymore()-related code goes here
319: yy_cp = yy_c_buf_p;
320:
321: /* support of yytext */
322: *yy_cp = yy_hold_char;
323:
324: /* yy_bp points to the position in yy_ch_buf of the start of the
325: * current run.
326: */
327: yy_bp = yy_cp;
328:
329: %% code to set up and find next match goes here
330:
331: yy_find_action:
332: %% code to find the action number goes here
333:
334: YY_DO_BEFORE_ACTION;
335: YY_USER_ACTION;
336:
337: do_action: /* this label is used only to access EOF actions */
338:
339: %% debug code goes here
340:
341: switch ( yy_act )
342: {
343: %% actions go here
344:
345: case YY_END_OF_BUFFER:
346: {
347: /* amount of text matched not including the EOB char */
348: int yy_amount_of_matched_text = yy_cp - yytext - 1;
349:
350: /* undo the effects of YY_DO_BEFORE_ACTION */
351: *yy_cp = yy_hold_char;
352:
353: /* note that here we test for yy_c_buf_p "<=" to the position
354: * of the first EOB in the buffer, since yy_c_buf_p will
355: * already have been incremented past the NUL character
356: * (since all states make transitions on EOB to the end-
357: * of-buffer state). Contrast this with the test in yyinput().
358: */
359: if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
360: /* this was really a NUL */
361: {
362: yy_state_type yy_next_state;
363:
364: yy_c_buf_p = yytext + yy_amount_of_matched_text;
365:
366: yy_current_state = yy_get_previous_state();
367:
368: /* okay, we're now positioned to make the
369: * NUL transition. We couldn't have
370: * yy_get_previous_state() go ahead and do it
371: * for us because it doesn't know how to deal
372: * with the possibility of jamming (and we
373: * don't want to build jamming into it because
374: * then it will run more slowly)
375: */
376:
377: yy_next_state = yy_try_NUL_trans( yy_current_state );
378:
379: yy_bp = yytext + YY_MORE_ADJ;
380:
381: if ( yy_next_state )
382: {
383: /* consume the NUL */
384: yy_cp = ++yy_c_buf_p;
385: yy_current_state = yy_next_state;
386: goto yy_match;
387: }
388:
389: else
390: {
391: %% code to do backtracking for compressed tables and set up yy_cp goes here
392: goto yy_find_action;
393: }
394: }
395:
396: else switch ( yy_get_next_buffer() )
397: {
398: case EOB_ACT_END_OF_FILE:
399: {
400: yy_did_buffer_switch_on_eof = 0;
401:
402: if ( yywrap() )
403: {
404: /* note: because we've taken care in
405: * yy_get_next_buffer() to have set up yytext,
406: * we can now set up yy_c_buf_p so that if some
407: * total hoser (like flex itself) wants
408: * to call the scanner after we return the
409: * YY_NULL, it'll still work - another YY_NULL
410: * will get returned.
411: */
412: yy_c_buf_p = yytext + YY_MORE_ADJ;
413:
414: yy_act = YY_STATE_EOF((yy_start - 1) / 2);
415: goto do_action;
416: }
417:
418: else
419: {
420: if ( ! yy_did_buffer_switch_on_eof )
421: YY_NEW_FILE;
422: }
423: }
424: break;
425:
426: case EOB_ACT_CONTINUE_SCAN:
427: yy_c_buf_p = yytext + yy_amount_of_matched_text;
428:
429: yy_current_state = yy_get_previous_state();
430:
431: yy_cp = yy_c_buf_p;
432: yy_bp = yytext + YY_MORE_ADJ;
433: goto yy_match;
434:
435: case EOB_ACT_LAST_MATCH:
436: yy_c_buf_p =
437: &yy_current_buffer->yy_ch_buf[yy_n_chars];
438:
439: yy_current_state = yy_get_previous_state();
440:
441: yy_cp = yy_c_buf_p;
442: yy_bp = yytext + YY_MORE_ADJ;
443: goto yy_find_action;
444: }
445: break;
446: }
447:
448: default:
449: #ifdef FLEX_DEBUG
450: printf( "action # %d\n", yy_act );
451: #endif
452: YY_FATAL_ERROR(
453: "fatal flex scanner internal error--no action found" );
454: }
455: }
456: }
457:
458:
459: /* yy_get_next_buffer - try to read in a new buffer
460: *
461: * synopsis
462: * int yy_get_next_buffer();
463: *
464: * returns a code representing an action
465: * EOB_ACT_LAST_MATCH -
466: * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
467: * EOB_ACT_END_OF_FILE - end of file
468: */
469:
470: static int yy_get_next_buffer()
471:
472: {
473: register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
474: register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
475: register int number_to_move, i;
476: int ret_val;
477:
478: if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
479: YY_FATAL_ERROR(
480: "fatal flex scanner internal error--end of buffer missed" );
481:
482: /* try to read more data */
483:
484: /* first move last chars to start of buffer */
485: number_to_move = yy_c_buf_p - yytext;
486:
487: for ( i = 0; i < number_to_move; ++i )
488: *(dest++) = *(source++);
489:
490: if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
491: /* don't do the read, it's not guaranteed to return an EOF,
492: * just force an EOF
493: */
494: yy_n_chars = 0;
495:
496: else
497: {
498: int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
499:
500: if ( num_to_read > YY_READ_BUF_SIZE )
501: num_to_read = YY_READ_BUF_SIZE;
502:
503: else if ( num_to_read <= 0 )
504: YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
505:
506: /* read in more data */
507: YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
508: yy_n_chars, num_to_read );
509: }
510:
511: if ( yy_n_chars == 0 )
512: {
513: if ( number_to_move == 1 )
514: {
515: ret_val = EOB_ACT_END_OF_FILE;
516: yy_current_buffer->yy_eof_status = EOF_DONE;
517: }
518:
519: else
520: {
521: ret_val = EOB_ACT_LAST_MATCH;
522: yy_current_buffer->yy_eof_status = EOF_PENDING;
523: }
524: }
525:
526: else
527: ret_val = EOB_ACT_CONTINUE_SCAN;
528:
529: yy_n_chars += number_to_move;
530: yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
531: yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
532:
533: /* yytext begins at the second character in yy_ch_buf; the first
534: * character is the one which preceded it before reading in the latest
535: * buffer; it needs to be kept around in case it's a newline, so
536: * yy_get_previous_state() will have with '^' rules active
537: */
538:
539: yytext = &yy_current_buffer->yy_ch_buf[1];
540:
541: return ( ret_val );
542: }
543:
544:
545: /* yy_get_previous_state - get the state just before the EOB char was reached
546: *
547: * synopsis
548: * yy_state_type yy_get_previous_state();
549: */
550:
551: static yy_state_type yy_get_previous_state()
552:
553: {
554: register yy_state_type yy_current_state;
555: register YY_CHAR *yy_cp;
556:
557: %% code to get the start state into yy_current_state goes here
558:
559: for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
560: {
561: %% code to find the next state goes here
562: }
563:
564: return ( yy_current_state );
565: }
566:
567:
568: /* yy_try_NUL_trans - try to make a transition on the NUL character
569: *
570: * synopsis
571: * next_state = yy_try_NUL_trans( current_state );
572: */
573:
574: #ifdef YY_USE_PROTOS
575: static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
576: #else
577: static yy_state_type yy_try_NUL_trans( yy_current_state )
578: register yy_state_type yy_current_state;
579: #endif
580:
581: {
582: register int yy_is_jam;
583: %% code to find the next state, and perhaps do backtracking, goes here
584:
585: return ( yy_is_jam ? 0 : yy_current_state );
586: }
587:
588:
589: #ifdef YY_USE_PROTOS
590: static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
591: #else
592: static void yyunput( c, yy_bp )
593: YY_CHAR c;
594: register YY_CHAR *yy_bp;
595: #endif
596:
597: {
598: register YY_CHAR *yy_cp = yy_c_buf_p;
599:
600: /* undo effects of setting up yytext */
601: *yy_cp = yy_hold_char;
602:
603: if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
604: { /* need to shift things up to make room */
605: register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
606: register YY_CHAR *dest =
607: &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
608: register YY_CHAR *source =
609: &yy_current_buffer->yy_ch_buf[number_to_move];
610:
611: while ( source > yy_current_buffer->yy_ch_buf )
612: *--dest = *--source;
613:
614: yy_cp += dest - source;
615: yy_bp += dest - source;
616: yy_n_chars = yy_current_buffer->yy_buf_size;
617:
618: if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
619: YY_FATAL_ERROR( "flex scanner push-back overflow" );
620: }
621:
622: if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
623: yy_cp[-2] = '\n';
624:
625: *--yy_cp = c;
626:
627: /* note: the formal parameter *must* be called "yy_bp" for this
628: * macro to now work correctly
629: */
630: YY_DO_BEFORE_ACTION; /* set up yytext again */
631: }
632:
633:
634: #ifdef __cplusplus
635: static int yyinput()
636: #else
637: static int input()
638: #endif
639:
640: {
641: int c;
642: YY_CHAR *yy_cp = yy_c_buf_p;
643:
644: *yy_cp = yy_hold_char;
645:
646: if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
647: {
648: /* yy_c_buf_p now points to the character we want to return.
649: * If this occurs *before* the EOB characters, then it's a
650: * valid NUL; if not, then we've hit the end of the buffer.
651: */
652: if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
653: /* this was really a NUL */
654: *yy_c_buf_p = '\0';
655:
656: else
657: { /* need more input */
658: yytext = yy_c_buf_p;
659: ++yy_c_buf_p;
660:
661: switch ( yy_get_next_buffer() )
662: {
663: case EOB_ACT_END_OF_FILE:
664: {
665: if ( yywrap() )
666: {
667: yy_c_buf_p = yytext + YY_MORE_ADJ;
668: return ( EOF );
669: }
670:
671: YY_NEW_FILE;
672:
673: #ifdef __cplusplus
674: return ( yyinput() );
675: #else
676: return ( input() );
677: #endif
678: }
679: break;
680:
681: case EOB_ACT_CONTINUE_SCAN:
682: yy_c_buf_p = yytext + YY_MORE_ADJ;
683: break;
684:
685: case EOB_ACT_LAST_MATCH:
686: #ifdef __cplusplus
687: YY_FATAL_ERROR( "unexpected last match in yyinput()" );
688: #else
689: YY_FATAL_ERROR( "unexpected last match in input()" );
690: #endif
691: }
692: }
693: }
694:
695: c = *yy_c_buf_p;
696: yy_hold_char = *++yy_c_buf_p;
697:
698: return ( c );
699: }
700:
701:
702: #ifdef YY_USE_PROTOS
703: void yyrestart( FILE *input_file )
704: #else
705: void yyrestart( input_file )
706: FILE *input_file;
707: #endif
708:
709: {
710: yy_init_buffer( yy_current_buffer, input_file );
711: yy_load_buffer_state();
712: }
713:
714:
715: #ifdef YY_USE_PROTOS
716: void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
717: #else
718: void yy_switch_to_buffer( new_buffer )
719: YY_BUFFER_STATE new_buffer;
720: #endif
721:
722: {
723: if ( yy_current_buffer == new_buffer )
724: return;
725:
726: if ( yy_current_buffer )
727: {
728: /* flush out information for old buffer */
729: *yy_c_buf_p = yy_hold_char;
730: yy_current_buffer->yy_buf_pos = yy_c_buf_p;
731: yy_current_buffer->yy_n_chars = yy_n_chars;
732: }
733:
734: yy_current_buffer = new_buffer;
735: yy_load_buffer_state();
736:
737: /* we don't actually know whether we did this switch during
738: * EOF (yywrap()) processing, but the only time this flag
739: * is looked at is after yywrap() is called, so it's safe
740: * to go ahead and always set it.
741: */
742: yy_did_buffer_switch_on_eof = 1;
743: }
744:
745:
746: #ifdef YY_USE_PROTOS
747: void yy_load_buffer_state( void )
748: #else
749: void yy_load_buffer_state()
750: #endif
751:
752: {
753: yy_n_chars = yy_current_buffer->yy_n_chars;
754: yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
755: yyin = yy_current_buffer->yy_input_file;
756: yy_hold_char = *yy_c_buf_p;
757: }
758:
759:
760: #ifdef YY_USE_PROTOS
761: YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
762: #else
763: YY_BUFFER_STATE yy_create_buffer( file, size )
764: FILE *file;
765: int size;
766: #endif
767:
768: {
769: YY_BUFFER_STATE b;
770:
771: b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
772:
773: if ( ! b )
774: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
775:
776: b->yy_buf_size = size;
777:
778: /* yy_ch_buf has to be 2 characters longer than the size given because
779: * we need to put in 2 end-of-buffer characters.
780: */
781: b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
782:
783: if ( ! b->yy_ch_buf )
784: YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
785:
786: yy_init_buffer( b, file );
787:
788: return ( b );
789: }
790:
791:
792: #ifdef YY_USE_PROTOS
793: void yy_delete_buffer( YY_BUFFER_STATE b )
794: #else
795: void yy_delete_buffer( b )
796: YY_BUFFER_STATE b;
797: #endif
798:
799: {
800: if ( b == yy_current_buffer )
801: yy_current_buffer = (YY_BUFFER_STATE) 0;
802:
803: free( (char *) b->yy_ch_buf );
804: free( (char *) b );
805: }
806:
807:
808: #ifdef YY_USE_PROTOS
809: void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
810: #else
811: void yy_init_buffer( b, file )
812: YY_BUFFER_STATE b;
813: FILE *file;
814: #endif
815:
816: {
817: b->yy_input_file = file;
818:
819: /* we put in the '\n' and start reading from [1] so that an
820: * initial match-at-newline will be true.
821: */
822:
823: b->yy_ch_buf[0] = '\n';
824: b->yy_n_chars = 1;
825:
826: /* we always need two end-of-buffer characters. The first causes
827: * a transition to the end-of-buffer state. The second causes
828: * a jam in that state.
829: */
830: b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
831: b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
832:
833: b->yy_buf_pos = &b->yy_ch_buf[1];
834:
835: b->yy_eof_status = EOF_NOT_SEEN;
836: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.