?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / fm / eversholt / common / esclex.c
blobc0760361d3189abccf95abac630ac29326054fdd
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 = "/opt/gcc/4.4.4/bin/cpp";
77 #ifdef ESC
78 static const char *Cppargs;
79 static const char *Cppstdargs = "-undef -P -I.";
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 = "/opt/gcc/4.4.4/bin/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), NULL, 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), NULL, 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 }
unleashed repo fork