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