1%{
2/*-
3 * Copyright (c) 1980, 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by the University of
17 * California, Berkeley and its contributors.
18 * 4. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)lang.l 8.1 (Berkeley) 6/6/93
| 1%{
2/*-
3 * Copyright (c) 1980, 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by the University of
17 * California, Berkeley and its contributors.
18 * 4. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)lang.l 8.1 (Berkeley) 6/6/93
|
35 * $FreeBSD: head/usr.sbin/config/lang.l 110897 2003-02-15 02:39:13Z ru $
| 35 * $FreeBSD: head/usr.sbin/config/lang.l 111582 2003-02-26 23:36:59Z ru $
|
36 */
37
38#include <assert.h>
39#include <ctype.h>
40#include <string.h>
41#include "y.tab.h"
42#include "config.h"
43
44#define YY_NO_UNPUT
45
46/*
47 * Data for returning to previous files from include files.
48 */
49struct incl {
50 struct incl *in_prev; /* previous includes in effect, if any */
51 YY_BUFFER_STATE in_buf; /* previous lex state */
52 const char *in_fname; /* previous file name */
53 int in_lineno; /* previous line number */
54 int in_ateof; /* token to insert at EOF */
55};
56static struct incl *inclp;
57static const char *lastfile;
58
59/*
60 * Key word table
61 */
62
63struct kt {
64 const char *kt_name;
65 int kt_val;
66} key_words[] = {
67 { "config", CONFIG },
68 { "cpu", CPU },
69 { "device", DEVICE },
| 36 */
37
38#include <assert.h>
39#include <ctype.h>
40#include <string.h>
41#include "y.tab.h"
42#include "config.h"
43
44#define YY_NO_UNPUT
45
46/*
47 * Data for returning to previous files from include files.
48 */
49struct incl {
50 struct incl *in_prev; /* previous includes in effect, if any */
51 YY_BUFFER_STATE in_buf; /* previous lex state */
52 const char *in_fname; /* previous file name */
53 int in_lineno; /* previous line number */
54 int in_ateof; /* token to insert at EOF */
55};
56static struct incl *inclp;
57static const char *lastfile;
58
59/*
60 * Key word table
61 */
62
63struct kt {
64 const char *kt_name;
65 int kt_val;
66} key_words[] = {
67 { "config", CONFIG },
68 { "cpu", CPU },
69 { "device", DEVICE },
|
| 70 { "nodevice", NODEVICE },
|
70 { "env", ENV },
71 { "hints", HINTS },
72 { "ident", IDENT },
73 { "machine", ARCH }, /* MACHINE is defined in /sys/param.h */
74 { "makeoptions", MAKEOPTIONS },
| 71 { "env", ENV },
72 { "hints", HINTS },
73 { "ident", IDENT },
74 { "machine", ARCH }, /* MACHINE is defined in /sys/param.h */
75 { "makeoptions", MAKEOPTIONS },
|
| 76 { "nomakeoption", NOMAKEOPTION },
|
75 { "maxusers", MAXUSERS },
| 77 { "maxusers", MAXUSERS },
|
76 { "nodevice", NODEVICE },
| |
77 { "profile", PROFILE },
78 { "option", OPTIONS },
79 { "options", OPTIONS },
| 78 { "profile", PROFILE },
79 { "option", OPTIONS },
80 { "options", OPTIONS },
|
| 81 { "nooption", NOOPTION },
|
80 { "include", INCLUDE },
81 { 0, 0 },
82};
83
84
85static int endinclude(void);
86int include(const char *, int);
87int kw_lookup(char *);
88unsigned int octal(const char *);
89unsigned int hex(const char *);
90int yyerror(const char *);
91
92%}
93WORD [A-Za-z_][-A-Za-z_]*
94ID [A-Za-z_][-A-Za-z_0-9]*
95%START NONUM TOEOL
96%%
97<NONUM>{WORD} {
98 int i;
99
100 BEGIN 0;
101 if ((i = kw_lookup(yytext)) == -1)
102 {
103 yylval.str = strdup(yytext);
104 return ID;
105 }
106 return i;
107 }
108<INITIAL>{WORD}/[0-9]* {
109 int i;
110
111 if ((i = kw_lookup(yytext)) == -1)
112 REJECT;
113 if (i == DEVICE || i == NODEVICE)
114 BEGIN NONUM;
115 return i;
116 }
117<INITIAL>{ID} {
118 BEGIN 0;
119 yylval.str = strdup(yytext);
120 return ID;
121 }
122\\\"[^"]+\\\" {
123 BEGIN 0;
124 yytext[yyleng-2] = '"';
125 yytext[yyleng-1] = '\0';
126 yylval.str = strdup(yytext + 1);
127 return ID;
128 }
129\"[^"]+\" {
130 BEGIN 0;
131 yytext[yyleng-1] = '\0';
132 yylval.str = strdup(yytext + 1);
133 return ID;
134 }
135<TOEOL>[^# \t\n]* {
136 BEGIN 0;
137 yylval.str = strdup(yytext);
138 return ID;
139 }
1400[0-7]* {
141 yylval.val = octal(yytext);
142 return NUMBER;
143 }
1440x[0-9a-fA-F]+ {
145 yylval.val = hex(yytext);
146 return NUMBER;
147 }
148-?[1-9][0-9]* {
149 yylval.val = atoi(yytext);
150 return NUMBER;
151 }
152"?" {
153 yylval.val = -1;
154 return NUMBER;
155 }
156\n/[ \t] {
157 yyline++;
158 }
159\n {
160 yyline++;
161 return SEMICOLON;
162 }
163#.* { /* Ignored (comment) */; }
164[ \t\f]* { /* Ignored (white space) */; }
165";" { return SEMICOLON; }
166"," { return COMMA; }
167"=" { BEGIN TOEOL; return EQUALS; }
168<<EOF>> {
169 int tok;
170
171 if (inclp == NULL)
172 return YY_NULL;
173 tok = endinclude();
174 if (tok != 0)
175 return tok;
176 /* otherwise continue scanning */
177 }
178. { return yytext[0]; }
179
180%%
181/*
182 * kw_lookup
183 * Look up a string in the keyword table. Returns a -1 if the
184 * string is not a keyword otherwise it returns the keyword number
185 */
186
187int
188kw_lookup(char *word)
189{
190 struct kt *kp;
191
192 for (kp = key_words; kp->kt_name != 0; kp++)
193 if (eq(word, kp->kt_name))
194 return kp->kt_val;
195 return -1;
196}
197
198/*
199 * Number conversion routines
200 */
201
202unsigned int
203octal(const char *str)
204{
205 unsigned int num;
206
207 (void) sscanf(str, "%o", &num);
208 return num;
209}
210
211unsigned int
212hex(const char *str)
213{
214 unsigned int num;
215
216 (void) sscanf(str+2, "%x", &num);
217 return num;
218}
219
220
221/*
222 * Open the named file for inclusion at the current point. Returns 0 on
223 * success (file opened and previous state pushed), nonzero on failure
224 * (fopen failed, complaint made). The `ateof' parameter controls the
225 * token to be inserted at the end of the include file. If ateof == 0,
226 * then nothing is inserted.
227 */
228int
229include(const char *fname, int ateof)
230{
231 FILE *fp;
232 struct incl *in;
233
234 fp = fopen(fname, "r");
235 if (fp == NULL) {
236 yyerror("cannot open file");
237 return (-1);
238 }
239 in = malloc(sizeof(*in));
240 assert(in != NULL);
241 in->in_prev = inclp;
242 in->in_buf = YY_CURRENT_BUFFER;
243 in->in_fname = yyfile;
244 in->in_lineno = yyline;
245 in->in_ateof = ateof;
246 inclp = in;
247 yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
248 yyfile = fname;
249 yyline = 0;
250 return (0);
251}
252
253/*
254 * Terminate the most recent inclusion.
255 */
256static int
257endinclude()
258{
259 struct incl *in;
260 int ateof;
261
262 in = inclp;
263 assert(in != NULL);
264 inclp = in->in_prev;
265 lastfile = yyfile;
266 yy_delete_buffer(YY_CURRENT_BUFFER);
267 (void)fclose(yyin);
268 yy_switch_to_buffer(in->in_buf);
269 yyfile = in->in_fname;
270 yyline = in->in_lineno;
271 ateof = in->in_ateof;
272 free(in);
273
274 return (ateof);
275}
| 82 { "include", INCLUDE },
83 { 0, 0 },
84};
85
86
87static int endinclude(void);
88int include(const char *, int);
89int kw_lookup(char *);
90unsigned int octal(const char *);
91unsigned int hex(const char *);
92int yyerror(const char *);
93
94%}
95WORD [A-Za-z_][-A-Za-z_]*
96ID [A-Za-z_][-A-Za-z_0-9]*
97%START NONUM TOEOL
98%%
99<NONUM>{WORD} {
100 int i;
101
102 BEGIN 0;
103 if ((i = kw_lookup(yytext)) == -1)
104 {
105 yylval.str = strdup(yytext);
106 return ID;
107 }
108 return i;
109 }
110<INITIAL>{WORD}/[0-9]* {
111 int i;
112
113 if ((i = kw_lookup(yytext)) == -1)
114 REJECT;
115 if (i == DEVICE || i == NODEVICE)
116 BEGIN NONUM;
117 return i;
118 }
119<INITIAL>{ID} {
120 BEGIN 0;
121 yylval.str = strdup(yytext);
122 return ID;
123 }
124\\\"[^"]+\\\" {
125 BEGIN 0;
126 yytext[yyleng-2] = '"';
127 yytext[yyleng-1] = '\0';
128 yylval.str = strdup(yytext + 1);
129 return ID;
130 }
131\"[^"]+\" {
132 BEGIN 0;
133 yytext[yyleng-1] = '\0';
134 yylval.str = strdup(yytext + 1);
135 return ID;
136 }
137<TOEOL>[^# \t\n]* {
138 BEGIN 0;
139 yylval.str = strdup(yytext);
140 return ID;
141 }
1420[0-7]* {
143 yylval.val = octal(yytext);
144 return NUMBER;
145 }
1460x[0-9a-fA-F]+ {
147 yylval.val = hex(yytext);
148 return NUMBER;
149 }
150-?[1-9][0-9]* {
151 yylval.val = atoi(yytext);
152 return NUMBER;
153 }
154"?" {
155 yylval.val = -1;
156 return NUMBER;
157 }
158\n/[ \t] {
159 yyline++;
160 }
161\n {
162 yyline++;
163 return SEMICOLON;
164 }
165#.* { /* Ignored (comment) */; }
166[ \t\f]* { /* Ignored (white space) */; }
167";" { return SEMICOLON; }
168"," { return COMMA; }
169"=" { BEGIN TOEOL; return EQUALS; }
170<<EOF>> {
171 int tok;
172
173 if (inclp == NULL)
174 return YY_NULL;
175 tok = endinclude();
176 if (tok != 0)
177 return tok;
178 /* otherwise continue scanning */
179 }
180. { return yytext[0]; }
181
182%%
183/*
184 * kw_lookup
185 * Look up a string in the keyword table. Returns a -1 if the
186 * string is not a keyword otherwise it returns the keyword number
187 */
188
189int
190kw_lookup(char *word)
191{
192 struct kt *kp;
193
194 for (kp = key_words; kp->kt_name != 0; kp++)
195 if (eq(word, kp->kt_name))
196 return kp->kt_val;
197 return -1;
198}
199
200/*
201 * Number conversion routines
202 */
203
204unsigned int
205octal(const char *str)
206{
207 unsigned int num;
208
209 (void) sscanf(str, "%o", &num);
210 return num;
211}
212
213unsigned int
214hex(const char *str)
215{
216 unsigned int num;
217
218 (void) sscanf(str+2, "%x", &num);
219 return num;
220}
221
222
223/*
224 * Open the named file for inclusion at the current point. Returns 0 on
225 * success (file opened and previous state pushed), nonzero on failure
226 * (fopen failed, complaint made). The `ateof' parameter controls the
227 * token to be inserted at the end of the include file. If ateof == 0,
228 * then nothing is inserted.
229 */
230int
231include(const char *fname, int ateof)
232{
233 FILE *fp;
234 struct incl *in;
235
236 fp = fopen(fname, "r");
237 if (fp == NULL) {
238 yyerror("cannot open file");
239 return (-1);
240 }
241 in = malloc(sizeof(*in));
242 assert(in != NULL);
243 in->in_prev = inclp;
244 in->in_buf = YY_CURRENT_BUFFER;
245 in->in_fname = yyfile;
246 in->in_lineno = yyline;
247 in->in_ateof = ateof;
248 inclp = in;
249 yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
250 yyfile = fname;
251 yyline = 0;
252 return (0);
253}
254
255/*
256 * Terminate the most recent inclusion.
257 */
258static int
259endinclude()
260{
261 struct incl *in;
262 int ateof;
263
264 in = inclp;
265 assert(in != NULL);
266 inclp = in->in_prev;
267 lastfile = yyfile;
268 yy_delete_buffer(YY_CURRENT_BUFFER);
269 (void)fclose(yyin);
270 yy_switch_to_buffer(in->in_buf);
271 yyfile = in->in_fname;
272 yyline = in->in_lineno;
273 ateof = in->in_ateof;
274 free(in);
275
276 return (ateof);
277}
|