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

%{
/*	lang.l	1.14	83/05/18	*/

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