Home | History | Annotate | Line # | Download | only in lint1
func.c revision 1.85
      1  1.85    rillig /*	$NetBSD: func.c,v 1.85 2021/03/21 12:08:34 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.85    rillig __RCSID("$NetBSD: func.c,v 1.85 2021/03/21 12:08:34 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.78    rillig  * Control statements if, for, while and switch do not reset seen_fallthrough
     71  1.78    rillig  * because this must be done by the controlled statement. At least for if this
     72  1.78    rillig  * is 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.78    rillig bool	seen_fallthrough;
     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.79    rillig 	case_label_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.79    rillig 	for (cl = ci->c_case_labels; 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.81    rillig 	for (sym = dcs->d_func_proto_syms; sym != NULL; sym = sym->s_dlnxt) {
    227  1.77    rillig 		if (sym->s_block_level != -1) {
    228  1.77    rillig 			lint_assert(sym->s_block_level == 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.81    rillig 	dcs->d_func_def_pos = fsym->s_def_pos;
    286   1.1       cgd 
    287  1.80    rillig 	if ((rdsym = dcs->d_redeclared_symbol) != 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.81    rillig 	arg = dcs->d_func_args;
    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.81    rillig 		outfdef(funcsym, &dcs->d_func_def_pos,
    400  1.81    rillig 		    cstmt->c_had_return_value, funcsym->s_osdef,
    401  1.81    rillig 		    dcs->d_func_args);
    402   1.1       cgd 	}
    403   1.1       cgd 
    404   1.1       cgd 	/*
    405   1.1       cgd 	 * remove all symbols declared during argument declaration from
    406   1.1       cgd 	 * the symbol table
    407   1.1       cgd 	 */
    408  1.41    rillig 	lint_assert(dcs->d_next == NULL);
    409  1.41    rillig 	lint_assert(dcs->d_ctx == EXTERN);
    410  1.81    rillig 	rmsyms(dcs->d_func_proto_syms);
    411   1.1       cgd 
    412   1.1       cgd 	/* must be set on level 0 */
    413  1.59    rillig 	reached = true;
    414   1.1       cgd }
    415   1.1       cgd 
    416   1.1       cgd void
    417  1.42    rillig named_label(sym_t *sym)
    418  1.42    rillig {
    419  1.42    rillig 
    420  1.42    rillig 	if (sym->s_set) {
    421  1.42    rillig 		/* label %s redefined */
    422  1.42    rillig 		error(194, sym->s_name);
    423  1.42    rillig 	} else {
    424  1.42    rillig 		mark_as_set(sym);
    425  1.42    rillig 	}
    426  1.42    rillig 
    427  1.59    rillig 	reached = true;
    428  1.42    rillig }
    429  1.42    rillig 
    430  1.43    rillig static void
    431  1.75    rillig check_case_label_enum(const tnode_t *tn, const cstk_t *ci)
    432  1.75    rillig {
    433  1.75    rillig 	/* similar to typeok_enum in tree.c */
    434  1.75    rillig 
    435  1.75    rillig 	if (!(tn->tn_type->t_is_enum || ci->c_swtype->t_is_enum))
    436  1.75    rillig 		return;
    437  1.75    rillig 	if (tn->tn_type->t_is_enum && ci->c_swtype->t_is_enum &&
    438  1.75    rillig 	    tn->tn_type->t_enum == ci->c_swtype->t_enum)
    439  1.75    rillig 		return;
    440  1.75    rillig 
    441  1.76    rillig #if 0 /* not yet ready, see msg_130.c */
    442  1.75    rillig 	/* enum type mismatch: '%s' '%s' '%s' */
    443  1.75    rillig 	warning(130, type_name(ci->c_swtype), getopname(EQ),
    444  1.75    rillig 	    type_name(tn->tn_type));
    445  1.76    rillig #endif
    446  1.75    rillig }
    447  1.75    rillig 
    448  1.75    rillig static void
    449  1.43    rillig check_case_label(tnode_t *tn, cstk_t *ci)
    450   1.1       cgd {
    451  1.79    rillig 	case_label_t *cl;
    452  1.11     itohy 	val_t	*v;
    453  1.11     itohy 	val_t	nv;
    454   1.1       cgd 	tspec_t	t;
    455   1.1       cgd 
    456  1.42    rillig 	if (ci == NULL) {
    457  1.42    rillig 		/* case not in switch */
    458  1.42    rillig 		error(195);
    459  1.43    rillig 		return;
    460  1.43    rillig 	}
    461  1.43    rillig 
    462  1.43    rillig 	if (tn != NULL && tn->tn_op != CON) {
    463  1.42    rillig 		/* non-constant case expression */
    464  1.42    rillig 		error(197);
    465  1.43    rillig 		return;
    466  1.43    rillig 	}
    467  1.43    rillig 
    468  1.55    rillig 	if (tn != NULL && !is_integer(tn->tn_type->t_tspec)) {
    469  1.42    rillig 		/* non-integral case expression */
    470  1.42    rillig 		error(198);
    471  1.43    rillig 		return;
    472  1.42    rillig 	}
    473   1.1       cgd 
    474  1.75    rillig 	check_case_label_enum(tn, ci);
    475  1.75    rillig 
    476  1.43    rillig 	lint_assert(ci->c_swtype != NULL);
    477   1.1       cgd 
    478  1.78    rillig 	if (reached && !seen_fallthrough) {
    479  1.43    rillig 		if (hflag)
    480  1.43    rillig 			/* fallthrough on case statement */
    481  1.43    rillig 			warning(220);
    482  1.43    rillig 	}
    483   1.1       cgd 
    484  1.43    rillig 	t = tn->tn_type->t_tspec;
    485  1.43    rillig 	if (t == LONG || t == ULONG ||
    486  1.43    rillig 	    t == QUAD || t == UQUAD) {
    487  1.43    rillig 		if (tflag)
    488  1.45    rillig 			/* case label must be of type `int' in traditional C */
    489  1.43    rillig 			warning(203);
    490  1.43    rillig 	}
    491   1.1       cgd 
    492  1.43    rillig 	/*
    493  1.43    rillig 	 * get the value of the expression and convert it
    494  1.43    rillig 	 * to the type of the switch expression
    495  1.43    rillig 	 */
    496  1.60    rillig 	v = constant(tn, true);
    497  1.64    rillig 	(void)memset(&nv, 0, sizeof nv);
    498  1.56    rillig 	convert_constant(CASE, 0, ci->c_swtype, &nv, v);
    499  1.43    rillig 	free(v);
    500  1.43    rillig 
    501  1.43    rillig 	/* look if we had this value already */
    502  1.79    rillig 	for (cl = ci->c_case_labels; cl != NULL; cl = cl->cl_next) {
    503  1.43    rillig 		if (cl->cl_val.v_quad == nv.v_quad)
    504  1.43    rillig 			break;
    505  1.43    rillig 	}
    506  1.55    rillig 	if (cl != NULL && is_uinteger(nv.v_tspec)) {
    507  1.43    rillig 		/* duplicate case in switch: %lu */
    508  1.43    rillig 		error(200, (u_long)nv.v_quad);
    509  1.43    rillig 	} else if (cl != NULL) {
    510  1.43    rillig 		/* duplicate case in switch: %ld */
    511  1.43    rillig 		error(199, (long)nv.v_quad);
    512  1.43    rillig 	} else {
    513  1.68    rillig 		check_getopt_case_label(nv.v_quad);
    514  1.68    rillig 
    515  1.42    rillig 		/*
    516  1.43    rillig 		 * append the value to the list of
    517  1.43    rillig 		 * case values
    518  1.42    rillig 		 */
    519  1.79    rillig 		cl = xcalloc(1, sizeof *cl);
    520  1.43    rillig 		cl->cl_val = nv;
    521  1.79    rillig 		cl->cl_next = ci->c_case_labels;
    522  1.79    rillig 		ci->c_case_labels = cl;
    523  1.42    rillig 	}
    524  1.43    rillig }
    525  1.43    rillig 
    526  1.43    rillig void
    527  1.43    rillig case_label(tnode_t *tn)
    528  1.43    rillig {
    529  1.43    rillig 	cstk_t	*ci;
    530  1.43    rillig 
    531  1.51    rillig 	/* find the innermost switch statement */
    532  1.48    rillig 	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
    533  1.43    rillig 		continue;
    534  1.43    rillig 
    535  1.43    rillig 	check_case_label(tn, ci);
    536  1.43    rillig 
    537  1.42    rillig 	tfreeblk();
    538  1.42    rillig 
    539  1.59    rillig 	reached = true;
    540  1.42    rillig }
    541  1.42    rillig 
    542  1.42    rillig void
    543  1.42    rillig default_label(void)
    544  1.42    rillig {
    545  1.42    rillig 	cstk_t	*ci;
    546   1.1       cgd 
    547  1.51    rillig 	/* find the innermost switch statement */
    548  1.48    rillig 	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
    549  1.42    rillig 		continue;
    550   1.1       cgd 
    551  1.42    rillig 	if (ci == NULL) {
    552  1.42    rillig 		/* default outside switch */
    553  1.42    rillig 		error(201);
    554  1.42    rillig 	} else if (ci->c_default) {
    555  1.42    rillig 		/* duplicate default in switch */
    556  1.42    rillig 		error(202);
    557  1.42    rillig 	} else {
    558  1.78    rillig 		if (reached && !seen_fallthrough) {
    559  1.42    rillig 			if (hflag)
    560  1.42    rillig 				/* fallthrough on default statement */
    561  1.42    rillig 				warning(284);
    562   1.1       cgd 		}
    563  1.59    rillig 		ci->c_default = true;
    564  1.42    rillig 	}
    565  1.42    rillig 
    566  1.59    rillig 	reached = true;
    567   1.1       cgd }
    568   1.1       cgd 
    569  1.39    rillig static tnode_t *
    570  1.39    rillig check_controlling_expression(tnode_t *tn)
    571  1.39    rillig {
    572  1.39    rillig 
    573  1.39    rillig 	if (tn != NULL)
    574  1.39    rillig 		tn = cconv(tn);
    575  1.39    rillig 	if (tn != NULL)
    576  1.60    rillig 		tn = promote(NOOP, false, tn);
    577  1.39    rillig 
    578  1.55    rillig 	if (tn != NULL && !is_scalar(tn->tn_type->t_tspec)) {
    579  1.39    rillig 		/* C99 6.5.15p4 for the ?: operator; see typeok:QUEST */
    580  1.39    rillig 		/* C99 6.8.4.1p1 for if statements */
    581  1.39    rillig 		/* C99 6.8.5p2 for while, do and for loops */
    582  1.39    rillig 		/* controlling expressions must have scalar type */
    583  1.39    rillig 		error(204);
    584  1.39    rillig 		return NULL;
    585  1.39    rillig 	}
    586  1.39    rillig 
    587  1.65    rillig 	if (tn != NULL && Tflag && !is_typeok_bool_operand(tn)) {
    588  1.57    rillig 		/* controlling expression must be bool, not '%s' */
    589  1.57    rillig 		error(333, tspec_name(tn->tn_type->t_tspec));
    590  1.57    rillig 		return NULL;
    591  1.57    rillig 	}
    592  1.57    rillig 
    593  1.39    rillig 	return tn;
    594  1.39    rillig }
    595  1.39    rillig 
    596   1.1       cgd /*
    597  1.44    rillig  * T_IF T_LPAREN expr T_RPAREN
    598   1.1       cgd  */
    599   1.1       cgd void
    600  1.14     lukem if1(tnode_t *tn)
    601   1.1       cgd {
    602  1.14     lukem 
    603   1.1       cgd 	if (tn != NULL)
    604  1.39    rillig 		tn = check_controlling_expression(tn);
    605   1.1       cgd 	if (tn != NULL)
    606  1.67    rillig 		expr(tn, false, true, false, false);
    607   1.1       cgd 	pushctrl(T_IF);
    608   1.1       cgd }
    609   1.1       cgd 
    610   1.1       cgd /*
    611   1.1       cgd  * if_without_else
    612   1.1       cgd  * if_without_else T_ELSE
    613   1.1       cgd  */
    614   1.1       cgd void
    615  1.14     lukem if2(void)
    616   1.1       cgd {
    617  1.14     lukem 
    618  1.59    rillig 	cstmt->c_rchif = reached;
    619  1.59    rillig 	reached = true;
    620   1.1       cgd }
    621   1.1       cgd 
    622   1.1       cgd /*
    623   1.1       cgd  * if_without_else
    624  1.54    rillig  * if_without_else T_ELSE statement
    625   1.1       cgd  */
    626   1.1       cgd void
    627  1.59    rillig if3(bool els)
    628   1.1       cgd {
    629  1.14     lukem 
    630   1.1       cgd 	if (els) {
    631  1.48    rillig 		reached |= cstmt->c_rchif;
    632   1.1       cgd 	} else {
    633  1.59    rillig 		reached = true;
    634   1.1       cgd 	}
    635   1.1       cgd 	popctrl(T_IF);
    636   1.1       cgd }
    637   1.1       cgd 
    638   1.1       cgd /*
    639  1.44    rillig  * T_SWITCH T_LPAREN expr T_RPAREN
    640   1.1       cgd  */
    641   1.1       cgd void
    642  1.14     lukem switch1(tnode_t *tn)
    643   1.1       cgd {
    644   1.1       cgd 	tspec_t	t;
    645   1.1       cgd 	type_t	*tp;
    646   1.1       cgd 
    647   1.1       cgd 	if (tn != NULL)
    648   1.1       cgd 		tn = cconv(tn);
    649   1.1       cgd 	if (tn != NULL)
    650  1.60    rillig 		tn = promote(NOOP, false, tn);
    651  1.55    rillig 	if (tn != NULL && !is_integer(tn->tn_type->t_tspec)) {
    652   1.1       cgd 		/* switch expression must have integral type */
    653   1.1       cgd 		error(205);
    654   1.1       cgd 		tn = NULL;
    655   1.1       cgd 	}
    656   1.1       cgd 	if (tn != NULL && tflag) {
    657   1.1       cgd 		t = tn->tn_type->t_tspec;
    658   1.1       cgd 		if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
    659   1.1       cgd 			/* switch expr. must be of type `int' in trad. C */
    660   1.1       cgd 			warning(271);
    661   1.1       cgd 		}
    662   1.1       cgd 	}
    663   1.1       cgd 
    664   1.1       cgd 	/*
    665  1.37    rillig 	 * Remember the type of the expression. Because it's possible
    666  1.37    rillig 	 * that (*tp) is allocated on tree memory, the type must be
    667   1.1       cgd 	 * duplicated. This is not too complicated because it is
    668   1.1       cgd 	 * only an integer type.
    669   1.1       cgd 	 */
    670   1.1       cgd 	tp = xcalloc(1, sizeof (type_t));
    671   1.1       cgd 	if (tn != NULL) {
    672   1.1       cgd 		tp->t_tspec = tn->tn_type->t_tspec;
    673  1.71    rillig 		if ((tp->t_is_enum = tn->tn_type->t_is_enum) != false)
    674   1.1       cgd 			tp->t_enum = tn->tn_type->t_enum;
    675   1.1       cgd 	} else {
    676   1.1       cgd 		tp->t_tspec = INT;
    677   1.1       cgd 	}
    678   1.1       cgd 
    679  1.68    rillig 	check_getopt_begin_switch();
    680  1.67    rillig 	expr(tn, true, false, true, false);
    681   1.1       cgd 
    682   1.1       cgd 	pushctrl(T_SWITCH);
    683  1.59    rillig 	cstmt->c_switch = true;
    684  1.48    rillig 	cstmt->c_swtype = tp;
    685   1.1       cgd 
    686  1.59    rillig 	reached = rchflg = false;
    687  1.78    rillig 	seen_fallthrough = true;
    688   1.1       cgd }
    689   1.1       cgd 
    690   1.1       cgd /*
    691  1.54    rillig  * switch_expr statement
    692   1.1       cgd  */
    693   1.1       cgd void
    694  1.14     lukem switch2(void)
    695   1.1       cgd {
    696   1.8  christos 	int	nenum = 0, nclab = 0;
    697   1.1       cgd 	sym_t	*esym;
    698  1.79    rillig 	case_label_t *cl;
    699   1.1       cgd 
    700  1.48    rillig 	lint_assert(cstmt->c_swtype != NULL);
    701   1.1       cgd 
    702   1.1       cgd 	/*
    703   1.1       cgd 	 * If the switch expression was of type enumeration, count the case
    704   1.1       cgd 	 * labels and the number of enumerators. If both counts are not
    705   1.1       cgd 	 * equal print a warning.
    706   1.1       cgd 	 */
    707  1.71    rillig 	if (cstmt->c_swtype->t_is_enum) {
    708   1.1       cgd 		nenum = nclab = 0;
    709  1.48    rillig 		lint_assert(cstmt->c_swtype->t_enum != NULL);
    710  1.70    rillig 		for (esym = cstmt->c_swtype->t_enum->en_first_enumerator;
    711  1.32    rillig 		     esym != NULL; esym = esym->s_next) {
    712   1.1       cgd 			nenum++;
    713   1.1       cgd 		}
    714  1.79    rillig 		for (cl = cstmt->c_case_labels; cl != NULL; cl = cl->cl_next)
    715   1.1       cgd 			nclab++;
    716  1.48    rillig 		if (hflag && eflag && nenum != nclab && !cstmt->c_default) {
    717   1.1       cgd 			/* enumeration value(s) not handled in switch */
    718   1.1       cgd 			warning(206);
    719   1.1       cgd 		}
    720   1.1       cgd 	}
    721   1.1       cgd 
    722  1.68    rillig 	check_getopt_end_switch();
    723  1.68    rillig 
    724  1.48    rillig 	if (cstmt->c_break) {
    725   1.1       cgd 		/*
    726  1.68    rillig 		 * end of switch always reached (c_break is only set if the
    727   1.1       cgd 		 * break statement can be reached).
    728   1.1       cgd 		 */
    729  1.59    rillig 		reached = true;
    730  1.48    rillig 	} else if (!cstmt->c_default &&
    731  1.71    rillig 		   (!hflag || !cstmt->c_swtype->t_is_enum || nenum != nclab)) {
    732   1.1       cgd 		/*
    733   1.1       cgd 		 * there are possible values which are not handled in
    734   1.1       cgd 		 * switch
    735   1.1       cgd 		 */
    736  1.59    rillig 		reached = true;
    737   1.1       cgd 	}	/*
    738   1.1       cgd 		 * otherwise the end of the switch expression is reached
    739   1.1       cgd 		 * if the end of the last statement inside it is reached.
    740   1.1       cgd 		 */
    741   1.1       cgd 
    742   1.1       cgd 	popctrl(T_SWITCH);
    743   1.1       cgd }
    744   1.1       cgd 
    745   1.1       cgd /*
    746  1.44    rillig  * T_WHILE T_LPAREN expr T_RPAREN
    747   1.1       cgd  */
    748   1.1       cgd void
    749  1.14     lukem while1(tnode_t *tn)
    750   1.1       cgd {
    751  1.14     lukem 
    752   1.1       cgd 	if (!reached) {
    753   1.1       cgd 		/* loop not entered at top */
    754   1.1       cgd 		warning(207);
    755  1.59    rillig 		reached = true;
    756   1.1       cgd 	}
    757   1.1       cgd 
    758   1.1       cgd 	if (tn != NULL)
    759  1.39    rillig 		tn = check_controlling_expression(tn);
    760   1.1       cgd 
    761   1.1       cgd 	pushctrl(T_WHILE);
    762  1.59    rillig 	cstmt->c_loop = true;
    763  1.58    rillig 	if (tn != NULL && tn->tn_op == CON)
    764  1.84    rillig 		cstmt->c_maybe_endless = constant_is_nonzero(tn);
    765   1.1       cgd 
    766  1.68    rillig 	check_getopt_begin_while(tn);
    767  1.67    rillig 	expr(tn, false, true, true, false);
    768   1.1       cgd }
    769   1.1       cgd 
    770   1.1       cgd /*
    771  1.54    rillig  * while_expr statement
    772   1.1       cgd  * while_expr error
    773   1.1       cgd  */
    774   1.1       cgd void
    775  1.14     lukem while2(void)
    776   1.1       cgd {
    777  1.14     lukem 
    778   1.1       cgd 	/*
    779   1.1       cgd 	 * The end of the loop can be reached if it is no endless loop
    780   1.1       cgd 	 * or there was a break statement which was reached.
    781   1.1       cgd 	 */
    782  1.84    rillig 	reached = !cstmt->c_maybe_endless || cstmt->c_break;
    783  1.59    rillig 	rchflg = false;
    784   1.1       cgd 
    785  1.68    rillig 	check_getopt_end_while();
    786   1.1       cgd 	popctrl(T_WHILE);
    787   1.1       cgd }
    788   1.1       cgd 
    789   1.1       cgd /*
    790   1.1       cgd  * T_DO
    791   1.1       cgd  */
    792   1.1       cgd void
    793  1.14     lukem do1(void)
    794   1.1       cgd {
    795  1.14     lukem 
    796   1.1       cgd 	if (!reached) {
    797   1.1       cgd 		/* loop not entered at top */
    798   1.1       cgd 		warning(207);
    799  1.59    rillig 		reached = true;
    800   1.1       cgd 	}
    801   1.1       cgd 
    802   1.1       cgd 	pushctrl(T_DO);
    803  1.59    rillig 	cstmt->c_loop = true;
    804   1.1       cgd }
    805   1.1       cgd 
    806   1.1       cgd /*
    807  1.54    rillig  * do statement do_while_expr
    808   1.1       cgd  * do error
    809   1.1       cgd  */
    810   1.1       cgd void
    811  1.14     lukem do2(tnode_t *tn)
    812   1.1       cgd {
    813  1.14     lukem 
    814   1.1       cgd 	/*
    815  1.28    rillig 	 * If there was a continue statement, the expression controlling the
    816   1.1       cgd 	 * loop is reached.
    817   1.1       cgd 	 */
    818  1.85    rillig 	if (cstmt->c_continue)
    819  1.59    rillig 		reached = true;
    820   1.1       cgd 
    821   1.1       cgd 	if (tn != NULL)
    822  1.39    rillig 		tn = check_controlling_expression(tn);
    823   1.1       cgd 
    824   1.1       cgd 	if (tn != NULL && tn->tn_op == CON) {
    825  1.84    rillig 		cstmt->c_maybe_endless = constant_is_nonzero(tn);
    826  1.85    rillig 		if (!cstmt->c_maybe_endless && cstmt->c_continue)
    827  1.46    rillig 			/* continue in 'do ... while (0)' loop */
    828  1.46    rillig 			error(323);
    829   1.1       cgd 	}
    830   1.1       cgd 
    831  1.67    rillig 	expr(tn, false, true, true, true);
    832   1.1       cgd 
    833  1.84    rillig 	if (cstmt->c_maybe_endless)
    834  1.83    rillig 		reached = false;
    835  1.83    rillig 	if (cstmt->c_break)
    836  1.83    rillig 		reached = true;
    837  1.59    rillig 	rchflg = false;
    838   1.1       cgd 
    839   1.1       cgd 	popctrl(T_DO);
    840   1.1       cgd }
    841   1.1       cgd 
    842   1.1       cgd /*
    843  1.44    rillig  * T_FOR T_LPAREN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPAREN
    844   1.1       cgd  */
    845   1.1       cgd void
    846  1.14     lukem for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
    847   1.1       cgd {
    848  1.14     lukem 
    849   1.1       cgd 	/*
    850  1.73    rillig 	 * If there is no initialization expression it is possible that
    851   1.1       cgd 	 * it is intended not to enter the loop at top.
    852   1.1       cgd 	 */
    853   1.1       cgd 	if (tn1 != NULL && !reached) {
    854   1.1       cgd 		/* loop not entered at top */
    855   1.1       cgd 		warning(207);
    856  1.59    rillig 		reached = true;
    857   1.1       cgd 	}
    858   1.1       cgd 
    859   1.1       cgd 	pushctrl(T_FOR);
    860  1.59    rillig 	cstmt->c_loop = true;
    861   1.1       cgd 
    862   1.1       cgd 	/*
    863  1.73    rillig 	 * Store the tree memory for the reinitialization expression.
    864   1.1       cgd 	 * Also remember this expression itself. We must check it at
    865   1.1       cgd 	 * the end of the loop to get "used but not set" warnings correct.
    866   1.1       cgd 	 */
    867  1.48    rillig 	cstmt->c_fexprm = tsave();
    868  1.48    rillig 	cstmt->c_f3expr = tn3;
    869  1.48    rillig 	cstmt->c_fpos = curr_pos;
    870  1.48    rillig 	cstmt->c_cfpos = csrc_pos;
    871   1.1       cgd 
    872   1.1       cgd 	if (tn1 != NULL)
    873  1.67    rillig 		expr(tn1, false, false, true, false);
    874   1.1       cgd 
    875   1.1       cgd 	if (tn2 != NULL)
    876  1.39    rillig 		tn2 = check_controlling_expression(tn2);
    877   1.1       cgd 	if (tn2 != NULL)
    878  1.67    rillig 		expr(tn2, false, true, true, false);
    879   1.1       cgd 
    880  1.84    rillig 	cstmt->c_maybe_endless =
    881  1.74    rillig 	    tn2 == NULL || (tn2->tn_op == CON && constant_is_nonzero(tn2));
    882   1.1       cgd 
    883  1.73    rillig 	/* Checking the reinitialization expression is done in for2() */
    884   1.1       cgd 
    885  1.59    rillig 	reached = true;
    886   1.1       cgd }
    887   1.1       cgd 
    888   1.1       cgd /*
    889  1.54    rillig  * for_exprs statement
    890   1.1       cgd  * for_exprs error
    891   1.1       cgd  */
    892   1.1       cgd void
    893  1.14     lukem for2(void)
    894   1.1       cgd {
    895   1.1       cgd 	pos_t	cpos, cspos;
    896   1.1       cgd 	tnode_t	*tn3;
    897   1.1       cgd 
    898  1.85    rillig 	if (cstmt->c_continue)
    899  1.59    rillig 		reached = true;
    900   1.1       cgd 
    901  1.36    rillig 	cpos = curr_pos;
    902  1.36    rillig 	cspos = csrc_pos;
    903   1.1       cgd 
    904  1.73    rillig 	/* Restore the tree memory for the reinitialization expression */
    905  1.48    rillig 	trestor(cstmt->c_fexprm);
    906  1.48    rillig 	tn3 = cstmt->c_f3expr;
    907  1.48    rillig 	curr_pos = cstmt->c_fpos;
    908  1.48    rillig 	csrc_pos = cstmt->c_cfpos;
    909   1.1       cgd 
    910   1.1       cgd 	/* simply "statement not reached" would be confusing */
    911   1.1       cgd 	if (!reached && !rchflg) {
    912   1.1       cgd 		/* end-of-loop code not reached */
    913   1.1       cgd 		warning(223);
    914  1.59    rillig 		reached = true;
    915   1.1       cgd 	}
    916   1.1       cgd 
    917   1.1       cgd 	if (tn3 != NULL) {
    918  1.67    rillig 		expr(tn3, false, false, true, false);
    919   1.1       cgd 	} else {
    920   1.1       cgd 		tfreeblk();
    921   1.1       cgd 	}
    922   1.1       cgd 
    923  1.36    rillig 	curr_pos = cpos;
    924  1.36    rillig 	csrc_pos = cspos;
    925   1.1       cgd 
    926   1.1       cgd 	/* An endless loop without break will never terminate */
    927  1.84    rillig 	/* TODO: What if the loop contains a 'return'? */
    928  1.84    rillig 	reached = cstmt->c_break || !cstmt->c_maybe_endless;
    929  1.59    rillig 	rchflg = false;
    930   1.1       cgd 
    931   1.1       cgd 	popctrl(T_FOR);
    932   1.1       cgd }
    933   1.1       cgd 
    934   1.1       cgd /*
    935   1.1       cgd  * T_GOTO identifier T_SEMI
    936   1.1       cgd  */
    937   1.1       cgd void
    938  1.14     lukem dogoto(sym_t *lab)
    939   1.1       cgd {
    940  1.14     lukem 
    941  1.60    rillig 	mark_as_used(lab, false, false);
    942   1.1       cgd 
    943  1.31    rillig 	check_statement_reachable();
    944   1.1       cgd 
    945  1.59    rillig 	reached = rchflg = false;
    946   1.1       cgd }
    947   1.1       cgd 
    948   1.1       cgd /*
    949   1.1       cgd  * T_BREAK T_SEMI
    950   1.1       cgd  */
    951   1.1       cgd void
    952  1.14     lukem dobreak(void)
    953   1.1       cgd {
    954   1.1       cgd 	cstk_t	*ci;
    955   1.1       cgd 
    956  1.48    rillig 	ci = cstmt;
    957   1.1       cgd 	while (ci != NULL && !ci->c_loop && !ci->c_switch)
    958  1.48    rillig 		ci = ci->c_surrounding;
    959   1.1       cgd 
    960   1.1       cgd 	if (ci == NULL) {
    961   1.1       cgd 		/* break outside loop or switch */
    962   1.1       cgd 		error(208);
    963   1.1       cgd 	} else {
    964   1.1       cgd 		if (reached)
    965  1.59    rillig 			ci->c_break = true;
    966   1.1       cgd 	}
    967   1.1       cgd 
    968   1.1       cgd 	if (bflag)
    969  1.31    rillig 		check_statement_reachable();
    970   1.1       cgd 
    971  1.59    rillig 	reached = rchflg = false;
    972   1.1       cgd }
    973   1.1       cgd 
    974   1.1       cgd /*
    975   1.1       cgd  * T_CONTINUE T_SEMI
    976   1.1       cgd  */
    977   1.1       cgd void
    978  1.14     lukem docont(void)
    979   1.1       cgd {
    980   1.1       cgd 	cstk_t	*ci;
    981   1.1       cgd 
    982  1.48    rillig 	for (ci = cstmt; ci != NULL && !ci->c_loop; ci = ci->c_surrounding)
    983  1.14     lukem 		continue;
    984   1.1       cgd 
    985   1.1       cgd 	if (ci == NULL) {
    986   1.1       cgd 		/* continue outside loop */
    987   1.1       cgd 		error(209);
    988   1.1       cgd 	} else {
    989  1.85    rillig 		/* TODO: only if reachable, for symmetry with c_break */
    990  1.85    rillig 		ci->c_continue = true;
    991   1.1       cgd 	}
    992   1.1       cgd 
    993  1.31    rillig 	check_statement_reachable();
    994   1.1       cgd 
    995  1.59    rillig 	reached = rchflg = false;
    996   1.1       cgd }
    997   1.1       cgd 
    998   1.1       cgd /*
    999   1.1       cgd  * T_RETURN T_SEMI
   1000   1.1       cgd  * T_RETURN expr T_SEMI
   1001   1.1       cgd  */
   1002   1.1       cgd void
   1003  1.14     lukem doreturn(tnode_t *tn)
   1004   1.1       cgd {
   1005   1.1       cgd 	tnode_t	*ln, *rn;
   1006   1.1       cgd 	cstk_t	*ci;
   1007   1.1       cgd 	op_t	op;
   1008   1.1       cgd 
   1009  1.48    rillig 	for (ci = cstmt; ci->c_surrounding != NULL; ci = ci->c_surrounding)
   1010  1.14     lukem 		continue;
   1011   1.1       cgd 
   1012  1.82    rillig 	if (tn != NULL)
   1013  1.63    rillig 		ci->c_had_return_value = true;
   1014  1.82    rillig 	else
   1015  1.63    rillig 		ci->c_had_return_noval = true;
   1016   1.1       cgd 
   1017   1.1       cgd 	if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
   1018   1.1       cgd 		/* void function %s cannot return value */
   1019   1.1       cgd 		error(213, funcsym->s_name);
   1020   1.1       cgd 		tfreeblk();
   1021   1.1       cgd 		tn = NULL;
   1022   1.1       cgd 	} else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
   1023   1.1       cgd 		/*
   1024   1.1       cgd 		 * Assume that the function has a return value only if it
   1025   1.1       cgd 		 * is explicitly declared.
   1026   1.1       cgd 		 */
   1027  1.69    rillig 		if (!funcsym->s_return_type_implicit_int)
   1028   1.1       cgd 			/* function %s expects to return value */
   1029   1.1       cgd 			warning(214, funcsym->s_name);
   1030   1.1       cgd 	}
   1031   1.1       cgd 
   1032   1.1       cgd 	if (tn != NULL) {
   1033   1.1       cgd 
   1034   1.1       cgd 		/* Create a temporary node for the left side */
   1035   1.1       cgd 		ln = tgetblk(sizeof (tnode_t));
   1036   1.1       cgd 		ln->tn_op = NAME;
   1037   1.1       cgd 		ln->tn_type = tduptyp(funcsym->s_type->t_subt);
   1038  1.59    rillig 		ln->tn_type->t_const = false;
   1039  1.59    rillig 		ln->tn_lvalue = true;
   1040   1.1       cgd 		ln->tn_sym = funcsym;		/* better than nothing */
   1041   1.1       cgd 
   1042   1.1       cgd 		tn = build(RETURN, ln, tn);
   1043   1.1       cgd 
   1044   1.1       cgd 		if (tn != NULL) {
   1045   1.1       cgd 			rn = tn->tn_right;
   1046   1.1       cgd 			while ((op = rn->tn_op) == CVT || op == PLUS)
   1047   1.1       cgd 				rn = rn->tn_left;
   1048  1.62    rillig 			if (rn->tn_op == ADDR && rn->tn_left->tn_op == NAME &&
   1049   1.1       cgd 			    rn->tn_left->tn_sym->s_scl == AUTO) {
   1050   1.1       cgd 				/* %s returns pointer to automatic object */
   1051   1.1       cgd 				warning(302, funcsym->s_name);
   1052   1.1       cgd 			}
   1053   1.1       cgd 		}
   1054   1.1       cgd 
   1055  1.67    rillig 		expr(tn, true, false, true, false);
   1056   1.1       cgd 
   1057   1.1       cgd 	} else {
   1058   1.1       cgd 
   1059  1.31    rillig 		check_statement_reachable();
   1060   1.1       cgd 
   1061   1.1       cgd 	}
   1062   1.1       cgd 
   1063  1.59    rillig 	reached = rchflg = false;
   1064   1.1       cgd }
   1065   1.1       cgd 
   1066   1.1       cgd /*
   1067   1.7       jpo  * Do some cleanup after a global declaration or definition.
   1068  1.28    rillig  * Especially remove information about unused lint comments.
   1069   1.1       cgd  */
   1070   1.1       cgd void
   1071  1.59    rillig global_clean_up_decl(bool silent)
   1072   1.1       cgd {
   1073   1.1       cgd 	pos_t	cpos;
   1074   1.1       cgd 
   1075  1.36    rillig 	cpos = curr_pos;
   1076   1.1       cgd 
   1077   1.1       cgd 	if (nargusg != -1) {
   1078   1.6       jpo 		if (!silent) {
   1079  1.36    rillig 			curr_pos = argsused_pos;
   1080  1.40    rillig 			/* must precede function definition: ** %s ** */
   1081   1.1       cgd 			warning(282, "ARGSUSED");
   1082   1.1       cgd 		}
   1083   1.1       cgd 		nargusg = -1;
   1084   1.1       cgd 	}
   1085   1.1       cgd 	if (nvararg != -1) {
   1086   1.6       jpo 		if (!silent) {
   1087  1.36    rillig 			curr_pos = vapos;
   1088  1.40    rillig 			/* must precede function definition: ** %s ** */
   1089   1.1       cgd 			warning(282, "VARARGS");
   1090   1.1       cgd 		}
   1091   1.1       cgd 		nvararg = -1;
   1092   1.1       cgd 	}
   1093  1.49    rillig 	if (printflike_argnum != -1) {
   1094   1.6       jpo 		if (!silent) {
   1095  1.36    rillig 			curr_pos = printflike_pos;
   1096  1.40    rillig 			/* must precede function definition: ** %s ** */
   1097   1.1       cgd 			warning(282, "PRINTFLIKE");
   1098   1.1       cgd 		}
   1099  1.49    rillig 		printflike_argnum = -1;
   1100   1.1       cgd 	}
   1101  1.49    rillig 	if (scanflike_argnum != -1) {
   1102   1.6       jpo 		if (!silent) {
   1103  1.36    rillig 			curr_pos = scanflike_pos;
   1104  1.40    rillig 			/* must precede function definition: ** %s ** */
   1105   1.1       cgd 			warning(282, "SCANFLIKE");
   1106   1.1       cgd 		}
   1107  1.49    rillig 		scanflike_argnum = -1;
   1108   1.1       cgd 	}
   1109   1.1       cgd 
   1110  1.36    rillig 	curr_pos = cpos;
   1111   1.7       jpo 
   1112  1.59    rillig 	dcs->d_asm = false;
   1113   1.1       cgd }
   1114   1.1       cgd 
   1115   1.1       cgd /*
   1116   1.1       cgd  * ARGSUSED comment
   1117   1.1       cgd  *
   1118   1.1       cgd  * Only the first n arguments of the following function are checked
   1119   1.1       cgd  * for usage. A missing argument is taken to be 0.
   1120   1.1       cgd  */
   1121   1.1       cgd void
   1122  1.14     lukem argsused(int n)
   1123   1.1       cgd {
   1124  1.14     lukem 
   1125   1.1       cgd 	if (n == -1)
   1126   1.1       cgd 		n = 0;
   1127   1.1       cgd 
   1128   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1129   1.1       cgd 		/* must be outside function: ** %s ** */
   1130   1.1       cgd 		warning(280, "ARGSUSED");
   1131   1.1       cgd 		return;
   1132   1.1       cgd 	}
   1133   1.1       cgd 	if (nargusg != -1) {
   1134   1.1       cgd 		/* duplicate use of ** %s ** */
   1135   1.1       cgd 		warning(281, "ARGSUSED");
   1136   1.1       cgd 	}
   1137   1.1       cgd 	nargusg = n;
   1138  1.36    rillig 	argsused_pos = curr_pos;
   1139   1.1       cgd }
   1140   1.1       cgd 
   1141   1.1       cgd /*
   1142   1.1       cgd  * VARARGS comment
   1143   1.1       cgd  *
   1144  1.28    rillig  * Causes lint2 to check only the first n arguments for compatibility
   1145  1.28    rillig  * with the function definition. A missing argument is taken to be 0.
   1146   1.1       cgd  */
   1147   1.1       cgd void
   1148  1.14     lukem varargs(int n)
   1149   1.1       cgd {
   1150  1.14     lukem 
   1151   1.1       cgd 	if (n == -1)
   1152   1.1       cgd 		n = 0;
   1153   1.1       cgd 
   1154   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1155   1.1       cgd 		/* must be outside function: ** %s ** */
   1156   1.1       cgd 		warning(280, "VARARGS");
   1157   1.1       cgd 		return;
   1158   1.1       cgd 	}
   1159   1.1       cgd 	if (nvararg != -1) {
   1160  1.40    rillig 		/* duplicate use of ** %s ** */
   1161   1.1       cgd 		warning(281, "VARARGS");
   1162   1.1       cgd 	}
   1163   1.1       cgd 	nvararg = n;
   1164  1.36    rillig 	vapos = curr_pos;
   1165   1.1       cgd }
   1166   1.1       cgd 
   1167   1.1       cgd /*
   1168   1.1       cgd  * PRINTFLIKE comment
   1169   1.1       cgd  *
   1170   1.1       cgd  * Check all arguments until the (n-1)-th as usual. The n-th argument is
   1171   1.1       cgd  * used the check the types of remaining arguments.
   1172   1.1       cgd  */
   1173   1.1       cgd void
   1174  1.14     lukem printflike(int n)
   1175   1.1       cgd {
   1176  1.14     lukem 
   1177   1.1       cgd 	if (n == -1)
   1178   1.1       cgd 		n = 0;
   1179   1.1       cgd 
   1180   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1181   1.1       cgd 		/* must be outside function: ** %s ** */
   1182   1.1       cgd 		warning(280, "PRINTFLIKE");
   1183   1.1       cgd 		return;
   1184   1.1       cgd 	}
   1185  1.49    rillig 	if (printflike_argnum != -1) {
   1186   1.1       cgd 		/* duplicate use of ** %s ** */
   1187   1.1       cgd 		warning(281, "PRINTFLIKE");
   1188   1.1       cgd 	}
   1189  1.49    rillig 	printflike_argnum = n;
   1190  1.36    rillig 	printflike_pos = curr_pos;
   1191   1.1       cgd }
   1192   1.1       cgd 
   1193   1.1       cgd /*
   1194   1.1       cgd  * SCANFLIKE comment
   1195   1.1       cgd  *
   1196   1.1       cgd  * Check all arguments until the (n-1)-th as usual. The n-th argument is
   1197   1.1       cgd  * used the check the types of remaining arguments.
   1198   1.1       cgd  */
   1199   1.1       cgd void
   1200  1.14     lukem scanflike(int n)
   1201   1.1       cgd {
   1202  1.14     lukem 
   1203   1.1       cgd 	if (n == -1)
   1204   1.1       cgd 		n = 0;
   1205   1.1       cgd 
   1206   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1207   1.1       cgd 		/* must be outside function: ** %s ** */
   1208   1.1       cgd 		warning(280, "SCANFLIKE");
   1209   1.1       cgd 		return;
   1210   1.1       cgd 	}
   1211  1.49    rillig 	if (scanflike_argnum != -1) {
   1212   1.1       cgd 		/* duplicate use of ** %s ** */
   1213   1.1       cgd 		warning(281, "SCANFLIKE");
   1214   1.1       cgd 	}
   1215  1.49    rillig 	scanflike_argnum = n;
   1216  1.36    rillig 	scanflike_pos = curr_pos;
   1217   1.1       cgd }
   1218   1.1       cgd 
   1219   1.1       cgd /*
   1220  1.50    rillig  * Set the line number for a CONSTCOND comment. At this and the following
   1221   1.1       cgd  * line no warnings about constants in conditional contexts are printed.
   1222   1.1       cgd  */
   1223   1.1       cgd /* ARGSUSED */
   1224   1.1       cgd void
   1225  1.14     lukem constcond(int n)
   1226   1.1       cgd {
   1227  1.14     lukem 
   1228  1.59    rillig 	constcond_flag = true;
   1229   1.1       cgd }
   1230   1.1       cgd 
   1231   1.1       cgd /*
   1232   1.1       cgd  * Suppress printing of "fallthrough on ..." warnings until next
   1233   1.1       cgd  * statement.
   1234   1.1       cgd  */
   1235   1.1       cgd /* ARGSUSED */
   1236   1.1       cgd void
   1237  1.14     lukem fallthru(int n)
   1238   1.1       cgd {
   1239  1.14     lukem 
   1240  1.78    rillig 	seen_fallthrough = true;
   1241   1.1       cgd }
   1242   1.1       cgd 
   1243   1.1       cgd /*
   1244   1.1       cgd  * Stop warnings about statements which cannot be reached. Also tells lint
   1245   1.1       cgd  * that the following statements cannot be reached (e.g. after exit()).
   1246   1.1       cgd  */
   1247   1.1       cgd /* ARGSUSED */
   1248   1.1       cgd void
   1249  1.14     lukem notreach(int n)
   1250   1.1       cgd {
   1251  1.14     lukem 
   1252  1.59    rillig 	reached = false;
   1253  1.59    rillig 	rchflg = true;
   1254   1.1       cgd }
   1255   1.1       cgd 
   1256   1.1       cgd /* ARGSUSED */
   1257   1.1       cgd void
   1258  1.14     lukem lintlib(int n)
   1259   1.1       cgd {
   1260  1.14     lukem 
   1261   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1262   1.1       cgd 		/* must be outside function: ** %s ** */
   1263   1.1       cgd 		warning(280, "LINTLIBRARY");
   1264   1.1       cgd 		return;
   1265   1.1       cgd 	}
   1266  1.59    rillig 	llibflg = true;
   1267  1.59    rillig 	vflag = false;
   1268   1.1       cgd }
   1269   1.1       cgd 
   1270   1.1       cgd /*
   1271   1.1       cgd  * Suppress most warnings at the current and the following line.
   1272   1.1       cgd  */
   1273   1.1       cgd /* ARGSUSED */
   1274   1.1       cgd void
   1275  1.14     lukem linted(int n)
   1276   1.1       cgd {
   1277  1.14     lukem 
   1278  1.12  christos #ifdef DEBUG
   1279  1.25  christos 	printf("%s, %d: lwarn = %d\n", curr_pos.p_file, curr_pos.p_line, n);
   1280  1.12  christos #endif
   1281  1.25  christos 	lwarn = n;
   1282  1.16   thorpej }
   1283  1.16   thorpej 
   1284  1.16   thorpej /*
   1285  1.16   thorpej  * Suppress bitfield type errors on the current line.
   1286  1.16   thorpej  */
   1287  1.16   thorpej /* ARGSUSED */
   1288  1.16   thorpej void
   1289  1.16   thorpej bitfieldtype(int n)
   1290  1.16   thorpej {
   1291  1.16   thorpej 
   1292  1.16   thorpej #ifdef DEBUG
   1293  1.47    rillig 	printf("%s, %d: bitfieldtype_ok = true\n", curr_pos.p_file,
   1294  1.16   thorpej 	    curr_pos.p_line);
   1295  1.16   thorpej #endif
   1296  1.47    rillig 	bitfieldtype_ok = true;
   1297   1.1       cgd }
   1298   1.1       cgd 
   1299   1.1       cgd /*
   1300  1.28    rillig  * PROTOLIB in conjunction with LINTLIBRARY can be used to handle
   1301   1.1       cgd  * prototypes like function definitions. This is done if the argument
   1302  1.28    rillig  * to PROTOLIB is nonzero. Otherwise prototypes are handled normally.
   1303   1.1       cgd  */
   1304   1.1       cgd void
   1305  1.14     lukem protolib(int n)
   1306   1.1       cgd {
   1307  1.14     lukem 
   1308   1.3       jpo 	if (dcs->d_ctx != EXTERN) {
   1309   1.1       cgd 		/* must be outside function: ** %s ** */
   1310   1.1       cgd 		warning(280, "PROTOLIB");
   1311   1.1       cgd 		return;
   1312   1.1       cgd 	}
   1313  1.59    rillig 	plibflg = n != 0;
   1314   1.6       jpo }
   1315   1.6       jpo 
   1316  1.59    rillig /* The next statement/declaration may use "long long" without a diagnostic. */
   1317   1.6       jpo /* ARGSUSED */
   1318   1.6       jpo void
   1319  1.14     lukem longlong(int n)
   1320   1.6       jpo {
   1321  1.14     lukem 
   1322  1.59    rillig 	quadflg = true;
   1323   1.1       cgd }
   1324