1 /* $NetBSD: func.c,v 1.22 2005/09/24 15:30:35 perry Exp $ */
2
3 /*
4 * Copyright (c) 1994, 1995 Jochen Pohl
5 * All Rights Reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Jochen Pohl for
18 * The NetBSD Project.
19 * 4. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <sys/cdefs.h>
35 #if defined(__RCSID) && !defined(lint)
36 __RCSID("$NetBSD: func.c,v 1.16 2002/01/03 04:25:15 thorpej Exp $");
37 #endif
38 __FBSDID("$FreeBSD: stable/10/usr.bin/xlint/lint1/func.c 281168 2015-04-06 19:56:27Z pfg $");
39
40 #include <stdlib.h>
41 #include <string.h>
42
43 #include "lint1.h"
44 #include "cgram.h"
45
46 /*
47 * Contains a pointer to the symbol table entry of the current function
48 * definition.
49 */
50 sym_t *funcsym;
51
52 /* Is set as long as a statement can be reached. Must be set at level 0. */
53 int reached = 1;
54
55 /*
56 * Is set as long as NOTREACHED is in effect.
57 * Is reset everywhere where reached can become 0.
58 */
59 int rchflg;
60
61 /*
62 * In conjunction with reached controls printing of "fallthrough on ..."
63 * warnings.
64 * Reset by each statement and set by FALLTHROUGH, switch (switch1())
65 * and case (label()).
66 *
67 * Control statements if, for, while and switch do not reset ftflg because
68 * this must be done by the controlled statement. At least for if this is
69 * important because ** FALLTHROUGH ** after "if (expr) stmnt" is evaluated
70 * before the following token, which causes reduction of above, is read.
71 * This means that ** FALLTHROUGH ** after "if ..." would always be ignored.
72 */
73 int ftflg;
74
75 /* Top element of stack for control statements */
76 cstk_t *cstk;
77
78 /*
79 * Number of arguments which will be checked for usage in following
80 * function definition. -1 stands for all arguments.
81 *
82 * The position of the last ARGSUSED comment is stored in aupos.
83 */
84 int nargusg = -1;
85 pos_t aupos;
86
87 /*
88 * Number of arguments of the following function definition whose types
89 * shall be checked by lint2. -1 stands for all arguments.
90 *
91 * The position of the last VARARGS comment is stored in vapos.
92 */
93 int nvararg = -1;
94 pos_t vapos;
95
96 /*
97 * Both prflstr and scflstrg contain the number of the argument which
98 * shall be used to check the types of remaining arguments (for PRINTFLIKE
99 * and SCANFLIKE).
100 *
101 * prflpos and scflpos are the positions of the last PRINTFLIKE or
102 * SCANFLIKE comment.
103 */
104 int prflstrg = -1;
105 int scflstrg = -1;
106 pos_t prflpos;
107 pos_t scflpos;
108
109 /*
110 * Are both plibflg and llibflg set, prototypes are written as function
111 * definitions to the output file.
112 */
113 int plibflg;
114
115 /*
116 * Nonzero means that no warnings about constants in conditional
117 * context are printed.
118 */
119 int ccflg;
120
121 /*
122 * llibflg is set if a lint library shall be created. The effect of
123 * llibflg is that all defined symbols are treated as used.
124 * (The LINTLIBRARY comment also resets vflag.)
125 */
126 int llibflg;
127
128 /*
129 * Nonzero if warnings are suppressed by a LINTED directive
130 */
131 int nowarn;
132
133 /*
134 * Nonzero if bitfield type errors are suppressed by a BITFIELDTYPE
135 * directive.
136 */
137 int bitfieldtype_ok;
138
139 /*
140 * Nonzero if complaints about use of "long long" are suppressed in
141 * the next statement or declaration.
142 */
143 int quadflg;
144
145 /*
146 * Puts a new element at the top of the stack used for control statements.
147 */
148 void
pushctrl(int env)149 pushctrl(int env)
150 {
151 cstk_t *ci;
152
153 if ((ci = calloc(1, sizeof (cstk_t))) == NULL)
154 nomem();
155 ci->c_env = env;
156 ci->c_nxt = cstk;
157 cstk = ci;
158 }
159
160 /*
161 * Removes the top element of the stack used for control statements.
162 */
163 void
popctrl(int env)164 popctrl(int env)
165 {
166 cstk_t *ci;
167 clst_t *cl;
168
169 if (cstk == NULL || cstk->c_env != env)
170 LERROR("popctrl()");
171
172 cstk = (ci = cstk)->c_nxt;
173
174 while ((cl = ci->c_clst) != NULL) {
175 ci->c_clst = cl->cl_nxt;
176 free(cl);
177 }
178
179 if (ci->c_swtype != NULL)
180 free(ci->c_swtype);
181
182 free(ci);
183 }
184
185 /*
186 * Prints a warning if a statement cannot be reached.
187 */
188 void
chkreach(void)189 chkreach(void)
190 {
191 if (!reached && !rchflg) {
192 /* statement not reached */
193 warning(193);
194 reached = 1;
195 }
196 }
197
198 /*
199 * Called after a function declaration which introduces a function definition
200 * and before an (optional) old style argument declaration list.
201 *
202 * Puts all symbols declared in the Prototype or in an old style argument
203 * list back to the symbol table.
204 *
205 * Does the usual checking of storage class, type (return value),
206 * redeclaration etc..
207 */
208 void
funcdef(sym_t * fsym)209 funcdef(sym_t *fsym)
210 {
211 int n, warn;
212 sym_t *arg, *sym, *rdsym;
213
214 funcsym = fsym;
215
216 /*
217 * Put all symbols declared in the argument list back to the
218 * symbol table.
219 */
220 for (sym = dcs->d_fpsyms; sym != NULL; sym = sym->s_dlnxt) {
221 if (sym->s_blklev != -1) {
222 if (sym->s_blklev != 1)
223 LERROR("funcdef()");
224 inssym(1, sym);
225 }
226 }
227
228 /*
229 * In osfunc() we did not know whether it is an old style function
230 * definition or only an old style declaration, if there are no
231 * arguments inside the argument list ("f()").
232 */
233 if (!fsym->s_type->t_proto && fsym->s_args == NULL)
234 fsym->s_osdef = 1;
235
236 chktyp(fsym);
237
238 /*
239 * chktyp() checks for almost all possible errors, but not for
240 * incomplete return values (these are allowed in declarations)
241 */
242 if (fsym->s_type->t_subt->t_tspec != VOID &&
243 incompl(fsym->s_type->t_subt)) {
244 /* cannot return incomplete type */
245 error(67);
246 }
247
248 fsym->s_def = DEF;
249
250 if (fsym->s_scl == TYPEDEF) {
251 fsym->s_scl = EXTERN;
252 /* illegal storage class */
253 error(8);
254 }
255
256 if (dcs->d_inline)
257 fsym->s_inline = 1;
258
259 /*
260 * Arguments in new style function declarations need a name.
261 * (void is already removed from the list of arguments)
262 */
263 n = 1;
264 for (arg = fsym->s_type->t_args; arg != NULL; arg = arg->s_nxt) {
265 if (arg->s_scl == ABSTRACT) {
266 if (arg->s_name != unnamed)
267 LERROR("funcdef()");
268 /* formal parameter lacks name: param #%d */
269 error(59, n);
270 } else {
271 if (arg->s_name == unnamed)
272 LERROR("funcdef()");
273 }
274 n++;
275 }
276
277 /*
278 * We must also remember the position. s_dpos is overwritten
279 * if this is an old style definition and we had already a
280 * prototype.
281 */
282 STRUCT_ASSIGN(dcs->d_fdpos, fsym->s_dpos);
283
284 if ((rdsym = dcs->d_rdcsym) != NULL) {
285
286 if (!isredec(fsym, (warn = 0, &warn))) {
287
288 /*
289 * Print nothing if the newly defined function
290 * is defined in old style. A better warning will
291 * be printed in cluparg().
292 */
293 if (warn && !fsym->s_osdef) {
294 /* redeclaration of %s */
295 (*(sflag ? error : warning))(27, fsym->s_name);
296 prevdecl(-1, rdsym);
297 }
298
299 /* copy usage information */
300 cpuinfo(fsym, rdsym);
301
302 /*
303 * If the old symbol was a prototype and the new
304 * one is none, overtake the position of the
305 * declaration of the prototype.
306 */
307 if (fsym->s_osdef && rdsym->s_type->t_proto)
308 STRUCT_ASSIGN(fsym->s_dpos, rdsym->s_dpos);
309
310 /* complete the type */
311 compltyp(fsym, rdsym);
312
313 /* once a function is inline it remains inline */
314 if (rdsym->s_inline)
315 fsym->s_inline = 1;
316
317 }
318
319 /* remove the old symbol from the symbol table */
320 rmsym(rdsym);
321
322 }
323
324 if (fsym->s_osdef && !fsym->s_type->t_proto) {
325 if (sflag && hflag && strcmp(fsym->s_name, "main") != 0)
326 /* function definition is not a prototype */
327 warning(286);
328 }
329
330 if (dcs->d_notyp)
331 /* return value is implicitly declared to be int */
332 fsym->s_rimpl = 1;
333
334 reached = 1;
335 }
336
337 /*
338 * Called at the end of a function definition.
339 */
340 void
funcend(void)341 funcend(void)
342 {
343 sym_t *arg;
344 int n;
345
346 if (reached) {
347 cstk->c_noretval = 1;
348 if (funcsym->s_type->t_subt->t_tspec != VOID &&
349 !funcsym->s_rimpl) {
350 /* func. %s falls off bottom without returning value */
351 warning(217, funcsym->s_name);
352 }
353 }
354
355 /*
356 * This warning is printed only if the return value was implicitly
357 * declared to be int. Otherwise the wrong return statement
358 * has already printed a warning.
359 */
360 if (cstk->c_noretval && cstk->c_retval && funcsym->s_rimpl)
361 /* function %s has return (e); and return; */
362 warning(216, funcsym->s_name);
363
364 /* Print warnings for unused arguments */
365 arg = dcs->d_fargs;
366 n = 0;
367 while (arg != NULL && (nargusg == -1 || n < nargusg)) {
368 chkusg1(dcs->d_asm, arg);
369 arg = arg->s_nxt;
370 n++;
371 }
372 nargusg = -1;
373
374 /*
375 * write the information about the function definition to the
376 * output file
377 * inline functions explicitly declared extern are written as
378 * declarations only.
379 */
380 if (dcs->d_scl == EXTERN && funcsym->s_inline) {
381 outsym(funcsym, funcsym->s_scl, DECL);
382 } else {
383 outfdef(funcsym, &dcs->d_fdpos, cstk->c_retval,
384 funcsym->s_osdef, dcs->d_fargs);
385 }
386
387 /*
388 * remove all symbols declared during argument declaration from
389 * the symbol table
390 */
391 if (dcs->d_nxt != NULL || dcs->d_ctx != EXTERN)
392 LERROR("funcend()");
393 rmsyms(dcs->d_fpsyms);
394
395 /* must be set on level 0 */
396 reached = 1;
397 }
398
399 /*
400 * Process a label.
401 *
402 * typ type of the label (T_NAME, T_DEFAULT or T_CASE).
403 * sym symbol table entry of label if typ == T_NAME
404 * tn expression if typ == T_CASE
405 */
406 void
label(int typ,sym_t * sym,tnode_t * tn)407 label(int typ, sym_t *sym, tnode_t *tn)
408 {
409 cstk_t *ci;
410 clst_t *cl;
411 val_t *v;
412 val_t nv;
413 tspec_t t;
414
415 switch (typ) {
416
417 case T_NAME:
418 if (sym->s_set) {
419 /* label %s redefined */
420 error(194, sym->s_name);
421 } else {
422 setsflg(sym);
423 }
424 break;
425
426 case T_CASE:
427
428 /* find the stack entry for the innermost switch statement */
429 for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt)
430 continue;
431
432 if (ci == NULL) {
433 /* case not in switch */
434 error(195);
435 tn = NULL;
436 } else if (tn != NULL && tn->tn_op != CON) {
437 /* non-constant case expression */
438 error(197);
439 tn = NULL;
440 } else if (tn != NULL && !isityp(tn->tn_type->t_tspec)) {
441 /* non-integral case expression */
442 error(198);
443 tn = NULL;
444 }
445
446 if (tn != NULL) {
447
448 if (ci->c_swtype == NULL)
449 LERROR("label()");
450
451 if (reached && !ftflg) {
452 if (hflag)
453 /* fallthrough on case statement */
454 warning(220);
455 }
456
457 t = tn->tn_type->t_tspec;
458 if (t == LONG || t == ULONG ||
459 t == QUAD || t == UQUAD) {
460 if (tflag)
461 /* case label must be of type ... */
462 warning(203);
463 }
464
465 /*
466 * get the value of the expression and convert it
467 * to the type of the switch expression
468 */
469 v = constant(tn, 1);
470 (void) memset(&nv, 0, sizeof nv);
471 cvtcon(CASE, 0, ci->c_swtype, &nv, v);
472 free(v);
473
474 /* look if we had this value already */
475 for (cl = ci->c_clst; cl != NULL; cl = cl->cl_nxt) {
476 if (cl->cl_val.v_quad == nv.v_quad)
477 break;
478 }
479 if (cl != NULL && isutyp(nv.v_tspec)) {
480 /* duplicate case in switch, %lu */
481 error(200, (u_long)nv.v_quad);
482 } else if (cl != NULL) {
483 /* duplicate case in switch, %ld */
484 error(199, (long)nv.v_quad);
485 } else {
486 /*
487 * append the value to the list of
488 * case values
489 */
490 cl = xcalloc(1, sizeof (clst_t));
491 STRUCT_ASSIGN(cl->cl_val, nv);
492 cl->cl_nxt = ci->c_clst;
493 ci->c_clst = cl;
494 }
495 }
496 tfreeblk();
497 break;
498
499 case T_DEFAULT:
500
501 /* find the stack entry for the innermost switch statement */
502 for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt)
503 continue;
504
505 if (ci == NULL) {
506 /* default outside switch */
507 error(201);
508 } else if (ci->c_default) {
509 /* duplicate default in switch */
510 error(202);
511 } else {
512 if (reached && !ftflg) {
513 if (hflag)
514 /* fallthrough on default statement */
515 warning(284);
516 }
517 ci->c_default = 1;
518 }
519 break;
520 };
521 reached = 1;
522 }
523
524 /*
525 * T_IF T_LPARN expr T_RPARN
526 */
527 void
if1(tnode_t * tn)528 if1(tnode_t *tn)
529 {
530
531 if (tn != NULL)
532 tn = cconv(tn);
533 if (tn != NULL)
534 tn = promote(NOOP, 0, tn);
535 expr(tn, 0, 1, 1);
536 pushctrl(T_IF);
537 }
538
539 /*
540 * if_without_else
541 * if_without_else T_ELSE
542 */
543 void
if2(void)544 if2(void)
545 {
546
547 cstk->c_rchif = reached ? 1 : 0;
548 reached = 1;
549 }
550
551 /*
552 * if_without_else
553 * if_without_else T_ELSE stmnt
554 */
555 void
if3(int els)556 if3(int els)
557 {
558
559 if (els) {
560 reached |= cstk->c_rchif;
561 } else {
562 reached = 1;
563 }
564 popctrl(T_IF);
565 }
566
567 /*
568 * T_SWITCH T_LPARN expr T_RPARN
569 */
570 void
switch1(tnode_t * tn)571 switch1(tnode_t *tn)
572 {
573 tspec_t t;
574 type_t *tp;
575
576 if (tn != NULL)
577 tn = cconv(tn);
578 if (tn != NULL)
579 tn = promote(NOOP, 0, tn);
580 if (tn != NULL && !isityp(tn->tn_type->t_tspec)) {
581 /* switch expression must have integral type */
582 error(205);
583 tn = NULL;
584 }
585 if (tn != NULL && tflag) {
586 t = tn->tn_type->t_tspec;
587 if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
588 /* switch expr. must be of type `int' in trad. C */
589 warning(271);
590 }
591 }
592
593 /*
594 * Remember the type of the expression. Because its possible
595 * that (*tp) is allocated on tree memory the type must be
596 * duplicated. This is not too complicated because it is
597 * only an integer type.
598 */
599 if ((tp = calloc(1, sizeof (type_t))) == NULL)
600 nomem();
601 if (tn != NULL) {
602 tp->t_tspec = tn->tn_type->t_tspec;
603 if ((tp->t_isenum = tn->tn_type->t_isenum) != 0)
604 tp->t_enum = tn->tn_type->t_enum;
605 } else {
606 tp->t_tspec = INT;
607 }
608
609 expr(tn, 1, 0, 1);
610
611 pushctrl(T_SWITCH);
612 cstk->c_switch = 1;
613 cstk->c_swtype = tp;
614
615 reached = rchflg = 0;
616 ftflg = 1;
617 }
618
619 /*
620 * switch_expr stmnt
621 */
622 void
switch2(void)623 switch2(void)
624 {
625 int nenum = 0, nclab = 0;
626 sym_t *esym;
627 clst_t *cl;
628
629 if (cstk->c_swtype == NULL)
630 LERROR("switch2()");
631
632 /*
633 * If the switch expression was of type enumeration, count the case
634 * labels and the number of enumerators. If both counts are not
635 * equal print a warning.
636 */
637 if (cstk->c_swtype->t_isenum) {
638 nenum = nclab = 0;
639 if (cstk->c_swtype->t_enum == NULL)
640 LERROR("switch2()");
641 for (esym = cstk->c_swtype->t_enum->elem;
642 esym != NULL; esym = esym->s_nxt) {
643 nenum++;
644 }
645 for (cl = cstk->c_clst; cl != NULL; cl = cl->cl_nxt)
646 nclab++;
647 if (hflag && eflag && nenum != nclab && !cstk->c_default) {
648 /* enumeration value(s) not handled in switch */
649 warning(206);
650 }
651 }
652
653 if (cstk->c_break) {
654 /*
655 * end of switch alway reached (c_break is only set if the
656 * break statement can be reached).
657 */
658 reached = 1;
659 } else if (!cstk->c_default &&
660 (!hflag || !cstk->c_swtype->t_isenum || nenum != nclab)) {
661 /*
662 * there are possible values which are not handled in
663 * switch
664 */
665 reached = 1;
666 } /*
667 * otherwise the end of the switch expression is reached
668 * if the end of the last statement inside it is reached.
669 */
670
671 popctrl(T_SWITCH);
672 }
673
674 /*
675 * T_WHILE T_LPARN expr T_RPARN
676 */
677 void
while1(tnode_t * tn)678 while1(tnode_t *tn)
679 {
680
681 if (!reached) {
682 /* loop not entered at top */
683 warning(207);
684 reached = 1;
685 }
686
687 if (tn != NULL)
688 tn = cconv(tn);
689 if (tn != NULL)
690 tn = promote(NOOP, 0, tn);
691 if (tn != NULL && !issclt(tn->tn_type->t_tspec)) {
692 /* controlling expressions must have scalar type */
693 error(204);
694 tn = NULL;
695 }
696
697 pushctrl(T_WHILE);
698 cstk->c_loop = 1;
699 if (tn != NULL && tn->tn_op == CON) {
700 if (isityp(tn->tn_type->t_tspec)) {
701 cstk->c_infinite = tn->tn_val->v_quad != 0;
702 } else {
703 cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
704 }
705 }
706
707 expr(tn, 0, 1, 1);
708 }
709
710 /*
711 * while_expr stmnt
712 * while_expr error
713 */
714 void
while2(void)715 while2(void)
716 {
717
718 /*
719 * The end of the loop can be reached if it is no endless loop
720 * or there was a break statement which was reached.
721 */
722 reached = !cstk->c_infinite || cstk->c_break;
723 rchflg = 0;
724
725 popctrl(T_WHILE);
726 }
727
728 /*
729 * T_DO
730 */
731 void
do1(void)732 do1(void)
733 {
734
735 if (!reached) {
736 /* loop not entered at top */
737 warning(207);
738 reached = 1;
739 }
740
741 pushctrl(T_DO);
742 cstk->c_loop = 1;
743 }
744
745 /*
746 * do stmnt do_while_expr
747 * do error
748 */
749 void
do2(tnode_t * tn)750 do2(tnode_t *tn)
751 {
752
753 /*
754 * If there was a continue statement the expression controlling the
755 * loop is reached.
756 */
757 if (cstk->c_cont)
758 reached = 1;
759
760 if (tn != NULL)
761 tn = cconv(tn);
762 if (tn != NULL)
763 tn = promote(NOOP, 0, tn);
764 if (tn != NULL && !issclt(tn->tn_type->t_tspec)) {
765 /* controlling expressions must have scalar type */
766 error(204);
767 tn = NULL;
768 }
769
770 if (tn != NULL && tn->tn_op == CON) {
771 if (isityp(tn->tn_type->t_tspec)) {
772 cstk->c_infinite = tn->tn_val->v_quad != 0;
773 } else {
774 cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
775 }
776 }
777
778 expr(tn, 0, 1, 1);
779
780 /*
781 * The end of the loop is only reached if it is no endless loop
782 * or there was a break statement which could be reached.
783 */
784 reached = !cstk->c_infinite || cstk->c_break;
785 rchflg = 0;
786
787 popctrl(T_DO);
788 }
789
790 /*
791 * T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN
792 */
793 void
for1(tnode_t * tn1,tnode_t * tn2,tnode_t * tn3)794 for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
795 {
796
797 /*
798 * If there is no initialisation expression it is possible that
799 * it is intended not to enter the loop at top.
800 */
801 if (tn1 != NULL && !reached) {
802 /* loop not entered at top */
803 warning(207);
804 reached = 1;
805 }
806
807 pushctrl(T_FOR);
808 cstk->c_loop = 1;
809
810 /*
811 * Store the tree memory for the reinitialisation expression.
812 * Also remember this expression itself. We must check it at
813 * the end of the loop to get "used but not set" warnings correct.
814 */
815 cstk->c_fexprm = tsave();
816 cstk->c_f3expr = tn3;
817 STRUCT_ASSIGN(cstk->c_fpos, curr_pos);
818 STRUCT_ASSIGN(cstk->c_cfpos, csrc_pos);
819
820 if (tn1 != NULL)
821 expr(tn1, 0, 0, 1);
822
823 if (tn2 != NULL)
824 tn2 = cconv(tn2);
825 if (tn2 != NULL)
826 tn2 = promote(NOOP, 0, tn2);
827 if (tn2 != NULL && !issclt(tn2->tn_type->t_tspec)) {
828 /* controlling expressions must have scalar type */
829 error(204);
830 tn2 = NULL;
831 }
832 if (tn2 != NULL)
833 expr(tn2, 0, 1, 1);
834
835 if (tn2 == NULL) {
836 cstk->c_infinite = 1;
837 } else if (tn2->tn_op == CON) {
838 if (isityp(tn2->tn_type->t_tspec)) {
839 cstk->c_infinite = tn2->tn_val->v_quad != 0;
840 } else {
841 cstk->c_infinite = tn2->tn_val->v_ldbl != 0.0;
842 }
843 }
844
845 /* Checking the reinitialisation expression is done in for2() */
846
847 reached = 1;
848 }
849
850 /*
851 * for_exprs stmnt
852 * for_exprs error
853 */
854 void
for2(void)855 for2(void)
856 {
857 pos_t cpos, cspos;
858 tnode_t *tn3;
859
860 if (cstk->c_cont)
861 reached = 1;
862
863 STRUCT_ASSIGN(cpos, curr_pos);
864 STRUCT_ASSIGN(cspos, csrc_pos);
865
866 /* Restore the tree memory for the reinitialisation expression */
867 trestor(cstk->c_fexprm);
868 tn3 = cstk->c_f3expr;
869 STRUCT_ASSIGN(curr_pos, cstk->c_fpos);
870 STRUCT_ASSIGN(csrc_pos, cstk->c_cfpos);
871
872 /* simply "statement not reached" would be confusing */
873 if (!reached && !rchflg) {
874 /* end-of-loop code not reached */
875 warning(223);
876 reached = 1;
877 }
878
879 if (tn3 != NULL) {
880 expr(tn3, 0, 0, 1);
881 } else {
882 tfreeblk();
883 }
884
885 STRUCT_ASSIGN(curr_pos, cpos);
886 STRUCT_ASSIGN(csrc_pos, cspos);
887
888 /* An endless loop without break will never terminate */
889 reached = cstk->c_break || !cstk->c_infinite;
890 rchflg = 0;
891
892 popctrl(T_FOR);
893 }
894
895 /*
896 * T_GOTO identifier T_SEMI
897 * T_GOTO error T_SEMI
898 */
899 void
dogoto(sym_t * lab)900 dogoto(sym_t *lab)
901 {
902
903 setuflg(lab, 0, 0);
904
905 chkreach();
906
907 reached = rchflg = 0;
908 }
909
910 /*
911 * T_BREAK T_SEMI
912 */
913 void
dobreak(void)914 dobreak(void)
915 {
916 cstk_t *ci;
917
918 ci = cstk;
919 while (ci != NULL && !ci->c_loop && !ci->c_switch)
920 ci = ci->c_nxt;
921
922 if (ci == NULL) {
923 /* break outside loop or switch */
924 error(208);
925 } else {
926 if (reached)
927 ci->c_break = 1;
928 }
929
930 if (bflag)
931 chkreach();
932
933 reached = rchflg = 0;
934 }
935
936 /*
937 * T_CONTINUE T_SEMI
938 */
939 void
docont(void)940 docont(void)
941 {
942 cstk_t *ci;
943
944 for (ci = cstk; ci != NULL && !ci->c_loop; ci = ci->c_nxt)
945 continue;
946
947 if (ci == NULL) {
948 /* continue outside loop */
949 error(209);
950 } else {
951 ci->c_cont = 1;
952 }
953
954 chkreach();
955
956 reached = rchflg = 0;
957 }
958
959 /*
960 * T_RETURN T_SEMI
961 * T_RETURN expr T_SEMI
962 */
963 void
doreturn(tnode_t * tn)964 doreturn(tnode_t *tn)
965 {
966 tnode_t *ln, *rn;
967 cstk_t *ci;
968 op_t op;
969
970 for (ci = cstk; ci->c_nxt != NULL; ci = ci->c_nxt)
971 continue;
972
973 if (tn != NULL) {
974 ci->c_retval = 1;
975 } else {
976 ci->c_noretval = 1;
977 }
978
979 if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
980 /* void function %s cannot return value */
981 error(213, funcsym->s_name);
982 tfreeblk();
983 tn = NULL;
984 } else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
985 /*
986 * Assume that the function has a return value only if it
987 * is explicitly declared.
988 */
989 if (!funcsym->s_rimpl)
990 /* function %s expects to return value */
991 warning(214, funcsym->s_name);
992 }
993
994 if (tn != NULL) {
995
996 /* Create a temporary node for the left side */
997 ln = tgetblk(sizeof (tnode_t));
998 ln->tn_op = NAME;
999 ln->tn_type = tduptyp(funcsym->s_type->t_subt);
1000 ln->tn_type->t_const = 0;
1001 ln->tn_lvalue = 1;
1002 ln->tn_sym = funcsym; /* better than nothing */
1003
1004 tn = build(RETURN, ln, tn);
1005
1006 if (tn != NULL) {
1007 rn = tn->tn_right;
1008 while ((op = rn->tn_op) == CVT || op == PLUS)
1009 rn = rn->tn_left;
1010 if (rn->tn_op == AMPER && rn->tn_left->tn_op == NAME &&
1011 rn->tn_left->tn_sym->s_scl == AUTO) {
1012 /* %s returns pointer to automatic object */
1013 warning(302, funcsym->s_name);
1014 }
1015 }
1016
1017 expr(tn, 1, 0, 1);
1018
1019 } else {
1020
1021 chkreach();
1022
1023 }
1024
1025 reached = rchflg = 0;
1026 }
1027
1028 /*
1029 * Do some cleanup after a global declaration or definition.
1030 * Especially remove informations about unused lint comments.
1031 */
1032 void
glclup(int silent)1033 glclup(int silent)
1034 {
1035 pos_t cpos;
1036
1037 STRUCT_ASSIGN(cpos, curr_pos);
1038
1039 if (nargusg != -1) {
1040 if (!silent) {
1041 STRUCT_ASSIGN(curr_pos, aupos);
1042 /* must precede function definition: %s */
1043 warning(282, "ARGSUSED");
1044 }
1045 nargusg = -1;
1046 }
1047 if (nvararg != -1) {
1048 if (!silent) {
1049 STRUCT_ASSIGN(curr_pos, vapos);
1050 /* must precede function definition: %s */
1051 warning(282, "VARARGS");
1052 }
1053 nvararg = -1;
1054 }
1055 if (prflstrg != -1) {
1056 if (!silent) {
1057 STRUCT_ASSIGN(curr_pos, prflpos);
1058 /* must precede function definition: %s */
1059 warning(282, "PRINTFLIKE");
1060 }
1061 prflstrg = -1;
1062 }
1063 if (scflstrg != -1) {
1064 if (!silent) {
1065 STRUCT_ASSIGN(curr_pos, scflpos);
1066 /* must precede function definition: %s */
1067 warning(282, "SCANFLIKE");
1068 }
1069 scflstrg = -1;
1070 }
1071
1072 STRUCT_ASSIGN(curr_pos, cpos);
1073
1074 dcs->d_asm = 0;
1075 }
1076
1077 /*
1078 * ARGSUSED comment
1079 *
1080 * Only the first n arguments of the following function are checked
1081 * for usage. A missing argument is taken to be 0.
1082 */
1083 void
argsused(int n)1084 argsused(int n)
1085 {
1086
1087 if (n == -1)
1088 n = 0;
1089
1090 if (dcs->d_ctx != EXTERN) {
1091 /* must be outside function: ** %s ** */
1092 warning(280, "ARGSUSED");
1093 return;
1094 }
1095 if (nargusg != -1) {
1096 /* duplicate use of ** %s ** */
1097 warning(281, "ARGSUSED");
1098 }
1099 nargusg = n;
1100 STRUCT_ASSIGN(aupos, curr_pos);
1101 }
1102
1103 /*
1104 * VARARGS comment
1105 *
1106 * Makes that lint2 checks only the first n arguments for compatibility
1107 * to the function definition. A missing argument is taken to be 0.
1108 */
1109 void
varargs(int n)1110 varargs(int n)
1111 {
1112
1113 if (n == -1)
1114 n = 0;
1115
1116 if (dcs->d_ctx != EXTERN) {
1117 /* must be outside function: ** %s ** */
1118 warning(280, "VARARGS");
1119 return;
1120 }
1121 if (nvararg != -1) {
1122 /* duplicate use of ** %s ** */
1123 warning(281, "VARARGS");
1124 }
1125 nvararg = n;
1126 STRUCT_ASSIGN(vapos, curr_pos);
1127 }
1128
1129 /*
1130 * PRINTFLIKE comment
1131 *
1132 * Check all arguments until the (n-1)-th as usual. The n-th argument is
1133 * used the check the types of remaining arguments.
1134 */
1135 void
printflike(int n)1136 printflike(int n)
1137 {
1138
1139 if (n == -1)
1140 n = 0;
1141
1142 if (dcs->d_ctx != EXTERN) {
1143 /* must be outside function: ** %s ** */
1144 warning(280, "PRINTFLIKE");
1145 return;
1146 }
1147 if (prflstrg != -1) {
1148 /* duplicate use of ** %s ** */
1149 warning(281, "PRINTFLIKE");
1150 }
1151 prflstrg = n;
1152 STRUCT_ASSIGN(prflpos, curr_pos);
1153 }
1154
1155 /*
1156 * SCANFLIKE comment
1157 *
1158 * Check all arguments until the (n-1)-th as usual. The n-th argument is
1159 * used the check the types of remaining arguments.
1160 */
1161 void
scanflike(int n)1162 scanflike(int n)
1163 {
1164
1165 if (n == -1)
1166 n = 0;
1167
1168 if (dcs->d_ctx != EXTERN) {
1169 /* must be outside function: ** %s ** */
1170 warning(280, "SCANFLIKE");
1171 return;
1172 }
1173 if (scflstrg != -1) {
1174 /* duplicate use of ** %s ** */
1175 warning(281, "SCANFLIKE");
1176 }
1177 scflstrg = n;
1178 STRUCT_ASSIGN(scflpos, curr_pos);
1179 }
1180
1181 /*
1182 * Set the linenumber for a CONSTCOND comment. At this and the following
1183 * line no warnings about constants in conditional contexts are printed.
1184 */
1185 /* ARGSUSED */
1186 void
constcond(int n)1187 constcond(int n)
1188 {
1189
1190 ccflg = 1;
1191 }
1192
1193 /*
1194 * Suppress printing of "fallthrough on ..." warnings until next
1195 * statement.
1196 */
1197 /* ARGSUSED */
1198 void
fallthru(int n)1199 fallthru(int n)
1200 {
1201
1202 ftflg = 1;
1203 }
1204
1205 /*
1206 * Stop warnings about statements which cannot be reached. Also tells lint
1207 * that the following statements cannot be reached (e.g. after exit()).
1208 */
1209 /* ARGSUSED */
1210 void
notreach(int n)1211 notreach(int n)
1212 {
1213
1214 reached = 0;
1215 rchflg = 1;
1216 }
1217
1218 /* ARGSUSED */
1219 void
lintlib(int n)1220 lintlib(int n)
1221 {
1222
1223 if (dcs->d_ctx != EXTERN) {
1224 /* must be outside function: ** %s ** */
1225 warning(280, "LINTLIBRARY");
1226 return;
1227 }
1228 llibflg = 1;
1229 vflag = 0;
1230 }
1231
1232 /*
1233 * Suppress most warnings at the current and the following line.
1234 */
1235 /* ARGSUSED */
1236 void
linted(int n)1237 linted(int n)
1238 {
1239
1240 #ifdef DEBUG
1241 printf("%s, %d: nowarn = 1\n", curr_pos.p_file, curr_pos.p_line);
1242 #endif
1243 nowarn = 1;
1244 }
1245
1246 /*
1247 * Suppress bitfield type errors on the current line.
1248 */
1249 /* ARGSUSED */
1250 void
bitfieldtype(int n)1251 bitfieldtype(int n)
1252 {
1253
1254 #ifdef DEBUG
1255 printf("%s, %d: bitfieldtype_ok = 1\n", curr_pos.p_file,
1256 curr_pos.p_line);
1257 #endif
1258 bitfieldtype_ok = 1;
1259 }
1260
1261 /*
1262 * PROTOTLIB in conjunction with LINTLIBRARY can be used to handle
1263 * prototypes like function definitions. This is done if the argument
1264 * to PROTOLIB is nonzero. Otherwise prototypes are handled normaly.
1265 */
1266 void
protolib(int n)1267 protolib(int n)
1268 {
1269
1270 if (dcs->d_ctx != EXTERN) {
1271 /* must be outside function: ** %s ** */
1272 warning(280, "PROTOLIB");
1273 return;
1274 }
1275 plibflg = n == 0 ? 0 : 1;
1276 }
1277
1278 /*
1279 * Set quadflg to nonzero which means that the next statement/declaration
1280 * may use "long long" without an error or warning.
1281 */
1282 /* ARGSUSED */
1283 void
longlong(int n)1284 longlong(int n)
1285 {
1286
1287 quadflg = 1;
1288 }
1289