xref: /titanic_44/usr/src/cmd/fm/eversholt/common/esclex.c (revision 379c004d1f26b343f034bba8a350290691d00d38)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  *
25  * esclex.c -- lexer for esc
26  *
27  * this module provides lexical analysis and error handling routine
28  * expected by the yacc-generated parser (i.e. yylex() and yyerror()).
29  * it also does lots of tracking of things like filenames, line numbers,
30  * and what tokens are seen on a line up to the point where a syntax error
31  * was found.  this module also arranges for the input source files to
32  * be run through cpp.
33  */
34 
35 #include <stdio.h>
36 #include <ctype.h>
37 #include <string.h>
38 #include <stdlib.h>
39 #include <unistd.h>
40 #include <time.h>
41 #include <errno.h>
42 #include "out.h"
43 #include "alloc.h"
44 #include "stats.h"
45 #include "stable.h"
46 #include "lut.h"
47 #include "literals.h"
48 #include "tree.h"
49 #include "esclex.h"
50 #include "eftread.h"
51 #include "check.h"
52 #include "y.tab.h"
53 
54 /* ridiculously long token buffer -- disallow any token longer than this */
55 #define	MAXTOK	8192
56 static char Tok[MAXTOK];
57 
58 /* some misc stats we keep on the lexer & parser */
59 static struct stats *Tokcount;
60 static struct stats *Lexelapse;
61 struct stats *Filecount;
62 struct filestats {
63 	struct filestats *next;
64 	struct stats *stats;
65 	struct stats *idstats;
66 } *Fstats;
67 
68 static int Errcount;
69 
70 /* input file state */
71 static char **Files;
72 static const char *Fileopened;
73 static FILE *Fp;
74 static int Line;
75 static const char *File;
76 static const char *Cpp = "/usr/bin/cpp";
77 #ifdef	ESC
78 static const char *Cppargs;
79 static const char *Cppstdargs = "-undef -Y.";
80 #endif	/* ESC */
81 
82 /* for debugging */
83 static int Lexecho;	/* echo tokens as we read them */
84 
85 /* forward declarations of our internal routines */
86 static int record(int tok, const char *s);
87 static void dumpline(int flags);
88 static void doident();
89 static void dopragma(const char *tok);
90 
91 /*
92  * table of reserved words.  this table is only used by lex_init()
93  * to intialize the Rwords lookup table.
94  */
95 static const struct {
96 	const char *word;
97 	const int val;
98 } Rwords[] = {
99 	{ "asru", ASRU },
100 	{ "count", COUNT },
101 	{ "div", DIV },
102 	{ "engine", ENGINE },
103 	{ "event", EVENT },
104 	{ "fru", FRU },
105 	{ "if", IF },
106 	{ "mask", MASK },
107 	{ "prop", PROP },
108 	{ "config", CONFIG },
109 	/*
110 	 * PATHFUNC indicates functions that operate only on paths
111 	 * and quotes
112 	 */
113 	{ "is_connected", PATHFUNC },
114 	{ "is_under", PATHFUNC },
115 	{ "is_on", PATHFUNC },
116 	{ "is_present", PATHFUNC },
117 	{ "is_type", PATHFUNC },
118 	{ "has_fault", PATHFUNC },
119 	{ "confprop", PATHFUNC },
120 	{ "confprop_defined", PATHFUNC },
121 };
122 
123 /*
124  * Rwordslut is a lookup table of reserved words.  lhs is the word
125  * (in the string table) and the rhs is the token value returned
126  * by the yylex() for that word.
127  */
128 static struct lut *Rwordslut;
129 
130 static const struct {
131 	const char *suffix;
132 	const unsigned long long nsec;
133 } Timesuffix[] = {
134 	{ "nanosecond",		1ULL },
135 	{ "nanoseconds",	1ULL },
136 	{ "nsec",		1ULL },
137 	{ "nsecs",		1ULL },
138 	{ "ns",			1ULL },
139 	{ "microsecond",	1000ULL },
140 	{ "microseconds",	1000ULL },
141 	{ "usec",		1000ULL },
142 	{ "usecs",		1000ULL },
143 	{ "us",			1000ULL },
144 	{ "millisecond",	1000000ULL },
145 	{ "milliseconds",	1000000ULL },
146 	{ "msec",		1000000ULL },
147 	{ "msecs",		1000000ULL },
148 	{ "ms",			1000000ULL },
149 	{ "second",		1000000000ULL },
150 	{ "seconds",		1000000000ULL },
151 	{ "s",			1000000000ULL },
152 	{ "minute",		1000000000ULL * 60 },
153 	{ "minutes",		1000000000ULL * 60 },
154 	{ "min",		1000000000ULL * 60 },
155 	{ "mins",		1000000000ULL * 60 },
156 	{ "m",			1000000000ULL * 60 },
157 	{ "hour",		1000000000ULL * 60 * 60 },
158 	{ "hours",		1000000000ULL * 60 * 60 },
159 	{ "hr",			1000000000ULL * 60 * 60 },
160 	{ "hrs",		1000000000ULL * 60 * 60 },
161 	{ "h",			1000000000ULL * 60 * 60 },
162 	{ "day",		1000000000ULL * 60 * 60 * 24 },
163 	{ "days",		1000000000ULL * 60 * 60 * 24 },
164 	{ "d",			1000000000ULL * 60 * 60 * 24 },
165 	{ "week",		1000000000ULL * 60 * 60 * 24 * 7 },
166 	{ "weeks",		1000000000ULL * 60 * 60 * 24 * 7 },
167 	{ "wk",			1000000000ULL * 60 * 60 * 24 * 7 },
168 	{ "wks",		1000000000ULL * 60 * 60 * 24 * 7 },
169 	{ "month",		1000000000ULL * 60 * 60 * 24 * 30 },
170 	{ "months",		1000000000ULL * 60 * 60 * 24 * 30 },
171 	{ "year",		1000000000ULL * 60 * 60 * 24 * 365 },
172 	{ "years",		1000000000ULL * 60 * 60 * 24 * 365 },
173 	{ "yr",			1000000000ULL * 60 * 60 * 24 * 365 },
174 	{ "yrs",		1000000000ULL * 60 * 60 * 24 * 365 },
175 };
176 
177 /*
178  * some wrappers around the general lut functions to provide type checking...
179  */
180 
181 static struct lut *
182 lex_s2i_lut_add(struct lut *root, const char *s, intptr_t i)
183 {
184 	return (lut_add(root, (void *)s, (void *)i, NULL));
185 }
186 
187 static int
188 lex_s2i_lut_lookup(struct lut *root, const char *s)
189 {
190 	return ((intptr_t)lut_lookup(root, (void *)s, NULL));
191 }
192 
193 static struct lut *
194 lex_s2ullp_lut_add(struct lut *root, const char *s,
195     const unsigned long long *ullp)
196 {
197 	return (lut_add(root, (void *)s, (void *)ullp, NULL));
198 }
199 
200 const unsigned long long *
201 lex_s2ullp_lut_lookup(struct lut *root, const char *s)
202 {
203 	return ((unsigned long long *)lut_lookup(root, (void *)s, NULL));
204 }
205 
206 /*
207  * lex_init -- initialize the lexer with appropriate filenames & debug flags
208  */
209 
210 /*ARGSUSED*/
211 void
212 lex_init(char **av, const char *cppargs, int lexecho)
213 {
214 	int i;
215 #ifdef	ESC
216 	const char *ptr;
217 #endif	/* ESC */
218 
219 	Lexecho = lexecho;
220 	Tokcount = stats_new_counter("lex.tokens", "total tokens in", 1);
221 	Filecount = stats_new_counter("lex.files", "total files read", 0);
222 	Lexelapse = stats_new_elapse("lex.time", "elapsed lex/parse time", 1);
223 
224 #ifdef	ESC
225 	Cppargs = cppargs;
226 
227 	/* allow user to tell us where cpp is if it is some weird place */
228 	if (ptr = getenv("_ESC_CPP"))
229 		Cpp = ptr;
230 
231 	/* and in case it takes some special stdargs */
232 	if (ptr = getenv("_ESC_CPP_STDARGS"))
233 		Cppstdargs = ptr;
234 
235 	/* verify we can find cpp */
236 	if (access(Cpp, X_OK) < 0) {
237 		Cpp = "/usr/lib/cpp";
238 		if (access(Cpp, X_OK) < 0)
239 			out(O_DIE, "can't locate cpp");
240 	}
241 #endif	/* ESC */
242 
243 	Files = av;
244 
245 	/* verify we can find all the input files */
246 	while (*av) {
247 		if (strlen(*av) >= MAXTOK - strlen(Cpp) - 3)
248 			out(O_DIE, "filename too long: %.100s...", *av);
249 		if (access(*av, R_OK) < 0)
250 			out(O_DIE|O_SYS, "%s", *av);
251 		av++;
252 		stats_counter_bump(Filecount);
253 	}
254 
255 	/* put reserved words into the string table & a lookup table */
256 	for (i = 0; i < sizeof (Rwords) / sizeof (*Rwords); i++)
257 		Rwordslut = lex_s2i_lut_add(Rwordslut,
258 		    stable(Rwords[i].word), Rwords[i].val);
259 
260 	/* initialize table of timeval suffixes */
261 	for (i = 0; i < sizeof (Timesuffix) / sizeof (*Timesuffix); i++) {
262 		Timesuffixlut = lex_s2ullp_lut_add(Timesuffixlut,
263 		    stable(Timesuffix[i].suffix), &Timesuffix[i].nsec);
264 	}
265 
266 	/* record start time */
267 	stats_elapse_start(Lexelapse);
268 }
269 
270 void
271 closefile(void)
272 {
273 	if (Fp != NULL) {
274 #ifdef	ESC
275 		if (pclose(Fp) > 0)
276 			out(O_DIE, "cpp errors while reading \"%s\", "
277 			    "bailing out.", Fileopened);
278 #else
279 		(void) fclose(Fp);
280 #endif	/* ESC */
281 	}
282 	Fp = NULL;
283 }
284 
285 /*
286  * yylex -- the lexer, called yylex() because that's what yacc wants
287  */
288 
289 int
290 yylex()
291 {
292 	int c;
293 	int nextc;
294 	char *ptr = Tok;
295 	char *eptr = &Tok[MAXTOK];
296 	const char *cptr;
297 	int startline;
298 	int val;
299 	static int bol = 1;	/* true if we're at beginning of line */
300 
301 	for (;;) {
302 		while (Fp == NULL) {
303 			char ibuf[80];
304 
305 			if (*Files == NULL)
306 				return (record(EOF, NULL));
307 			Fileopened = stable(*Files++);
308 #ifdef	ESC
309 			sprintf(Tok, "%s %s %s %s",
310 			    Cpp, Cppstdargs, Cppargs, Fileopened);
311 			if ((Fp = popen(Tok, "r")) == NULL)
312 				out(O_DIE|O_SYS, "%s", Tok);
313 #else
314 			Fp = eftread_fopen(Fileopened, ibuf, sizeof (ibuf));
315 #endif	/* ESC */
316 			Line = 1;
317 			bol = 1;
318 
319 			/* add name to stats for visibility */
320 			if (Fp != NULL) {
321 				static int fnum;
322 				char nbuf[100];
323 				struct filestats *nfs = MALLOC(sizeof (*nfs));
324 
325 				(void) sprintf(nbuf, "lex.file%d", fnum);
326 				nfs->stats = stats_new_string(nbuf, "", 0);
327 				stats_string_set(nfs->stats, Fileopened);
328 
329 				if (ibuf[0] != '\0') {
330 					(void) sprintf(nbuf, "lex.file%d-ident",
331 					    fnum);
332 					nfs->idstats =
333 					    stats_new_string(nbuf, "", 0);
334 					stats_string_set(nfs->idstats, ibuf);
335 				} else {
336 					nfs->idstats = NULL;
337 				}
338 
339 				nfs->next = Fstats;
340 				Fstats = nfs;
341 				fnum++;
342 			}
343 		}
344 
345 		switch (c = getc(Fp)) {
346 		case '#':
347 			/* enforce that we're at beginning of line */
348 			if (!bol)
349 				return (record(c, NULL));
350 
351 			while ((c = getc(Fp)) != EOF &&
352 			    (c == ' ' || c == '\t'))
353 				;
354 			if (!isdigit(c)) {
355 				/*
356 				 * three cases here:
357 				 *	#pragma
358 				 *	#ident
359 				 *	#something-we-don't-understand
360 				 * anything we don't expect we just ignore.
361 				 */
362 				*ptr++ = c;
363 				while ((c = getc(Fp)) != EOF && isalnum(c))
364 					if (ptr < eptr - 1)
365 						*ptr++ = c;
366 				*ptr++ = '\0';
367 				if (strcmp(Tok, "pragma") == 0) {
368 					/* skip white space */
369 					while ((c = getc(Fp)) != EOF &&
370 					    (c == ' ' || c == '\t'))
371 						;
372 
373 					if (c == EOF || c == '\n')
374 						outfl(O_DIE, File, Line,
375 						    "bad #pragma");
376 
377 					/* pull in next token */
378 					ptr = Tok;
379 					*ptr++ = c;
380 					while ((c = getc(Fp)) != EOF &&
381 					    !isspace(c))
382 						if (ptr < eptr - 1)
383 							*ptr++ = c;
384 					*ptr++ = '\0';
385 					(void) ungetc(c, Fp);
386 
387 					dopragma(Tok);
388 				} else if (strcmp(Tok, "ident") == 0)
389 					doident();
390 			} else {
391 				/* handle file & line info from cpp */
392 				Line = 0;
393 				do {
394 					if (!isdigit(c))
395 						break;
396 					Line = Line * 10 + c - '0';
397 				} while ((c = getc(Fp)) != EOF);
398 				Line--;		/* newline will increment it */
399 				while (c != EOF && isspace(c))
400 					c = getc(Fp);
401 				if (c != '"')
402 					outfl(O_DIE, File, Line,
403 					    "bad # statement (file name)");
404 				while ((c = getc(Fp)) != EOF && c != '"')
405 					if (ptr < eptr - 1)
406 						*ptr++ = c;
407 				*ptr++ = '\0';
408 				if (c != '"')
409 					outfl(O_DIE, File, Line,
410 					    "bad # statement (quotes)");
411 				File = stable(Tok);
412 			}
413 			/* skip the rest of the cpp line */
414 			while ((c = getc(Fp)) != EOF && c != '\n' && c != '\r')
415 				;
416 			if (c == EOF)
417 				return (record(c, NULL));
418 			else
419 				(void) ungetc(c, Fp);
420 			ptr = Tok;
421 			break;
422 
423 		case EOF:
424 			closefile();
425 			continue;
426 
427 		case '\n':
428 			Line++;
429 			bol = 1;
430 			break;
431 
432 		case '\r':
433 		case ' ':
434 		case '\t':
435 			bol = 0;
436 			break;
437 
438 		case '/':
439 			bol = 0;
440 			/* comment handling */
441 			if ((nextc = getc(Fp)) == EOF)
442 				outfl(O_DIE, File, Line, "unexpected EOF");
443 			else if (nextc == '*') {
444 				startline = Line;
445 				while ((c = getc(Fp)) != EOF) {
446 					if (c == '\n')
447 						Line++;
448 					else if (c == '*' &&
449 					    (((c = getc(Fp)) == EOF) ||
450 					    (c == '/')))
451 						break;
452 				}
453 				if (c == EOF) {
454 					outfl(O_DIE, File, Line,
455 					    "end of comment not seen "
456 					    "(started on line %d)",
457 					    startline);
458 				}
459 			} else {
460 				/* wasn't a comment, return the '/' token */
461 				(void) ungetc(nextc, Fp);
462 				return (record(c, NULL));
463 			}
464 			break;
465 
466 		case '"': {
467 			int prevc;
468 
469 			bol = 0;
470 			prevc = '\0';
471 			/* quoted string handling */
472 			startline = Line;
473 			for (;;) {
474 				c = getc(Fp);
475 				if (c == EOF)
476 					outfl(O_DIE, File, Line,
477 					    "end of string not seen "
478 					    "(started on line %d)",
479 					    startline);
480 				else if (c == '\n')
481 					Line++;
482 				else if (c == '"' && prevc != '\\')
483 					break;
484 				else if (ptr < eptr)
485 					*ptr++ = c;
486 				prevc = c;
487 			}
488 			if (ptr >= eptr)
489 				out(O_DIE, File, Line, "string too long");
490 			*ptr++ = '\0';
491 			return (record(QUOTE, stable(Tok)));
492 		}
493 		case '&':
494 			bol = 0;
495 			/* && */
496 			if ((nextc = getc(Fp)) == '&')
497 				return (record(AND, NULL));
498 			else {
499 				(void) ungetc(nextc, Fp);
500 				return (record(c, NULL));
501 			}
502 			/*NOTREACHED*/
503 			break;
504 
505 		case '|':
506 			bol = 0;
507 			/* || */
508 			if ((nextc = getc(Fp)) == '|')
509 				return (record(OR, NULL));
510 			else {
511 				(void) ungetc(nextc, Fp);
512 				return (record(c, NULL));
513 			}
514 			/*NOTREACHED*/
515 			break;
516 
517 		case '!':
518 			bol = 0;
519 			/* ! or != */
520 			if ((nextc = getc(Fp)) == '=')
521 				return (record(NE, NULL));
522 			else {
523 				(void) ungetc(nextc, Fp);
524 				return (record(c, NULL));
525 			}
526 			/*NOTREACHED*/
527 			break;
528 
529 		case '=':
530 			bol = 0;
531 			/* == */
532 			if ((nextc = getc(Fp)) == '=')
533 				return (record(EQ, NULL));
534 			else {
535 				(void) ungetc(nextc, Fp);
536 				return (record(c, NULL));
537 			}
538 			/*NOTREACHED*/
539 			break;
540 
541 		case '-':
542 			bol = 0;
543 			/* -> */
544 			if ((nextc = getc(Fp)) == '>')
545 				return (record(ARROW, stable(Tok)));
546 			else {
547 				(void) ungetc(nextc, Fp);
548 				return (record(c, NULL));
549 			}
550 			/*NOTREACHED*/
551 			break;
552 
553 		case '<':
554 			bol = 0;
555 			if ((nextc = getc(Fp)) == '=')
556 				/* <= */
557 				return (record(LE, NULL));
558 			else if (nextc == '<')
559 				/* << */
560 				return (record(LSHIFT, NULL));
561 			else {
562 				(void) ungetc(nextc, Fp);
563 				return (record(c, NULL));
564 			}
565 			/*NOTREACHED*/
566 			break;
567 
568 		case '>':
569 			bol = 0;
570 			if ((nextc = getc(Fp)) == '=')
571 				/* >= */
572 				return (record(GE, NULL));
573 			else if (nextc == '>')
574 				/* >> */
575 				return (record(RSHIFT, NULL));
576 			else {
577 				(void) ungetc(nextc, Fp);
578 				return (record(c, NULL));
579 			}
580 			/*NOTREACHED*/
581 			break;
582 
583 		default:
584 			bol = 0;
585 			if (isdigit(c)) {
586 				int base;
587 
588 				/* collect rest of number */
589 				if (c == '0') {
590 					*ptr++ = c;
591 					if ((c = getc(Fp)) == EOF) {
592 						*ptr++ = '\0';
593 						return (record(NUMBER,
594 						    stable(Tok)));
595 					} else if (c == 'x' || c == 'X') {
596 						*ptr++ = c;
597 						base = 16;
598 					} else {
599 						(void) ungetc(c, Fp);
600 						base = 8;
601 					}
602 				} else {
603 					*ptr++ = c;
604 					base = 10;
605 				}
606 				while ((c = getc(Fp)) != EOF) {
607 					if (ptr >= eptr)
608 						out(O_DIE, File, Line,
609 						    "number too long");
610 
611 					switch (base) {
612 					case 16:
613 						if (c >= 'a' && c <= 'f' ||
614 						    c >= 'A' && c <= 'F') {
615 							*ptr++ = c;
616 							continue;
617 						}
618 						/*FALLTHRU*/
619 					case 10:
620 						if (c >= '8' && c <= '9') {
621 							*ptr++ = c;
622 							continue;
623 						}
624 						/*FALLTHRU*/
625 					case 8:
626 						if (c >= '0' && c <= '7') {
627 							*ptr++ = c;
628 							continue;
629 						}
630 						/* not valid for this base */
631 						*ptr++ = '\0';
632 						(void) ungetc(c, Fp);
633 						return (record(NUMBER,
634 						    stable(Tok)));
635 					}
636 				}
637 				*ptr++ = '\0';
638 				return (record(NUMBER, stable(Tok)));
639 			} else if (isalpha(c)) {
640 				/* collect identifier */
641 				*ptr++ = c;
642 				for (;;) {
643 					c = getc(Fp);
644 					if ((isalnum(c) || c == '_') &&
645 					    ptr < eptr)
646 						*ptr++ = c;
647 					else {
648 						(void) ungetc(c, Fp);
649 						break;
650 					}
651 				}
652 				if (ptr >= eptr)
653 					out(O_DIE, File, Line,
654 					    "identifier too long");
655 				*ptr++ = '\0';
656 				cptr = stable(Tok);
657 				if (val = lex_s2i_lut_lookup(Rwordslut, cptr)) {
658 					return (record(val, cptr));
659 				}
660 				return (record(ID, cptr));
661 			} else
662 				return (record(c, NULL));
663 		}
664 		/*NOTREACHED*/
665 	}
666 }
667 
668 /*
669  * the record()/dumpline() routines are used to track & report
670  * the list of tokens seen on a given line.  this is used in two ways.
671  * first, syntax errors found by the parser are reported by us (via
672  * yyerror()) and we tack on the tokens processed so far on the current
673  * line to help indicate exactly where the error is.  second, if "lexecho"
674  * debugging is turned on, these routines provide it.
675  */
676 #define	MAXRECORD 1000
677 static int Recordedline;
678 static struct {
679 	int tok;
680 	const char *s;
681 } Recorded[MAXRECORD];
682 static int Recordnext;
683 
684 static int
685 record(int tok, const char *s)
686 {
687 	stats_counter_bump(Tokcount);
688 	if (Line != Recordedline) {
689 		/* starting new line, dump out the previous line */
690 		if (Lexecho && Recordedline) {
691 			outfl(O_NONL, File, Recordedline, "lex: ");
692 			dumpline(O_OK);
693 		}
694 		Recordedline = Line;
695 		Recordnext = 0;
696 	}
697 	if (Recordnext >= MAXRECORD)
698 		outfl(O_DIE, File, Line, "line too long, bailing out");
699 	Recorded[Recordnext].tok = tok;
700 	Recorded[Recordnext++].s = s;
701 
702 	yylval.tok.s = s;
703 	yylval.tok.file = File;
704 	yylval.tok.line = Line;
705 	return (tok);
706 }
707 
708 /*ARGSUSED*/
709 static void
710 dumpline(int flags)
711 {
712 	int i;
713 
714 	for (i = 0; i < Recordnext; i++)
715 		if (Recorded[i].s && Recorded[i].tok != ARROW)
716 			switch (Recorded[i].tok) {
717 			case T_QUOTE:
718 				out(flags|O_NONL, " \"%s\"",
719 				    Recorded[i].s);
720 				break;
721 
722 			default:
723 				out(flags|O_NONL, " %s",
724 				    Recorded[i].s);
725 				break;
726 			}
727 		else
728 			switch (Recorded[i].tok) {
729 			case EOF:
730 				out(flags|O_NONL, " EOF");
731 				break;
732 			case ARROW:
733 				out(flags|O_NONL, " ->%s",
734 				    Recorded[i].s);
735 				break;
736 			case EQ:
737 				out(flags|O_NONL, " ==");
738 				break;
739 			case NE:
740 				out(flags|O_NONL, " !=");
741 				break;
742 			case OR:
743 				out(flags|O_NONL, " ||");
744 				break;
745 			case AND:
746 				out(flags|O_NONL, " &&");
747 				break;
748 			case LE:
749 				out(flags|O_NONL, " <=");
750 				break;
751 			case GE:
752 				out(flags|O_NONL, " >=");
753 				break;
754 			case LSHIFT:
755 				out(flags|O_NONL, " <<");
756 				break;
757 			case RSHIFT:
758 				out(flags|O_NONL, " >>");
759 				break;
760 			default:
761 				if (isprint(Recorded[i].tok))
762 					out(flags|O_NONL, " %c",
763 					    Recorded[i].tok);
764 				else
765 					out(flags|O_NONL, " '\\%03o'",
766 					    Recorded[i].tok);
767 				break;
768 			}
769 	out(flags, NULL);
770 }
771 
772 /*
773  * yyerror -- report a pareser error, called yyerror because yacc wants it
774  */
775 
776 void
777 yyerror(const char *s)
778 {
779 	Errcount++;
780 	outfl(O_ERR|O_NONL, File, Line, "%s, tokens: ", s);
781 	dumpline(O_ERR);
782 }
783 
784 /*
785  * doident -- handle "#pragma ident" directives
786  */
787 static void
788 doident()
789 {
790 	int c;
791 	char *ptr = Tok;
792 	char *eptr = &Tok[MAXTOK];
793 
794 	/* skip white space and quotes */
795 	while ((c = getc(Fp)) != EOF &&
796 	    (c == ' ' || c == '\t' || c == '"'))
797 		;
798 
799 	if (c == EOF || c == '\n')
800 		outfl(O_DIE, File, Line, "bad ident");
801 
802 	/* pull in next token */
803 	ptr = Tok;
804 	*ptr++ = c;
805 	while ((c = getc(Fp)) != EOF && c != '"' && c != '\n')
806 		if (ptr < eptr - 1)
807 			*ptr++ = c;
808 	*ptr++ = '\0';
809 	if (c != '\n') {
810 		/* skip to end of line (including close quote, if any) */
811 		while ((c = getc(Fp)) != EOF && c != '\n')
812 			;
813 	}
814 	(void) ungetc(c, Fp);
815 	Ident = lut_add(Ident, (void *)stable(Tok), (void *)0, NULL);
816 
817 	outfl(O_VERB, File, Line, "pragma set: ident \"%s\"", Tok);
818 }
819 
820 /*
821  * dodictionary -- handle "#pragma dictionary" directives
822  */
823 static void
824 dodictionary()
825 {
826 	int c;
827 	char *ptr = Tok;
828 	char *eptr = &Tok[MAXTOK];
829 
830 	/* skip white space and quotes */
831 	while ((c = getc(Fp)) != EOF &&
832 	    (c == ' ' || c == '\t' || c == '"'))
833 		;
834 
835 	if (c == EOF || c == '\n')
836 		outfl(O_DIE, File, Line, "bad dictionary");
837 
838 	/* pull in next token */
839 	ptr = Tok;
840 	*ptr++ = c;
841 	while ((c = getc(Fp)) != EOF && c != '"' && c != '\n')
842 		if (ptr < eptr - 1)
843 			*ptr++ = c;
844 	*ptr++ = '\0';
845 	if (c != '\n') {
846 		/* skip to end of line (including close quote, if any) */
847 		while ((c = getc(Fp)) != EOF && c != '\n')
848 			;
849 	}
850 	(void) ungetc(c, Fp);
851 	Dicts = lut_add(Dicts, (void *)stable(Tok), (void *)0, NULL);
852 
853 	outfl(O_VERB, File, Line, "pragma set: dictionary \"%s\"", Tok);
854 }
855 
856 /*
857  * doallow_cycles -- handle "#pragma allow_cycles" directives
858  */
859 static void
860 doallow_cycles()
861 {
862 	int c;
863 	char *ptr = Tok;
864 	char *eptr = &Tok[MAXTOK];
865 	unsigned long long newlevel;
866 
867 	/*
868 	 * by default the compiler does not allow cycles or loops
869 	 * in propagations.  when cycles are encountered, the
870 	 * compiler prints out an error message.
871 	 *
872 	 *   "#pragma allow_cycles" and
873 	 *   "#pragma allow_cycles 0"
874 	 * allow cycles, but any such cycle will produce a warning
875 	 * message.
876 	 *
877 	 *   "#pragma allow_cycles N"
878 	 * with N > 0 will allow cycles and not produce any
879 	 * warning messages.
880 	 */
881 
882 	/* skip white space and quotes */
883 	while ((c = getc(Fp)) != EOF &&
884 	    (c == ' ' || c == '\t' || c == '"'))
885 		;
886 
887 	if (c == EOF || c == '\n')
888 		newlevel = 0ULL;
889 	else {
890 
891 		/* pull in next token */
892 		ptr = Tok;
893 		*ptr++ = c;
894 		while ((c = getc(Fp)) != EOF && c != '"' && c != '\n')
895 			if (ptr < eptr - 1)
896 				*ptr++ = c;
897 		*ptr++ = '\0';
898 		if (c != '\n') {
899 			/* skip to end of line */
900 			while ((c = getc(Fp)) != EOF && c != '\n')
901 				;
902 		}
903 		newlevel = strtoll(Tok, NULL, 0);
904 	}
905 	(void) ungetc(c, Fp);
906 
907 	(void) check_cycle_level(newlevel);
908 	outfl(O_VERB, File, Line,
909 	    "pragma set: allow_cycles (%s)",
910 	    newlevel ? "no warnings" : "with warnings");
911 }
912 
913 /*
914  * dopragma -- handle #pragma directives
915  */
916 static void
917 dopragma(const char *tok)
918 {
919 	if (strcmp(tok, "ident") == 0)
920 		doident();
921 	else if (strcmp(tok, "dictionary") == 0)
922 		dodictionary();
923 	else if (strcmp(tok, "new_errors_only") == 0) {
924 		if (Pragma_new_errors_only++ == 0)
925 			outfl(O_VERB, File, Line,
926 			    "pragma set: new_errors_only");
927 	} else if (strcmp(tok, "trust_ereports") == 0) {
928 		if (Pragma_trust_ereports++ == 0)
929 			outfl(O_VERB, File, Line,
930 			    "pragma set: trust_ereports");
931 	} else if (strcmp(tok, "allow_cycles") == 0)
932 		doallow_cycles();
933 	else
934 		outfl(O_VERB, File, Line,
935 		    "unknown pragma ignored: \"%s\"", tok);
936 }
937 
938 /*
939  * lex_fini -- finalize the lexer
940  */
941 
942 int
943 lex_fini(void)
944 {
945 	stats_elapse_stop(Lexelapse);
946 	closefile();
947 	if (Lexecho) {
948 		outfl(O_OK, File, Line, "lex: ");
949 		dumpline(O_OK);
950 	}
951 	return (Errcount);
952 }
953 
954 void
955 lex_free(void)
956 {
957 	struct filestats *nfstats = Fstats;
958 
959 	/*
960 	 * Free up memory consumed by the lexer
961 	 */
962 	stats_delete(Tokcount);
963 	stats_delete(Filecount);
964 	stats_delete(Lexelapse);
965 	while (nfstats != NULL) {
966 		Fstats = nfstats->next;
967 		stats_delete(nfstats->stats);
968 		if (nfstats->idstats != NULL)
969 			stats_delete(nfstats->idstats);
970 		FREE(nfstats);
971 		nfstats = Fstats;
972 	}
973 	lut_free(Timesuffixlut, NULL, NULL);
974 	lut_free(Rwordslut, NULL, NULL);
975 	lut_free(Ident, NULL, NULL);
976 	lut_free(Dicts, NULL, NULL);
977 }
978