Correct sizeof(pointer) bugs that should have been sizeof(*pointer)
[dragonfly.git] / usr.bin / xlint / lint1 / scan.l
1 %{
2 /*      $NetBSD: scan.l,v 1.8 1995/10/23 13:38:51 jpo Exp $     */
3
4 /*
5  * Copyright (c) 1994, 1995 Jochen Pohl
6  * All Rights Reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by Jochen Pohl for
19  *      The NetBSD Project.
20  * 4. The name of the author may not be used to endorse or promote products
21  *    derived from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34  * $NetBSD: scan.l,v 1.8 1995/10/23 13:38:51 jpo Exp $
35  * $DragonFly: src/usr.bin/xlint/lint1/scan.l,v 1.8 2006/01/17 23:49:13 dillon Exp $
36  */
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include <limits.h>
41 #include <float.h>
42 #include <ctype.h>
43 #include <errno.h>
44 #include <err.h>
45 #include <math.h>
46
47 #include "lint1.h"
48 #include "y.tab.h"
49
50 #define CHAR_MASK       (~(~0 << CHAR_BIT))
51
52 /* Current position (its also updated when an included file is parsed) */
53 pos_t   curr_pos = { 1, "" };
54
55 /*
56  * Current position in C source (not updated when an included file is
57  * parsed).
58  */
59 pos_t   csrc_pos = { 1, "" };
60
61 static  void    incline(void);
62 static  void    badchar(int);
63 static  sbuf_t  *allocsb(void);
64 static  void    freesb(sbuf_t *);
65 static  int     inpc(void);
66 static  int     hash(const char *);
67 static  sym_t   *search(sbuf_t *);
68 static  int     name(void);
69 static  int     keyw(sym_t *);
70 static  int     icon(int);
71 static  int     fcon(void);
72 static  int     operator(int, op_t);
73 static  int     ccon(void);
74 static  int     wccon(void);
75 static  int     getescc(int);
76 static  void    directive(void);
77 static  void    comment(void);
78 static  int     string(void);
79 static  int     wcstrg(void);
80
81 %}
82
83 L       [_A-Za-z]
84 D       [0-9]
85 NZD     [1-9]
86 OD      [0-7]
87 HD      [0-9A-Fa-f]
88 EX      ([eE][+-]?[0-9]+)
89
90 %%
91
92 {L}({L}|{D})*                   return (name());
93 0{OD}*[lLuU]*                   return (icon(8));
94 {NZD}{D}*[lLuU]*                return (icon(10));
95 0[xX]{HD}+[lLuU]*               return (icon(16));
96 {D}+\.{D}*{EX}?[fFlL]?          |
97 {D}+{EX}[fFlL]?                 |
98 \.{D}+{EX}?[fFlL]?              return (fcon());
99 "="                             return (operator(T_ASSIGN, ASSIGN));
100 "*="                            return (operator(T_OPASS, MULASS));
101 "/="                            return (operator(T_OPASS, DIVASS));
102 "%="                            return (operator(T_OPASS, MODASS));
103 "+="                            return (operator(T_OPASS, ADDASS));
104 "-="                            return (operator(T_OPASS, SUBASS));
105 "<<="                           return (operator(T_OPASS, SHLASS));
106 ">>="                           return (operator(T_OPASS, SHRASS));
107 "&="                            return (operator(T_OPASS, ANDASS));
108 "^="                            return (operator(T_OPASS, XORASS));
109 "|="                            return (operator(T_OPASS, ORASS));
110 "||"                            return (operator(T_LOGOR, LOGOR));
111 "&&"                            return (operator(T_LOGAND, LOGAND));
112 "|"                             return (operator(T_OR, OR));
113 "&"                             return (operator(T_AND, AND));
114 "^"                             return (operator(T_XOR, XOR));
115 "=="                            return (operator(T_EQOP, EQ));
116 "!="                            return (operator(T_EQOP, NE));
117 "<"                             return (operator(T_RELOP, LT));
118 ">"                             return (operator(T_RELOP, GT));
119 "<="                            return (operator(T_RELOP, LE));
120 ">="                            return (operator(T_RELOP, GE));
121 "<<"                            return (operator(T_SHFTOP, SHL));
122 ">>"                            return (operator(T_SHFTOP, SHR));
123 "++"                            return (operator(T_INCDEC, INC));
124 "--"                            return (operator(T_INCDEC, DEC));
125 "->"                            return (operator(T_STROP, ARROW));
126 "."                             return (operator(T_STROP, POINT));
127 "+"                             return (operator(T_ADDOP, PLUS));
128 "-"                             return (operator(T_ADDOP, MINUS));
129 "*"                             return (operator(T_MULT, MULT));
130 "/"                             return (operator(T_DIVOP, DIV));
131 "%"                             return (operator(T_DIVOP, MOD));
132 "!"                             return (operator(T_UNOP, NOT));
133 "~"                             return (operator(T_UNOP, COMPL));
134 "\""                            return (string());
135 "L\""                           return (wcstrg());
136 ";"                             return (T_SEMI);
137 "{"                             return (T_LBRACE);
138 "}"                             return (T_RBRACE);
139 ","                             return (T_COMMA);
140 ":"                             return (T_COLON);
141 "?"                             return (T_QUEST);
142 "["                             return (T_LBRACK);
143 "]"                             return (T_RBRACK);
144 "("                             return (T_LPARN);
145 ")"                             return (T_RPARN);
146 "..."                           return (T_ELLIPSE);
147 "'"                             return (ccon());
148 "L'"                            return (wccon());
149 ^#.*$                           directive();
150 \n                              incline();
151 \t|" "|\f|\v                    ;
152 "/*"                            comment();
153 .                               badchar(yytext[0]);
154
155 %%
156
157 static void
158 incline()
159 {
160         curr_pos.p_line++;
161         if (curr_pos.p_file == csrc_pos.p_file)
162                 csrc_pos.p_line++;
163 }
164
165 static void
166 badchar(c)
167         int     c;
168 {
169         /* unknown character \%o */
170         error(250, c);
171 }
172
173 /*
174  * Keywords.
175  * During initialisation they are written to the symbol table.
176  */
177 static  struct  kwtab {
178         const   char *kw_name;  /* keyword */
179         int     kw_token;       /* token returned by yylex() */
180         scl_t   kw_scl;         /* storage class if kw_token T_SCLASS */
181         tspec_t kw_tspec;       /* type spec. if kw_token T_TYPE or T_SOU */
182         tqual_t kw_tqual;       /* type qual. fi kw_token T_QUAL */
183         u_int   kw_stdc : 1;    /* STDC keyword */
184         u_int   kw_gcc : 1;     /* GCC keyword */
185 } kwtab[] = {
186         { "asm",        T_ASM,          0,      0,      0,        0, 1 },
187         { "__asm",      T_ASM,          0,      0,      0,        0, 0 },
188         { "__asm__",    T_ASM,          0,      0,      0,        0, 0 },
189         { "auto",       T_SCLASS,       AUTO,   0,      0,        0, 0 },
190         { "break",      T_BREAK,        0,      0,      0,        0, 0 },
191         { "case",       T_CASE,         0,      0,      0,        0, 0 },
192         { "char",       T_TYPE,         0,      CHAR,   0,        0, 0 },
193         { "const",      T_QUAL,         0,      0,      CONST,    1, 0 },
194         { "__const__",  T_QUAL,         0,      0,      CONST,    0, 0 },
195         { "__const",    T_QUAL,         0,      0,      CONST,    0, 0 },
196         { "continue",   T_CONTINUE,     0,      0,      0,        0, 0 },
197         { "default",    T_DEFAULT,      0,      0,      0,        0, 0 },
198         { "do",         T_DO,           0,      0,      0,        0, 0 },
199         { "double",     T_TYPE,         0,      DOUBLE, 0,        0, 0 },
200         { "else",       T_ELSE,         0,      0,      0,        0, 0 },
201         { "enum",       T_ENUM,         0,      0,      0,        0, 0 },
202         { "extern",     T_SCLASS,       EXTERN, 0,      0,        0, 0 },
203         { "float",      T_TYPE,         0,      FLOAT,  0,        0, 0 },
204         { "for",        T_FOR,          0,      0,      0,        0, 0 },
205         { "goto",       T_GOTO,         0,      0,      0,        0, 0 },
206         { "if",         T_IF,           0,      0,      0,        0, 0 },
207         { "inline",     T_SCLASS,       INLINE, 0,      0,        0, 1 },
208         { "__inline__", T_SCLASS,       INLINE, 0,      0,        0, 0 },
209         { "__inline",   T_SCLASS,       INLINE, 0,      0,        0, 0 },
210         { "int",        T_TYPE,         0,      INT,    0,        0, 0 },
211         { "long",       T_TYPE,         0,      LONG,   0,        0, 0 },
212         { "register",   T_SCLASS,       REG,    0,      0,        0, 0 },
213         { "return",     T_RETURN,       0,      0,      0,        0, 0 },
214         { "short",      T_TYPE,         0,      SHORT,  0,        0, 0 },
215         { "signed",     T_TYPE,         0,      SIGNED, 0,        1, 0 },
216         { "__signed__", T_TYPE,         0,      SIGNED, 0,        0, 0 },
217         { "__signed",   T_TYPE,         0,      SIGNED, 0,        0, 0 },
218         { "sizeof",     T_SIZEOF,       0,      0,      0,        0, 0 },
219         { "static",     T_SCLASS,       STATIC, 0,      0,        0, 0 },
220         { "struct",     T_SOU,          0,      STRUCT, 0,        0, 0 },
221         { "switch",     T_SWITCH,       0,      0,      0,        0, 0 },
222         { "typedef",    T_SCLASS,       TYPEDEF, 0,     0,        0, 0 },
223         { "union",      T_SOU,          0,      UNION,  0,        0, 0 },
224         { "unsigned",   T_TYPE,         0,      UNSIGN, 0,        0, 0 },
225         { "void",       T_TYPE,         0,      VOID,   0,        0, 0 },
226         { "volatile",   T_QUAL,         0,      0,      VOLATILE, 1, 0 },
227         { "__volatile__", T_QUAL,       0,      0,      VOLATILE, 0, 0 },
228         { "__volatile", T_QUAL,         0,      0,      VOLATILE, 0, 0 },
229         { "while",      T_WHILE,        0,      0,      0,        0, 0 },
230         { NULL,         0,              0,      0,      0,        0, 0 }
231 };
232
233 /* Symbol table */
234 static  sym_t   *symtab[HSHSIZ1];
235
236 /* bit i of the entry with index i is set */
237 u_quad_t qbmasks[sizeof(u_quad_t) * CHAR_BIT];
238
239 /* least significant i bits are set in the entry with index i */
240 u_quad_t qlmasks[sizeof(u_quad_t) * CHAR_BIT + 1];
241
242 /* least significant i bits are not set in the entry with index i */
243 u_quad_t qumasks[sizeof(u_quad_t) * CHAR_BIT + 1];
244
245 /* free list for sbuf structures */
246 static  sbuf_t   *sbfrlst;
247
248 /* Typ of next expected symbol */
249 symt_t  symtyp;
250
251
252 /*
253  * All keywords are written to the symbol table. This saves us looking
254  * in a extra table for each name we found.
255  */
256 void
257 initscan()
258 {
259         struct  kwtab *kw;
260         sym_t   *sym;
261         int     h, i;
262         u_quad_t uq;
263
264         for (kw = kwtab; kw->kw_name != NULL; kw++) {
265                 if (kw->kw_stdc && tflag)
266                         continue;
267                 if (kw->kw_gcc && !gflag)
268                         continue;
269                 sym = getblk(sizeof (sym_t));
270                 sym->s_name = kw->kw_name;
271                 sym->s_keyw = 1;
272                 sym->s_value.v_quad = kw->kw_token;
273                 if (kw->kw_token == T_TYPE || kw->kw_token == T_SOU) {
274                         sym->s_tspec = kw->kw_tspec;
275                 } else if (kw->kw_token == T_SCLASS) {
276                         sym->s_scl = kw->kw_scl;
277                 } else if (kw->kw_token == T_QUAL) {
278                         sym->s_tqual = kw->kw_tqual;
279                 }
280                 h = hash(sym->s_name);
281                 if ((sym->s_link = symtab[h]) != NULL)
282                         symtab[h]->s_rlink = &sym->s_link;
283                 (symtab[h] = sym)->s_rlink = &symtab[h];
284         }
285
286         /* initialize bit-masks for quads */
287         for (i = 0; i < sizeof (u_quad_t) * CHAR_BIT; i++) {
288                 qbmasks[i] = (u_quad_t)1 << i;
289                 uq = ~(u_quad_t)0 << i;
290                 qumasks[i] = uq;
291                 qlmasks[i] = ~uq;
292         }
293         qumasks[i] = 0;
294         qlmasks[i] = ~(u_quad_t)0;
295 }
296
297 /*
298  * Get a free sbuf structure, if possible from the free list
299  */
300 static sbuf_t *
301 allocsb()
302 {
303         sbuf_t  *sb;
304
305         if ((sb = sbfrlst) != NULL) {
306                 sbfrlst = sb->sb_nxt;
307         } else {
308                 sb = xmalloc(sizeof (sbuf_t));
309         }
310         (void)memset(sb, 0, sizeof (*sb));
311         return (sb);
312 }
313
314 /*
315  * Put a sbuf structure to the free list
316  */
317 static void
318 freesb(sb)
319         sbuf_t  *sb;
320 {
321         sb->sb_nxt = sbfrlst;
322         sbfrlst = sb;
323 }
324
325 /*
326  * Read a character and ensure that it is positive (except EOF).
327  * Increment line count(s) if necessary.
328  */
329 static int
330 inpc()
331 {
332         int     c;
333
334         if ((c = input()) != EOF && (c &= CHAR_MASK) == '\n')
335                 incline();
336         return (c);
337 }
338
339 static int
340 hash(s)
341         const   char *s;
342 {
343         u_int   v;
344         const   u_char *us;
345
346         v = 0;
347         for (us = (const u_char *)s; *us != '\0'; us++) {
348                 v = (v << sizeof (v)) + *us;
349                 v ^= v >> (sizeof (v) * CHAR_BIT - sizeof (v));
350         }
351         return (v % HSHSIZ1);
352 }
353
354 /*
355  * Lex has found a letter followed by zero or more letters or digits.
356  * It looks for a symbol in the symbol table with the same name. This
357  * symbol must either be a keyword or a symbol of the type required by
358  * symtyp (label, member, tag, ...).
359  *
360  * If it is a keyword, the token is returned. In some cases it is described
361  * more deeply by data written to yylval.
362  *
363  * If it is a symbol, T_NAME is returned and the pointer to a sbuf struct
364  * is stored in yylval. This struct contains the name of the symbol, it's
365  * length and hash value. If there is already a symbol of the same name
366  * and type in the symbol table, the sbuf struct also contains a pointer
367  * to the symbol table entry.
368  */
369 static int
370 name()
371 {
372         char    *s;
373         sbuf_t  *sb;
374         sym_t   *sym;
375         int     tok;
376
377         sb = allocsb();
378         sb->sb_name = yytext;
379         sb->sb_len = yyleng;
380         sb->sb_hash = hash(yytext);
381
382         if ((sym = search(sb)) != NULL && sym->s_keyw) {
383                 freesb(sb);
384                 return (keyw(sym));
385         }
386
387         sb->sb_sym = sym;
388
389         if (sym != NULL) {
390                 if (blklev < sym->s_blklev)
391                         lerror("name() 1");
392                 sb->sb_name = sym->s_name;
393                 sb->sb_len = strlen(sym->s_name);
394                 tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
395         } else {
396                 s = getblk(yyleng + 1);
397                 (void)memcpy(s, yytext, yyleng + 1);
398                 sb->sb_name = s;
399                 sb->sb_len = yyleng;
400                 tok = T_NAME;
401         }
402
403         yylval.y_sb = sb;
404         return (tok);
405 }
406
407 static sym_t *
408 search(sb)
409         sbuf_t  *sb;
410 {
411         sym_t   *sym;
412
413         for (sym = symtab[sb->sb_hash]; sym != NULL; sym = sym->s_link) {
414                 if (strcmp(sym->s_name, sb->sb_name) == 0) {
415                         if (sym->s_keyw || sym->s_kind == symtyp)
416                                 return (sym);
417                 }
418         }
419
420         return (NULL);
421 }
422
423 static int
424 keyw(sym)
425         sym_t   *sym;
426 {
427         int     t;
428
429         if ((t = (int)sym->s_value.v_quad) == T_SCLASS) {
430                 yylval.y_scl = sym->s_scl;
431         } else if (t == T_TYPE || t == T_SOU) {
432                 yylval.y_tspec = sym->s_tspec;
433         } else if (t == T_QUAL) {
434                 yylval.y_tqual = sym->s_tqual;
435         }
436         return (t);
437 }
438
439 /*
440  * Convert a string representing an integer into internal representation.
441  * The value is returned in yylval. icon() (and yylex()) returns T_CON.
442  */
443 static int
444 icon(base)
445         int     base;
446 {
447         int     l_suffix, u_suffix;
448         int     len;
449         const   char *cp;
450         char    c, *eptr;
451         tspec_t typ;
452         u_long  ul;
453         u_quad_t uq;
454         int     ansiu;
455         static  tspec_t contypes[2][3] = {
456                 { INT,  LONG,  QUAD },
457                 { UINT, ULONG, UQUAD }
458         };
459
460         cp = yytext;
461         len = yyleng;
462
463         /* skip 0x */
464         if (base == 16) {
465                 cp += 2;
466                 len -= 2;
467         }
468
469         /* read suffixes */
470         l_suffix = u_suffix = 0;
471         for ( ; ; ) {
472                 if ((c = cp[len - 1]) == 'l' || c == 'L') {
473                         l_suffix++;
474                 } else if (c == 'u' || c == 'U') {
475                         u_suffix++;
476                 } else {
477                         break;
478                 }
479                 len--;
480         }
481         if (l_suffix > 2 || u_suffix > 1) {
482                 /* malformed integer constant */
483                 warning(251);
484                 if (l_suffix > 2)
485                         l_suffix = 2;
486                 if (u_suffix > 1)
487                         u_suffix = 1;
488         }
489         if (tflag && u_suffix != 0) {
490                 /* suffix U is illegal in traditional C */
491                 warning(97);
492         }
493         typ = contypes[u_suffix][l_suffix];
494
495         errno = 0;
496         if (l_suffix < 2) {
497                 ul = strtoul(cp, &eptr, base);
498         } else {
499                 uq = strtouq(cp, &eptr, base);
500         }
501         if (eptr != cp + len)
502                 lerror("icon() 1");
503         if (errno != 0)
504                 /* integer constant out of range */
505                 warning(252);
506
507         /*
508          * If the value is to big for the current type, we must choose
509          * another type.
510          */
511         ansiu = 0;
512         switch (typ) {
513         case INT:
514                 if (ul <= INT_MAX) {
515                         /* ok */
516                 } else if (ul <= (unsigned)UINT_MAX && base != 10) {
517                         typ = UINT;
518                 } else if (ul <= LONG_MAX) {
519                         typ = LONG;
520                 } else {
521                         typ = ULONG;
522                 }
523                 if (typ == UINT || typ == ULONG) {
524                         if (tflag) {
525                                 typ = LONG;
526                         } else if (!sflag) {
527                                 /*
528                                  * Remember that the constant is unsigned
529                                  * only in ANSI C
530                                  */
531                                 ansiu = 1;
532                         }
533                 }
534                 break;
535         case UINT:
536                 if (ul > (u_int)UINT_MAX)
537                         typ = ULONG;
538                 break;
539         case LONG:
540                 if (ul > LONG_MAX && !tflag) {
541                         typ = ULONG;
542                         if (!sflag)
543                                 ansiu = 1;
544                 }
545                 break;
546         case QUAD:
547                 if (uq > QUAD_MAX && !tflag) {
548                         typ = UQUAD;
549                         if (!sflag)
550                                 ansiu = 1;
551                 }
552                 break;
553                 /* LINTED (enumeration values not handled in switch) */
554         default:
555                 break;
556         }
557
558         if (typ != QUAD && typ != UQUAD) {
559                 if (isutyp(typ)) {
560                         uq = ul;
561                 } else {
562                         uq = (quad_t)(long)ul;
563                 }
564         }
565
566         uq = (u_quad_t)xsign((quad_t)uq, typ, -1);
567
568         (yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
569         yylval.y_val->v_ansiu = ansiu;
570         yylval.y_val->v_quad = (quad_t)uq;
571
572         return (T_CON);
573 }
574
575 /*
576  * Returns 1 if t is a signed type and the value is negative.
577  *
578  * len is the number of significant bits. If len is -1, len is set
579  * to the width of type t.
580  */
581 int
582 sign(q, t, len)
583         quad_t  q;
584         tspec_t t;
585         int     len;
586 {
587         if (t == PTR || isutyp(t))
588                 return (0);
589         return (msb(q, t, len));
590 }
591
592 int
593 msb(q, t, len)
594         quad_t  q;
595         tspec_t t;
596         int     len;
597 {
598         if (len <= 0)
599                 len = size(t);
600         return ((q & qbmasks[len - 1]) != 0);
601 }
602
603 /*
604  * Extends the sign of q.
605  */
606 quad_t
607 xsign(q, t, len)
608         quad_t  q;
609         tspec_t t;
610         int     len;
611 {
612         if (len <= 0)
613                 len = size(t);
614
615         if (t == PTR || isutyp(t) || !sign(q, t, len)) {
616                 q &= qlmasks[len];
617         } else {
618                 q |= qumasks[len];
619         }
620         return (q);
621 }
622
623 /*
624  * Convert a string representing a floating point value into its interal
625  * representation. Type and value are returned in yylval. fcon()
626  * (and yylex()) returns T_CON.
627  * XXX Currently it is not possible to convert constants of type
628  * long double which are greater then DBL_MAX.
629  */
630 static int
631 fcon()
632 {
633         const   char *cp;
634         int     len;
635         tspec_t typ;
636         char    c, *eptr;
637         double  d;
638         float   f;
639
640         cp = yytext;
641         len = yyleng;
642
643         if ((c = cp[len - 1]) == 'f' || c == 'F') {
644                 typ = FLOAT;
645                 len--;
646         } else if (c == 'l' || c == 'L') {
647                 typ = LDOUBLE;
648                 len--;
649         } else {
650                 typ = DOUBLE;
651         }
652
653         if (tflag && typ != DOUBLE) {
654                 /* suffixes F and L are illegal in traditional C */
655                 warning(98);
656         }
657
658         errno = 0;
659         d = strtod(cp, &eptr);
660         if (eptr != cp + len)
661                 lerror("fcon() 1");
662         if (errno != 0)
663                 /* floating-point constant out of range */
664                 warning(248);
665
666         if (typ == FLOAT) {
667                 f = (float)d;
668                 if (isinf(f)) {
669                         /* floating-point constant out of range */
670                         warning(248);
671                         f = f > 0 ? FLT_MAX : -FLT_MAX;
672                 }
673         }
674
675         (yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
676         if (typ == FLOAT) {
677                 yylval.y_val->v_ldbl = f;
678         } else {
679                 yylval.y_val->v_ldbl = d;
680         }
681
682         return (T_CON);
683 }
684
685 static int
686 operator(t, o)
687         int     t;
688         op_t    o;
689 {
690         yylval.y_op = o;
691         return (t);
692 }
693
694 /*
695  * Called if lex found a leading \'.
696  */
697 static int
698 ccon()
699 {
700         int     n, val, c;
701         char    cv;
702
703         n = 0;
704         val = 0;
705         while ((c = getescc('\'')) >= 0) {
706                 val = (val << CHAR_BIT) + c;
707                 n++;
708         }
709         if (c == -2) {
710                 /* unterminated character constant */
711                 error(253);
712         } else {
713                 if (n > sizeof (int) || (n > 1 && (pflag || hflag))) {
714                         /* too many characters in character constant */
715                         error(71);
716                 } else if (n > 1) {
717                         /* multi-character character constant */
718                         warning(294);
719                 } else if (n == 0) {
720                         /* empty character constant */
721                         error(73);
722                 }
723         }
724         if (n == 1) {
725                 cv = (char)val;
726                 val = cv;
727         }
728
729         yylval.y_val = xcalloc(1, sizeof (val_t));
730         yylval.y_val->v_tspec = INT;
731         yylval.y_val->v_quad = val;
732
733         return (T_CON);
734 }
735
736 /*
737  * Called if lex found a leading L\'
738  */
739 static int
740 wccon()
741 {
742         static  char buf[MB_LEN_MAX + 1];
743         int     i, c;
744         wchar_t wc;
745
746         i = 0;
747         while ((c = getescc('\'')) >= 0) {
748                 if (i < MB_CUR_MAX)
749                         buf[i] = (char)c;
750                 i++;
751         }
752
753         wc = 0;
754
755         if (c == -2) {
756                 /* unterminated character constant */
757                 error(253);
758         } else if (c == 0) {
759                 /* empty character constant */
760                 error(73);
761         } else {
762                 if (i > MB_CUR_MAX) {
763                         i = MB_CUR_MAX;
764                         /* too many characters in character constant */
765                         error(71);
766                 } else {
767                         buf[i] = '\0';
768                         (void)mbtowc(NULL, NULL, 0);
769                         if (mbtowc(&wc, buf, MB_CUR_MAX) < 0)
770                                 /* invalid multibyte character */
771                                 error(291);
772                 }
773         }
774
775         yylval.y_val = xcalloc(1, sizeof (val_t));
776         yylval.y_val->v_tspec = WCHAR;
777         yylval.y_val->v_quad = wc;
778
779         return (T_CON);
780 }
781
782 /*
783  * Read a character which is part of a character constant or of a string
784  * and handle escapes.
785  *
786  * The Argument is the character which delimits the character constant or
787  * string.
788  *
789  * Returns -1 if the end of the character constant or string is reached,
790  * -2 if the EOF is reached, and the charachter otherwise.
791  */
792 static int
793 getescc(d)
794         int     d;
795 {
796         static  int pbc = -1;
797         int     n, c, v;
798
799         if (pbc == -1) {
800                 c = inpc();
801         } else {
802                 c = pbc;
803                 pbc = -1;
804         }
805         if (c == d)
806                 return (-1);
807         switch (c) {
808         case '\n':
809                 /* newline in string or char constant */
810                 error(254);
811                 return (-2);
812         case EOF:
813                 return (-2);
814         case '\\':
815                 switch (c = inpc()) {
816                 case '"':
817                         if (tflag && d == '\'')
818                                 /* \" inside character constant undef. ... */
819                                 warning(262);
820                         return ('"');
821                 case '\'':
822                         return ('\'');
823                 case '?':
824                         if (tflag)
825                                 /* \? undefined in traditional C */
826                                 warning(263);
827                         return ('?');
828                 case '\\':
829                         return ('\\');
830                 case 'a':
831                         if (tflag)
832                                 /* \a undefined in traditional C */
833                                 warning(81);
834                         return ('\a');
835                 case 'b':
836                         return ('\b');
837                 case 'f':
838                         return ('\f');
839                 case 'n':
840                         return ('\n');
841                 case 'r':
842                         return ('\r');
843                 case 't':
844                         return ('\t');
845                 case 'v':
846                         if (tflag)
847                                 /* \v undefined in traditional C */
848                                 warning(264);
849                         return ('\v');
850                 case '8': case '9':
851                         /* bad octal digit %c */
852                         warning(77, c);
853                         /* FALLTHROUGH */
854                 case '0': case '1': case '2': case '3':
855                 case '4': case '5': case '6': case '7':
856                         n = 3;
857                         v = 0;
858                         do {
859                                 v = (v << 3) + (c - '0');
860                                 c = inpc();
861                         } while (--n && isdigit(c) && (tflag || c <= '7'));
862                         if (tflag && n > 0 && isdigit(c))
863                                 /* bad octal digit %c */
864                                 warning(77, c);
865                         pbc = c;
866                         if (v > UCHAR_MAX) {
867                                 /* character escape does not fit in char. */
868                                 warning(76);
869                                 v &= CHAR_MASK;
870                         }
871                         return (v);
872                 case 'x':
873                         if (tflag)
874                                 /* \x undefined in traditional C */
875                                 warning(82);
876                         v = 0;
877                         n = 0;
878                         while ((c = inpc()) >= 0 && isxdigit(c)) {
879                                 c = isdigit(c) ?
880                                         c - '0' : toupper(c) - 'A' + 10;
881                                 v = (v << 4) + c;
882                                 if (n >= 0) {
883                                         if ((v & ~CHAR_MASK) != 0) {
884                                                 /* overflow in hex escape */
885                                                 warning(75);
886                                                 n = -1;
887                                         } else {
888                                                 n++;
889                                         }
890                                 }
891                         }
892                         pbc = c;
893                         if (n == 0) {
894                                 /* no hex digits follow \x */
895                                 error(74);
896                         } if (n == -1) {
897                                 v &= CHAR_MASK;
898                         }
899                         return (v);
900                 case '\n':
901                         return (getescc(d));
902                 case EOF:
903                         return (-2);
904                 default:
905                         if (isprint(c)) {
906                                 /* dubious escape \%c */
907                                 warning(79, c);
908                         } else {
909                                 /* dubious escape \%o */
910                                 warning(80, c);
911                         }
912                 }
913         }
914         return (c);
915 }
916
917 /*
918  * Called for preprocessor directives. Currently implemented are:
919  *      # lineno
920  *      # lineno "filename"
921  */
922 static void
923 directive()
924 {
925         const   char *cp, *fn;
926         char    c, *eptr;
927         size_t  fnl;
928         long    ln;
929         static  int first = 1;
930
931         /* Go to first non-whitespace after # */
932         for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++) ;
933
934         if (!isdigit(c)) {
935         error:
936                 /* undefined or invalid # directive */
937                 warning(255);
938                 return;
939         }
940         ln = strtol(--cp, &eptr, 10);
941         if (cp == eptr)
942                 goto error;
943         if ((c = *(cp = eptr)) != ' ' && c != '\t' && c != '\0')
944                 goto error;
945         while ((c = *cp++) == ' ' || c == '\t') ;
946         if (c != '\0') {
947                 if (c != '"')
948                         goto error;
949                 fn = cp;
950                 while ((c = *cp) != '"' && c != '\0')
951                         cp++;
952                 if (c != '"')
953                         goto error;
954                 if ((fnl = cp++ - fn) > PATH_MAX)
955                         goto error;
956                 while ((c = *cp++) == ' ' || c == '\t') ;
957 #if 0
958                 if (c != '\0')
959                         warning("extra character(s) after directive");
960 #endif
961                 curr_pos.p_file = fnnalloc(fn, fnl);
962                 /*
963                  * If this is the first directive, the name is the name
964                  * of the C source file as specified at the command line.
965                  * It is written to the output file.
966                  */
967                 if (first) {
968                         csrc_pos.p_file = curr_pos.p_file;
969                         outsrc(curr_pos.p_file);
970                         first = 0;
971                 }
972         }
973         curr_pos.p_line = (int)ln - 1;
974         if (curr_pos.p_file == csrc_pos.p_file)
975                 csrc_pos.p_line = (int)ln - 1;
976 }
977
978 /*
979  * Handle lint comments. Following comments are currently understood:
980  *      ARGSUSEDn
981  *      CONSTCOND CONSTANTCOND CONSTANTCONDITION
982  *      FALLTHRU FALLTHROUGH
983  *      LINTLIBRARY
984  *      LINTED NOSTRICT
985  *      LONGLONG
986  *      NOTREACHED
987  *      PRINTFLIKEn
988  *      PROTOLIB
989  *      SCANFLIKEn
990  *      VARARGSn
991  * If one of this comments is recognized, the arguments, if any, are
992  * parsed and a function which handles this comment is called.
993  */
994 static void
995 comment()
996 {
997         int     c, lc;
998         static struct {
999                 const   char *keywd;
1000                 int     arg;
1001                 void    (*func)(int);
1002         } keywtab[] = {
1003                 { "ARGSUSED",           1,      argsused        },
1004                 { "CONSTCOND",          0,      constcond       },
1005                 { "CONSTANTCOND",       0,      constcond       },
1006                 { "CONSTANTCONDITION",  0,      constcond       },
1007                 { "FALLTHRU",           0,      fallthru        },
1008                 { "FALLTHROUGH",        0,      fallthru        },
1009                 { "LINTLIBRARY",        0,      lintlib         },
1010                 { "LINTED",             0,      linted          },
1011                 { "LONGLONG",           0,      longlong        },
1012                 { "NOSTRICT",           0,      linted          },
1013                 { "NOTREACHED",         0,      notreach        },
1014                 { "PRINTFLIKE",         1,      printflike      },
1015                 { "PROTOLIB",           1,      protolib        },
1016                 { "SCANFLIKE",          1,      scanflike       },
1017                 { "VARARGS",            1,      varargs         },
1018         };
1019         char    keywd[32];
1020         char    arg[32];
1021         int     l, i, a;
1022         int     eoc;
1023
1024         eoc = 0;
1025
1026         /* Skip white spaces after the start of the comment */
1027         while ((c = inpc()) != EOF && isspace(c)) ;
1028
1029         /* Read the potential keyword to keywd */
1030         l = 0;
1031         while (c != EOF && isupper(c) && l < sizeof (keywd) - 1) {
1032                 keywd[l++] = (char)c;
1033                 c = inpc();
1034         }
1035         keywd[l] = '\0';
1036
1037         /* look for the keyword */
1038         for (i = 0; i < sizeof (keywtab) / sizeof (keywtab[0]); i++) {
1039                 if (strcmp(keywtab[i].keywd, keywd) == 0)
1040                         break;
1041         }
1042         if (i == sizeof (keywtab) / sizeof (keywtab[0]))
1043                 goto skip_rest;
1044
1045         /* skip white spaces after the keyword */
1046         while (c != EOF && isspace(c))
1047                 c = inpc();
1048
1049         /* read the argument, if the keyword accepts one and there is one */
1050         l = 0;
1051         if (keywtab[i].arg) {
1052                 while (c != EOF && isdigit(c) && l < sizeof (arg) - 1) {
1053                         arg[l++] = (char)c;
1054                         c = inpc();
1055                 }
1056         }
1057         arg[l] = '\0';
1058         a = l != 0 ? atoi(arg) : -1;
1059
1060         /* skip white spaces after the argument */
1061         while (c != EOF && isspace(c))
1062                 c = inpc();
1063
1064         if (c != '*' || (c = inpc()) != '/') {
1065                 if (keywtab[i].func != linted)
1066                         /* extra characters in lint comment */
1067                         warning(257);
1068         } else {
1069                 /*
1070                  * remember that we have already found the end of the
1071                  * comment
1072                  */
1073                 eoc = 1;
1074         }
1075
1076         if (keywtab[i].func != NULL)
1077                 (*keywtab[i].func)(a);
1078
1079  skip_rest:
1080         while (!eoc) {
1081                 lc = c;
1082                 if ((c = inpc()) == EOF) {
1083                         /* unterminated comment */
1084                         error(256);
1085                         break;
1086                 }
1087                 if (lc == '*' && c == '/')
1088                         eoc = 1;
1089         }
1090 }
1091
1092 /*
1093  * Clear flags for lint comments LINTED, LONGLONG and CONSTCOND.
1094  * clrwflgs() is called after function definitions and global and
1095  * local declarations and definitions. It is also called between
1096  * the controlling expression and the body of control statements
1097  * (if, switch, for, while).
1098  */
1099 void
1100 clrwflgs()
1101 {
1102         nowarn = 0;
1103         quadflg = 0;
1104         ccflg = 0;
1105 }
1106
1107 /*
1108  * Strings are stored in a dynamically alloceted buffer and passed
1109  * in yylval.y_xstrg to the parser. The parser or the routines called
1110  * by the parser are responsible for freeing this buffer.
1111  */
1112 static int
1113 string()
1114 {
1115         u_char  *s;
1116         int     c;
1117         size_t  len, max;
1118         strg_t  *strg;
1119
1120         s = xmalloc(max = 64);
1121
1122         len = 0;
1123         while ((c = getescc('"')) >= 0) {
1124                 /* +1 to reserve space for a trailing NUL character */
1125                 if (len + 1 == max)
1126                         s = xrealloc(s, max *= 2);
1127                 s[len++] = (char)c;
1128         }
1129         s[len] = '\0';
1130         if (c == -2)
1131                 /* unterminated string constant */
1132                 error(258);
1133
1134         strg = xcalloc(1, sizeof (strg_t));
1135         strg->st_tspec = CHAR;
1136         strg->st_len = len;
1137         strg->st_cp = s;
1138
1139         yylval.y_strg = strg;
1140         return (T_STRING);
1141 }
1142
1143 static int
1144 wcstrg()
1145 {
1146         char    *s;
1147         int     c, i, n, wi;
1148         size_t  len, max, wlen;
1149         wchar_t *ws;
1150         strg_t  *strg;
1151
1152         s = xmalloc(max = 64);
1153         len = 0;
1154         while ((c = getescc('"')) >= 0) {
1155                 /* +1 to save space for a trailing NUL character */
1156                 if (len + 1 >= max)
1157                         s = xrealloc(s, max *= 2);
1158                 s[len++] = (char)c;
1159         }
1160         s[len] = '\0';
1161         if (c == -2)
1162                 /* unterminated string constant */
1163                 error(258);
1164
1165         /* get length of wide character string */
1166         (void)mblen(NULL, 0);
1167         for (i = 0, wlen = 0; i < len; i += n, wlen++) {
1168                 if ((n = mblen(&s[i], MB_CUR_MAX)) == -1) {
1169                         /* invalid multibyte character */
1170                         error(291);
1171                         break;
1172                 }
1173                 if (n == 0)
1174                         n = 1;
1175         }
1176
1177         ws = xmalloc((wlen + 1) * sizeof (wchar_t));
1178
1179         /* convert from multibyte to wide char */
1180         (void)mbtowc(NULL, NULL, 0);
1181         for (i = 0, wi = 0; i < len; i += n, wi++) {
1182                 if ((n = mbtowc(&ws[wi], &s[i], MB_CUR_MAX)) == -1)
1183                         break;
1184                 if (n == 0)
1185                         n = 1;
1186         }
1187         ws[wi] = 0;
1188         free(s);
1189
1190         strg = xcalloc(1, sizeof (strg_t));
1191         strg->st_tspec = WCHAR;
1192         strg->st_len = wlen;
1193         strg->st_wcp = ws;
1194
1195         yylval.y_strg = strg;
1196         return (T_STRING);
1197 }
1198
1199 /*
1200  * As noted above the scanner does not create new symbol table entries
1201  * for symbols it cannot find in the symbol table. This is to avoid
1202  * putting undeclared symbols into the symbol table if a syntax error
1203  * occurs.
1204  *
1205  * getsym() is called as soon as it is probably ok to put the symbol to
1206  * the symbol table. This does not mean that it is not possible that
1207  * symbols are put to the symbol table which are than not completely
1208  * declared due to syntax errors. To avoid too many problems in this
1209  * case symbols get type int in getsym().
1210  *
1211  * XXX calls to getsym() should be delayed until decl1*() is called
1212  */
1213 sym_t *
1214 getsym(sb)
1215         sbuf_t  *sb;
1216 {
1217         dinfo_t *di;
1218         char    *s;
1219         sym_t   *sym;
1220
1221         sym = sb->sb_sym;
1222
1223         /*
1224          * During member declaration it is possible that name() looked
1225          * for symbols of type FVFT, although it should have looked for
1226          * symbols of type FTAG. Same can happen for labels. Both cases
1227          * are compensated here.
1228          */
1229         if (symtyp == FMOS || symtyp == FLAB) {
1230                 if (sym == NULL || sym->s_kind == FVFT)
1231                         sym = search(sb);
1232         }
1233
1234         if (sym != NULL) {
1235                 if (sym->s_kind != symtyp)
1236                         lerror("storesym() 1");
1237                 symtyp = FVFT;
1238                 freesb(sb);
1239                 return (sym);
1240         }
1241
1242         /* create a new symbol table entry */
1243
1244         /* labels must always be allocated at level 1 (outhermost block) */
1245         if (symtyp == FLAB) {
1246                 sym = getlblk(1, sizeof (sym_t));
1247                 s = getlblk(1, sb->sb_len + 1);
1248                 (void)memcpy(s, sb->sb_name, sb->sb_len + 1);
1249                 sym->s_name = s;
1250                 sym->s_blklev = 1;
1251                 di = dcs;
1252                 while (di->d_nxt != NULL && di->d_nxt->d_nxt != NULL)
1253                         di = di->d_nxt;
1254                 if (di->d_ctx != AUTO)
1255                         lerror("storesym() 2");
1256         } else {
1257                 sym = getblk(sizeof (sym_t));
1258                 sym->s_name = sb->sb_name;
1259                 sym->s_blklev = blklev;
1260                 di = dcs;
1261         }
1262
1263         STRUCT_ASSIGN(sym->s_dpos, curr_pos);
1264         if ((sym->s_kind = symtyp) != FLAB)
1265                 sym->s_type = gettyp(INT);
1266
1267         symtyp = FVFT;
1268
1269         if ((sym->s_link = symtab[sb->sb_hash]) != NULL)
1270                 symtab[sb->sb_hash]->s_rlink = &sym->s_link;
1271         (symtab[sb->sb_hash] = sym)->s_rlink = &symtab[sb->sb_hash];
1272
1273         *di->d_ldlsym = sym;
1274         di->d_ldlsym = &sym->s_dlnxt;
1275
1276         freesb(sb);
1277         return (sym);
1278 }
1279
1280 /*
1281  * Remove a symbol forever from the symbol table. s_blklev
1282  * is set to -1 to avoid that the symbol will later be put
1283  * back to the symbol table.
1284  */
1285 void
1286 rmsym(sym)
1287         sym_t   *sym;
1288 {
1289         if ((*sym->s_rlink = sym->s_link) != NULL)
1290                 sym->s_link->s_rlink = sym->s_rlink;
1291         sym->s_blklev = -1;
1292         sym->s_link = NULL;
1293 }
1294
1295 /*
1296  * Remove a list of symbols declared at one level from the symbol
1297  * table.
1298  */
1299 void
1300 rmsyms(syms)
1301         sym_t   *syms;
1302 {
1303         sym_t   *sym;
1304
1305         for (sym = syms; sym != NULL; sym = sym->s_dlnxt) {
1306                 if (sym->s_blklev != -1) {
1307                         if ((*sym->s_rlink = sym->s_link) != NULL)
1308                                 sym->s_link->s_rlink = sym->s_rlink;
1309                         sym->s_link = NULL;
1310                         sym->s_rlink = NULL;
1311                 }
1312         }
1313 }
1314
1315 /*
1316  * Put a symbol into the symbol table
1317  */
1318 void
1319 inssym(bl, sym)
1320         int     bl;
1321         sym_t   *sym;
1322 {
1323         int     h;
1324
1325         h = hash(sym->s_name);
1326         if ((sym->s_link = symtab[h]) != NULL)
1327                 symtab[h]->s_rlink = &sym->s_link;
1328         (symtab[h] = sym)->s_rlink = &symtab[h];
1329         sym->s_blklev = bl;
1330         if (sym->s_link != NULL && sym->s_blklev < sym->s_link->s_blklev)
1331                 lerror("inssym()");
1332 }
1333
1334 /*
1335  * Called at level 0 after syntax errors
1336  * Removes all symbols which are not declared at level 0 from the
1337  * symbol table. Also frees all memory which is not associated with
1338  * level 0.
1339  */
1340 void
1341 cleanup()
1342 {
1343         sym_t   *sym, *nsym;
1344         int     i;
1345
1346         for (i = 0; i < HSHSIZ1; i++) {
1347                 for (sym = symtab[i]; sym != NULL; sym = nsym) {
1348                         nsym = sym->s_link;
1349                         if (sym->s_blklev >= 1) {
1350                                 if ((*sym->s_rlink = nsym) != NULL)
1351                                         nsym->s_rlink = sym->s_rlink;
1352                         }
1353                 }
1354         }
1355
1356         for (i = mblklev; i > 0; i--)
1357                 freelblk(i);
1358 }
1359
1360 /*
1361  * Create a new symbol with the name of an existing symbol.
1362  */
1363 sym_t *
1364 pushdown(sym)
1365         sym_t   *sym;
1366 {
1367         int     h;
1368         sym_t   *nsym;
1369
1370         h = hash(sym->s_name);
1371         nsym = getblk(sizeof (sym_t));
1372         if (sym->s_blklev > blklev)
1373                 lerror("pushdown()");
1374         nsym->s_name = sym->s_name;
1375         STRUCT_ASSIGN(nsym->s_dpos, curr_pos);
1376         nsym->s_kind = sym->s_kind;
1377         nsym->s_blklev = blklev;
1378
1379         if ((nsym->s_link = symtab[h]) != NULL)
1380                 symtab[h]->s_rlink = &nsym->s_link;
1381         (symtab[h] = nsym)->s_rlink = &symtab[h];
1382
1383         *dcs->d_ldlsym = nsym;
1384         dcs->d_ldlsym = &nsym->s_dlnxt;
1385
1386         return (nsym);
1387 }
1388
1389 /*
1390  * Free any dynamically allocated memory referenced by
1391  * the value stack or yylval.
1392  * The type of information in yylval is described by tok.
1393  */
1394 void
1395 freeyyv(sp, tok)
1396         void    *sp;
1397         int     tok;
1398 {
1399         if (tok == T_NAME || tok == T_TYPENAME) {
1400                 sbuf_t *sb = *(sbuf_t **)sp;
1401                 freesb(sb);
1402         } else if (tok == T_CON) {
1403                 val_t *val = *(val_t **)sp;
1404                 free(val);
1405         } else if (tok == T_STRING) {
1406                 strg_t *strg = *(strg_t **)sp;
1407                 if (strg->st_tspec == CHAR) {
1408                         free(strg->st_cp);
1409                 } else if (strg->st_tspec == WCHAR) {
1410                         free(strg->st_wcp);
1411                 } else {
1412                         lerror("fryylv() 1");
1413                 }
1414                 free(strg);
1415         }
1416 }