usr.bin/xlint/lint1/func.c

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