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