[unix-history] / usr / src / usr.sbin / config / lang.l

%{

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)lang.l	5.2 (Berkeley) %G%
 */

#include <ctype.h>
#include "y.tab.h"
#include "config.h"

#define tprintf if (do_trace) printf

/*
 * Key word table
 */

struct kt {
	char *kt_name;
	int kt_val;
} key_words[] = {
	{ "and",	AND },
	{ "args",	ARGS },
	{ "at",		AT },
	{ "config",	CONFIG },
	{ "controller",	CONTROLLER },
	{ "cpu",	CPU },
	{ "csr",	CSR },
	{ "device",	DEVICE },
	{ "disk",	DISK },
	{ "drive",	DRIVE },
	{ "dst",	DST },
	{ "dumps",	DUMPS },
	{ "flags",	FLAGS },
	{ "hz",		HZ },
	{ "ident",	IDENT },
	{ "machine",	MACHINE },
	{ "major",	MAJOR },
	{ "makeoptions", MAKEOPTIONS },
	{ "master",	MASTER },
	{ "maxusers",	MAXUSERS },
	{ "mba",	MBA },
	{ "minor",	MINOR },
	{ "nexus",	NEXUS },
	{ "on",		ON },
	{ "options",	OPTIONS },
	{ "priority",	PRIORITY },
	{ "pseudo-device",PSEUDO_DEVICE },
	{ "root",	ROOT },
	{ "size",	SIZE },
	{ "slave",	SLAVE },
	{ "swap",	SWAP },
	{ "tape",	DEVICE },
	{ "timezone",	TIMEZONE },
	{ "trace",	TRACE },
	{ "uba",	UBA },
	{ "vector",	VECTOR },
	{ 0, 0 },
};
%}
WORD	[A-Za-z_][-A-Za-z_]*
%%
{WORD}		{
			int i;

			if ((i = kw_lookup(yytext)) == -1)
			{
				yylval.str = yytext;
				tprintf("id(%s) ", yytext);
				return ID;
			}
			tprintf("(%s) ", yytext);
			return i;
		}
\"[^"]+\"	{
			yytext[strlen(yytext)-1] = '\0';
			yylval.str = yytext + 1;
			return ID;
		}
0[0-7]*		{
			yylval.val = octal(yytext);
			tprintf("#O:%o ", yylval.val);
			return NUMBER;
		}
0x[0-9a-fA-F]+	{
			yylval.val = hex(yytext);
			tprintf("#X:%x ", yylval.val);
			return NUMBER;
		}
[1-9][0-9]*	{
			yylval.val = atoi(yytext);
			tprintf("#D:%d ", yylval.val);
			return NUMBER;
		}
[0-9]"."[0-9]*	{
			double atof();
			yylval.val = (int) (60 * atof(yytext) + 0.5);
			return FPNUMBER;
		}
"-"		{
			return MINUS;
		}
"?"		{
			yylval.val = -1;
			tprintf("? ");
			return NUMBER;
		}
\n/[ \t]	{
			yyline++;
			tprintf("\n... ");
		}
\n		{
			yyline++;
			tprintf("\n");
			return SEMICOLON;
		}
#.*		{	/* Ignored (comment) */;	}
[ \t]*		{	/* Ignored (white space) */;	}
";"		{	return SEMICOLON;		}
","		{	return COMMA;			}
"="		{	return EQUALS;			}
"@"		{	return AT;			}
.		{	return yytext[0];		}

%%
/*
 * kw_lookup
 *	Look up a string in the keyword table.  Returns a -1 if the
 *	string is not a keyword otherwise it returns the keyword number
 */

kw_lookup(word)
register char *word;
{
	register struct kt *kp;

	for (kp = key_words; kp->kt_name != 0; kp++)
		if (eq(word, kp->kt_name))
			return kp->kt_val;
	return -1;
}

/*
 * Number conversion routines
 */

octal(str)
char *str;
{
	int num;

	(void) sscanf(str, "%o", &num);
	return num;
}

hex(str)
char *str;
{
	int num;

	(void) sscanf(str+2, "%x", &num);
	return num;
}
Commit	Line	Data
bc2ed385	1	%{
cd68466f DF	2
	3	/*
	4	* Copyright (c) 1980 Regents of the University of California.
	5	* All rights reserved. The Berkeley software License Agreement
	6	* specifies the terms and conditions for redistribution.
	7	*
7c1d4665	8	* @(#)lang.l 5.2 (Berkeley) %G%
cd68466f	9	*/
bc2ed385 MT	10
	11	#include <ctype.h>
	12	#include "y.tab.h"
	13	#include "config.h"
	14
	15	#define tprintf if (do_trace) printf
b3043913	16
bc2ed385 MT	17	/*
	18	* Key word table
	19	*/
	20
	21	struct kt {
	22	char *kt_name;
	23	int kt_val;
	24	} key_words[] = {
36edb824 SL	25	{ "and", AND },
	26	{ "args", ARGS },
	27	{ "at", AT },
	28	{ "config", CONFIG },
	29	{ "controller", CONTROLLER },
	30	{ "cpu", CPU },
	31	{ "csr", CSR },
	32	{ "device", DEVICE },
	33	{ "disk", DISK },
	34	{ "drive", DRIVE },
	35	{ "dst", DST },
	36	{ "dumps", DUMPS },
	37	{ "flags", FLAGS },
	38	{ "hz", HZ },
	39	{ "ident", IDENT },
	40	{ "machine", MACHINE },
	41	{ "major", MAJOR },
7c1d4665	42	{ "makeoptions", MAKEOPTIONS },
36edb824 SL	43	{ "master", MASTER },
	44	{ "maxusers", MAXUSERS },
	45	{ "mba", MBA },
	46	{ "minor", MINOR },
	47	{ "nexus", NEXUS },
	48	{ "on", ON },
	49	{ "options", OPTIONS },
	50	{ "priority", PRIORITY },
	51	{ "pseudo-device",PSEUDO_DEVICE },
	52	{ "root", ROOT },
	53	{ "size", SIZE },
	54	{ "slave", SLAVE },
	55	{ "swap", SWAP },
	56	{ "tape", DEVICE },
	57	{ "timezone", TIMEZONE },
	58	{ "trace", TRACE },
	59	{ "uba", UBA },
	60	{ "vector", VECTOR },
	61	{ 0, 0 },
bc2ed385 MT	62	};
bc2ed385 MT	63	%}
b3043913	64	WORD [A-Za-z_][-A-Za-z_]*
bc2ed385 MT	65	%%
	66	{WORD} {
	67	int i;
	68
	69	if ((i = kw_lookup(yytext)) == -1)
	70	{
22d68ad0	71	yylval.str = yytext;
bc2ed385 MT	72	tprintf("id(%s) ", yytext);
	73	return ID;
	74	}
	75	tprintf("(%s) ", yytext);
	76	return i;
	77	}
dea0cacc MT	78	\"[^"]+\" {
dea0cacc MT	79	yytext[strlen(yytext)-1] = '\0';
36edb824	80	yylval.str = yytext + 1;
dea0cacc MT	81	return ID;
dea0cacc MT	82	}
bc2ed385	83	0[0-7]* {
22d68ad0 BJ	84	yylval.val = octal(yytext);
22d68ad0 BJ	85	tprintf("#O:%o ", yylval.val);
bc2ed385 MT	86	return NUMBER;
bc2ed385 MT	87	}
4cab9f3e	88	0x[0-9a-fA-F]+ {
22d68ad0 BJ	89	yylval.val = hex(yytext);
22d68ad0 BJ	90	tprintf("#X:%x ", yylval.val);
bc2ed385 MT	91	return NUMBER;
	92	}
	93	[1-9][0-9]* {
22d68ad0 BJ	94	yylval.val = atoi(yytext);
22d68ad0 BJ	95	tprintf("#D:%d ", yylval.val);
bc2ed385 MT	96	return NUMBER;
bc2ed385 MT	97	}
a5e18d6b	98	[0-9]"."[0-9]* {
22d68ad0 BJ	99	double atof();
22d68ad0 BJ	100	yylval.val = (int) (60 * atof(yytext) + 0.5);
a5e18d6b MT	101	return FPNUMBER;
a5e18d6b MT	102	}
57b7808b BJ	103	"-" {
	104	return MINUS;
	105	}
bc2ed385	106	"?" {
22d68ad0	107	yylval.val = -1;
bc2ed385 MT	108	tprintf("? ");
	109	return NUMBER;
	110	}
	111	\n/[ \t] {
	112	yyline++;
	113	tprintf("\n... ");
	114	}
	115	\n {
	116	yyline++;
	117	tprintf("\n");
	118	return SEMICOLON;
	119	}
45a827f6	120	#.* { /* Ignored (comment) */; }
bc2ed385 MT	121	[ \t]* { /* Ignored (white space) */; }
bc2ed385 MT	122	";" { return SEMICOLON; }
9c98d1fb	123	"," { return COMMA; }
45a827f6	124	"=" { return EQUALS; }
0bf41cfc	125	"@" { return AT; }
45a827f6 RE	126	. { return yytext[0]; }
45a827f6 RE	127
bc2ed385 MT	128	%%
	129	/*
	130	* kw_lookup
	131	* Look up a string in the keyword table. Returns a -1 if the
	132	* string is not a keyword otherwise it returns the keyword number
	133	*/
	134
	135	kw_lookup(word)
	136	register char *word;
	137	{
	138	register struct kt *kp;
	139
	140	for (kp = key_words; kp->kt_name != 0; kp++)
	141	if (eq(word, kp->kt_name))
	142	return kp->kt_val;
	143	return -1;
	144	}
	145
	146	/*
	147	* Number conversion routines
	148	*/
	149
	150	octal(str)
	151	char *str;
	152	{
	153	int num;
	154
22d68ad0	155	(void) sscanf(str, "%o", &num);
bc2ed385 MT	156	return num;
	157	}
	158
	159	hex(str)
	160	char *str;
	161	{
	162	int num;
	163
22d68ad0	164	(void) sscanf(str+2, "%x", &num);
bc2ed385 MT	165	return num;
bc2ed385 MT	166	}