lib/flex/yylex.c

   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 <ctype.h>
  32 #include "flexdef.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         }