![[BACK]](/icons/back.gif){kind=icon}
Return to scan.l CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex|
Return to scan.l CVS log | Up to [local] / src / usr.bin / lex |
1.1 ! deraadt 1: /* scan.l - scanner for flex input */
! 2:
! 3: %{
! 4: /*-
! 5: * Copyright (c) 1990 The Regents of the University of California.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * Vern Paxson.
! 10: *
! 11: * The United States Government has rights in this work pursuant
! 12: * to contract no. DE-AC03-76SF00098 between the United States
! 13: * Department of Energy and the University of California.
! 14: *
! 15: * Redistribution and use in source and binary forms are permitted provided
! 16: * that: (1) source distributions retain this entire copyright notice and
! 17: * comment, and (2) distributions including binaries display the following
! 18: * acknowledgement: ``This product includes software developed by the
! 19: * University of California, Berkeley and its contributors'' in the
! 20: * documentation or other materials provided with the distribution and in
! 21: * all advertising materials mentioning features or use of this software.
! 22: * Neither the name of the University nor the names of its contributors may
! 23: * be used to endorse or promote products derived from this software without
! 24: * specific prior written permission.
! 25: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
! 26: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
! 27: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
! 28: */
! 29:
! 30: /* $Header: /a/cvsroot/src/usr.bin/lex/scan.l,v 1.8 1995/05/05 05:35:41 jtc Exp $ */
! 31:
! 32: #include "flexdef.h"
! 33: #include "parse.h"
! 34:
! 35: #define ACTION_ECHO add_action( yytext )
! 36: #define ACTION_IFDEF(def, should_define) \
! 37: { \
! 38: if ( should_define ) \
! 39: action_define( def, 1 ); \
! 40: }
! 41:
! 42: #define MARK_END_OF_PROLOG mark_prolog();
! 43:
! 44: #define YY_DECL \
! 45: int flexscan()
! 46:
! 47: #define RETURNCHAR \
! 48: yylval = (unsigned char) yytext[0]; \
! 49: return CHAR;
! 50:
! 51: #define RETURNNAME \
! 52: strcpy( nmstr, yytext ); \
! 53: return NAME;
! 54:
! 55: #define PUT_BACK_STRING(str, start) \
! 56: for ( i = strlen( str ) - 1; i >= start; --i ) \
! 57: unput((str)[i])
! 58:
! 59: #define CHECK_REJECT(str) \
! 60: if ( all_upper( str ) ) \
! 61: reject = true;
! 62:
! 63: #define CHECK_YYMORE(str) \
! 64: if ( all_lower( str ) ) \
! 65: yymore_used = true;
! 66: %}
! 67:
! 68: %option caseless nodefault outfile="scan.c" stack noyy_top_state
! 69: %option nostdinit
! 70:
! 71: %x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
! 72: %x FIRSTCCL CCL ACTION RECOVER COMMENT ACTION_STRING PERCENT_BRACE_ACTION
! 73: %x OPTION LINEDIR
! 74:
! 75: WS [[:blank:]]+
! 76: OPTWS [[:blank:]]*
! 77: NOT_WS [^[:blank:]\n]
! 78:
! 79: NL \r?\n
! 80:
! 81: NAME ([[:alpha:]_][[:alnum:]_-]*)
! 82: NOT_NAME [^[:alpha:]_*\n]+
! 83:
! 84: SCNAME {NAME}
! 85:
! 86: ESCSEQ (\\([^\n]|[0-7]{1,3}|x[[:xdigit:]]{1,2}))
! 87:
! 88: FIRST_CCL_CHAR ([^\\\n]|{ESCSEQ})
! 89: CCL_CHAR ([^\\\n\]]|{ESCSEQ})
! 90: CCL_EXPR ("[:"[[:alpha:]]+":]")
! 91:
! 92: LEXOPT [aceknopr]
! 93:
! 94: %%
! 95: static int bracelevel, didadef, indented_code;
! 96: static int doing_rule_action = false;
! 97: static int option_sense;
! 98:
! 99: int doing_codeblock = false;
! 100: int i;
! 101: Char nmdef[MAXLINE], myesc();
! 102:
! 103:
! 104: <INITIAL>{
! 105: ^{WS} indented_code = true; BEGIN(CODEBLOCK);
! 106: ^"/*" ACTION_ECHO; yy_push_state( COMMENT );
! 107: ^#{OPTWS}line{WS} yy_push_state( LINEDIR );
! 108: ^"%s"{NAME}? return SCDECL;
! 109: ^"%x"{NAME}? return XSCDECL;
! 110: ^"%{".*{NL} {
! 111: ++linenum;
! 112: line_directive_out( (FILE *) 0, 1 );
! 113: indented_code = false;
! 114: BEGIN(CODEBLOCK);
! 115: }
! 116:
! 117: {WS} /* discard */
! 118:
! 119: ^"%%".* {
! 120: sectnum = 2;
! 121: bracelevel = 0;
! 122: mark_defs1();
! 123: line_directive_out( (FILE *) 0, 1 );
! 124: BEGIN(SECT2PROLOG);
! 125: return SECTEND;
! 126: }
! 127:
! 128: ^"%pointer".*{NL} yytext_is_array = false; ++linenum;
! 129: ^"%array".*{NL} yytext_is_array = true; ++linenum;
! 130:
! 131: ^"%option" BEGIN(OPTION); return OPTION_OP;
! 132:
! 133: ^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL} ++linenum; /* ignore */
! 134: ^"%"{LEXOPT}{WS}.*{NL} ++linenum; /* ignore */
! 135:
! 136: ^"%"[^sxaceknopr{}].* synerr( _( "unrecognized '%' directive" ) );
! 137:
! 138: ^{NAME} {
! 139: strcpy( nmstr, yytext );
! 140: didadef = false;
! 141: BEGIN(PICKUPDEF);
! 142: }
! 143:
! 144: {SCNAME} RETURNNAME;
! 145: ^{OPTWS}{NL} ++linenum; /* allows blank lines in section 1 */
! 146: {OPTWS}{NL} ACTION_ECHO; ++linenum; /* maybe end of comment line */
! 147: }
! 148:
! 149:
! 150: <COMMENT>{
! 151: "*/" ACTION_ECHO; yy_pop_state();
! 152: "*" ACTION_ECHO;
! 153: [^*\n]+ ACTION_ECHO;
! 154: [^*\n]*{NL} ++linenum; ACTION_ECHO;
! 155: }
! 156:
! 157: <LINEDIR>{
! 158: \n yy_pop_state();
! 159: [[:digit:]]+ linenum = myctoi( yytext );
! 160:
! 161: \"[^"\n]*\" {
! 162: flex_free( (void *) infilename );
! 163: infilename = copy_string( yytext + 1 );
! 164: infilename[strlen( infilename ) - 1] = '\0';
! 165: }
! 166: . /* ignore spurious characters */
! 167: }
! 168:
! 169: <CODEBLOCK>{
! 170: ^"%}".*{NL} ++linenum; BEGIN(INITIAL);
! 171:
! 172: {NAME}|{NOT_NAME}|. ACTION_ECHO;
! 173:
! 174: {NL} {
! 175: ++linenum;
! 176: ACTION_ECHO;
! 177: if ( indented_code )
! 178: BEGIN(INITIAL);
! 179: }
! 180: }
! 181:
! 182:
! 183: <PICKUPDEF>{
! 184: {WS} /* separates name and definition */
! 185:
! 186: {NOT_WS}.* {
! 187: strcpy( (char *) nmdef, yytext );
! 188:
! 189: /* Skip trailing whitespace. */
! 190: for ( i = strlen( (char *) nmdef ) - 1;
! 191: i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
! 192: --i )
! 193: ;
! 194:
! 195: nmdef[i + 1] = '\0';
! 196:
! 197: ndinstal( nmstr, nmdef );
! 198: didadef = true;
! 199: }
! 200:
! 201: {NL} {
! 202: if ( ! didadef )
! 203: synerr( _( "incomplete name definition" ) );
! 204: BEGIN(INITIAL);
! 205: ++linenum;
! 206: }
! 207: }
! 208:
! 209:
! 210: <OPTION>{
! 211: {NL} ++linenum; BEGIN(INITIAL);
! 212: {WS} option_sense = true;
! 213:
! 214: "=" return '=';
! 215:
! 216: no option_sense = ! option_sense;
! 217:
! 218: 7bit csize = option_sense ? 128 : 256;
! 219: 8bit csize = option_sense ? 256 : 128;
! 220:
! 221: align long_align = option_sense;
! 222: always-interactive {
! 223: action_define( "YY_ALWAYS_INTERACTIVE", option_sense );
! 224: }
! 225: array yytext_is_array = option_sense;
! 226: backup backing_up_report = option_sense;
! 227: batch interactive = ! option_sense;
! 228: "c++" C_plus_plus = option_sense;
! 229: caseful|case-sensitive caseins = ! option_sense;
! 230: caseless|case-insensitive caseins = option_sense;
! 231: debug ddebug = option_sense;
! 232: default spprdflt = ! option_sense;
! 233: ecs useecs = option_sense;
! 234: fast {
! 235: useecs = usemecs = false;
! 236: use_read = fullspd = true;
! 237: }
! 238: full {
! 239: useecs = usemecs = false;
! 240: use_read = fulltbl = true;
! 241: }
! 242: input ACTION_IFDEF("YY_NO_INPUT", ! option_sense);
! 243: interactive interactive = option_sense;
! 244: lex-compat lex_compat = option_sense;
! 245: main {
! 246: action_define( "YY_MAIN", option_sense );
! 247: do_yywrap = ! option_sense;
! 248: }
! 249: meta-ecs usemecs = option_sense;
! 250: never-interactive {
! 251: action_define( "YY_NEVER_INTERACTIVE", option_sense );
! 252: }
! 253: perf-report performance_report += option_sense ? 1 : -1;
! 254: pointer yytext_is_array = ! option_sense;
! 255: read use_read = option_sense;
! 256: reject reject_really_used = option_sense;
! 257: stack action_define( "YY_STACK_USED", option_sense );
! 258: stdinit do_stdinit = option_sense;
! 259: stdout use_stdout = option_sense;
! 260: unput ACTION_IFDEF("YY_NO_UNPUT", ! option_sense);
! 261: verbose printstats = option_sense;
! 262: warn nowarn = ! option_sense;
! 263: yylineno do_yylineno = option_sense;
! 264: yymore yymore_really_used = option_sense;
! 265: yywrap do_yywrap = option_sense;
! 266:
! 267: yy_push_state ACTION_IFDEF("YY_NO_PUSH_STATE", ! option_sense);
! 268: yy_pop_state ACTION_IFDEF("YY_NO_POP_STATE", ! option_sense);
! 269: yy_top_state ACTION_IFDEF("YY_NO_TOP_STATE", ! option_sense);
! 270:
! 271: yy_scan_buffer ACTION_IFDEF("YY_NO_SCAN_BUFFER", ! option_sense);
! 272: yy_scan_bytes ACTION_IFDEF("YY_NO_SCAN_BYTES", ! option_sense);
! 273: yy_scan_string ACTION_IFDEF("YY_NO_SCAN_STRING", ! option_sense);
! 274:
! 275: outfile return OPT_OUTFILE;
! 276: prefix return OPT_PREFIX;
! 277: yyclass return OPT_YYCLASS;
! 278:
! 279: \"[^"\n]*\" {
! 280: strcpy( nmstr, yytext + 1 );
! 281: nmstr[strlen( nmstr ) - 1] = '\0';
! 282: return NAME;
! 283: }
! 284:
! 285: (([a-mo-z]|n[a-np-z])[[:alpha:]\-+]*)|. {
! 286: format_synerr( _( "unrecognized %%option: %s" ),
! 287: yytext );
! 288: BEGIN(RECOVER);
! 289: }
! 290: }
! 291:
! 292: <RECOVER>.*{NL} ++linenum; BEGIN(INITIAL);
! 293:
! 294:
! 295: <SECT2PROLOG>{
! 296: ^"%{".* ++bracelevel; yyless( 2 ); /* eat only %{ */
! 297: ^"%}".* --bracelevel; yyless( 2 ); /* eat only %} */
! 298:
! 299: ^{WS}.* ACTION_ECHO; /* indented code in prolog */
! 300:
! 301: ^{NOT_WS}.* { /* non-indented code */
! 302: if ( bracelevel <= 0 )
! 303: { /* not in %{ ... %} */
! 304: yyless( 0 ); /* put it all back */
! 305: yy_set_bol( 1 );
! 306: mark_prolog();
! 307: BEGIN(SECT2);
! 308: }
! 309: else
! 310: ACTION_ECHO;
! 311: }
! 312:
! 313: .* ACTION_ECHO;
! 314: {NL} ++linenum; ACTION_ECHO;
! 315:
! 316: <<EOF>> {
! 317: mark_prolog();
! 318: sectnum = 0;
! 319: yyterminate(); /* to stop the parser */
! 320: }
! 321: }
! 322:
! 323: <SECT2>{
! 324: ^{OPTWS}{NL} ++linenum; /* allow blank lines in section 2 */
! 325:
! 326: ^{OPTWS}"%{" {
! 327: indented_code = false;
! 328: doing_codeblock = true;
! 329: bracelevel = 1;
! 330: BEGIN(PERCENT_BRACE_ACTION);
! 331: }
! 332:
! 333: ^{OPTWS}"<" BEGIN(SC); return '<';
! 334: ^{OPTWS}"^" return '^';
! 335: \" BEGIN(QUOTE); return '"';
! 336: "{"/[[:digit:]] BEGIN(NUM); return '{';
! 337: "$"/([[:blank:]]|{NL}) return '$';
! 338:
! 339: {WS}"%{" {
! 340: bracelevel = 1;
! 341: BEGIN(PERCENT_BRACE_ACTION);
! 342:
! 343: if ( in_rule )
! 344: {
! 345: doing_rule_action = true;
! 346: in_rule = false;
! 347: return '\n';
! 348: }
! 349: }
! 350: {WS}"|".*{NL} continued_action = true; ++linenum; return '\n';
! 351:
! 352: ^{WS}"/*" {
! 353: yyless( yyleng - 2 ); /* put back '/', '*' */
! 354: bracelevel = 0;
! 355: continued_action = false;
! 356: BEGIN(ACTION);
! 357: }
! 358:
! 359: ^{WS} /* allow indented rules */
! 360:
! 361: {WS} {
! 362: /* This rule is separate from the one below because
! 363: * otherwise we get variable trailing context, so
! 364: * we can't build the scanner using -{f,F}.
! 365: */
! 366: bracelevel = 0;
! 367: continued_action = false;
! 368: BEGIN(ACTION);
! 369:
! 370: if ( in_rule )
! 371: {
! 372: doing_rule_action = true;
! 373: in_rule = false;
! 374: return '\n';
! 375: }
! 376: }
! 377:
! 378: {OPTWS}{NL} {
! 379: bracelevel = 0;
! 380: continued_action = false;
! 381: BEGIN(ACTION);
! 382: unput( '\n' ); /* so <ACTION> sees it */
! 383:
! 384: if ( in_rule )
! 385: {
! 386: doing_rule_action = true;
! 387: in_rule = false;
! 388: return '\n';
! 389: }
! 390: }
! 391:
! 392: ^{OPTWS}"<<EOF>>" |
! 393: "<<EOF>>" return EOF_OP;
! 394:
! 395: ^"%%".* {
! 396: sectnum = 3;
! 397: BEGIN(SECT3);
! 398: yyterminate(); /* to stop the parser */
! 399: }
! 400:
! 401: "["({FIRST_CCL_CHAR}|{CCL_EXPR})({CCL_CHAR}|{CCL_EXPR})* {
! 402: int cclval;
! 403:
! 404: strcpy( nmstr, yytext );
! 405:
! 406: /* Check to see if we've already encountered this
! 407: * ccl.
! 408: */
! 409: if ( (cclval = ccllookup( (Char *) nmstr )) != 0 )
! 410: {
! 411: if ( input() != ']' )
! 412: synerr( _( "bad character class" ) );
! 413:
! 414: yylval = cclval;
! 415: ++cclreuse;
! 416: return PREVCCL;
! 417: }
! 418: else
! 419: {
! 420: /* We fudge a bit. We know that this ccl will
! 421: * soon be numbered as lastccl + 1 by cclinit.
! 422: */
! 423: cclinstal( (Char *) nmstr, lastccl + 1 );
! 424:
! 425: /* Push back everything but the leading bracket
! 426: * so the ccl can be rescanned.
! 427: */
! 428: yyless( 1 );
! 429:
! 430: BEGIN(FIRSTCCL);
! 431: return '[';
! 432: }
! 433: }
! 434:
! 435: "{"{NAME}"}" {
! 436: register Char *nmdefptr;
! 437: Char *ndlookup();
! 438:
! 439: strcpy( nmstr, yytext + 1 );
! 440: nmstr[yyleng - 2] = '\0'; /* chop trailing brace */
! 441:
! 442: if ( (nmdefptr = ndlookup( nmstr )) == 0 )
! 443: format_synerr(
! 444: _( "undefined definition {%s}" ),
! 445: nmstr );
! 446:
! 447: else
! 448: { /* push back name surrounded by ()'s */
! 449: int len = strlen( (char *) nmdefptr );
! 450:
! 451: if ( lex_compat || nmdefptr[0] == '^' ||
! 452: (len > 0 && nmdefptr[len - 1] == '$') )
! 453: { /* don't use ()'s after all */
! 454: PUT_BACK_STRING((char *) nmdefptr, 0);
! 455:
! 456: if ( nmdefptr[0] == '^' )
! 457: BEGIN(CARETISBOL);
! 458: }
! 459:
! 460: else
! 461: {
! 462: unput(')');
! 463: PUT_BACK_STRING((char *) nmdefptr, 0);
! 464: unput('(');
! 465: }
! 466: }
! 467: }
! 468:
! 469: [/|*+?.(){}] return (unsigned char) yytext[0];
! 470: . RETURNCHAR;
! 471: }
! 472:
! 473:
! 474: <SC>{
! 475: [,*] return (unsigned char) yytext[0];
! 476: ">" BEGIN(SECT2); return '>';
! 477: ">"/^ BEGIN(CARETISBOL); return '>';
! 478: {SCNAME} RETURNNAME;
! 479: . {
! 480: format_synerr( _( "bad <start condition>: %s" ),
! 481: yytext );
! 482: }
! 483: }
! 484:
! 485: <CARETISBOL>"^" BEGIN(SECT2); return '^';
! 486:
! 487:
! 488: <QUOTE>{
! 489: [^"\n] RETURNCHAR;
! 490: \" BEGIN(SECT2); return '"';
! 491:
! 492: {NL} {
! 493: synerr( _( "missing quote" ) );
! 494: BEGIN(SECT2);
! 495: ++linenum;
! 496: return '"';
! 497: }
! 498: }
! 499:
! 500:
! 501: <FIRSTCCL>{
! 502: "^"/[^-\]\n] BEGIN(CCL); return '^';
! 503: "^"/("-"|"]") return '^';
! 504: . BEGIN(CCL); RETURNCHAR;
! 505: }
! 506:
! 507: <CCL>{
! 508: -/[^\]\n] return '-';
! 509: [^\]\n] RETURNCHAR;
! 510: "]" BEGIN(SECT2); return ']';
! 511: .|{NL} {
! 512: synerr( _( "bad character class" ) );
! 513: BEGIN(SECT2);
! 514: return ']';
! 515: }
! 516: }
! 517:
! 518: <FIRSTCCL,CCL>{
! 519: "[:alnum:]" BEGIN(CCL); return CCE_ALNUM;
! 520: "[:alpha:]" BEGIN(CCL); return CCE_ALPHA;
! 521: "[:blank:]" BEGIN(CCL); return CCE_BLANK;
! 522: "[:cntrl:]" BEGIN(CCL); return CCE_CNTRL;
! 523: "[:digit:]" BEGIN(CCL); return CCE_DIGIT;
! 524: "[:graph:]" BEGIN(CCL); return CCE_GRAPH;
! 525: "[:lower:]" BEGIN(CCL); return CCE_LOWER;
! 526: "[:print:]" BEGIN(CCL); return CCE_PRINT;
! 527: "[:punct:]" BEGIN(CCL); return CCE_PUNCT;
! 528: "[:space:]" BEGIN(CCL); return CCE_SPACE;
! 529: "[:upper:]" BEGIN(CCL); return CCE_UPPER;
! 530: "[:xdigit:]" BEGIN(CCL); return CCE_XDIGIT;
! 531: {CCL_EXPR} {
! 532: format_synerr(
! 533: _( "bad character class expression: %s" ),
! 534: yytext );
! 535: BEGIN(CCL); return CCE_ALNUM;
! 536: }
! 537: }
! 538:
! 539: <NUM>{
! 540: [[:digit:]]+ {
! 541: yylval = myctoi( yytext );
! 542: return NUMBER;
! 543: }
! 544:
! 545: "," return ',';
! 546: "}" BEGIN(SECT2); return '}';
! 547:
! 548: . {
! 549: synerr( _( "bad character inside {}'s" ) );
! 550: BEGIN(SECT2);
! 551: return '}';
! 552: }
! 553:
! 554: {NL} {
! 555: synerr( _( "missing }" ) );
! 556: BEGIN(SECT2);
! 557: ++linenum;
! 558: return '}';
! 559: }
! 560: }
! 561:
! 562:
! 563: <PERCENT_BRACE_ACTION>{
! 564: {OPTWS}"%}".* bracelevel = 0;
! 565:
! 566: <ACTION>"/*" ACTION_ECHO; yy_push_state( COMMENT );
! 567:
! 568: <CODEBLOCK,ACTION>{
! 569: "reject" {
! 570: ACTION_ECHO;
! 571: CHECK_REJECT(yytext);
! 572: }
! 573: "yymore" {
! 574: ACTION_ECHO;
! 575: CHECK_YYMORE(yytext);
! 576: }
! 577: }
! 578:
! 579: {NAME}|{NOT_NAME}|. ACTION_ECHO;
! 580: {NL} {
! 581: ++linenum;
! 582: ACTION_ECHO;
! 583: if ( bracelevel == 0 ||
! 584: (doing_codeblock && indented_code) )
! 585: {
! 586: if ( doing_rule_action )
! 587: add_action( "\tYY_BREAK\n" );
! 588:
! 589: doing_rule_action = doing_codeblock = false;
! 590: BEGIN(SECT2);
! 591: }
! 592: }
! 593: }
! 594:
! 595:
! 596: /* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
! 597: <ACTION>{
! 598: "{" ACTION_ECHO; ++bracelevel;
! 599: "}" ACTION_ECHO; --bracelevel;
! 600: [^[:alpha:]_{}"'/\n]+ ACTION_ECHO;
! 601: {NAME} ACTION_ECHO;
! 602: "'"([^'\\\n]|\\.)*"'" ACTION_ECHO; /* character constant */
! 603: \" ACTION_ECHO; BEGIN(ACTION_STRING);
! 604: {NL} {
! 605: ++linenum;
! 606: ACTION_ECHO;
! 607: if ( bracelevel == 0 )
! 608: {
! 609: if ( doing_rule_action )
! 610: add_action( "\tYY_BREAK\n" );
! 611:
! 612: doing_rule_action = false;
! 613: BEGIN(SECT2);
! 614: }
! 615: }
! 616: . ACTION_ECHO;
! 617: }
! 618:
! 619: <ACTION_STRING>{
! 620: [^"\\\n]+ ACTION_ECHO;
! 621: \\. ACTION_ECHO;
! 622: {NL} ++linenum; ACTION_ECHO;
! 623: \" ACTION_ECHO; BEGIN(ACTION);
! 624: . ACTION_ECHO;
! 625: }
! 626:
! 627: <COMMENT,ACTION,ACTION_STRING><<EOF>> {
! 628: synerr( _( "EOF encountered inside an action" ) );
! 629: yyterminate();
! 630: }
! 631:
! 632:
! 633: <SECT2,QUOTE,FIRSTCCL,CCL>{ESCSEQ} {
! 634: yylval = myesc( (Char *) yytext );
! 635:
! 636: if ( YY_START == FIRSTCCL )
! 637: BEGIN(CCL);
! 638:
! 639: return CHAR;
! 640: }
! 641:
! 642:
! 643: <SECT3>{
! 644: .*(\n?) ECHO;
! 645: <<EOF>> sectnum = 0; yyterminate();
! 646: }
! 647:
! 648: <*>.|\n format_synerr( _( "bad character: %s" ), yytext );
! 649:
! 650: %%
! 651:
! 652:
! 653: int yywrap()
! 654: {
! 655: if ( --num_input_files > 0 )
! 656: {
! 657: set_input_file( *++input_files );
! 658: return 0;
! 659: }
! 660:
! 661: else
! 662: return 1;
! 663: }
! 664:
! 665:
! 666: /* set_input_file - open the given file (if NULL, stdin) for scanning */
! 667:
! 668: void set_input_file( file )
! 669: char *file;
! 670: {
! 671: if ( file && strcmp( file, "-" ) )
! 672: {
! 673: infilename = copy_string( file );
! 674: yyin = fopen( infilename, "r" );
! 675:
! 676: if ( yyin == NULL )
! 677: lerrsf( _( "can't open %s" ), file );
! 678: }
! 679:
! 680: else
! 681: {
! 682: yyin = stdin;
! 683: infilename = copy_string( "<stdin>" );
! 684: }
! 685:
! 686: linenum = 1;
! 687: }
! 688:
! 689:
! 690: /* Wrapper routines for accessing the scanner's malloc routines. */
! 691:
! 692: void *flex_alloc( size )
! 693: size_t size;
! 694: {
! 695: return (void *) malloc( size );
! 696: }
! 697:
! 698: void *flex_realloc( ptr, size )
! 699: void *ptr;
! 700: size_t size;
! 701: {
! 702: return (void *) realloc( ptr, size );
! 703: }
! 704:
! 705: void flex_free( ptr )
! 706: void *ptr;
! 707: {
! 708: if ( ptr )
! 709: free( ptr );
! 710: }