2b5d2472c3adaaf648a11fdc2abb90695e44cad9
[dragonfly.git] / usr.bin / lex / 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 are permitted provided
15  * that: (1) source distributions retain this entire copyright notice and
16  * comment, and (2) distributions including binaries display the following
17  * acknowledgement:  ``This product includes software developed by the
18  * University of California, Berkeley and its contributors'' in the
19  * documentation or other materials provided with the distribution and in
20  * all advertising materials mentioning features or use of this software.
21  * Neither the name of the University nor the names of its contributors may
22  * be used to endorse or promote products derived from this software without
23  * 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 /* $FreeBSD: src/usr.bin/lex/yylex.c,v 1.5 1999/10/27 07:56:48 obrien Exp $ */
31 /* $DragonFly: src/usr.bin/lex/yylex.c,v 1.3 2003/10/04 20:36:47 hmp Exp $ */
32
33 #include <ctype.h>
34 #include "flexdef.h"
35 #include "parse.h"
36
37
38 /* yylex - scan for a regular expression token */
39
40 int yylex(void)
41         {
42         int toktype;
43         static int beglin = false;
44         extern char *yytext;
45
46         if ( eofseen )
47                 toktype = EOF;
48         else
49                 toktype = flexscan();
50
51         if ( toktype == EOF || toktype == 0 )
52                 {
53                 eofseen = 1;
54
55                 if ( sectnum == 1 )
56                         {
57                         synerr( _( "premature EOF" ) );
58                         sectnum = 2;
59                         toktype = SECTEND;
60                         }
61
62                 else
63                         toktype = 0;
64                 }
65
66         if ( trace )
67                 {
68                 if ( beglin )
69                         {
70                         fprintf( stderr, "%d\t", num_rules + 1 );
71                         beglin = 0;
72                         }
73
74                 switch ( toktype )
75                         {
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                         case '+':
95                         case ',':
96                                 (void) putc( toktype, stderr );
97                                 break;
98
99                         case '\n':
100                                 (void) putc( '\n', stderr );
101
102                                 if ( sectnum == 2 )
103                                 beglin = 1;
104
105                                 break;
106
107                         case SCDECL:
108                                 fputs( "%s", stderr );
109                                 break;
110
111                         case XSCDECL:
112                                 fputs( "%x", stderr );
113                                 break;
114
115                         case SECTEND:
116                                 fputs( "%%\n", stderr );
117
118                                 /* We set beglin to be true so we'll start
119                                  * writing out numbers as we echo rules.
120                                  * flexscan() has already assigned sectnum.
121                                  */
122                                 if ( sectnum == 2 )
123                                         beglin = 1;
124
125                                 break;
126
127                         case NAME:
128                                 fprintf( stderr, "'%s'", nmstr );
129                                 break;
130
131                         case CHAR:
132                                 switch ( yylval )
133                                         {
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                                         case '+':
153                                         case ',':
154                                                 fprintf( stderr, "\\%c",
155                                                         yylval );
156                                                 break;
157
158                                         default:
159                                                 if ( ! isascii( yylval ) ||
160                                                      ! isprint( yylval ) )
161                                                         fprintf( stderr,
162                                                                 "\\%.3o",
163                                                         (unsigned int) yylval );
164                                                 else
165                                                         (void) putc( yylval,
166                                                                 stderr );
167                                         break;
168                                         }
169
170                                 break;
171
172                         case NUMBER:
173                                 fprintf( stderr, "%d", yylval );
174                                 break;
175
176                         case PREVCCL:
177                                 fprintf( stderr, "[%d]", yylval );
178                                 break;
179
180                         case EOF_OP:
181                                 fprintf( stderr, "<<EOF>>" );
182                                 break;
183
184                         case OPTION_OP:
185                                 fprintf( stderr, "%s ", yytext );
186                                 break;
187
188                         case OPT_OUTFILE:
189                         case OPT_PREFIX:
190                         case CCE_ALNUM:
191                         case CCE_ALPHA:
192                         case CCE_BLANK:
193                         case CCE_CNTRL:
194                         case CCE_DIGIT:
195                         case CCE_GRAPH:
196                         case CCE_LOWER:
197                         case CCE_PRINT:
198                         case CCE_PUNCT:
199                         case CCE_SPACE:
200                         case CCE_UPPER:
201                         case CCE_XDIGIT:
202                                 fprintf( stderr, "%s", yytext );
203                                 break;
204
205                         case 0:
206                                 fprintf( stderr, _( "End Marker\n" ) );
207                                 break;
208
209                         default:
210                                 fprintf( stderr,
211                                 _( "*Something Weird* - tok: %d val: %d\n" ),
212                                         toktype, yylval );
213                                 break;
214                         }
215                 }
216
217         return toktype;
218         }