[unix-history] / usr / src / usr.bin / pascal / pdx / command / token.l

%{
/* Copyright (c) 1982 Regents of the University of California */

static char sccsid[] = "@(#)token.l 1.1 %G%";

/*
 * Token definitions for pdx scanner.
 */

#include "defs.h"
#include "command.h"
#include "y.tab.h"
#include "symtab.h"
#include "sym.h"
#include "process.h"
#include "process/pxinfo.h"

char *initfile = ".pdxinit";

/*
 * This is a silly "lex" thing.
 */

#define yywrap()	(1)

/*
 * Override Lex default input macros.
 */

#undef  input
#undef  unput

#define unput(c)	ungetc(c, yyin)

%}

blank		[ \t]
white		{blank}+
alpha		[a-zA-Z]
digit		[0-9]
n		{digit}+
h		[0-9a-fA-F]+
e		(("e"|"E")("+"|"-")?{n})
alphanum	[a-zA-Z0-9]
ident		{alpha}{alphanum}*
filenm		[^ \t\n"<>!*"]+
qfilenm		{filenm}/":"
string		'[^']+'('[^']*')*
newline		"\n"
char		.

%Start file sh

%%

{white}		;
^sh{white}.*$	{ BEGIN 0; yylval.y_string = &yytext[3]; return(SH); }
^sh		{ BEGIN 0; yylval.y_string = NIL; return(SH); }
^{ident}	{ return(findcmd(yytext)); }
{n}?\.{n}{e}?	{ yylval.y_real = atof(yytext); return(REAL); }
0{n}		{ yylval.y_long = octal(yytext); return(INT); }
0x{h}		{ yylval.y_long = hex(yytext); return(INT); }
{n}		{ yylval.y_long = atol(yytext); return(INT); }
<file>{filenm}	{ yylval.y_string = strdup(yytext); return(FILENAME); }
{qfilenm}	{ yylval.y_string = strdup(yytext); return(FILENAME); }
at		{ return(AT); }
{ident}		{ return(ident(yytext)); }
{string}	{ yylval.y_string = yytext; return(STRING); }
"%dp"		{ yylval.y_long = (long) DP; return(INT); }
{newline}	{ BEGIN 0; nlflag = TRUE; return('\n'); }
{char}		{ return(yylval.y_int = yytext[0]); }

%%

LOCAL SYMTAB *dbtab, *specialtab;

/*
 * Look for the given string in the debugger keyword table.
 * If it's there, return the associated token, otherwise report an error.
 */

LOCAL int findcmd(s)
char *s;
{
	register SYM *p;

	if ((p = st_lookup(dbtab, s)) == NIL) {
		error("\"%s\" is not a command", s);
	}
	yylval.y_int = tokval(p);
	switch (toknum(p)) {
		case ALIAS:
		case DUMP:
		case EDIT:
		case CHFILE:
		case RUN:
		case SOURCE:
		case STATUS:
			BEGIN file;
			break;

		default:
			/* do nothing */;
	}
	return(toknum(p));
}

/*
 * Look for a symbol, first in the special table (if, in, etc.)
 * then in the symbol table.  If it's there, return the SYM pointer,
 * otherwise it's an error.
 */

LOCAL int ident(s)
char *s;
{
	register SYM *p;

	if ((p = st_lookup(specialtab, s)) != NIL) {
		yylval.y_sym = p;
		return(toknum(p));
	}
	p = st_lookup(symtab, s);
	if (p == NIL) {
		if (strcmp(s, "nil") == 0) {
			yylval.y_long = 0L;
			return(INT);
		} else {
			error("\"%s\" is not defined", s);
		}
	}
	yylval.y_sym = p;
	return(NAME);
}

/*
 * Convert a string to octal.  No check that digits are less than 8.
 */

LOCAL int octal(s)
char *s;
{
	register char *p;
	register int n;

	n = 0;
	for (p = s; *p != '\0'; p++) {
		n = 8*n + (*p - '0');
	}
	return(n);
}

/*
 * Convert a string to hex.
 */

LOCAL int hex(s)
char *s;
{
	register char *p;
	register int n;

	n = 0;
	for (p = s+2; *p != '\0'; p++) {
		n *= 16;
		if (*p >= 'a' && *p <= 'f') {
			n += (*p - 'a' + 10);
		} else if (*p >= 'A' && *p <= 'F') {
			n += (*p - 'A' + 10);
		} else {
			n += (*p - '0');
		}
	}
	return(n);
}

/*
 * Initialize the debugger keyword table (dbtab) and special symbol
 * table (specialtab).
 */

#define db_keyword(nm, n)	make_keyword(dbtab, nm, n)
#define sp_keyword(nm, n)	make_keyword(specialtab, nm, n)

lexinit()
{
	dbtab = st_creat(150);
	db_keyword("alias", ALIAS);
	db_keyword("assign", ASSIGN);
	db_keyword("call", CALL);
	db_keyword("cont", CONT);
	db_keyword("delete", DELETE);
	db_keyword("dump", DUMP);
	db_keyword("edit", EDIT);
	db_keyword("file", CHFILE);
	db_keyword("gripe", GRIPE);
	db_keyword("help", HELP);
	db_keyword("list", LIST);
	db_keyword("next", NEXT);
	db_keyword("pi", REMAKE);
	db_keyword("print", PRINT);
	db_keyword("quit", QUIT);
	db_keyword("run", RUN);
	db_keyword("sh", SH);
	db_keyword("source", SOURCE);
	db_keyword("status", STATUS);
	db_keyword("step", STEP);
	db_keyword("stop", STOP);
	db_keyword("stopi", STOPI);
	db_keyword("trace", TRACE);
	db_keyword("tracei", TRACEI);
	db_keyword("whatis", WHATIS);
	db_keyword("where", WHERE);
	db_keyword("which", WHICH);
	db_keyword("xd", XD);
	db_keyword("xi", XI);

	specialtab = st_creat(10);
	sp_keyword("div", DIV);
	sp_keyword("mod", MOD);
	sp_keyword("in", IN);
	sp_keyword("if", IF);
	sp_keyword("and", AND);
	sp_keyword("or", OR);
}

/*
 * Send an alias directive over to the symbol table manager.
 */

alias(new, old)
char *new, *old;
{
	if (old == NIL) {
		print_alias(dbtab, new);
	} else {
		enter_alias(dbtab, new, old);
	}
}

/*
 * Input file management routines, "yyin" is Lex's idea of
 * where the input comes from.
 */

#define MAXINPUT 10

LOCAL FILE *infp[MAXINPUT];
LOCAL FILE **curfp = &infp[0];

LOCAL BOOLEAN isnewfile;

/*
 * Initially, we set the input to the initfile if it exists.
 * If it does exist, we play a game or two to avoid generating
 * multiple prompts.
 */

initinput()
{
	FILE *fp;

	fp = fopen(initfile, "r");
	if (fp != NIL) {
		fclose(fp);
		setinput(initfile);
	}
	nlflag = TRUE;
}

/*
 * Set the input to the named file.  It is expected that the file exists
 * and is readable.
 */

setinput(filename)
char *filename;
{
	register FILE *fp;

	if ((fp = fopen(filename, "r")) == NIL) {
		error("can't open %s", filename);
	}
	if (curfp >= &infp[MAXINPUT]) {
		error("unreasonable input nesting on %s", filename);
	}
	*curfp++ = yyin;
	yyin = fp;
	isnewfile = TRUE;
}

BOOLEAN isstdin()
{
	return((BOOLEAN) (yyin == stdin));
}

LOCAL int input()
{
	register int c;

	if (isnewfile) {
		isnewfile = FALSE;
		return('\n');
	}
	while ((c = getc(yyin)) == EOF) {
		if (curfp == &infp[0]) {
			return(0);
		} else {
			fclose(yyin);
			yyin = *--curfp;
			if (yyin == stdin) {
				prompt();
			}
		}
	}
	return(c);
}

/*
 * Handle an input string by stripping the quotes and converting
 * two interior quotes to one.  Copy to newly allocated space and
 * return a pointer to it.
 *
 * The handling of strings here is not particularly efficient,
 * nor need it be.
 */

LOCAL char *pstring(p)
char *p;
{
	int i, len;
	char *r, *newp;

	len = strlen(p);
	r = newp = alloc(len - 2 + 1, char);
	for (i = 1; i < len - 1; i++) {
		if (p[i] == '\'' && p[i+1] == '\'') {
			i++;
		}
		*newp++ = p[i];
	}
	*newp = '\0';
	return(r);
}

/*
 * prompt for a command
 */

prompt()
{
	nlflag = FALSE;
	if (yyin == stdin) {
		printf("> ");
		fflush(stdout);
	}
}
Commit	Line	Data
6858bd7a ML	1	%{
	2	/* Copyright (c) 1982 Regents of the University of California */
	3
	4	static char sccsid[] = "@(#)token.l 1.1 %G%";
	5
	6	/*
	7	* Token definitions for pdx scanner.
	8	*/
	9
	10	#include "defs.h"
	11	#include "command.h"
	12	#include "y.tab.h"
	13	#include "symtab.h"
	14	#include "sym.h"
	15	#include "process.h"
	16	#include "process/pxinfo.h"
	17
	18	char *initfile = ".pdxinit";
	19
	20	/*
	21	* This is a silly "lex" thing.
	22	*/
	23
	24	#define yywrap() (1)
	25
	26	/*
	27	* Override Lex default input macros.
	28	*/
	29
	30	#undef input
	31	#undef unput
	32
	33	#define unput(c) ungetc(c, yyin)
	34
	35	%}
	36
	37	blank [ \t]
	38	white {blank}+
	39	alpha [a-zA-Z]
	40	digit [0-9]
	41	n {digit}+
	42	h [0-9a-fA-F]+
	43	e (("e"\|"E")("+"\|"-")?{n})
	44	alphanum [a-zA-Z0-9]
	45	ident {alpha}{alphanum}*
	46	filenm [^ \t\n"<>!*"]+
	47	qfilenm {filenm}/":"
	48	string '[^']+'('[^']')
	49	newline "\n"
	50	char .
	51
	52	%Start file sh
	53
	54	%%
	55
	56	{white} ;
	57	^sh{white}.*$ { BEGIN 0; yylval.y_string = &yytext[3]; return(SH); }
	58	^sh { BEGIN 0; yylval.y_string = NIL; return(SH); }
	59	^{ident} { return(findcmd(yytext)); }
	60	{n}?\.{n}{e}? { yylval.y_real = atof(yytext); return(REAL); }
	61	0{n} { yylval.y_long = octal(yytext); return(INT); }
	62	0x{h} { yylval.y_long = hex(yytext); return(INT); }
	63	{n} { yylval.y_long = atol(yytext); return(INT); }
	64	<file>{filenm} { yylval.y_string = strdup(yytext); return(FILENAME); }
65	{qfilenm} { yylval.y_string = strdup(yytext); return(FILENAME); }
66	at { return(AT); }
67	{ident} { return(ident(yytext)); }
68	{string} { yylval.y_string = yytext; return(STRING); }
69	"%dp" { yylval.y_long = (long) DP; return(INT); }
70	{newline} { BEGIN 0; nlflag = TRUE; return('\n'); }
71	{char} { return(yylval.y_int = yytext[0]); }
72
73	%%
74
75	LOCAL SYMTAB dbtab, specialtab;
76
77	/*
78	* Look for the given string in the debugger keyword table.
79	* If it's there, return the associated token, otherwise report an error.
80	*/
81
82	LOCAL int findcmd(s)
83	char *s;
84	{
85	register SYM *p;
86
87	if ((p = st_lookup(dbtab, s)) == NIL) {
88	error("\"%s\" is not a command", s);
89	}
90	yylval.y_int = tokval(p);
91	switch (toknum(p)) {
92	case ALIAS:
93	case DUMP:
94	case EDIT:
95	case CHFILE:
96	case RUN:
97	case SOURCE:
98	case STATUS:
99	BEGIN file;
100	break;
101
102	default:
103	/* do nothing */;
104	}
105	return(toknum(p));
106	}
107
108	/*
109	* Look for a symbol, first in the special table (if, in, etc.)
110	* then in the symbol table. If it's there, return the SYM pointer,
111	* otherwise it's an error.
112	*/
113
114	LOCAL int ident(s)
115	char *s;
116	{
117	register SYM *p;
118
119	if ((p = st_lookup(specialtab, s)) != NIL) {
120	yylval.y_sym = p;
121	return(toknum(p));
122	}
123	p = st_lookup(symtab, s);
124	if (p == NIL) {
125	if (strcmp(s, "nil") == 0) {
126	yylval.y_long = 0L;
127	return(INT);
128	} else {
129	error("\"%s\" is not defined", s);
130	}
131	}
132	yylval.y_sym = p;
133	return(NAME);
134	}
135
136	/*
137	* Convert a string to octal. No check that digits are less than 8.
138	*/
139
140	LOCAL int octal(s)
141	char *s;
142	{
143	register char *p;
144	register int n;
145
146	n = 0;
147	for (p = s; *p != '\0'; p++) {
148	n = 8n + (p - '0');
149	}
150	return(n);
151	}
152
153	/*
154	* Convert a string to hex.
155	*/
156
157	LOCAL int hex(s)
158	char *s;
159	{
160	register char *p;
161	register int n;
162
163	n = 0;
164	for (p = s+2; *p != '\0'; p++) {
165	n *= 16;
166	if (p >= 'a' && p <= 'f') {
167	n += (*p - 'a' + 10);
168	} else if (p >= 'A' && p <= 'F') {
169	n += (*p - 'A' + 10);
170	} else {
171	n += (*p - '0');
172	}
173	}
174	return(n);
175	}
176
177	/*
178	* Initialize the debugger keyword table (dbtab) and special symbol
179	* table (specialtab).
180	*/
181
182	#define db_keyword(nm, n) make_keyword(dbtab, nm, n)
183	#define sp_keyword(nm, n) make_keyword(specialtab, nm, n)
184
185	lexinit()
186	{
187	dbtab = st_creat(150);
188	db_keyword("alias", ALIAS);
189	db_keyword("assign", ASSIGN);
190	db_keyword("call", CALL);
191	db_keyword("cont", CONT);
192	db_keyword("delete", DELETE);
193	db_keyword("dump", DUMP);
194	db_keyword("edit", EDIT);
195	db_keyword("file", CHFILE);
196	db_keyword("gripe", GRIPE);
197	db_keyword("help", HELP);
198	db_keyword("list", LIST);
199	db_keyword("next", NEXT);
200	db_keyword("pi", REMAKE);
201	db_keyword("print", PRINT);
202	db_keyword("quit", QUIT);
203	db_keyword("run", RUN);
204	db_keyword("sh", SH);
205	db_keyword("source", SOURCE);
206	db_keyword("status", STATUS);
207	db_keyword("step", STEP);
208	db_keyword("stop", STOP);
209	db_keyword("stopi", STOPI);
210	db_keyword("trace", TRACE);
211	db_keyword("tracei", TRACEI);
212	db_keyword("whatis", WHATIS);
213	db_keyword("where", WHERE);
214	db_keyword("which", WHICH);
215	db_keyword("xd", XD);
216	db_keyword("xi", XI);
217
218	specialtab = st_creat(10);
219	sp_keyword("div", DIV);
220	sp_keyword("mod", MOD);
221	sp_keyword("in", IN);
222	sp_keyword("if", IF);
223	sp_keyword("and", AND);
224	sp_keyword("or", OR);
225	}
226
227	/*
228	* Send an alias directive over to the symbol table manager.
229	*/
230
231	alias(new, old)
232	char new, old;
233	{
234	if (old == NIL) {
235	print_alias(dbtab, new);
236	} else {
237	enter_alias(dbtab, new, old);
238	}
239	}
240
241	/*
242	* Input file management routines, "yyin" is Lex's idea of
243	* where the input comes from.
244	*/
245
246	#define MAXINPUT 10
247
248	LOCAL FILE *infp[MAXINPUT];
249	LOCAL FILE **curfp = &infp[0];
250
251	LOCAL BOOLEAN isnewfile;
252
253	/*
254	* Initially, we set the input to the initfile if it exists.
255	* If it does exist, we play a game or two to avoid generating
256	* multiple prompts.
257	*/
258
259	initinput()
260	{
261	FILE *fp;
262
263	fp = fopen(initfile, "r");
264	if (fp != NIL) {
265	fclose(fp);
266	setinput(initfile);
267	}
268	nlflag = TRUE;
269	}
270
271	/*
272	* Set the input to the named file. It is expected that the file exists
273	* and is readable.
274	*/
275
276	setinput(filename)
277	char *filename;
278	{
279	register FILE *fp;
280
281	if ((fp = fopen(filename, "r")) == NIL) {
282	error("can't open %s", filename);
283	}
284	if (curfp >= &infp[MAXINPUT]) {
285	error("unreasonable input nesting on %s", filename);
286	}
287	*curfp++ = yyin;
288	yyin = fp;
289	isnewfile = TRUE;
290	}
291
292	BOOLEAN isstdin()
293	{
294	return((BOOLEAN) (yyin == stdin));
295	}
296
297	LOCAL int input()
298	{
299	register int c;
300
301	if (isnewfile) {
302	isnewfile = FALSE;
303	return('\n');
304	}
305	while ((c = getc(yyin)) == EOF) {
306	if (curfp == &infp[0]) {
307	return(0);
308	} else {
309	fclose(yyin);
310	yyin = *--curfp;
311	if (yyin == stdin) {
312	prompt();
313	}
314	}
315	}
316	return(c);
317	}
318
319	/*
320	* Handle an input string by stripping the quotes and converting
321	* two interior quotes to one. Copy to newly allocated space and
322	* return a pointer to it.
323	*
324	* The handling of strings here is not particularly efficient,
325	* nor need it be.
326	*/
327
328	LOCAL char *pstring(p)
329	char *p;
330	{
331	int i, len;
332	char r, newp;
333
334	len = strlen(p);
335	r = newp = alloc(len - 2 + 1, char);
336	for (i = 1; i < len - 1; i++) {
337	if (p[i] == '\'' && p[i+1] == '\'') {
338	i++;
339	}
340	*newp++ = p[i];
341	}
342	*newp = '\0';
343	return(r);
344	}
345
346	/*
347	* prompt for a command
348	*/
349
350	prompt()
351	{
352	nlflag = FALSE;
353	if (yyin == stdin) {
354	printf("> ");
355	fflush(stdout);
356	}
357	}