[apple/network_cmds.git] / setkey.tproj / token.l

/*	$FreeBSD: src/usr.sbin/setkey/token.l,v 1.2.2.3 2001/07/03 11:02:17 ume Exp $	*/
/*	$KAME: token.l,v 1.21 2001/05/18 05:35:01 sakane Exp $	*/

/*
 * Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

%option noyywrap
%{
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <net/route.h>
#include <net/pfkeyv2.h>
#include <netkey/keydb.h>
#include <netkey/key_debug.h>
#include <netinet/in.h>
#include <netinet6/ipsec.h>

#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "vchar.h"
#ifdef __NetBSD__
#include "parse.h"
#else
#include "y.tab.h"
#endif

#define DECHO \
	if (f_debug) {printf("<%d>", yy_start); ECHO ; printf("\n"); }

#define CMDARG \
{ \
	char *__buf__ = strdup(yytext), *__p__; \
	for (__p__ = __buf__; *__p__ != NULL; __p__++) \
		if (*__p__ == '\n' || *__p__ == '\t') \
			*__p__ = ' '; \
	strcat(cmdarg, __buf__); \
	free(__buf__); \
}

#define PREPROC	DECHO CMDARG

int lineno = 1;
char cmdarg[8192]; /* XXX: BUFSIZ is the better ? */

extern u_char m_buf[BUFSIZ];
extern u_int m_len;
extern int f_debug;

int yylex __P((void));
void yyfatal __P((const char *s));
void yyerror __P((const char *s));
extern void parse_init __P((void));
int parse __P((FILE **));
int yyparse __P((void));

%}

/* common section */
nl		\n
ws		[ \t]+
digit		[0-9]
letter		[0-9A-Za-z]
hexdigit	[0-9A-Fa-f]
/*octet		(([01]?{digit}?{digit})|((2([0-4]{digit}))|(25[0-5])))*/
special		[()+\|\?\*,]
dot		\.
comma		\,
hyphen		\-
colon		\:
slash		\/
bcl		\{
ecl		\}
blcl		\[
elcl		\]
percent		\%
semi		\;
usec		{dot}{digit}{1,6}
comment		\#.*
ccomment	"/*"
bracketstring	\<[^>]*\>
quotedstring	\"[^"]*\"
decstring	{digit}+
hexpair		{hexdigit}{hexdigit}
hexstring	0[xX]{hexdigit}+
octetstring	{octet}({dot}{octet})+
ipaddress	[a-fA-F0-9:]([a-fA-F0-9:\.]*|[a-fA-F0-9:\.]*%[a-zA-Z0-9]*)
ipaddrmask	{slash}{digit}{1,3}
ipaddrport	{blcl}{decstring}{elcl}
keyword		{letter}{letter}+
name		{letter}(({letter}|{digit}|{hyphen})*({letter}|{digit}))*
hostname	{name}(({dot}{name})+{dot}?)?

%s S_PL

%%

add		{ PREPROC; return(ADD); }
delete		{ PREPROC; return(DELETE); }
deleteall	{ PREPROC; return(DELETEALL); }
get		{ PREPROC; return(GET); }
flush		{ PREPROC; return(FLUSH); }
dump		{ PREPROC; return(DUMP); }

	/* for management SPD */
spdadd		{ PREPROC; return(SPDADD); }
spddelete	{ PREPROC; return(SPDDELETE); }
spddump		{ PREPROC; return(SPDDUMP); }
spdflush	{ PREPROC; return(SPDFLUSH); }
{hyphen}P	{ BEGIN S_PL; PREPROC; return(F_POLICY); }
<S_PL>[a-zA-Z0-9:\.\-_/ \n\t][a-zA-Z0-9:\.\-_/ \n\t]* {
		yymore();

		/* count up for nl */
		    {
			char *p;
			for (p = yytext; *p != NULL; p++)
				if (*p == '\n')
					lineno++;
		    }

		yylval.val.len = strlen(yytext);
		yylval.val.buf = strdup(yytext);

		return(PL_REQUESTS);
}
<S_PL>{semi}	{ PREPROC; BEGIN INITIAL; return(EOT); }

	/* security protocols */
ah		{ PREPROC; yylval.num = 0; return(PR_AH); }
esp		{ PREPROC; yylval.num = 0; return(PR_ESP); }
ah-old		{ PREPROC; yylval.num = 1; return(PR_AH); }
esp-old		{ PREPROC; yylval.num = 1; return(PR_ESP); }
ipcomp		{ PREPROC; yylval.num = 0; return(PR_IPCOMP); }

	/* authentication alogorithm */
{hyphen}A	{ PREPROC; return(F_AUTH); }
hmac-md5	{ PREPROC; yylval.num = SADB_AALG_MD5HMAC; return(ALG_AUTH); }
hmac-sha1	{ PREPROC; yylval.num = SADB_AALG_SHA1HMAC; return(ALG_AUTH); }
keyed-md5	{ PREPROC; yylval.num = SADB_X_AALG_MD5; return(ALG_AUTH); }
keyed-sha1	{ PREPROC; yylval.num = SADB_X_AALG_SHA; return(ALG_AUTH); }
hmac-sha2-256	{ PREPROC; yylval.num = SADB_X_AALG_SHA2_256; return(ALG_AUTH); }
hmac-sha2-384	{ PREPROC; yylval.num = SADB_X_AALG_SHA2_384; return(ALG_AUTH); }
hmac-sha2-512	{ PREPROC; yylval.num = SADB_X_AALG_SHA2_512; return(ALG_AUTH); }
null		{ PREPROC; yylval.num = SADB_X_AALG_NULL; return(ALG_AUTH); }

	/* encryption alogorithm */
{hyphen}E	{ PREPROC; return(F_ENC); }
des-cbc		{ PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC); }
3des-cbc	{ PREPROC; yylval.num = SADB_EALG_3DESCBC; return(ALG_ENC); }
simple		{ PREPROC; yylval.num = SADB_EALG_NULL; return(ALG_ENC); }
blowfish-cbc	{ PREPROC; yylval.num = SADB_X_EALG_BLOWFISHCBC; return(ALG_ENC); }
cast128-cbc	{ PREPROC; yylval.num = SADB_X_EALG_CAST128CBC; return(ALG_ENC); }
des-deriv	{ PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DESDERIV); }
des-32iv	{ PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DES32IV); }
rijndael-cbc	{ PREPROC; yylval.num = SADB_X_EALG_RIJNDAELCBC; return(ALG_ENC); }

	/* compression algorithms */
{hyphen}C	{ PREPROC; return(F_COMP); }
oui		{ PREPROC; yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
deflate		{ PREPROC; yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
lzs		{ PREPROC; yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
{hyphen}R	{ PREPROC; return(F_RAWCPI); }

	/* extension */
{hyphen}m	{ PREPROC; return(F_MODE); }
transport	{ PREPROC; yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
tunnel		{ PREPROC; yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
{hyphen}u	{ PREPROC; return(F_REQID); }
{hyphen}f	{ PREPROC; return(F_EXT); }
random-pad	{ PREPROC; yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
seq-pad		{ PREPROC; yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
zero-pad	{ PREPROC; yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
nocyclic-seq	{ PREPROC; return(NOCYCLICSEQ); }
{hyphen}r	{ PREPROC; return(F_REPLAY); }
{hyphen}lh	{ PREPROC; return(F_LIFETIME_HARD); }
{hyphen}ls	{ PREPROC; return(F_LIFETIME_SOFT); }

	/* ... */
any		{ PREPROC; return(ANY); }
{ws}		{ PREPROC; }
{nl}		{ lineno++; }
{comment}
{semi}		{ PREPROC; return(EOT); }

	/* parameter */
{decstring}	{
			char *bp;

			PREPROC;
			yylval.num = strtoul(yytext, &bp, 10);
			return(DECSTRING);
		}

{ipaddress}	{
			PREPROC;

			yylval.val.len = yyleng;
			yylval.val.buf = strdup(yytext);

			return(ADDRESS);
		}

{ipaddrmask}	{
			PREPROC;
			yytext++;
			yylval.num = atoi(yytext);
			return(PREFIX);
		}

{ipaddrport}	{
			char *p = yytext;
			PREPROC;
			while (*++p != ']') ;
			*p = NULL;
			yytext++;
			yylval.num = atoi(yytext);
			return(PORT);
		}

{blcl}any{elcl}	{
			PREPROC;
			return(PORTANY);
		}

{hexstring}	{
			int len = yyleng - 2; /* (str - "0x") */
			PREPROC;
			yylval.val.len = (len & 1) + (len / 2);
			/* fixed string if length is odd. */
			if (len & 1) {
				yytext[1] = '0';
				yylval.val.buf = strdup(yytext + 1);
			} else
				yylval.val.buf = strdup(yytext + 2);

			return(HEXSTRING);
		}

{quotedstring}	{
			char *p = yytext;
			PREPROC;
			while (*++p != '"') ;
			*p = NULL;
			yytext++;
			yylval.val.len = yyleng - 2;
			yylval.val.buf = strdup(yytext);

			return(QUOTEDSTRING);
		}

[a-z0-9.\-]*	{
			yylval.val.len = yyleng;
			yylval.val.buf = strdup(yytext);
			return(STRING);
		}

.		{
			yyfatal("Syntax error");
			/*NOTREACHED*/
		}

%%

void
yyfatal(s)
	const char *s;
{
	yyerror(s);
	exit(1);
}

void
yyerror(s)
	const char *s;
{
	printf("line %d: %s at [%s]\n", lineno, s, yytext);
}

int
parse(fp)
	FILE **fp;
{
	yyin = *fp;

	parse_init();

	if (yyparse()) {
		printf("parse failed, line %d.\n", lineno);
		return(-1);
	}

	return(0);
}
Commit	Line	Data
7ba0088d A	1	/* $FreeBSD: src/usr.sbin/setkey/token.l,v 1.2.2.3 2001/07/03 11:02:17 ume Exp $ */
	2	/* $KAME: token.l,v 1.21 2001/05/18 05:35:01 sakane Exp $ */
	3
	4	/*
	5	* Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the name of the project nor the names of its contributors
	17	* may be used to endorse or promote products derived from this software
	18	* without specific prior written permission.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	21	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	23	* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	24	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	25	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	26	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	27	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	28	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	29	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	30	* SUCH DAMAGE.
	31	*/
	32
	33	%option noyywrap
	34	%{
	35	#include <sys/types.h>
	36	#include <sys/param.h>
	37	#include <sys/socket.h>
	38	#include <net/route.h>
	39	#include <net/pfkeyv2.h>
	40	#include <netkey/keydb.h>
	41	#include <netkey/key_debug.h>
	42	#include <netinet/in.h>
	43	#include <netinet6/ipsec.h>
	44
	45	#include <stdlib.h>
	46	#include <limits.h>
	47	#include <string.h>
	48	#include <unistd.h>
	49	#include <errno.h>
	50	#include "vchar.h"
	51	#ifdef __NetBSD__
	52	#include "parse.h"
	53	#else
	54	#include "y.tab.h"
	55	#endif
	56
	57	#define DECHO \
	58	if (f_debug) {printf("<%d>", yy_start); ECHO ; printf("\n"); }
	59
	60	#define CMDARG \
	61	{ \
	62	char __buf__ = strdup(yytext), __p__; \
	63	for (__p__ = __buf__; *__p__ != NULL; __p__++) \
	64	if (__p__ == '\n' \|\| __p__ == '\t') \
65	*__p__ = ' '; \
66	strcat(cmdarg, __buf__); \
67	free(__buf__); \
68	}
69
70	#define PREPROC DECHO CMDARG
71
72	int lineno = 1;
73	char cmdarg[8192]; /* XXX: BUFSIZ is the better ? */
74
75	extern u_char m_buf[BUFSIZ];
76	extern u_int m_len;
77	extern int f_debug;
78
79	int yylex __P((void));
80	void yyfatal __P((const char *s));
81	void yyerror __P((const char *s));
82	extern void parse_init __P((void));
83	int parse __P((FILE **));
84	int yyparse __P((void));
85
86	%}
87
88	/* common section */
89	nl \n
90	ws [ \t]+
91	digit [0-9]
92	letter [0-9A-Za-z]
93	hexdigit [0-9A-Fa-f]
94	/octet (([01]?{digit}?{digit})\|((2([0-4]{digit}))\|(25[0-5])))/
95	special [()+\\|\?\*,]
96	dot \.
97	comma \,
98	hyphen \-
99	colon \:
100	slash \/
101	bcl \{
102	ecl \}
103	blcl \[
104	elcl \]
105	percent \%
106	semi \;
107	usec {dot}{digit}{1,6}
108	comment \#.*
109	ccomment "/*"
110	bracketstring \<[^>]*\>
111	quotedstring \"[^"]*\"
112	decstring {digit}+
113	hexpair {hexdigit}{hexdigit}
114	hexstring 0[xX]{hexdigit}+
115	octetstring {octet}({dot}{octet})+
116	ipaddress [a-fA-F0-9:]([a-fA-F0-9:\.]\|[a-fA-F0-9:\.]%[a-zA-Z0-9]*)
117	ipaddrmask {slash}{digit}{1,3}
118	ipaddrport {blcl}{decstring}{elcl}
119	keyword {letter}{letter}+
120	name {letter}(({letter}\|{digit}\|{hyphen})({letter}\|{digit}))
121	hostname {name}(({dot}{name})+{dot}?)?
122
123	%s S_PL
124
125	%%
126
127	add { PREPROC; return(ADD); }
128	delete { PREPROC; return(DELETE); }
129	deleteall { PREPROC; return(DELETEALL); }
130	get { PREPROC; return(GET); }
131	flush { PREPROC; return(FLUSH); }
132	dump { PREPROC; return(DUMP); }
133
134	/* for management SPD */
135	spdadd { PREPROC; return(SPDADD); }
136	spddelete { PREPROC; return(SPDDELETE); }
137	spddump { PREPROC; return(SPDDUMP); }
138	spdflush { PREPROC; return(SPDFLUSH); }
139	{hyphen}P { BEGIN S_PL; PREPROC; return(F_POLICY); }
140	<S_PL>[a-zA-Z0-9:\.\-_/ \n\t][a-zA-Z0-9:\.\-_/ \n\t]* {
141	yymore();
142
143	/* count up for nl */
144	{
145	char *p;
146	for (p = yytext; *p != NULL; p++)
147	if (*p == '\n')
148	lineno++;
149	}
150
151	yylval.val.len = strlen(yytext);
152	yylval.val.buf = strdup(yytext);
153
154	return(PL_REQUESTS);
155	}
156	<S_PL>{semi} { PREPROC; BEGIN INITIAL; return(EOT); }
157
158	/* security protocols */
159	ah { PREPROC; yylval.num = 0; return(PR_AH); }
160	esp { PREPROC; yylval.num = 0; return(PR_ESP); }
161	ah-old { PREPROC; yylval.num = 1; return(PR_AH); }
162	esp-old { PREPROC; yylval.num = 1; return(PR_ESP); }
163	ipcomp { PREPROC; yylval.num = 0; return(PR_IPCOMP); }
164
165	/* authentication alogorithm */
166	{hyphen}A { PREPROC; return(F_AUTH); }
167	hmac-md5 { PREPROC; yylval.num = SADB_AALG_MD5HMAC; return(ALG_AUTH); }
168	hmac-sha1 { PREPROC; yylval.num = SADB_AALG_SHA1HMAC; return(ALG_AUTH); }
169	keyed-md5 { PREPROC; yylval.num = SADB_X_AALG_MD5; return(ALG_AUTH); }
170	keyed-sha1 { PREPROC; yylval.num = SADB_X_AALG_SHA; return(ALG_AUTH); }
171	hmac-sha2-256 { PREPROC; yylval.num = SADB_X_AALG_SHA2_256; return(ALG_AUTH); }
172	hmac-sha2-384 { PREPROC; yylval.num = SADB_X_AALG_SHA2_384; return(ALG_AUTH); }
173	hmac-sha2-512 { PREPROC; yylval.num = SADB_X_AALG_SHA2_512; return(ALG_AUTH); }
174	null { PREPROC; yylval.num = SADB_X_AALG_NULL; return(ALG_AUTH); }
175
176	/* encryption alogorithm */
177	{hyphen}E { PREPROC; return(F_ENC); }
178	des-cbc { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC); }
179	3des-cbc { PREPROC; yylval.num = SADB_EALG_3DESCBC; return(ALG_ENC); }
180	simple { PREPROC; yylval.num = SADB_EALG_NULL; return(ALG_ENC); }
181	blowfish-cbc { PREPROC; yylval.num = SADB_X_EALG_BLOWFISHCBC; return(ALG_ENC); }
182	cast128-cbc { PREPROC; yylval.num = SADB_X_EALG_CAST128CBC; return(ALG_ENC); }
183	des-deriv { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DESDERIV); }
184	des-32iv { PREPROC; yylval.num = SADB_EALG_DESCBC; return(ALG_ENC_DES32IV); }
185	rijndael-cbc { PREPROC; yylval.num = SADB_X_EALG_RIJNDAELCBC; return(ALG_ENC); }
186
187	/* compression algorithms */
188	{hyphen}C { PREPROC; return(F_COMP); }
189	oui { PREPROC; yylval.num = SADB_X_CALG_OUI; return(ALG_COMP); }
190	deflate { PREPROC; yylval.num = SADB_X_CALG_DEFLATE; return(ALG_COMP); }
191	lzs { PREPROC; yylval.num = SADB_X_CALG_LZS; return(ALG_COMP); }
192	{hyphen}R { PREPROC; return(F_RAWCPI); }
193
194	/* extension */
195	{hyphen}m { PREPROC; return(F_MODE); }
196	transport { PREPROC; yylval.num = IPSEC_MODE_TRANSPORT; return(MODE); }
197	tunnel { PREPROC; yylval.num = IPSEC_MODE_TUNNEL; return(MODE); }
198	{hyphen}u { PREPROC; return(F_REQID); }
199	{hyphen}f { PREPROC; return(F_EXT); }
200	random-pad { PREPROC; yylval.num = SADB_X_EXT_PRAND; return(EXTENSION); }
201	seq-pad { PREPROC; yylval.num = SADB_X_EXT_PSEQ; return(EXTENSION); }
202	zero-pad { PREPROC; yylval.num = SADB_X_EXT_PZERO; return(EXTENSION); }
203	nocyclic-seq { PREPROC; return(NOCYCLICSEQ); }
204	{hyphen}r { PREPROC; return(F_REPLAY); }
205	{hyphen}lh { PREPROC; return(F_LIFETIME_HARD); }
206	{hyphen}ls { PREPROC; return(F_LIFETIME_SOFT); }
207
208	/* ... */
209	any { PREPROC; return(ANY); }
210	{ws} { PREPROC; }
211	{nl} { lineno++; }
212	{comment}
213	{semi} { PREPROC; return(EOT); }
214
215	/* parameter */
216	{decstring} {
217	char *bp;
218
219	PREPROC;
220	yylval.num = strtoul(yytext, &bp, 10);
221	return(DECSTRING);
222	}
223
224	{ipaddress} {
225	PREPROC;
226
227	yylval.val.len = yyleng;
228	yylval.val.buf = strdup(yytext);
229
230	return(ADDRESS);
231	}
232
233	{ipaddrmask} {
234	PREPROC;
235	yytext++;
236	yylval.num = atoi(yytext);
237	return(PREFIX);
238	}
239
240	{ipaddrport} {
241	char *p = yytext;
242	PREPROC;
243	while (*++p != ']') ;
244	*p = NULL;
245	yytext++;
246	yylval.num = atoi(yytext);
247	return(PORT);
248	}
249
250	{blcl}any{elcl} {
251	PREPROC;
252	return(PORTANY);
253	}
254
255	{hexstring} {
256	int len = yyleng - 2; /* (str - "0x") */
257	PREPROC;
258	yylval.val.len = (len & 1) + (len / 2);
259	/* fixed string if length is odd. */
260	if (len & 1) {
261	yytext[1] = '0';
262	yylval.val.buf = strdup(yytext + 1);
263	} else
264	yylval.val.buf = strdup(yytext + 2);
265
266	return(HEXSTRING);
267	}
268
269	{quotedstring} {
270	char *p = yytext;
271	PREPROC;
272	while (*++p != '"') ;
273	*p = NULL;
274	yytext++;
275	yylval.val.len = yyleng - 2;
276	yylval.val.buf = strdup(yytext);
277
278	return(QUOTEDSTRING);
279	}
280
281	[a-z0-9.\-]* {
282	yylval.val.len = yyleng;
283	yylval.val.buf = strdup(yytext);
284	return(STRING);
285	}
286
287	. {
288	yyfatal("Syntax error");
289	/NOTREACHED/
290	}
291
292	%%
293
294	void
295	yyfatal(s)
296	const char *s;
297	{
298	yyerror(s);
299	exit(1);
300	}
301
302	void
303	yyerror(s)
304	const char *s;
305	{
306	printf("line %d: %s at [%s]\n", lineno, s, yytext);
307	}
308
309	int
310	parse(fp)
311	FILE **fp;
312	{
313	yyin = *fp;
314
315	parse_init();
316
317	if (yyparse()) {
318	printf("parse failed, line %d.\n", lineno);
319	return(-1);
320	}
321
322	return(0);
323	}