home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / flex254.zip / yylex.c < prev   
C/C++ Source or Header  |  1998-02-15  |  5KB  |  217 lines
  1. /* yylex - scanner front-end for flex */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms with or without
  15.  * modification are permitted provided that: (1) source distributions retain
  16.  * this entire copyright notice and comment, and (2) distributions including
  17.  * binaries display the following acknowledgement:  ``This product includes
  18.  * software developed by the University of California, Berkeley and its
  19.  * contributors'' in the documentation or other materials provided with the
  20.  * distribution and in all advertising materials mentioning features or use
  21.  * of this software.  Neither the name of the University nor the names of
  22.  * its contributors may be used to endorse or promote products derived from
  23.  * this software without specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. /* $Header: /home/daffy/u0/vern/flex/RCS/yylex.c,v 2.13 95/03/04 16:10:41 vern Exp $ */
  30.  
  31. #include "flexdef.h"
  32. #include <ctype.h>
  33. #include "parse.h"
  34.  
  35.  
  36. /* yylex - scan for a regular expression token */
  37.  
  38. int yylex()
  39.     {
  40.     int toktype;
  41.     static int beglin = false;
  42.     extern char *yytext;
  43.  
  44.     if ( eofseen )
  45.         toktype = EOF;
  46.     else
  47.         toktype = flexscan();
  48.  
  49.     if ( toktype == EOF || toktype == 0 )
  50.         {
  51.         eofseen = 1;
  52.  
  53.         if ( sectnum == 1 )
  54.             {
  55.             synerr( _( "premature EOF" ) );
  56.             sectnum = 2;
  57.             toktype = SECTEND;
  58.             }
  59.  
  60.         else
  61.             toktype = 0;
  62.         }
  63.  
  64.     if ( trace )
  65.         {
  66.         if ( beglin )
  67.             {
  68.             fprintf( stderr, "%d\t", num_rules + 1 );
  69.             beglin = 0;
  70.             }
  71.  
  72.         switch ( toktype )
  73.             {
  74.             case '<':
  75.             case '>':
  76.             case '^':
  77.             case '$':
  78.             case '"':
  79.             case '[':
  80.             case ']':
  81.             case '{':
  82.             case '}':
  83.             case '|':
  84.             case '(':
  85.             case ')':
  86.             case '-':
  87.             case '/':
  88.             case '\\':
  89.             case '?':
  90.             case '.':
  91.             case '*':
  92.             case '+':
  93.             case ',':
  94.                 (void) putc( toktype, stderr );
  95.                 break;
  96.  
  97.             case '\n':
  98.                 (void) putc( '\n', stderr );
  99.  
  100.                 if ( sectnum == 2 )
  101.                 beglin = 1;
  102.  
  103.                 break;
  104.  
  105.             case SCDECL:
  106.                 fputs( "%s", stderr );
  107.                 break;
  108.  
  109.             case XSCDECL:
  110.                 fputs( "%x", stderr );
  111.                 break;
  112.  
  113.             case SECTEND:
  114.                 fputs( "%%\n", stderr );
  115.  
  116.                 /* We set beglin to be true so we'll start
  117.                  * writing out numbers as we echo rules.
  118.                  * flexscan() has already assigned sectnum.
  119.                  */
  120.                 if ( sectnum == 2 )
  121.                     beglin = 1;
  122.  
  123.                 break;
  124.  
  125.             case NAME:
  126.                 fprintf( stderr, "'%s'", nmstr );
  127.                 break;
  128.  
  129.             case CHAR:
  130.                 switch ( yylval )
  131.                     {
  132.                     case '<':
  133.                     case '>':
  134.                     case '^':
  135.                     case '$':
  136.                     case '"':
  137.                     case '[':
  138.                     case ']':
  139.                     case '{':
  140.                     case '}':
  141.                     case '|':
  142.                     case '(':
  143.                     case ')':
  144.                     case '-':
  145.                     case '/':
  146.                     case '\\':
  147.                     case '?':
  148.                     case '.':
  149.                     case '*':
  150.                     case '+':
  151.                     case ',':
  152.                         fprintf( stderr, "\\%c",
  153.                             yylval );
  154.                         break;
  155.  
  156.                     default:
  157.                         if ( ! isascii( yylval ) ||
  158.                              ! isprint( yylval ) )
  159.                             fprintf( stderr,
  160.                                 "\\%.3o",
  161.                             (unsigned int) yylval );
  162.                         else
  163.                             (void) putc( yylval,
  164.                                 stderr );
  165.                     break;
  166.                     }
  167.  
  168.                 break;
  169.  
  170.             case NUMBER:
  171.                 fprintf( stderr, "%d", yylval );
  172.                 break;
  173.  
  174.             case PREVCCL:
  175.                 fprintf( stderr, "[%d]", yylval );
  176.                 break;
  177.  
  178.             case EOF_OP:
  179.                 fprintf( stderr, "<<EOF>>" );
  180.                 break;
  181.  
  182.             case OPTION_OP:
  183.                 fprintf( stderr, "%s ", yytext );
  184.                 break;
  185.  
  186.             case OPT_OUTFILE:
  187.             case OPT_PREFIX:
  188.             case CCE_ALNUM:
  189.             case CCE_ALPHA:
  190.             case CCE_BLANK:
  191.             case CCE_CNTRL:
  192.             case CCE_DIGIT:
  193.             case CCE_GRAPH:
  194.             case CCE_LOWER:
  195.             case CCE_PRINT:
  196.             case CCE_PUNCT:
  197.             case CCE_SPACE:
  198.             case CCE_UPPER:
  199.             case CCE_XDIGIT:
  200.                 fprintf( stderr, "%s", yytext );
  201.                 break;
  202.  
  203.             case 0:
  204.                 fprintf( stderr, _( "End Marker\n" ) );
  205.                 break;
  206.  
  207.             default:
  208.                 fprintf( stderr,
  209.                 _( "*Something Weird* - tok: %d val: %d\n" ),
  210.                     toktype, yylval );
  211.                 break;
  212.             }
  213.         }
  214.  
  215.     return toktype;
  216.     }
  217.