WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/variable.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "config.h"
 #include "c_types.h"
 #include "ctype_ops.h"
 #include "exp_ops.h"
 #include "hashid_ops.h"
     analysis on function parameters and to 2 to suppress all variable
     analysis.  The flag anon_c_linkage may be set to true to indicate
     that objects with C linkage in anonymous namespaces are anonymous.
 */
-int suppress_variable = 0 ;
+int suppress_variable = 0;
-int anon_c_linkage = 0 ;
+int anon_c_linkage = 0;
 /*
     CHECK A VARIABLE OR FUNCTION USAGE
     example, the reach of a local variable is its scope, that of an internal
     variable is its translation unit, and that of an external variable is
     its entire program.
 */
-static void check_usage
+static void
-    PROTO_N ( ( id, blk, anon ) )
-    PROTO_T ( IDENTIFIER id X EXP blk X int anon )
+check_usage(IDENTIFIER id, EXP blk, int anon)
+{
-    int opt ;
+	int opt;
-    ERROR err ;
+	ERROR err;
-    LOCATION loc ;
+	LOCATION loc;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    if ( !IS_hashid_anon ( nm ) ) {
+	if (!IS_hashid_anon(nm)) {
-	/* Ignore anonymous identifiers */
+		/* Ignore anonymous identifiers */
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( anon == ANON_NAMESPACE && ( ds & dspec_c ) ) {
+		if (anon == ANON_NAMESPACE && (ds & dspec_c)) {
-	    if ( !anon_c_linkage ) anon = ANON_NONE ;
+			if (!anon_c_linkage) {
-	}
-	if ( ds & dspec_static ) {
-	    if ( !IS_NULL_exp ( blk ) || suppress_variable == 2 ) {
-		/* Global statics are external to a block etc. */
-		ds |= dspec_extern ;
+				anon = ANON_NONE;
-	    }
+			}
-	}
+		}
-	if ( anon || !( ds & dspec_extern ) ) {
-	    if ( ds & dspec_implicit ) {
-		/* Ignore implicitly declared constructors etc. */
-		/* EMPTY */
-	    } else if ( ds & ( dspec_inherit | dspec_alias ) ) {
-		/* Don't deal with inherited members here */
-		/* EMPTY */
-	    } else if ( ds & dspec_token ) {
-		/* Ignore tokenised identifiers */
-		/* EMPTY */
-	    } else if ( ds & dspec_defn ) {
-		if ( ds & dspec_used ) {
+		if (ds & dspec_static) {
-		    /* Defined and used */
-		    /* EMPTY */
-		} else {
-		    /* Defined but not used */
-		    if ( ds & ( dspec_inline | dspec_virtual ) ) {
+			if (!IS_NULL_exp(blk) || suppress_variable == 2) {
-			/* Ignore inline and virtual functions */
+				/* Global statics are external to a block
-			/* EMPTY */
+				 * etc. */
-		    } else {
-			if ( ds & dspec_auto ) {
+				ds |= dspec_extern;
-			    err = ERR_stmt_dcl_unused ( id ) ;
-			} else {
-			    if ( ds & dspec_static ) {
-				opt = OPT_discard_static ;
-			    } else {
-				opt = OPT_variable ;
-			    }
-			    err = ERR_basic_odr_unused ( id ) ;
-			    err = set_severity ( err, opt, 0 ) ;
-			}
-			if ( !IS_NULL_err ( err ) ) {
-			    DEREF_loc ( id_loc ( id ), loc ) ;
-			    report ( loc, err ) ;
 			}
-		    }
+		}
+		if (anon || !(ds & dspec_extern)) {
+			if (ds & dspec_implicit) {
+				/* Ignore implicitly declared constructors
-	    } else {
+				 * etc. */
+				/* EMPTY */
+			} else if (ds & (dspec_inherit | dspec_alias)) {
+				/* Don't deal with inherited members here */
+				/* EMPTY */
+			} else if (ds & dspec_token) {
+				/* Ignore tokenised identifiers */
+				/* EMPTY */
+			} else if (ds & dspec_defn) {
-		if ( ds & dspec_used ) {
+				if (ds & dspec_used) {
+					/* Defined and used */
+					/* EMPTY */
+				} else {
-		    /* Used but not defined */
+					/* Defined but not used */
-		    if ( IS_id_class_name_etc ( id ) ) {
+					if (ds & (dspec_inline |
+						  dspec_virtual)) {
+						/* Ignore inline and virtual
-			/* Alright for type names */
+						 * functions */
-			/* EMPTY */
+						/* EMPTY */
-		    } else {
+					} else {
-			if ( ds & dspec_inline ) {
+						if (ds & dspec_auto) {
+							err = ERR_stmt_dcl_unused(id);
+						} else {
+							if (ds & dspec_static) {
+								opt = OPT_discard_static;
+							} else {
+								opt = OPT_variable;
+							}
-			    err = ERR_basic_odr_inline ( id ) ;
+							err = ERR_basic_odr_unused(id);
+							err = set_severity(err, opt, 0);
+						}
+						if (!IS_NULL_err(err)) {
+							DEREF_loc(id_loc(id),
+								  loc);
+							report(loc, err);
+						}
+					}
+				}
 			} else {
+				if (ds & dspec_used) {
+					/* Used but not defined */
+					if (IS_id_class_name_etc(id)) {
+						/* Alright for type names */
+						/* EMPTY */
+					} else {
+						if (ds & dspec_inline) {
+							err = ERR_basic_odr_inline(id);
+						} else {
-			    err = ERR_basic_odr_undef ( id ) ;
+							err = ERR_basic_odr_undef(id);
+						}
+						if (!IS_NULL_err(err)) {
+							DEREF_loc(id_loc(id),
+								  loc);
+							report(loc, err);
+						}
+						ds |= dspec_defn;
+						COPY_dspec(id_storage(id), ds);
+					}
+				} else if (ds & dspec_virtual) {
+					/* Undefined virtual function */
+					if (ds & dspec_pure) {
+						/* Allow pure virtual
+						 * functions */
+						/* EMPTY */
+					} else {
+						err = ERR_basic_odr_undef(id);
+						if (!IS_NULL_err(err)) {
+							DEREF_loc(id_loc(id),
+								  loc);
+							report(loc, err);
+						}
+					}
+				} else if (ds & dspec_inline) {
+					/* Ignore inline functions */
+					/* EMPTY */
+				} else {
+					/* Not used or defined */
+					if (ds & dspec_static) {
+						opt = OPT_discard_static;
+					} else {
+						opt = OPT_variable;
+					}
+					err = ERR_basic_odr_redundant(id);
+					err = set_severity(err, opt, 0);
+					if (!IS_NULL_err(err)) {
+						DEREF_loc(id_loc(id), loc);
+						report(loc, err);
+					}
+				}
+			}
-			if ( !IS_NULL_err ( err ) ) {
-			    DEREF_loc ( id_loc ( id ), loc ) ;
-			    report ( loc, err ) ;
-			}
-			ds |= dspec_defn ;
-			COPY_dspec ( id_storage ( id ), ds ) ;
-		    }
-		} else if ( ds & dspec_virtual ) {
-		    /* Undefined virtual function */
-		    if ( ds & dspec_pure ) {
-			/* Allow pure virtual functions */
-			/* EMPTY */
-		    } else {
-			err = ERR_basic_odr_undef ( id ) ;
-			if ( !IS_NULL_err ( err ) ) {
-			    DEREF_loc ( id_loc ( id ), loc ) ;
-			    report ( loc, err ) ;
-			}
-		    }
-		} else if ( ds & dspec_inline ) {
-		    /* Ignore inline functions */
-		    /* EMPTY */
-		} else {
-		    /* Not used or defined */
-		    if ( ds & dspec_static ) {
-			opt = OPT_discard_static ;
-		    } else {
-			opt = OPT_variable ;
-		    }
-		    err = ERR_basic_odr_redundant ( id ) ;
-		    err = set_severity ( err, opt, 0 ) ;
-		    if ( !IS_NULL_err ( err ) ) {
-			DEREF_loc ( id_loc ( id ), loc ) ;
-			report ( loc, err ) ;
-		    }
+		}
-	    }
+	}
-    }
-    return ;
+	return;
+}
 /*
     CHECK A TEMPLATE IDENTIFIER
     This routine calls check_identifier for each instance of the template
     id.  t gives the template type, otherwise the parameters are as in
     check_identifier.
 */
-static void check_template_id
+static void
+check_template_id(TYPE t, IDENTIFIER id, NAMESPACE ns, EXP blk, int anon,
+		  int chk)
+{
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
+	if (!(ds & dspec_done)) {
+		/* Scan through template applications */
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
+		INSTANCE apps = DEREF_inst(tok_templ_apps(sort));
-    PROTO_N ( ( t, id, ns, blk, anon, chk ) )
+		COPY_dspec(id_storage(id), (ds | dspec_done));
+		while (!IS_NULL_inst(apps)) {
-    PROTO_T ( TYPE t X IDENTIFIER id X NAMESPACE ns X EXP blk X
+			DECL_SPEC acc = DEREF_dspec(inst_templ_access(apps));
+			if (!(acc & (dspec_main | dspec_alias))) {
+				if ((acc & dspec_instance) &&
+				    !(acc & dspec_mutable)) {
+					IDENTIFIER aid =
+					    DEREF_id(inst_templ_id(apps));
+					IGNORE check_identifier(aid, ns, blk,
-	      int anon X int chk )
+								anon, chk);
+				}
+			}
+			apps = DEREF_inst(inst_next(apps));
+		}
+		if (spec_unit) {
+			spec_unit = save_end(spec_unit, NULL_nspace);
+		}
+		COPY_dspec(id_storage(id), ds);
+	}
+	return;
+}
+/*
+    CHECK A CLASS USAGE
+    This routine checks the class usage information cu for the type ct.
+*/
+static void
+check_class_usage(CLASS_TYPE ct, CLASS_USAGE cu)
+{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	LOCATION loc;
-    if ( !( ds & dspec_done ) ) {
+	if (cu & cusage_destr) {
-	/* Scan through template applications */
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+		IDENTIFIER id = DEREF_id(ctype_destr(ct));
-	INSTANCE apps = DEREF_inst ( tok_templ_apps ( sort ) ) ;
-	COPY_dspec ( id_storage ( id ), ( ds | dspec_done ) ) ;
-	while ( !IS_NULL_inst ( apps ) ) {
+		if (!IS_NULL_id(id) && IS_id_mem_func(id)) {
-	    DECL_SPEC acc = DEREF_dspec ( inst_templ_access ( apps ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( !( acc & ( dspec_main | dspec_alias ) ) ) {
+			if (!(ds & dspec_trivial)) {
-		if ( ( acc & dspec_instance ) && !( acc & dspec_mutable ) ) {
-		    IDENTIFIER aid = DEREF_id ( inst_templ_id ( apps ) ) ;
+				DEREF_loc(id_loc(id), loc);
-		    IGNORE check_identifier ( aid, ns, blk, anon, chk ) ;
+				report(loc, ERR_expr_delete_post(id));
+			}
+		}
-	    }
-	    apps = DEREF_inst ( inst_next ( apps ) ) ;
+	}
-	if ( spec_unit ) spec_unit = save_end ( spec_unit, NULL_nspace ) ;
-	COPY_dspec ( id_storage ( id ), ds ) ;
-    }
-    return ;
-}
-/*
-    CHECK A CLASS USAGE
-    This routine checks the class usage information cu for the type ct.
-*/
-static void check_class_usage
-    PROTO_N ( ( ct, cu ) )
-    PROTO_T ( CLASS_TYPE ct X CLASS_USAGE cu )
-{
-    LOCATION loc ;
-    if ( cu & cusage_destr ) {
+	if (cu & cusage_delete) {
-	IDENTIFIER id = DEREF_id ( ctype_destr ( ct ) ) ;
+		IDENTIFIER id = find_operator(ct, lex_delete);
-	if ( !IS_NULL_id ( id ) && IS_id_mem_func ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    if ( !( ds & dspec_trivial ) ) {
-		DEREF_loc ( id_loc ( id ), loc ) ;
+			DEREF_loc(id_loc(id), loc);
-		report ( loc, ERR_expr_delete_post ( id ) ) ;
+			report(loc, ERR_expr_delete_post(id));
-	    }
+		}
 	}
-    }
-    if ( cu & cusage_delete ) {
+	if (cu & cusage_delete_array) {
-	IDENTIFIER id = find_operator ( ct, lex_delete ) ;
+		IDENTIFIER id = find_operator(ct, lex_delete_Harray);
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    DEREF_loc ( id_loc ( id ), loc ) ;
+			DEREF_loc(id_loc(id), loc);
-	    report ( loc, ERR_expr_delete_post ( id ) ) ;
+			report(loc, ERR_expr_delete_post(id));
-	}
+		}
-    }
-    if ( cu & cusage_delete_array ) {
-	IDENTIFIER id = find_operator ( ct, lex_delete_Harray ) ;
-	if ( !IS_NULL_id ( id ) ) {
-	    DEREF_loc ( id_loc ( id ), loc ) ;
-	    report ( loc, ERR_expr_delete_post ( id ) ) ;
+	}
-    }
-    if ( cu & cusage_address ) {
+	if (cu & cusage_address) {
-	IDENTIFIER id = find_operator ( ct, lex_and_H1 ) ;
+		IDENTIFIER id = find_operator(ct, lex_and_H1);
-	while ( !IS_NULL_id ( id ) && IS_id_function_etc ( id ) ) {
+		while (!IS_NULL_id(id) && IS_id_function_etc(id)) {
-	    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
+			TYPE t = DEREF_type(id_function_etc_type(id));
-	    if ( min_no_args ( t ) == 1 ) {
+			if (min_no_args(t) == 1) {
-		DEREF_loc ( id_loc ( id ), loc ) ;
+				DEREF_loc(id_loc(id), loc);
-		report ( loc, ERR_expr_unary_op_ref_post ( id ) ) ;
+				report(loc, ERR_expr_unary_op_ref_post(id));
-		break ;
+				break;
-	    }
+			}
-	    id = DEREF_id ( id_function_etc_over ( id ) ) ;
+			id = DEREF_id(id_function_etc_over(id));
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     COMPLETE A TENTATIVE DEFINITION
     This routine completes a C-style tentative definition of the
     variable id.  That is, if id has not been defined elsewhere, then
     it is defined to be zero.
 */
-static int define_tentative
+static int
-    PROTO_N ( ( id, anon ) )
-    PROTO_T ( IDENTIFIER id X int anon )
+define_tentative(IDENTIFIER id, int anon)
 {
-    int def = 0 ;
+	int def = 0;
-    EXP e = DEREF_exp ( id_variable_etc_init ( id ) ) ;
+	EXP e = DEREF_exp(id_variable_etc_init(id));
-    if ( !IS_NULL_exp ( e ) && IS_exp_zero ( e ) ) {
+	if (!IS_NULL_exp(e) && IS_exp_zero(e)) {
-	LOCATION loc ;
+		LOCATION loc;
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	TYPE t = DEREF_type ( id_variable_etc_type ( id ) ) ;
+		TYPE t = DEREF_type(id_variable_etc_type(id));
-	bad_crt_loc++ ;
+		bad_crt_loc++;
-	loc = crt_loc ;
+		loc = crt_loc;
-	DEREF_loc ( id_loc ( id ), crt_loc ) ;
+		DEREF_loc(id_loc(id), crt_loc);
-	if ( anon || !( ds & dspec_extern ) ) {
+		if (anon || !(ds & dspec_extern)) {
-	    /* Types for internal objects should be complete */
+			/* Types for internal objects should be complete */
-	    ERROR err = check_complete ( t ) ;
+			ERROR err = check_complete(t);
-	    if ( !IS_NULL_err ( err ) ) {
+			if (!IS_NULL_err(err)) {
-		ERROR err2 = ERR_basic_types_tent_incompl ( id ) ;
+				ERROR err2 = ERR_basic_types_tent_incompl(id);
-		err = concat_error ( err, err2 ) ;
+				err = concat_error(err, err2);
-		report ( crt_loc, err ) ;
+				report(crt_loc, err);
-            }
+			}
-	}
+		}
-	if ( IS_type_array ( t ) ) {
+		if (IS_type_array(t)) {
-	    /* Complete array 'A []' to 'A [1]' */
+			/* Complete array 'A []' to 'A [1]' */
-	    NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+			NAT n = DEREF_nat(type_array_size(t));
-	    if ( IS_NULL_nat ( n ) ) {
+			if (IS_NULL_nat(n)) {
-		CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+				CV_SPEC qual = DEREF_cv(type_qual(t));
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+				TYPE s = DEREF_type(type_array_sub(t));
-		n = small_nat [1] ;
+				n = small_nat[1];
-		MAKE_type_array ( qual, s, n, t ) ;
+				MAKE_type_array(qual, s, n, t);
-		COPY_type ( id_variable_etc_type ( id ), t ) ;
+				COPY_type(id_variable_etc_type(id), t);
-	    }
+			}
-	}
+		}
-	e = init_general ( t, NULL_exp, id, 0 ) ;
+		e = init_general(t, NULL_exp, id, 0);
-	COPY_exp ( id_variable_etc_init ( id ), e ) ;
+		COPY_exp(id_variable_etc_init(id), e);
-	define_id ( id ) ;
+		define_id(id);
-	crt_loc = loc ;
+		crt_loc = loc;
-	bad_crt_loc-- ;
+		bad_crt_loc--;
-	def = 1 ;
+		def = 1;
-    }
+	}
-    return ( def ) ;
+	return (def);
 }
 /*
     CHECK A GLOBAL IDENTIFIER
     This routine applies the global program checks to the identifier id
     from the namespace ns.  If id is a class or namespace name then the
     checks are also applied recursively to the members of id.  The flag
     anon is true if the parent namespace of id is local to the current
     translation unit.  The routine returns the number of identifiers in
     id (allowing for overloaded functions).
 */
-unsigned long check_identifier
+unsigned long
-    PROTO_N ( ( id, ns, blk, anon, chk ) )
-    PROTO_T ( IDENTIFIER id X NAMESPACE ns X EXP blk X int anon X int chk )
+check_identifier(IDENTIFIER id, NAMESPACE ns, EXP blk, int anon, int chk)
 {
-    unsigned long n = 1 ;
+	unsigned long n = 1;
+	if (spec_unit) {
-    if ( spec_unit ) spec_unit = save_id ( spec_unit, id, ns ) ;
+		spec_unit = save_id(spec_unit, id, ns);
+	}
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_class_name_tag : {
+	case id_class_name_tag: {
-	    /* Check the members of a class */
+		/* Check the members of a class */
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( !( ds & dspec_implicit ) ) {
+		if (!(ds & dspec_implicit)) {
-		int templ = 0 ;
+			int templ = 0;
-		CLASS_TYPE ct ;
+			CLASS_TYPE ct;
-		CLASS_INFO ci ;
+			CLASS_INFO ci;
-		NAMESPACE cns ;
+			NAMESPACE cns;
-		int tchk = chk ;
+			int tchk = chk;
-		TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
+			TYPE t = DEREF_type(id_class_name_defn(id));
-		TYPE s = t ;
+			TYPE s = t;
-		while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		    /* Template classes */
+				/* Template classes */
-		    templ = 1 ;
+				templ = 1;
-		    tchk = 0 ;
+				tchk = 0;
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-		}
+			}
-		ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			ct = DEREF_ctype(type_compound_defn(t));
-		cns = DEREF_nspace ( ctype_member ( ct ) ) ;
+			cns = DEREF_nspace(ctype_member(ct));
-		ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+			ci = DEREF_cinfo(ctype_info(ct));
-		if ( ci & cinfo_complete ) {
+			if (ci & cinfo_complete) {
-		    /* Check class member namespace */
+				/* Check class member namespace */
-		    CLASS_USAGE cu = DEREF_cusage ( ctype_usage ( ct ) ) ;
+				CLASS_USAGE cu = DEREF_cusage(ctype_usage(ct));
-		    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+				IDENTIFIER cid = DEREF_id(ctype_name(ct));
-		    HASHID cnm = DEREF_hashid ( id_name ( cid ) ) ;
+				HASHID cnm = DEREF_hashid(id_name(cid));
-		    if ( IS_hashid_anon ( cnm ) ) anon = ANON_CLASS ;
+				if (IS_hashid_anon(cnm)) {
+					anon = ANON_CLASS;
+				}
 #if LANGUAGE_CPP
-		    if ( ( ci & cinfo_polymorphic ) && tchk ) {
+				if ((ci & cinfo_polymorphic) && tchk) {
-			/* Compile virtual function table */
+					/* Compile virtual function table */
-			compile_virtual ( ct, anon ) ;
+					compile_virtual(ct, anon);
-		    }
+				}
 #endif
-		    if ( cu != cusage_none ) {
+				if (cu != cusage_none) {
-			/* Check class usage */
+					/* Check class usage */
-			check_class_usage ( ct, cu ) ;
+					check_class_usage(ct, cu);
-		    }
+				}
-		} else {
+			} else {
-		    if ( ( ci & cinfo_incomplete ) && tchk ) {
+				if ((ci & cinfo_incomplete) && tchk) {
-			/* Report incomplete types */
+					/* Report incomplete types */
-			complete_class ( ct, 0 ) ;
+					complete_class(ct, 0);
-			ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+					ci = DEREF_cinfo(ctype_info(ct));
-			if ( !( ci & cinfo_complete ) ) {
+					if (!(ci & cinfo_complete)) {
-			    ERROR err = ERR_basic_types_completed ( t ) ;
+						ERROR err = ERR_basic_types_completed(t);
-			    if ( !IS_NULL_err ( err ) ) {
+						if (!IS_NULL_err(err)) {
-				LOCATION loc ;
+							LOCATION loc;
-				DEREF_loc ( id_loc ( id ), loc ) ;
+							DEREF_loc(id_loc(id),
+								  loc);
-				report ( loc, err ) ;
+							report(loc, err);
-			    }
+						}
+					}
+				}
+				cns = NULL_nspace;
+			}
+			IGNORE check_namespace(cns, NULL_exp, anon, tchk);
+			if (templ) {
+				/* Template classes */
+				check_template_id(s, id, ns, blk, anon, chk);
+			}
-		    }
-		    cns = NULL_nspace ;
-		}
-		IGNORE check_namespace ( cns, NULL_exp, anon, tchk ) ;
-		if ( templ ) {
-		    /* Template classes */
-		    check_template_id ( s, id, ns, blk, anon, chk ) ;
+		}
-	    }
-	    goto type_label ;
+		goto type_label;
-	}
-	case id_enum_name_tag :
-	case id_class_alias_tag :
-	case id_enum_alias_tag :
-	case id_type_alias_tag :
-	type_label : {
-	    /* Compile type names */
-	    if ( chk ) {
-		if ( anon ) check_usage ( id, blk, anon ) ;
-		if ( IS_NULL_exp ( blk ) ) compile_type ( id ) ;
-	    }
-	    break ;
-	}
-	case id_nspace_name_tag : {
-	    /* Check the members of a namespace */
-	    NAMESPACE cns = DEREF_nspace ( id_nspace_name_defn ( id ) ) ;
-	    n += check_namespace ( cns, NULL_exp, anon, chk ) ;
-	    break ;
+	}
-	case id_variable_tag : {
+	case id_enum_name_tag:
+	case id_class_alias_tag:
+	case id_enum_alias_tag:
+	case id_type_alias_tag:
+type_label:
-	    /* Check variable usage */
+		/* Compile type names */
-	    if ( chk ) {
+		if (chk) {
+			if (anon) {
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+				check_usage(id, blk, anon);
+			}
-		if ( ( ds & dspec_static ) && preserve_all ) {
+			if (IS_NULL_exp(blk)) {
-		    compile_preserve ( id ) ;
+				compile_type(id);
+			}
+		}
+		break;
+	case id_nspace_name_tag: {
+		/* Check the members of a namespace */
+		NAMESPACE cns = DEREF_nspace(id_nspace_name_defn(id));
+		n += check_namespace(cns, NULL_exp, anon, chk);
+		break;
+	}
+	case id_variable_tag:
+		/* Check variable usage */
+		if (chk) {
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
+			if ((ds & dspec_static) && preserve_all) {
+				compile_preserve(id);
+			}
-		check_usage ( id, blk, anon ) ;
+			check_usage(id, blk, anon);
-		if ( IS_NULL_exp ( blk ) ) {
+			if (IS_NULL_exp(blk)) {
-		    if ( ds & dspec_defn ) {
+				if (ds & dspec_defn) {
-			IGNORE define_tentative ( id, anon ) ;
+					IGNORE define_tentative(id, anon);
-		    }
+				}
-		    compile_variable ( id, 0 ) ;
+				compile_variable(id, 0);
-		} else {
+			} else {
-		    /* End of local block */
+				/* End of local block */
-		    if ( ds & dspec_auto ) {
+				if (ds & dspec_auto) {
-			EXP term ;
+					EXP term;
-			ds &= ~dspec_access ;
+					ds &= ~dspec_access;
-			COPY_dspec ( id_storage ( id ), ds ) ;
+					COPY_dspec(id_storage(id), ds);
-			term = DEREF_exp ( id_variable_etc_term ( id ) ) ;
+					term = DEREF_exp(id_variable_etc_term(id));
-			if ( !IS_NULL_exp ( term ) ) {
+					if (!IS_NULL_exp(term)) {
+						if (do_usage) {
+							dump_destr(id,
-			    if ( do_usage ) dump_destr ( id, &stmt_loc ) ;
+								   &stmt_loc);
+						}
+					}
+				}
+			}
-		    }
+		}
-	    }
-	    break ;
+		break;
-	}
-	case id_parameter_tag : {
+	case id_parameter_tag: {
-	    /* Check parameter usage */
+		/* Check parameter usage */
-	    if ( chk && suppress_variable == 0 ) {
+		if (chk && suppress_variable == 0) {
-		check_usage ( id, blk, anon ) ;
+			check_usage(id, blk, anon);
-	    }
+		}
-	    break ;
+		break;
 	}
-	case id_stat_member_tag : {
+	case id_stat_member_tag:
-	    /* Check static data member usage */
+		/* Check static data member usage */
-	    if ( anon == ANON_CLASS ) {
+		if (anon == ANON_CLASS) {
-		LOCATION loc ;
+			LOCATION loc;
-		DEREF_loc ( id_loc ( id ), loc ) ;
+			DEREF_loc(id_loc(id), loc);
-		report ( loc, ERR_class_static_data_anon ( id ) ) ;
+			report(loc, ERR_class_static_data_anon(id));
-	    }
-	    if ( chk ) {
-		check_usage ( id, blk, anon ) ;
-		if ( IS_NULL_exp ( blk ) ) {
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-		    if ( ds & dspec_defn ) {
-			IGNORE define_tentative ( id, anon ) ;
-		    }
-		    compile_variable ( id, 0 ) ;
+		}
+		if (chk) {
+			check_usage(id, blk, anon);
+			if (IS_NULL_exp(blk)) {
+				DECL_SPEC ds = DEREF_dspec(id_storage(id));
+				if (ds & dspec_defn) {
+					IGNORE define_tentative(id, anon);
+				}
+				compile_variable(id, 0);
+			}
+		}
+		break;
+	case id_function_tag:
+	case id_mem_func_tag:
+	case id_stat_mem_func_tag: {
+		/* Check member function usage */
+		TYPE t = DEREF_type(id_function_etc_type(id));
+		IDENTIFIER over = DEREF_id(id_function_etc_over(id));
+		if (!IS_NULL_id(over)) {
+			n += check_identifier(over, ns, blk, anon, chk);
+		}
+		if (IS_type_func(t)) {
+			/* Simple functions */
+			if (chk) {
+				DECL_SPEC ds = DEREF_dspec(id_storage(id));
+				if ((ds & dspec_static) && preserve_all) {
+					compile_preserve(id);
+				}
+				if (ds & dspec_inline) {
+					if (!anon) {
+						anon = ANON_INLINE;
-	    }
+					}
+				}
+				check_usage(id, blk, anon);
+				if (IS_NULL_exp(blk)) {
+					compile_function(id, 0);
+				}
+			}
+		} else {
+			/* Template functions */
+			check_template_id(t, id, ns, blk, anon, chk);
+		}
-	    break ;
+		break;
+	}
-	case id_function_tag :
+	case id_enumerator_tag:
-	case id_mem_func_tag :
-	case id_stat_mem_func_tag : {
-	    /* Check member function usage */
+		/* Check enumerator value */
-	    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
-	    IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
-	    if ( !IS_NULL_id ( over ) ) {
-		n += check_identifier ( over, ns, blk, anon, chk ) ;
-	    }
-	    if ( IS_type_func ( t ) ) {
-		/* Simple functions */
-		if ( chk ) {
+		if (chk) {
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			EXP e = DEREF_exp(id_enumerator_value(id));
-		    if ( ( ds & dspec_static ) && preserve_all ) {
+			if (overflow_exp(e)) {
-			compile_preserve ( id ) ;
+				compile_variable(id, 0);
-		    }
-		    if ( ds & dspec_inline ) {
-			if ( !anon ) anon = ANON_INLINE ;
-		    }
+			}
-		    check_usage ( id, blk, anon ) ;
-		    if ( IS_NULL_exp ( blk ) ) compile_function ( id, 0 ) ;
+		}
-	    } else {
-		/* Template functions */
-		check_template_id ( t, id, ns, blk, anon, chk ) ;
-	    }
-	    break ;
+		break;
-	}
-	case id_enumerator_tag : {
-	    /* Check enumerator value */
-	    if ( chk ) {
-		EXP e = DEREF_exp ( id_enumerator_value ( id ) ) ;
-		if ( overflow_exp ( e ) ) compile_variable ( id, 0 ) ;
-	    }
-	    break ;
-	}
-	case id_nspace_alias_tag :
+	case id_nspace_alias_tag:
-	case id_member_tag :
+	case id_member_tag:
-	case id_weak_param_tag : {
+	case id_weak_param_tag:
-	    /* Don't check these (yet) */
+		/* Don't check these (yet) */
-	    break ;
+		break;
+	}
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     CHECK A NAMESPACE
     of identifiers declared in ns.  ns may be a block scope associated
     with the statement blk.  The flag anon is true if the parent namespace
     of ns is local to the current translation unit.
 */
-unsigned long check_namespace
+unsigned long
-    PROTO_N ( ( ns, blk, anon, chk ) )
-    PROTO_T ( NAMESPACE ns X EXP blk X int anon X int chk )
+check_namespace(NAMESPACE ns, EXP blk, int anon, int chk)
+{
-    unsigned long n = 0 ;
+	unsigned long n = 0;
-    if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	MEMBER mem ;
+		MEMBER mem;
-	LIST ( IDENTIFIER ) extra ;
+		LIST(IDENTIFIER) extra;
-	/* Find namespace components */
+		/* Find namespace components */
-	switch ( TAG_nspace ( ns ) ) {
+		switch (TAG_nspace(ns)) {
-	    case nspace_named_tag :
+		case nspace_named_tag:
-	    case nspace_global_tag :
+		case nspace_global_tag:
-	    case nspace_ctype_tag : {
+		case nspace_ctype_tag:
-		mem = DEREF_member ( nspace_named_etc_first ( ns ) ) ;
+			mem = DEREF_member(nspace_named_etc_first(ns));
-		extra = DEREF_list ( nspace_named_etc_extra ( ns ) ) ;
+			extra = DEREF_list(nspace_named_etc_extra(ns));
-		break ;
+			break;
-	    }
-	    case nspace_unnamed_tag : {
+		case nspace_unnamed_tag:
-		mem = DEREF_member ( nspace_unnamed_first ( ns ) ) ;
+			mem = DEREF_member(nspace_unnamed_first(ns));
-		extra = DEREF_list ( nspace_unnamed_extra ( ns ) ) ;
+			extra = DEREF_list(nspace_unnamed_extra(ns));
-		if ( anon != ANON_GLOBAL && suppress_variable != 2 ) {
+			if (anon != ANON_GLOBAL && suppress_variable != 2) {
-		    anon = ANON_NAMESPACE ;
+				anon = ANON_NAMESPACE;
+			}
+			break;
+		default:
+			mem = DEREF_member(nspace_last(ns));
+			extra = NULL_list(IDENTIFIER);
+			anon = ANON_NONE;
+			break;
+		}
+		/* Scan through namespace members */
+		while (!IS_NULL_member(mem)) {
+			IDENTIFIER id = DEREF_id(member_id(mem));
+			IDENTIFIER alt = DEREF_id(member_alt(mem));
+			if (!IS_NULL_id(id)) {
+				n += check_identifier(id, ns, blk, anon, chk);
+			}
+			if (!IS_NULL_id(alt) && !EQ_id(id, alt)) {
+				n += check_identifier(alt, ns, blk, anon, chk);
+			}
+			mem = DEREF_member(member_next(mem));
+		}
-		break ;
-	    }
-	    default : {
-		mem = DEREF_member ( nspace_last ( ns ) ) ;
-		extra = NULL_list ( IDENTIFIER ) ;
-		anon = ANON_NONE ;
-		break ;
-	    }
-	}
-	/* Scan through namespace members */
+		/* Scan through extra namespace members */
-	while ( !IS_NULL_member ( mem ) ) {
+		while (!IS_NULL_list(extra)) {
-	    IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+			IDENTIFIER id = DEREF_id(HEAD_list(extra));
-	    IDENTIFIER alt = DEREF_id ( member_alt ( mem ) ) ;
-	    if ( !IS_NULL_id ( id ) ) {
-		n += check_identifier ( id, ns, blk, anon, chk ) ;
+			n += check_identifier(id, ns, blk, anon, chk);
-	    }
-	    if ( !IS_NULL_id ( alt ) && !EQ_id ( id, alt ) ) {
-		n += check_identifier ( alt, ns, blk, anon, chk ) ;
+			extra = TAIL_list(extra);
-	    }
+		}
-	    mem = DEREF_member ( member_next ( mem ) ) ;
 	}
-	/* Scan through extra namespace members */
-	while ( !IS_NULL_list ( extra ) ) {
+	if (spec_unit) {
-	    IDENTIFIER id = DEREF_id ( HEAD_list ( extra ) ) ;
-	    n += check_identifier ( id, ns, blk, anon, chk ) ;
-	    extra = TAIL_list ( extra ) ;
+		spec_unit = save_end(spec_unit, ns);
+	}
-    }
-    if ( spec_unit ) spec_unit = save_end ( spec_unit, ns ) ;
-    return ( n ) ;
+	return (n);
+}
 /*
     CHECK THE TOKEN NAMESPACE
     This routine applies the usage checks to the tokens declared in the
     translation unit.
 */
-static void check_token
+static void
-    PROTO_Z ()
+check_token(void)
+{
-    NAMESPACE ns = token_namespace ;
+    NAMESPACE ns = token_namespace;
-    MEMBER mem = DEREF_member ( nspace_global_first ( ns ) ) ;
+    MEMBER mem = DEREF_member(nspace_global_first(ns));
-    while ( !IS_NULL_member ( mem ) ) {
+    while (!IS_NULL_member(mem)) {
-	IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER id = DEREF_id(member_id(mem));
-	if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	    DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( !( ds & dspec_done ) ) {
+	    if (!(ds & dspec_done)) {
-		if ( ds & dspec_defn ) {
+		if (ds & dspec_defn) {
 		    /* Defined token */
-		    compile_token ( id, 1 ) ;
+		    compile_token(id, 1);
-		} else if ( !( ds & dspec_pure ) ) {
+		} else if (!(ds & dspec_pure)) {
 		    /* Undefined token */
-		    LOCATION loc ;
+		    LOCATION loc;
-		    TOKEN tok = DEREF_tok ( id_token_sort ( id ) ) ;
+		    TOKEN tok = DEREF_tok(id_token_sort(id));
-		    bad_crt_loc++ ;
+		    bad_crt_loc++;
-		    loc = crt_loc ;
+		    loc = crt_loc;
-		    DEREF_loc ( id_loc ( id ), crt_loc ) ;
+		    DEREF_loc(id_loc(id), crt_loc);
-		    if ( IS_tok_func ( tok ) ) {
+		    if (IS_tok_func(tok)) {
 			/* Implicitly define 'FUNC' tokens */
-			IDENTIFIER fn = DEREF_id ( id_token_alt ( id ) ) ;
+			IDENTIFIER fn = DEREF_id(id_token_alt(id));
-			COPY_id ( tok_func_defn ( tok ), fn ) ;
+			COPY_id(tok_func_defn(tok), fn);
-			ds |= dspec_defn ;
+			ds |= dspec_defn;
-			COPY_dspec ( id_storage ( id ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
-			if ( !( ds & dspec_explicit ) ) {
+			if (!(ds & dspec_explicit)) {
 			    /* Not explicitly redeclared */
-			    report ( crt_loc, ERR_token_def_implicit ( id ) ) ;
+			    report(crt_loc, ERR_token_def_implicit(id));
+			}
-			use_func_id ( fn, 0, 0 ) ;
+			use_func_id(fn, 0, 0);
-			compile_function ( fn, 0 ) ;
+			compile_function(fn, 0);
-			compile_token ( id, 1 ) ;
+			compile_token(id, 1);
-		    } else if ( ds & dspec_static ) {
+		    } else if (ds & dspec_static) {
 			/* Check for built-in token definitions */
-			if ( builtin_token ( id ) != -1 ) {
+			if (builtin_token(id)!= -1) {
-			    ds = DEREF_dspec ( id_storage ( id ) ) ;
+			    ds = DEREF_dspec(id_storage(id));
-			    if ( !( ds & dspec_defn ) ) {
+			    if (!(ds & dspec_defn)) {
-				compile_token ( id, 0 ) ;
+				compile_token(id, 0);
+			    }
-			} else if ( suppress_variable != 2 ) {
+			} else if (suppress_variable != 2) {
-			    compile_token ( id, 0 ) ;
+			    compile_token(id, 0);
+			}
+		    }
-		    crt_loc = loc ;
+		    crt_loc = loc;
-		    bad_crt_loc-- ;
+		    bad_crt_loc--;
+		}
+	    }
+	}
-	mem = DEREF_member ( member_next ( mem ) ) ;
+	mem = DEREF_member(member_next(mem));
+    }
-    return ;
+    return;
+}
 /*
     CHECK THE GLOBAL NAMESPACE
     This routine applies check_namespace to the global namespace,
     including checking the main function if complete is true.  It also
     calls check_token.
 */
-unsigned long check_global
+unsigned long
-    PROTO_N ( ( complete ) )
-    PROTO_T ( int complete )
+check_global(int complete)
+{
-    /* Check main function if necessary */
+	/* Check main function if necessary */
-    unsigned long n ;
+	unsigned long n;
-    int anon = ANON_NONE ;
+	int anon = ANON_NONE;
-    NAMESPACE ns = global_namespace ;
+	NAMESPACE ns = global_namespace;
-    if ( complete && suppress_variable != 2 ) {
+	if (complete && suppress_variable != 2) {
-	IDENTIFIER id = main_function ;
+		IDENTIFIER id = main_function;
-	HASHID nm = KEYWORD ( lex_main ) ;
+		HASHID nm = KEYWORD(lex_main);
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    /* Look up if not defined */
+			/* Look up if not defined */
-	    MEMBER mem = search_member ( ns, nm, 0 ) ;
+			MEMBER mem = search_member(ns, nm, 0);
-	    if ( !IS_NULL_member ( mem ) ) {
+			if (!IS_NULL_member(mem)) {
-		id = DEREF_id ( member_id ( mem ) ) ;
+				id = DEREF_id(member_id(mem));
-		if ( !IS_NULL_id ( id ) && IS_id_function ( id ) ) {
+				if (!IS_NULL_id(id) && IS_id_function(id)) {
-		    main_function = id ;
+					main_function = id;
+				} else {
+					id = NULL_id;
+				}
+			}
+		}
+		if (IS_NULL_id(id)) {
+			id = DEREF_id(hashid_id(nm));
+			id = underlying_id(id);
+			report(builtin_loc, ERR_basic_odr_undef(id));
 		} else {
-		    id = NULL_id ;
-		}
-	    }
-	}
-	if ( IS_NULL_id ( id ) ) {
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
-	    id = underlying_id ( id ) ;
-	    report ( builtin_loc, ERR_basic_odr_undef ( id ) ) ;
-	} else {
-	    /* Mark as being used */
+			/* Mark as being used */
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    ds |= ( dspec_used | dspec_called ) ;
+			ds |= (dspec_used | dspec_called);
-	    COPY_dspec ( id_storage ( id ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
-	}
+		}
-	anon = ANON_GLOBAL ;
+		anon = ANON_GLOBAL;
-    }
+	}
-    /* Apply checks to namespaces */
+	/* Apply checks to namespaces */
-    begin_spec () ;
+	begin_spec();
-    n = check_namespace ( ns, NULL_exp, anon, 1 ) ;
+	n = check_namespace(ns, NULL_exp, anon, 1);
-    end_spec () ;
+	end_spec();
-    check_token () ;
+	check_token();
-    return ( n ) ;
+	return (n);
 }
 /*
     CONSTRUCT A SET EXPRESSION
     This routine constructs the expression 'set ( a )'.
 */
-EXP make_set_exp
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+make_set_exp(EXP a)
 {
-    EXP e ;
+	EXP e;
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    a = convert_lvalue ( a ) ;
+	a = convert_lvalue(a);
-    MAKE_exp_set ( type_void, a, e ) ;
+	MAKE_exp_set(type_void, a, e);
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT AN UNUSED EXPRESSION
     This routine constructs the expression 'unused ( a )'.
 */
-EXP make_unused_exp
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+make_unused_exp(EXP a)
 {
-    EXP e ;
+	EXP e;
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    a = convert_lvalue ( a ) ;
+	a = convert_lvalue(a);
-    MAKE_exp_unused ( type_void, a, e ) ;
+	MAKE_exp_unused(type_void, a, e);
-    return ( e ) ;
+	return (e);
 }
 /*
     PRESERVE ALL STATIC IDENTIFIERS
     This flag is set to true to indicate that all static identifiers
     should be preserved.
 */
-int preserve_all = 0 ;
+int preserve_all = 0;
 /*
     PRESERVE AN IDENTIFIER
     This routine preserves or suspends the static identifier id, as
     indicated by the action act.
 */
-void preserve_id
+void
-    PROTO_N ( ( id, act ) )
-    PROTO_T ( IDENTIFIER id X int act )
+preserve_id(IDENTIFIER id, int act)
+{
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_function_tag : {
+	case id_function_tag: {
-	    IDENTIFIER over = DEREF_id ( id_function_over ( id ) ) ;
+		IDENTIFIER over = DEREF_id(id_function_over(id));
-	    if ( !IS_NULL_id ( over ) ) preserve_id ( over, act ) ;
-	    goto action_lab ;
-	}
-	case id_variable_tag :
-	action_lab : {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    if ( ds & dspec_static ) {
-		if ( act == lex_preserve ) {
+		if (!IS_NULL_id(over)) {
-		    compile_preserve ( id ) ;
+			preserve_id(over, act);
-		} else if ( act == lex_suspend ) {
-		    ds |= dspec_used ;
-		    COPY_dspec ( id_storage ( id ), ds ) ;
+		}
+		goto action_lab;
+	}
+	case id_variable_tag:
+action_lab: {
+		    DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		    if (ds & dspec_static) {
+			    if (act == lex_preserve) {
+				    compile_preserve(id);
+			    } else if (act == lex_suspend) {
+				    ds |= dspec_used;
+				    COPY_dspec(id_storage(id), ds);
+			    }
+		    }
+		    break;
+	    }
-	    break ;
-	}
-	default : {
+	default: {
-	    ERROR err = ERR_pragma_preserve_undecl ( act, id ) ;
+		ERROR err = ERR_pragma_preserve_undecl(act, id);
-	    report ( preproc_loc, err ) ;
+		report(preproc_loc, err);
-	    break ;
+		break;
+	}
-    }
+	}
-    return ;
+	return;
+}
 /*
     FLOW ANALYSIS FLAGS
     analysis routines.  The fact that va_variable equals dspec_auto and
     va_done equals dspec_done is important, but the other values are
     merely convenient.
 */
-typedef DECL_SPEC VAR_INFO ;
+typedef DECL_SPEC VAR_INFO;
 #define va_none			dspec_none
 #define va_used_this		dspec_used
 #define va_set			dspec_defn
 #define va_maybe_set		dspec_inherit
-#define va_filter		( va_used_this | va_set | va_maybe_set )
+#define va_filter		(va_used_this | va_set | va_maybe_set)
 #define va_any_use		dspec_static
 #define va_any_set		dspec_extern
 #define va_done			dspec_done
 #define va_partial		dspec_explicit
 #define va_member		dspec_friend
 #define va_this			dspec_typedef
 #define va_dummy		dspec_pure
-#define va_alias		( va_alias_used | va_alias_set )
+#define va_alias		(va_alias_used | va_alias_set)
-#define va_becomes		( va_assign | va_dummy )
+#define va_becomes		(va_assign | va_dummy)
-#define va_other		( va_address | va_becomes | va_partial )
+#define va_other		(va_address | va_becomes | va_partial)
-#define va_mask			( va_alias | va_other )
+#define va_mask			(va_alias | va_other)
 #define va_unreached		dspec_main
 /*
     The following declarations are required for the flow analysis
     routines.
 */
-static VAR_INFO flow_exp PROTO_S ( ( EXP, VAR_INFO ) ) ;
+static VAR_INFO flow_exp(EXP, VAR_INFO);
-static VAR_INFO flow_alias_exp PROTO_S ( ( EXP, VAR_INFO ) ) ;
+static VAR_INFO flow_alias_exp(EXP, VAR_INFO);
-static VAR_INFO flow_stmt PROTO_S ( ( EXP, VAR_INFO, int ) ) ;
+static VAR_INFO flow_stmt(EXP, VAR_INFO, int);
-static VAR_INFO flow_offset PROTO_S ( ( OFFSET, VAR_INFO, int ) ) ;
+static VAR_INFO flow_offset(OFFSET, VAR_INFO, int);
-static void set_variable PROTO_S ( ( IDENTIFIER, VAR_INFO ) ) ;
+static void set_variable(IDENTIFIER, VAR_INFO);
 /*
     LIST OF CURRENTLY ACTIVE VARIABLES
     The variable crt_flow_vars is used to hold a list of all the local
     variables which are in scope at any point in the variable analysis
     routines.
 */
-typedef LIST ( VARIABLE ) VAR_LIST ;
+typedef LIST(VARIABLE) VAR_LIST;
-static VAR_LIST crt_flow_vars = NULL_list ( VARIABLE ) ;
+static VAR_LIST crt_flow_vars = NULL_list(VARIABLE);
-static VAR_LIST crt_flow_mems = NULL_list ( VARIABLE ) ;
+static VAR_LIST crt_flow_mems = NULL_list(VARIABLE);
-static LIST ( IDENTIFIER ) crt_flow_assign = NULL_list ( IDENTIFIER ) ;
+static LIST(IDENTIFIER) crt_flow_assign = NULL_list(IDENTIFIER);
 /*
     START VARIABLE ANALYSIS
     This routine is called at the start of the analysis of the local
     variable id.
 */
-static void start_variable
+static void
-    PROTO_N ( ( id, ds, use ) )
-    PROTO_T ( IDENTIFIER id X DECL_SPEC ds X VAR_INFO use )
+start_variable(IDENTIFIER id, DECL_SPEC ds, VAR_INFO use)
+{
-    VARIABLE var ;
+	VARIABLE var;
-    use |= ( va_variable | va_done | va_used_this ) ;
+	use |= (va_variable | va_done | va_used_this);
-    if ( !( ds & dspec_used ) ) use |= va_ignore ;
+	if (!(ds & dspec_used)) {
+		use |= va_ignore;
+	}
-    var.id = id ;
+	var.id = id;
-    var.info = DEREF_dspec ( id_storage ( id ) ) ;
+	var.info = DEREF_dspec(id_storage(id));
-    COPY_dspec ( id_storage ( id ), use ) ;
+	COPY_dspec(id_storage(id), use);
-    CONS_var ( var, crt_flow_vars, crt_flow_vars ) ;
+	CONS_var(var, crt_flow_vars, crt_flow_vars);
-    DEREF_loc ( id_loc ( id ), stmt_loc ) ;
+	DEREF_loc(id_loc(id), stmt_loc);
-    return ;
+	return;
+}
 /*
     SHOULD VARIABLE ANALYSIS BE IGNORED?
     This routine checks whether any variable analysis errors involving
     the local variable id should be ignored.  This is done if id is an
     anonymous identifier or is a const variable all of whose uses have
     been replaced by its definition (see convert_lvalue).
 */
-static int ignore_variable
+static int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+ignore_variable(IDENTIFIER id)
 {
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    if ( IS_hashid_anon ( nm ) ) return ( 1 ) ;
+	if (IS_hashid_anon(nm)) {
+		return (1);
+	}
-    if ( IS_id_variable ( id ) ) {
+	if (IS_id_variable(id)) {
-	TYPE t = DEREF_type ( id_variable_type ( id ) ) ;
+		TYPE t = DEREF_type(id_variable_type(id));
-	CV_SPEC cv = find_cv_qual ( t ) ;
+		CV_SPEC cv = find_cv_qual(t);
-	if ( cv & cv_volatile ) {
+		if (cv & cv_volatile) {
-	    /* Ignore volatile variables */
+			/* Ignore volatile variables */
-	    return ( 1 ) ;
+			return (1);
-	}
+		}
-	if ( cv == ( cv_const | cv_lvalue ) ) {
+		if (cv == (cv_const | cv_lvalue)) {
-	    /* Check for const variables */
+			/* Check for const variables */
-	    EXP e = DEREF_exp ( id_variable_init ( id ) ) ;
+			EXP e = DEREF_exp(id_variable_init(id));
-	    if ( !IS_NULL_exp ( e ) ) {
+			if (!IS_NULL_exp(e)) {
-		if ( IS_exp_int_lit ( e ) ) return ( 1 ) ;
+				if (IS_exp_int_lit(e)) {
+					return (1);
+				}
-		if ( IS_exp_null ( e ) ) return ( 1 ) ;
+				if (IS_exp_null(e)) {
+					return (1);
-	    }
+				}
+			}
-	}
+		}
-    } else if ( IS_id_member ( id ) ) {
+	} else if (IS_id_member(id)) {
-	TYPE t = DEREF_type ( id_member_type ( id ) ) ;
+		TYPE t = DEREF_type(id_member_type(id));
-	CV_SPEC cv = find_cv_qual ( t ) ;
+		CV_SPEC cv = find_cv_qual(t);
-	if ( cv & cv_volatile ) {
+		if (cv & cv_volatile) {
-	    /* Ignore volatile members */
+			/* Ignore volatile members */
-	    return ( 1 ) ;
+			return (1);
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     END A VARIABLE SETTING
     This routine marks the end of the variable setting ds.  ret is true if
     this end of scope is due to a return statement.  In particular it
     checks whether the variable has been assigned to and not used.
 */
-static VAR_INFO end_usage
+static VAR_INFO
-    PROTO_N ( ( id, ds, ret ) )
-    PROTO_T ( IDENTIFIER id X VAR_INFO ds X int ret )
+end_usage(IDENTIFIER id, VAR_INFO ds, int ret)
 {
-    if ( ret && ( ds & va_member ) ) {
+	if (ret && (ds & va_member)) {
-	/* Class members are used after return */
+		/* Class members are used after return */
-	if ( ret == 2 ) {
+		if (ret == 2) {
-	    set_variable ( id, va_member ) ;
+			set_variable(id, va_member);
-	    ds = DEREF_dspec ( id_storage ( id ) ) ;
+			ds = DEREF_dspec(id_storage(id));
-	} else {
+		} else {
-	    ds |= va_used_this ;
+			ds |= va_used_this;
-	}
+		}
-    } else if ( !( ds & va_used_this ) && ( ds & va_set ) ) {
+	} else if (!(ds & va_used_this) && (ds & va_set)) {
-	if ( !( ds & va_ignore ) && !ignore_variable ( id ) ) {
+		if (!(ds & va_ignore) && !ignore_variable(id)) {
-	    report ( stmt_loc, ERR_stmt_dcl_reset ( id ) ) ;
+			report(stmt_loc, ERR_stmt_dcl_reset(id));
-	    ds |= va_error ;
+			ds |= va_error;
+		}
+		ds |= va_used_this;
+	}
-	ds |= va_used_this ;
-    }
-    return ( ds ) ;
+	return (ds);
+}
 /*
     END VARIABLE ANALYSIS
     This routine is called at the end of the analysis of a local
     variable.  Note that unused variable have already been dealt with.
 */
-static void end_variable
+static void
-    PROTO_N ( ( flow, ret ) )
-    PROTO_T ( int flow X int ret )
+end_variable(int flow, int ret)
 {
-    VARIABLE var ;
+	VARIABLE var;
-    DESTROY_CONS_var ( destroy, var, crt_flow_vars, crt_flow_vars ) ;
+	DESTROY_CONS_var(destroy, var, crt_flow_vars, crt_flow_vars);
-    if ( flow ) {
+	if (flow) {
-	VAR_INFO use = DEREF_dspec ( id_storage ( var.id ) ) ;
+		VAR_INFO use = DEREF_dspec(id_storage(var.id));
-	use = end_usage ( var.id, use, ret ) ;
+		use = end_usage(var.id, use, ret);
-	if ( !( use & ( va_member | va_ignore ) ) ) {
+		if (!(use & (va_member | va_ignore))) {
-	    if ( !( use & va_any_use ) ) {
+			if (!(use & va_any_use)) {
-		/* Not used in reached code */
+				/* Not used in reached code */
-		if ( !ignore_variable ( var.id ) ) {
+				if (!ignore_variable(var.id)) {
-		    LOCATION loc ;
+					LOCATION loc;
-		    DEREF_loc ( id_loc ( var.id ), loc ) ;
+					DEREF_loc(id_loc(var.id), loc);
+					report(loc,
-		    report ( loc, ERR_stmt_dcl_unused ( var.id ) ) ;
+					       ERR_stmt_dcl_unused(var.id));
-		}
+				}
-	    } else if ( !( use & va_any_set ) ) {
+			} else if (!(use & va_any_set)) {
-		/* Not set in reached code */
+				/* Not set in reached code */
+				if (!(use & va_error) &&
-		if ( !( use & va_error ) && !ignore_variable ( var.id ) ) {
+				    !ignore_variable(var.id)) {
-		    LOCATION loc ;
+					LOCATION loc;
-		    DEREF_loc ( id_loc ( var.id ), loc ) ;
+					DEREF_loc(id_loc(var.id), loc);
-		    report ( loc, ERR_stmt_dcl_unset ( var.id ) ) ;
+					report(loc, ERR_stmt_dcl_unset(var.id));
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    COPY_dspec ( id_storage ( var.id ), var.info ) ;
+	COPY_dspec(id_storage(var.id), var.info);
-    return ;
+	return;
 }
 /*
     SET A VARIABLE
     This routine adjusts the variable analysis information for the local
     variable use according to the analysis state use.
 */
-static void set_variable
+static void
+set_variable(IDENTIFIER id, VAR_INFO use)
+{
+	if (!(use & va_unreached)) {
+		VAR_INFO ds = DEREF_dspec(id_storage(id));
+		if (use & va_assign) {
+			/* Assignment */
+			if (use & va_dummy) {
+				set_variable(id, va_none);
+				ds = DEREF_dspec(id_storage(id));
+			}
+			if (use & va_partial) {
+				/* Partial assignment */
+				ds |= (va_maybe_set | va_any_set);
+				ds |= va_used_this;
+			} else {
+				/* Complete assignment */
+				ds = end_usage(id, ds, 0);
+				if (ds & va_assign) {
+					if (!(ds & va_ignore) &&
+					    !ignore_variable(id)) {
+						/* Multiple assignments */
+						report(stmt_loc,
+						       ERR_expr_ass_twice(id));
+						ds |= va_error;
+					}
+				}
+				CONS_id(id, crt_flow_assign, crt_flow_assign);
+				ds |= (va_set | va_maybe_set | va_any_set |
+				       va_assign);
+				ds &= ~va_used_this;
+			}
+		} else if (use & va_alias_set) {
+			/* Read-write alias */
+			ds |= (va_maybe_set | va_any_set);
+			ds |= (va_used_this | va_any_use);
+		} else if (use & va_alias_used) {
+			/* Read-only alias */
+			ds |= (va_used_this | va_any_use);
+		} else if (use & va_address) {
+			/* Address */
+			ds |= (va_used_this | va_any_use);
+		} else {
+			/* Use */
+			if (!(ds & (va_set | va_maybe_set))) {
+				/* Used without being set */
+				if (!(ds & va_ignore) && !ignore_variable(id)) {
+					ERROR err;
+					if (use & va_member) {
+						err = ERR_class_base_init_none(id);
+					} else {
+						err = ERR_stmt_dcl_unset(id);
+					}
+					report(stmt_loc, err);
+					ds |= va_error;
+				}
+				ds |= (va_maybe_set | va_any_set);
+			}
+			ds |= (va_used_this | va_any_use);
+		}
+		COPY_dspec(id_storage(id), ds);
+	}
+	return;
+}
+/*
-    PROTO_N ( ( id, use ) )
+    SET ALL CLASS MEMBERS
+    This routine calls set_variable for each of the class members in the
+    current variable list.
+*/
+static void
-    PROTO_T ( IDENTIFIER id X VAR_INFO use )
+set_members(VAR_INFO use)
+{
-    if ( !( use & va_unreached ) ) {
+	if (!(use & va_unreached)) {
-	VAR_INFO ds = DEREF_dspec ( id_storage ( id ) ) ;
+		VAR_LIST va = crt_flow_mems;
-	if ( use & va_assign ) {
+		while (!IS_NULL_list(va)) {
-	    /* Assignment */
-	    if ( use & va_dummy ) {
+			IDENTIFIER id = DEREF_id(var_id(HEAD_list(va)));
-		set_variable ( id, va_none ) ;
+			set_variable(id, use);
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    }
-	    if ( use & va_partial ) {
-		/* Partial assignment */
-		ds |= ( va_maybe_set | va_any_set ) ;
-		ds |= va_used_this ;
-	    } else {
-		/* Complete assignment */
-		ds = end_usage ( id, ds, 0 ) ;
-		if ( ds & va_assign ) {
-		    if ( !( ds & va_ignore ) && !ignore_variable ( id ) ) {
-			/* Multiple assignments */
-			report ( stmt_loc, ERR_expr_ass_twice ( id ) ) ;
-			ds |= va_error ;
+			va = TAIL_list(va);
-		    }
+		}
-		CONS_id ( id, crt_flow_assign, crt_flow_assign ) ;
-		ds |= ( va_set | va_maybe_set | va_any_set | va_assign ) ;
-		ds &= ~va_used_this ;
-	    }
-	} else if ( use & va_alias_set ) {
-	    /* Read-write alias */
-	    ds |= ( va_maybe_set | va_any_set ) ;
-	    ds |= ( va_used_this | va_any_use ) ;
-	} else if ( use & va_alias_used ) {
-	    /* Read-only alias */
-	    ds |= ( va_used_this | va_any_use ) ;
-	} else if ( use & va_address ) {
-	    /* Address */
-	    ds |= ( va_used_this | va_any_use ) ;
-	} else {
-	    /* Use */
-	    if ( !( ds & ( va_set | va_maybe_set ) ) ) {
-		/* Used without being set */
-		if ( !( ds & va_ignore ) && !ignore_variable ( id ) ) {
-		    ERROR err ;
-		    if ( use & va_member ) {
-			err = ERR_class_base_init_none ( id ) ;
-		    } else {
-			err = ERR_stmt_dcl_unset ( id ) ;
-		    }
-		    report ( stmt_loc, err ) ;
-		    ds |= va_error ;
-		}
-		ds |= ( va_maybe_set | va_any_set ) ;
-	    }
-	    ds |= ( va_used_this | va_any_use ) ;
+	}
-	COPY_dspec ( id_storage ( id ), ds ) ;
-    }
-    return ;
+	return;
+}
 /*
-    SET ALL CLASS MEMBERS
-    This routine calls set_variable for each of the class members in the
-    current variable list.
-*/
-static void set_members
-    PROTO_N ( ( use ) )
-    PROTO_T ( VAR_INFO use )
-{
-    if ( !( use & va_unreached ) ) {
-	VAR_LIST va = crt_flow_mems ;
-	while ( !IS_NULL_list ( va ) ) {
-	    IDENTIFIER id = DEREF_id ( var_id ( HEAD_list ( va ) ) ) ;
-	    set_variable ( id, use ) ;
-	    va = TAIL_list ( va ) ;
-	}
-    }
-    return ;
-}
-/*
     MERGE A VARIABLE SETTING
     This routine merges the variable analysis settings given by dp and dq.
     u indicates whether the variable set values are to be taken from dp,
     from dq, from both, or from neither.
 */
-static VAR_INFO merge_usage
+static VAR_INFO
-    PROTO_N ( ( dp, dq, u ) )
-    PROTO_T ( VAR_INFO dp X VAR_INFO dq X int u )
+merge_usage(VAR_INFO dp, VAR_INFO dq, int u)
+{
-    VAR_INFO ds = ( dp | dq ) ;
+	VAR_INFO ds = (dp | dq);
-    VAR_INFO dt = dspec_none ;
+	VAR_INFO dt = dspec_none;
-    switch ( u ) {
+	switch (u) {
+	case 0:
-	case 0 : dt = ( dp & dq ) ; break ;
+		dt = (dp & dq);
+		break;
+	case 1:
-	case 1 : dt = dp ; break ;
+		dt = dp;
+		break;
+	case 2:
-	case 2 : dt = dq ; break ;
+		dt = dq;
+		break;
-    }
+	}
-    ds = ( ( ds & ~va_filter ) | ( dt & va_filter ) ) ;
+	ds = ((ds & ~va_filter) | (dt & va_filter));
-    return ( ds ) ;
+	return (ds);
+}
 /*
     SEARCH A LIST OF VARIABLES
     This routine searches the list of variables p for one corresponding to
     id.  q is a member of p which corresponds to id is the simplest case.
     It returns a pointer to the variable if it exists and a null pointer
     otherwise.
 */
-static PTR ( VARIABLE ) search_vars
+static PTR(VARIABLE)
-    PROTO_N ( ( p, q, id ) )
-    PROTO_T ( VAR_LIST p X VAR_LIST q X IDENTIFIER id )
+search_vars(VAR_LIST p, VAR_LIST q, IDENTIFIER id)
 {
-    if ( !IS_NULL_list ( q ) ) {
+	if (!IS_NULL_list(q)) {
-	PTR ( VARIABLE ) ptr = HEAD_list ( q ) ;
+		PTR(VARIABLE) ptr = HEAD_list(q);
-	IDENTIFIER pid = DEREF_id ( var_id ( ptr ) ) ;
+		IDENTIFIER pid = DEREF_id(var_id(ptr));
-	if ( EQ_id ( pid, id ) ) return ( ptr ) ;
+		if (EQ_id(pid, id)) {
+			return (ptr);
-    }
+		}
+	}
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	PTR ( VARIABLE ) ptr = HEAD_list ( p ) ;
+		PTR(VARIABLE) ptr = HEAD_list(p);
-	IDENTIFIER pid = DEREF_id ( var_id ( ptr ) ) ;
+		IDENTIFIER pid = DEREF_id(var_id(ptr));
-	if ( EQ_id ( pid, id ) ) return ( ptr ) ;
+		if (EQ_id(pid, id)) {
+			return (ptr);
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( NULL_ptr ( VARIABLE ) ) ;
+	return (NULL_ptr(VARIABLE));
 }
 /*
     SAVE CURRENT VARIABLE SETTINGS
     This routine saves the current variable settings by merging them with
     those stored in the list va.
 */
-static VAR_LIST save_vars
+static VAR_LIST
-    PROTO_N ( ( va, cond ) )
-    PROTO_T ( VAR_LIST va X int cond )
+save_vars(VAR_LIST va, int cond)
 {
-    VAR_LIST vb = crt_flow_vars ;
+	VAR_LIST vb = crt_flow_vars;
-    VAR_LIST vc = va ;
+	VAR_LIST vc = va;
-    VAR_LIST vd = va ;
+	VAR_LIST vd = va;
-    while ( !IS_NULL_list ( vb ) ) {
+	while (!IS_NULL_list(vb)) {
-	VARIABLE var ;
+		VARIABLE var;
-	PTR ( VARIABLE ) pvar ;
+		PTR(VARIABLE) pvar;
-	var.id = DEREF_id ( var_id ( HEAD_list ( vb ) ) ) ;
+		var.id = DEREF_id(var_id(HEAD_list(vb)));
-	var.info = DEREF_dspec ( id_storage ( var.id ) ) ;
+		var.info = DEREF_dspec(id_storage(var.id));
-	if ( cond ) {
+		if (cond) {
-	    var.info |= va_used_this ;
+			var.info |= va_used_this;
-	    COPY_dspec ( id_storage ( var.id ), var.info ) ;
+			COPY_dspec(id_storage(var.id), var.info);
-	}
+		}
-	pvar = search_vars ( vc, vd, var.id ) ;
+		pvar = search_vars(vc, vd, var.id);
-	if ( IS_NULL_ptr ( pvar ) ) {
+		if (IS_NULL_ptr(pvar)) {
-	    /* Add new identifier to list */
+			/* Add new identifier to list */
-	    CONS_var ( var, va, va ) ;
+			CONS_var(var, va, va);
-	} else {
+		} else {
-	    /* Merge with existing information */
+			/* Merge with existing information */
-	    VAR_INFO acc = DEREF_dspec ( var_info ( pvar ) ) ;
+			VAR_INFO acc = DEREF_dspec(var_info(pvar));
-	    acc = merge_usage ( acc, var.info, 0 ) ;
+			acc = merge_usage(acc, var.info, 0);
-	    COPY_dspec ( var_info ( pvar ), acc ) ;
+			COPY_dspec(var_info(pvar), acc);
+		}
+		if (!IS_NULL_list(vd)) {
+			vd = TAIL_list(vd);
+		}
+		vb = TAIL_list(vb);
+	}
+	if (IS_NULL_list(vc)) {
+		va = REVERSE_list(va);
+	}
-	if ( !IS_NULL_list ( vd ) ) vd = TAIL_list ( vd ) ;
-	vb = TAIL_list ( vb ) ;
-    }
-    if ( IS_NULL_list ( vc ) ) va = REVERSE_list ( va ) ;
-    return ( va ) ;
+	return (va);
+}
 /*
     LOAD CURRENT VARIABLE SETTINGS
     This routine loads the current variable settings by merging them with
     those stored in the list va.
 */
-static void load_vars
+static void
-    PROTO_N ( ( va, u ) )
-    PROTO_T ( VAR_LIST va X int u )
+load_vars(VAR_LIST va, int u)
 {
-    VAR_LIST vb = crt_flow_vars ;
+	VAR_LIST vb = crt_flow_vars;
-    VAR_LIST vc = va ;
+	VAR_LIST vc = va;
-    while ( !IS_NULL_list ( vb ) ) {
+	while (!IS_NULL_list(vb)) {
-	IDENTIFIER id = DEREF_id ( var_id ( HEAD_list ( vb ) ) ) ;
+		IDENTIFIER id = DEREF_id(var_id(HEAD_list(vb)));
-	VAR_INFO acc = DEREF_dspec ( id_storage ( id ) ) ;
+		VAR_INFO acc = DEREF_dspec(id_storage(id));
-	PTR ( VARIABLE ) pvar = search_vars ( va, vc, id ) ;
+		PTR(VARIABLE)pvar = search_vars(va, vc, id);
-	if ( !IS_NULL_ptr ( pvar ) ) {
+		if (!IS_NULL_ptr(pvar)) {
-	    VAR_INFO pacc = DEREF_dspec ( var_info ( pvar ) ) ;
+			VAR_INFO pacc = DEREF_dspec(var_info(pvar));
-	    acc = merge_usage ( acc, pacc, u ) ;
+			acc = merge_usage(acc, pacc, u);
-	}
+		}
-	COPY_dspec ( id_storage ( id ), acc ) ;
+		COPY_dspec(id_storage(id), acc);
-	if ( !IS_NULL_list ( vc ) ) vc = TAIL_list ( vc ) ;
+		if (!IS_NULL_list(vc)) {
+			vc = TAIL_list(vc);
+		}
-	vb = TAIL_list ( vb ) ;
+		vb = TAIL_list(vb);
-    }
+	}
-    return ;
+	return;
 }
 /*
     SWAP CURRENT VARIABLE SETTINGS
     This routine swaps the current variable settings with those stored in
     the list va.
 */
+static void
+swap_vars(VAR_LIST va)
+{
+	while (!IS_NULL_list(va)) {
+		VARIABLE var;
+		VAR_INFO acc;
+		DEREF_var(HEAD_list(va), var);
+		acc = DEREF_dspec(id_storage(var.id));
+		COPY_dspec(var_info(HEAD_list(va)), acc);
+		COPY_dspec(id_storage(var.id), var.info);
+		va = TAIL_list(va);
+	}
+	return;
+}
+/*
+    MARK VARIABLE SETTINGS
+    This routine marks all the variables in the list va with use.
+*/
-static void swap_vars
+static void
-    PROTO_N ( ( va ) )
-    PROTO_T ( VAR_LIST va )
+mark_vars(VAR_LIST va, VAR_INFO use)
+{
-    while ( !IS_NULL_list ( va ) ) {
+	while (!IS_NULL_list(va)) {
-	VARIABLE var ;
-	VAR_INFO acc ;
-	DEREF_var ( HEAD_list ( va ), var ) ;
-	acc = DEREF_dspec ( id_storage ( var.id ) ) ;
-	COPY_dspec ( var_info ( HEAD_list ( va ) ), acc ) ;
-	COPY_dspec ( id_storage ( var.id ), var.info ) ;
-	va = TAIL_list ( va ) ;
-    }
-    return ;
-}
-/*
-    MARK VARIABLE SETTINGS
-    This routine marks all the variables in the list va with use.
-*/
-static void mark_vars
-    PROTO_N ( ( va, use ) )
-    PROTO_T ( VAR_LIST va X VAR_INFO use )
-{
-    while ( !IS_NULL_list ( va ) ) {
-	IDENTIFIER id = DEREF_id ( var_id ( HEAD_list ( va ) ) ) ;
+		IDENTIFIER id = DEREF_id(var_id(HEAD_list(va)));
-	VAR_INFO acc = DEREF_dspec ( id_storage ( id ) ) ;
+		VAR_INFO acc = DEREF_dspec(id_storage(id));
-	acc |= use ;
+		acc |= use;
-	COPY_dspec ( id_storage ( id ), acc ) ;
+		COPY_dspec(id_storage(id), acc);
-	va = TAIL_list ( va ) ;
+		va = TAIL_list(va);
-    }
+	}
-    return ;
+	return;
+}
 /*
     PERFORM FLOW ANALYSIS ON A GOTO STATEMENT
     This routine performs flow analysis on a jump to the label lab.  cond
     is true to indicate a conditional jump.
 */
-static VAR_INFO flow_goto_stmt
+static VAR_INFO
-    PROTO_N ( ( lab, use, cond ) )
-    PROTO_T ( IDENTIFIER lab X VAR_INFO use X int cond )
+flow_goto_stmt(IDENTIFIER lab, VAR_INFO use, int cond)
+{
-    if ( !( use & va_unreached ) ) {
+	if (!(use & va_unreached)) {
-	VAR_INFO ds = DEREF_dspec ( id_storage ( lab ) ) ;
+		VAR_INFO ds = DEREF_dspec(id_storage(lab));
-	if ( ds & dspec_reserve ) {
+		if (ds & dspec_reserve) {
-	    /* Has backward jump */
+			/* Has backward jump */
-	    mark_vars ( crt_flow_vars, va_used_this ) ;
+			mark_vars(crt_flow_vars, va_used_this);
-	} else {
+		} else {
-	    /* Only forward jumps */
+			/* Only forward jumps */
-	    VAR_LIST va = DEREF_list ( id_label_vars ( lab ) ) ;
+			VAR_LIST va = DEREF_list(id_label_vars(lab));
-	    va = save_vars ( va, cond ) ;
+			va = save_vars(va, cond);
-	    COPY_list ( id_label_vars ( lab ), va ) ;
+			COPY_list(id_label_vars(lab), va);
+		}
+		ds |= dspec_temp;
+		COPY_dspec(id_storage(lab), ds);
+		use |= va_unreached;
+	}
-	ds |= dspec_temp ;
-	COPY_dspec ( id_storage ( lab ), ds ) ;
-	use |= va_unreached ;
-    }
-    return ( use ) ;
+	return (use);
 }
 /*
     PERFORM FLOW ANALYSIS ON A LABELLED STATEMENT
     This routine performs flow analysis on the statement labelled by the
     label lab.
 */
-static VAR_INFO flow_label_stmt
+static VAR_INFO
-    PROTO_N ( ( lab, use, flow ) )
-    PROTO_T ( IDENTIFIER lab X VAR_INFO use X int flow )
+flow_label_stmt(IDENTIFIER lab, VAR_INFO use, int flow)
+{
-    EXP e = DEREF_exp ( id_label_stmt ( lab ) ) ;
+	EXP e = DEREF_exp(id_label_stmt(lab));
-    VAR_INFO ds = DEREF_dspec ( id_storage ( lab ) ) ;
+	VAR_INFO ds = DEREF_dspec(id_storage(lab));
-    if ( ds & dspec_reserve ) {
+	if (ds & dspec_reserve) {
-	/* Has backward jump */
+		/* Has backward jump */
-	mark_vars ( crt_flow_vars, ( va_maybe_set | va_used_this ) ) ;
+		mark_vars(crt_flow_vars,(va_maybe_set | va_used_this));
-	use &= ~va_unreached ;
+		use &= ~va_unreached;
-    } else {
+	} else {
-	/* Only forward jumps */
+		/* Only forward jumps */
-	int unreached = 0 ;
+		int unreached = 0;
-	VAR_LIST va = DEREF_list ( id_label_vars ( lab ) ) ;
+		VAR_LIST va = DEREF_list(id_label_vars(lab));
-	if ( use & va_unreached ) unreached = 2 ;
+		if (use & va_unreached) {
+			unreached = 2;
+		}
-	load_vars ( va, unreached ) ;
+		load_vars(va, unreached);
-	DESTROY_list ( va, SIZE_var ) ;
+		DESTROY_list(va, SIZE_var);
-	COPY_list ( id_label_vars ( lab ), NULL_list ( VARIABLE ) ) ;
+		COPY_list(id_label_vars(lab), NULL_list(VARIABLE));
+		if (ds & dspec_temp) {
-	if ( ds & dspec_temp ) use &= ~va_unreached ;
+			use &= ~va_unreached;
-    }
+		}
+	}
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	e = DEREF_exp ( exp_label_stmt_body ( e ) ) ;
+		e = DEREF_exp(exp_label_stmt_body(e));
-	use = flow_stmt ( e, use, flow ) ;
+		use = flow_stmt(e, use, flow);
-    }
+	}
-    return ( use ) ;
+	return (use);
+}
 /*
     CHECK A SEQUENCE POINT
     This routine is called at each sequence point in the flow analysis
     routines.  It clears the list of identifiers assigned since the last
     sequence point.
 */
-static void flow_sequence_point
+static void
-    PROTO_Z ()
+flow_sequence_point(void)
+{
-    LIST ( IDENTIFIER ) p = crt_flow_assign ;
+	LIST(IDENTIFIER) p = crt_flow_assign;
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	VAR_INFO ds ;
+		VAR_INFO ds;
-	IDENTIFIER id ;
+		IDENTIFIER id;
-	DESTROY_CONS_id ( destroy, id, p, p ) ;
+		DESTROY_CONS_id(destroy, id, p, p);
-	ds = DEREF_dspec ( id_storage ( id ) ) ;
+		ds = DEREF_dspec(id_storage(id));
-	ds &= ~va_assign ;
+		ds &= ~va_assign;
-	COPY_dspec ( id_storage ( id ), ds ) ;
+		COPY_dspec(id_storage(id), ds);
-    }
+	}
-    crt_flow_assign = NULL_list ( IDENTIFIER ) ;
+	crt_flow_assign = NULL_list(IDENTIFIER);
-    return ;
+	return;
+}
 /*
     PERFORM FLOW ANALYSIS ON AN UNREACHABLE STATEMENT
     This routine performs flow analysis following a return statement (in
     which case ret is true) or other expression which causes execution to
     cease.
 */
-static VAR_INFO flow_terminate
+static VAR_INFO
-    PROTO_N ( ( use, ret ) )
-    PROTO_T ( VAR_INFO use X int ret )
+flow_terminate(VAR_INFO use, int ret)
 {
-    if ( !( use & va_unreached ) ) {
+	if (!(use & va_unreached)) {
-	VAR_LIST va = crt_flow_vars ;
+		VAR_LIST va = crt_flow_vars;
-	while ( !IS_NULL_list ( va ) ) {
+		while (!IS_NULL_list(va)) {
-	    IDENTIFIER id = DEREF_id ( var_id ( HEAD_list ( va ) ) ) ;
+			IDENTIFIER id = DEREF_id(var_id(HEAD_list(va)));
-	    VAR_INFO ds = DEREF_dspec ( id_storage ( id ) ) ;
+			VAR_INFO ds = DEREF_dspec(id_storage(id));
-	    ds = end_usage ( id, ds, ret ) ;
+			ds = end_usage(id, ds, ret);
-	    COPY_dspec ( id_storage ( id ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
-	    va = TAIL_list ( va ) ;
+			va = TAIL_list(va);
-	}
+		}
-    }
+	}
-    UNUSED ( ret ) ;
+	UNUSED(ret);
-    use |= va_unreached ;
+	use |= va_unreached;
-    return ( use ) ;
+	return (use);
 }
 /*
     PERFORM FLOW ANALYSIS ON AN IF EXPRESSION
     This routine preforms flow analysis on the if expression with condition
     c and branches a and b.
 */
-static VAR_INFO flow_if_exp
+static VAR_INFO
-    PROTO_N ( ( c, a, b, use, flow ) )
-    PROTO_T ( EXP c X EXP a X EXP b X VAR_INFO use X int flow )
+flow_if_exp(EXP c, EXP a, EXP b, VAR_INFO use, int flow)
 {
-    VAR_LIST va ;
+	VAR_LIST va;
-    VAR_INFO ua, ub ;
+	VAR_INFO ua, ub;
-    int unreached = 0 ;
+	int unreached = 0;
-    unsigned cv = eval_const_cond ( c ) ;
+	unsigned cv = eval_const_cond(c);
-    if ( flow ) {
+	if (flow) {
-	/* Condition */
+		/* Condition */
-	use = flow_exp ( c, use ) ;
+		use = flow_exp(c, use);
-	flow_sequence_point () ;
+		flow_sequence_point();
-    }
+	}
-    ua = use ;
+	ua = use;
-    ub = use ;
+	ub = use;
-    if ( cv == BOOL_FALSE ) ua |= va_unreached ;
+	if (cv == BOOL_FALSE) {
+		ua |= va_unreached;
+	}
-    if ( cv == BOOL_TRUE ) ub |= va_unreached ;
+	if (cv == BOOL_TRUE) {
+		ub |= va_unreached;
+	}
-    va = save_vars ( NULL_list ( VARIABLE ), 1 ) ;
+	va = save_vars(NULL_list(VARIABLE), 1);
-    ua = flow_stmt ( a, ua, flow ) ;
+	ua = flow_stmt(a, ua, flow);
-    swap_vars ( va ) ;
+	swap_vars(va);
-    ub = flow_stmt ( b, ub, flow ) ;
+	ub = flow_stmt(b, ub, flow);
-    if ( ua & va_unreached ) unreached |= 1 ;
+	if (ua & va_unreached) {
+		unreached |= 1;
+	}
-    if ( ub & va_unreached ) unreached |= 2 ;
+	if (ub & va_unreached) {
+		unreached |= 2;
+	}
-    load_vars ( va, unreached ) ;
+	load_vars(va, unreached);
-    DESTROY_list ( va, SIZE_var ) ;
+	DESTROY_list(va, SIZE_var);
-    use = ( ua & ub ) ;
+	use = (ua & ub);
-    return ( use ) ;
+	return (use);
 }
 /*
     PROCESS A FLOW ANALYSIS DIRECTIVE
     This routine processes the flow analysis directive indicated by act
     to the expression e.
 */
-static VAR_INFO flow_set
+static VAR_INFO
-    PROTO_N ( ( e, use, act ) )
-    PROTO_T ( EXP e X VAR_INFO use X VAR_INFO act )
+flow_set(EXP e, VAR_INFO use, VAR_INFO act)
 {
-    if ( !( use & va_unreached ) && !IS_NULL_exp ( e ) ) {
+	if (!(use & va_unreached) && !IS_NULL_exp(e)) {
-	EXP a = NULL_exp ;
+		EXP a = NULL_exp;
-	if ( IS_exp_contents ( e ) ) {
+		if (IS_exp_contents(e)) {
-	    /* Check for simple lvalues */
+			/* Check for simple lvalues */
-	    a = DEREF_exp ( exp_contents_ptr ( e ) ) ;
+			a = DEREF_exp(exp_contents_ptr(e));
-	} else if ( IS_exp_address ( e ) ) {
+		} else if (IS_exp_address(e)) {
-	    /* Check for array to pointer conversions */
+			/* Check for array to pointer conversions */
-	    EXP b = DEREF_exp ( exp_address_arg ( e ) ) ;
+			EXP b = DEREF_exp(exp_address_arg(e));
-	    TYPE s = DEREF_type ( exp_type ( b ) ) ;
+			TYPE s = DEREF_type(exp_type(b));
-	    if ( IS_type_array ( s ) ) a = b ;
+			if (IS_type_array(s)) {
+				a = b;
+			}
-	}
+		}
-	if ( !IS_NULL_exp ( a ) && IS_exp_identifier ( a ) ) {
+		if (!IS_NULL_exp(a) && IS_exp_identifier(a)) {
-	    IDENTIFIER id = DEREF_id ( exp_identifier_id ( a ) ) ;
+			IDENTIFIER id = DEREF_id(exp_identifier_id(a));
-	    if ( IS_id_variable_etc ( id ) ) {
+			if (IS_id_variable_etc(id)) {
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+				DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		if ( ds & dspec_auto ) {
+				if (ds & dspec_auto) {
-		    if ( act & va_set ) {
+					if (act & va_set) {
-			/* Set variable */
+						/* Set variable */
-			ds |= ( va_set | va_maybe_set | va_any_set ) ;
+						ds |= (va_set | va_maybe_set |
+						       va_any_set);
-			ds &= ~va_used_this ;
+						ds &= ~va_used_this;
-		    } else {
+					} else {
-			/* Unused variable */
+						/* Unused variable */
-			set_variable ( id, act ) ;
+						set_variable(id, act);
-			ds = DEREF_dspec ( id_storage ( id ) ) ;
+						ds = DEREF_dspec(id_storage(id));
-			ds &= ~( va_set | va_maybe_set ) ;
+						ds &= ~(va_set | va_maybe_set);
-		    }
+					}
-		    COPY_dspec ( id_storage ( id ), ds ) ;
+					COPY_dspec(id_storage(id), ds);
+				}
-		}
+			}
-	    }
+		}
+	}
-    }
-    return ( use ) ;
+	return (use);
+}
 /*
     PERFORM FLOW ANALYSIS ON A LIST OF TOKEN ARGUMENTS
     This routine performs flow analysis on the list of token arguments p.
 */
-static VAR_INFO flow_token_list
+static VAR_INFO
-    PROTO_N ( ( p, use ) )
-    PROTO_T ( LIST ( TOKEN ) p X VAR_INFO use )
+flow_token_list(LIST(TOKEN) p, VAR_INFO use)
 {
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	TOKEN tok = DEREF_tok ( HEAD_list ( p ) ) ;
+		TOKEN tok = DEREF_tok(HEAD_list(p));
-	if ( !IS_NULL_tok ( tok ) ) {
+		if (!IS_NULL_tok(tok)) {
-	    switch ( TAG_tok ( tok ) ) {
+			switch (TAG_tok(tok)) {
-		case tok_exp_tag : {
+			case tok_exp_tag: {
-		    /* Expression tokens */
+				/* Expression tokens */
-		    EXP e = DEREF_exp ( tok_exp_value ( tok ) ) ;
+				EXP e = DEREF_exp(tok_exp_value(tok));
-		    use = flow_alias_exp ( e, use ) ;
+				use = flow_alias_exp(e, use);
-		    break ;
+				break;
-		}
+			}
-		case tok_stmt_tag : {
+			case tok_stmt_tag: {
-		    /* Statement tokens */
+				/* Statement tokens */
-		    EXP e = DEREF_exp ( tok_stmt_value ( tok ) ) ;
+				EXP e = DEREF_exp(tok_stmt_value(tok));
-		    use = flow_stmt ( e, use, 1 ) ;
+				use = flow_stmt(e, use, 1);
-		    break ;
+				break;
-		}
+			}
-		case tok_member_tag : {
+			case tok_member_tag: {
-		    /* Member tokens */
+				/* Member tokens */
-		    OFFSET off = DEREF_off ( tok_member_value ( tok ) ) ;
+				OFFSET off = DEREF_off(tok_member_value(tok));
-		    use = flow_offset ( off, use, 0 ) ;
+				use = flow_offset(off, use, 0);
-		    break ;
+				break;
+			}
+			}
+		}
-	    }
+		p = TAIL_list(p);
+	}
-	p = TAIL_list ( p ) ;
-    }
-    return ( use ) ;
+	return (use);
+}
 /*
     PERFORM FLOW ANALYSIS ON AN OFFSET
     This routine performs flow analysis on the offset off.  mem is true
     in member functions when the offset is being added to 'this'.
 */
-static VAR_INFO flow_offset
+static VAR_INFO
-    PROTO_N ( ( off, use, mem ) )
-    PROTO_T ( OFFSET off X VAR_INFO use X int mem )
+flow_offset(OFFSET off, VAR_INFO use, int mem)
 {
-    DECL_SPEC ua = ( use & ~va_mask ) ;
+	DECL_SPEC ua = (use & ~va_mask);
-    if ( IS_NULL_off ( off ) ) return ( ua ) ;
+	if (IS_NULL_off(off)) {
+		return (ua);
+	}
-    ASSERT ( ORDER_off == 13 ) ;
+	ASSERT(ORDER_off == 13);
-    switch ( TAG_off ( off ) ) {
+	switch (TAG_off(off)) {
-	case off_member_tag : {
+	case off_member_tag:
-	    /* Member offsets */
+		/* Member offsets */
-	    if ( mem ) {
+		if (mem) {
-		IDENTIFIER id = DEREF_id ( off_member_id ( off ) ) ;
+			IDENTIFIER id = DEREF_id(off_member_id(off));
-		VAR_INFO ds = DEREF_dspec ( id_storage ( id ) ) ;
+			VAR_INFO ds = DEREF_dspec(id_storage(id));
+			if (ds & va_variable) {
-		if ( ds & va_variable ) set_variable ( id, use ) ;
+				set_variable(id, use);
-	    }
+			}
-	    break ;
-	}
+		}
+		break;
-	case off_ptr_mem_tag : {
+	case off_ptr_mem_tag: {
-	    /* Pointer to member offsets */
+		/* Pointer to member offsets */
-	    EXP a = DEREF_exp ( off_ptr_mem_arg ( off ) ) ;
+		EXP a = DEREF_exp(off_ptr_mem_arg(off));
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp(a, ua);
-	    break ;
+		break;
 	}
-	case off_negate_tag : {
+	case off_negate_tag: {
-	    /* Negated offsets */
+		/* Negated offsets */
-	    OFFSET off1 = DEREF_off ( off_negate_arg ( off ) ) ;
+		OFFSET off1 = DEREF_off(off_negate_arg(off));
-	    ua = flow_offset ( off1, ua, 0 ) ;
+		ua = flow_offset(off1, ua, 0);
-	    break ;
+		break;
 	}
-	case off_plus_tag : {
+	case off_plus_tag: {
-	    /* Offset addition */
+		/* Offset addition */
-	    OFFSET off1 = DEREF_off ( off_plus_arg1 ( off ) ) ;
+		OFFSET off1 = DEREF_off(off_plus_arg1(off));
-	    OFFSET off2 = DEREF_off ( off_plus_arg2 ( off ) ) ;
+		OFFSET off2 = DEREF_off(off_plus_arg2(off));
-	    ua = flow_offset ( off1, ua, 0 ) ;
+		ua = flow_offset(off1, ua, 0);
-	    ua = flow_offset ( off2, ua, 0 ) ;
+		ua = flow_offset(off2, ua, 0);
-	    break ;
+		break;
 	}
-	case off_mult_tag : {
+	case off_mult_tag: {
-	    /* Offset multiplication */
+		/* Offset multiplication */
-	    OFFSET off1 = DEREF_off ( off_mult_arg1 ( off ) ) ;
+		OFFSET off1 = DEREF_off(off_mult_arg1(off));
-	    EXP a = DEREF_exp ( off_mult_arg2 ( off ) ) ;
+		EXP a = DEREF_exp(off_mult_arg2(off));
-	    ua = flow_offset ( off1, ua, 0 ) ;
+		ua = flow_offset(off1, ua, 0);
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp(a, ua);
-	    break ;
+		break;
 	}
-	case off_ptr_diff_tag : {
+	case off_ptr_diff_tag: {
-	    /* Difference of two pointers */
+		/* Difference of two pointers */
-	    EXP a = DEREF_exp ( off_ptr_diff_ptr1 ( off ) ) ;
+		EXP a = DEREF_exp(off_ptr_diff_ptr1(off));
-	    EXP b = DEREF_exp ( off_ptr_diff_ptr2 ( off ) ) ;
+		EXP b = DEREF_exp(off_ptr_diff_ptr2(off));
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp(a, ua);
-	    ua = flow_exp ( b, ua ) ;
+		ua = flow_exp(b, ua);
-	    break ;
+		break;
 	}
-	case off_token_tag : {
+	case off_token_tag: {
-	    /* Tokenised offsets */
+		/* Tokenised offsets */
-	    LIST ( TOKEN ) args = DEREF_list ( off_token_args ( off ) ) ;
+		LIST(TOKEN)args = DEREF_list(off_token_args(off));
-	    ua = flow_token_list ( args, ua ) ;
+		ua = flow_token_list(args, ua);
-	    break ;
+		break;
+	}
-    }
+	}
-    ua &= ~va_mask ;
+	ua &= ~va_mask;
-    return ( ua ) ;
+	return (ua);
+}
 /*
     PERFORM FLOW ANALYSIS ON A LIST OF EXPRESSIONS
     This routine performs flow analysis on the list of expressions p.
 */
-static VAR_INFO flow_exp_list
+static VAR_INFO
-    PROTO_N ( ( p, use, fn ) )
-    PROTO_T ( LIST ( EXP ) p X VAR_INFO use X int fn )
+flow_exp_list(LIST(EXP) p, VAR_INFO use, int fn)
 {
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP a = DEREF_exp(HEAD_list(p));
-	if ( !IS_NULL_exp ( a ) ) {
+		if (!IS_NULL_exp(a)) {
-	    VAR_INFO ua ;
+			VAR_INFO ua;
-	    if ( fn ) {
+			if (fn) {
-		ua = flow_alias_exp ( a, use ) ;
+				ua = flow_alias_exp(a, use);
-	    } else {
+			} else {
-		ua = flow_exp ( a, use ) ;
+				ua = flow_exp(a, use);
-	    }
+			}
-	    if ( ua & va_unreached ) use |= va_unreached ;
+			if (ua & va_unreached) {
+				use |= va_unreached;
+			}
+		}
+		p = TAIL_list(p);
+	}
-	p = TAIL_list ( p ) ;
-    }
-    return ( use ) ;
+	return (use);
+}
 /*
     PERFORM FLOW ANALYSIS ON AN ALIASED EXPRESSION
     This routine performs flow analysis on the expression e which may be
     aliased by being on the right hand side of an assignment.  Note that
     there are read-only and read-write aliases, depending on whether the
     access is through a pointer or reference to const or not.
 */
-static VAR_INFO flow_alias_exp
+static VAR_INFO
-    PROTO_N ( ( e, use ) )
-    PROTO_T ( EXP e X VAR_INFO use )
+flow_alias_exp(EXP e, VAR_INFO use)
 {
-    VAR_INFO ua = ( use | va_alias_used ) ;
+	VAR_INFO ua = (use | va_alias_used);
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	TYPE t = DEREF_type ( exp_type ( e ) ) ;
+		TYPE t = DEREF_type(exp_type(e));
-	CV_SPEC cv = find_cv_qual ( t ) ;
+		CV_SPEC cv = find_cv_qual(t);
-	if ( cv & cv_lvalue ) {
+		if (cv & cv_lvalue) {
-	    /* Aliased via lvalue */
+			/* Aliased via lvalue */
-	    if ( !( cv & cv_const ) ) ua |= va_alias_set ;
+			if (!(cv & cv_const)) {
+				ua |= va_alias_set;
+			}
-	}
+		}
-	if ( IS_type_ptr_etc ( t ) ) {
+		if (IS_type_ptr_etc(t)) {
-	    /* Aliased via pointer or reference */
+			/* Aliased via pointer or reference */
-	    TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_etc_sub(t));
-	    cv = find_cv_qual ( s ) ;
+			cv = find_cv_qual(s);
-	    if ( !( cv & cv_const ) ) ua |= va_alias_set ;
+			if (!(cv & cv_const)) {
+				ua |= va_alias_set;
+			}
+		}
+	}
-    }
-    ua = flow_exp ( e, ua ) ;
+	ua = flow_exp(e, ua);
-    return ( ua ) ;
+	return (ua);
+}
 /*
     PERFORM FLOW ANALYSIS ON AN EXPRESSION
     This routine performs flow analysis on the expression e.
 */
-static VAR_INFO flow_exp
+static VAR_INFO
-    PROTO_N ( ( e, use ) )
-    PROTO_T ( EXP e X VAR_INFO use )
+flow_exp(EXP e, VAR_INFO use)
+{
+	}
-	case exp_indir_tag : {
+	case exp_dynamic_tag: {
-	    /* Indirection expressions */
+		/* Dynamic initialiser expressions */
-	    EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
-	    if ( !IS_NULL_list ( crt_flow_mems ) && is_this_exp ( e ) ) {
-		/* Have '*this' */
-		set_members ( use ) ;
-		break ;
-	    }
-	    if ( IS_exp_add_ptr ( a ) ) {
-		EXP b = DEREF_exp ( exp_add_ptr_ptr ( a ) ) ;
-		OFFSET off = DEREF_off ( exp_add_ptr_off ( a ) ) ;
-		if ( !IS_NULL_list ( crt_flow_mems ) && is_this_exp ( b ) ) {
-		    /* Have 'this->off' */
-		    ua = flow_offset ( off, use, 1 ) ;
-		    break ;
-		}
-		if ( IS_exp_address ( b ) ) {
-		    /* Have 'c.off' */
-		    EXP c = DEREF_exp ( exp_address_arg ( b ) ) ;
-		    ua = flow_offset ( off, use, 0 ) ;
-		    if ( ua & va_unreached ) use |= va_unreached ;
-		    ua = flow_exp ( c, ( use | va_partial ) ) ;
-		    break ;
-		}
-	    } else if ( IS_exp_address ( a ) ) {
-		/* Have '*&b' */
-		EXP b = DEREF_exp ( exp_address_arg ( a ) ) ;
+		EXP a = DEREF_exp(exp_dynamic_arg(e));
-		ua = flow_exp ( b, use ) ;
+		ua = flow_exp(a, ua);
-		break ;
+		break;
-	    }
-	    ua = flow_exp ( a, ua ) ;
-	    break ;
+	}
-	case exp_contents_tag : {
+	case exp_aggregate_tag: {
-	    /* Contents expressions */
+		/* Aggregate initialiser expressions */
+		LIST(EXP) args;
-	    EXP a = DEREF_exp ( exp_contents_ptr ( e ) ) ;
+		args = DEREF_list(exp_aggregate_args(e));
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp_list(args, ua, 0);
-	    break ;
+		break;
+	}
-	case exp_address_tag : {
+	case exp_initialiser_tag: {
-	    /* Address expressions */
+		/* Constructor initialiser expressions */
-	    EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
+		int kind = DEREF_int(exp_initialiser_kind(e));
-	    if ( IS_exp_indir ( a ) && !is_this_exp ( a ) ) {
-		EXP b = DEREF_exp ( exp_indir_ptr ( a ) ) ;
+		LIST(EXP) p = DEREF_list(exp_initialiser_args(e));
-		TYPE t = DEREF_type ( exp_type ( b ) ) ;
+		LIST(OFFSET) q = DEREF_list(exp_initialiser_offs(e));
-		if ( !IS_type_ref ( t ) ) {
+		if (kind == 0) {
-		    ua = flow_exp ( b, use ) ;
+			q = NULL_list(OFFSET);
-		    break ;
+		}
+	}
-	case exp_comma_tag : {
-	    /* Comma expressions */
-	    LIST ( EXP ) p = DEREF_list ( exp_comma_args ( e ) ) ;
-	    if ( !IS_NULL_list ( p ) ) {
-		EXP a ;
-		for ( ; ; ) {
-		    a = DEREF_exp ( HEAD_list ( p ) ) ;
-		    p = TAIL_list ( p ) ;
-		    if ( IS_NULL_list ( p ) ) break ;
-		    ua = flow_exp ( a, ua ) ;
-		    flow_sequence_point () ;
-		    if ( ua & va_unreached ) use |= va_unreached ;
-		}
-		ua = flow_exp ( a, use ) ;
-	    }
-	    break ;
-	}
-	case exp_if_stmt_tag : {
+	case exp_if_stmt_tag: {
-	    /* Conditional expressions */
+		/* Conditional expressions */
-	    EXP c = DEREF_exp ( exp_if_stmt_cond ( e ) ) ;
+		EXP c = DEREF_exp(exp_if_stmt_cond(e));
-	    EXP a = DEREF_exp ( exp_if_stmt_true_code ( e ) ) ;
+		EXP a = DEREF_exp(exp_if_stmt_true_code(e));
-	    EXP b = DEREF_exp ( exp_if_stmt_false_code ( e ) ) ;
+		EXP b = DEREF_exp(exp_if_stmt_false_code(e));
-	    ua = flow_if_exp ( c, a, b, ua, 1 ) ;
+		ua = flow_if_exp(c, a, b, ua, 1);
-	    break ;
+		break;
 	}
-	case exp_exception_tag : {
+	case exp_exception_tag: {
-	    /* Exception expressions */
+		/* Exception expressions */
-	    EXP a = DEREF_exp ( exp_exception_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_exception_arg(e));
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp(a, ua);
-	    ua = flow_terminate ( ua, 1 ) ;
+		ua = flow_terminate(ua, 1);
-	    break ;
+		break;
 	}
-	case exp_set_tag : {
+	case exp_set_tag: {
-	    /* Set expressions */
+		/* Set expressions */
-	    EXP a = DEREF_exp ( exp_set_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_set_arg(e));
-	    ua = flow_set ( a, ua, va_set ) ;
+		ua = flow_set(a, ua, va_set);
-	    break ;
+		break;
 	}
-	case exp_unused_tag : {
+	case exp_unused_tag: {
-	    /* Unused expressions */
+		/* Unused expressions */
-	    EXP a = DEREF_exp ( exp_unused_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_unused_arg(e));
-	    ua = flow_set ( a, ua, va_none ) ;
+		ua = flow_set(a, ua, va_none);
-	    break ;
+		break;
 	}
-	case exp_op_tag : {
+	case exp_op_tag: {
-	    /* Undetermined expressions */
+		/* Undetermined expressions */
-	    EXP a = DEREF_exp ( exp_op_arg1 ( e ) ) ;
+		EXP a = DEREF_exp(exp_op_arg1(e));
-	    EXP b = DEREF_exp ( exp_op_arg2 ( e ) ) ;
+		EXP b = DEREF_exp(exp_op_arg2(e));
-	    ua = flow_exp ( a, ua ) ;
+		ua = flow_exp(a, ua);
-	    ua = flow_exp ( b, ua ) ;
+		ua = flow_exp(b, ua);
-	    break ;
+		break;
 	}
-	case exp_opn_tag : {
+	case exp_opn_tag: {
-	    /* Undetermined expressions */
+		/* Undetermined expressions */
-	    LIST ( EXP ) args = DEREF_list ( exp_opn_args ( e ) ) ;
+		LIST(EXP) args = DEREF_list(exp_opn_args(e));
-	    ua = flow_exp_list ( args, ua, 0 ) ;
+		ua = flow_exp_list(args, ua, 0);
-	    break ;
+		break;
 	}
-	case exp_token_tag : {
+	case exp_token_tag: {
-	    /* Tokenised expressions */
+		/* Tokenised expressions */
-	    LIST ( TOKEN ) args = DEREF_list ( exp_token_args ( e ) ) ;
+		LIST(TOKEN) args = DEREF_list(exp_token_args(e));
-	    ua = flow_token_list ( args, ua ) ;
+		ua = flow_token_list(args, ua);
-	    break ;
+		break;
 	}
-	case exp_dummy_tag : {
+	case exp_dummy_tag: {
-	    /* Dummy expressions */
+		/* Dummy expressions */
-	    EXP a = DEREF_exp ( exp_dummy_value ( e ) ) ;
+		EXP a = DEREF_exp(exp_dummy_value(e));
-	    ua = flow_exp ( a, use ) ;
+		ua = flow_exp(a, use);
-	    break ;
+		break;
 	}
-	case exp_paren_tag :
+	case exp_paren_tag:
-	case exp_copy_tag : {
+	case exp_copy_tag: {
-	    /* Parenthesised expressions */
+		/* Parenthesised expressions */
-	    EXP a = DEREF_exp ( exp_paren_etc_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_paren_etc_arg(e));
-	    ua = flow_exp ( a, use ) ;
+		ua = flow_exp(a, use);
-	    break ;
+		break;
+	}
-	case exp_location_tag : {
+	case exp_location_tag: {
-	    /* Location expressions */
+		/* Location expressions */
-	    EXP a = DEREF_exp ( exp_location_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_location_arg(e));
-	    ua = flow_exp ( a, use ) ;
+		ua = flow_exp(a, use);
-	    DEREF_loc ( exp_location_end ( e ), stmt_loc ) ;
+		DEREF_loc(exp_location_end(e), stmt_loc);
-	    break ;
+		break;
+	}
-	case exp_sequence_tag :
+	case exp_sequence_tag:
-	case exp_solve_stmt_tag :
+	case exp_solve_stmt_tag:
-	case exp_decl_stmt_tag :
+	case exp_decl_stmt_tag:
-	case exp_while_stmt_tag :
+	case exp_while_stmt_tag:
-	case exp_do_stmt_tag :
+	case exp_do_stmt_tag:
-	case exp_switch_stmt_tag :
+	case exp_switch_stmt_tag:
-	case exp_hash_if_tag :
+	case exp_hash_if_tag:
-	case exp_return_stmt_tag :
+	case exp_return_stmt_tag:
-	case exp_goto_stmt_tag :
+	case exp_goto_stmt_tag:
-	case exp_label_stmt_tag :
+	case exp_label_stmt_tag:
-	case exp_try_block_tag :
+	case exp_try_block_tag:
-	case exp_handler_tag :
+	case exp_handler_tag:
-	case exp_reach_tag :
+	case exp_reach_tag:
-	case exp_unreach_tag : {
+	case exp_unreach_tag:
-	    /* Statements */
+		/* Statements */
-	    ua = flow_stmt ( e, ua, 1 ) ;
+		ua = flow_stmt(e, ua, 1);
-	    break ;
+		break;
+	}
-    }
-    ua &= ~va_mask ;
+	ua &= ~va_mask;
-    return ( ua ) ;
+	return (ua);
+}
 /*
     PERFORM FLOW ANALYSIS FOR DESTRUCTORS
     This routine performs flow analysis for any destructors called by
     the goto or return statement a.  b gives smallest statement enclosing
     both the jump and its destination.
 */
-static void flow_jump
+static void
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+flow_jump(EXP a, EXP b)
 {
-    unsigned long d = no_destructors ;
+	unsigned long d = no_destructors;
-    while ( !IS_NULL_exp ( a ) && !EQ_exp ( a, b ) && d ) {
+	while (!IS_NULL_exp(a) && !EQ_exp(a, b) && d) {
-	/* Scan up to enclosing statement */
+		/* Scan up to enclosing statement */
-	if ( IS_exp_decl_stmt ( a ) ) {
+		if (IS_exp_decl_stmt(a)) {
-	    IDENTIFIER id = DEREF_id ( exp_decl_stmt_id ( a ) ) ;
+			IDENTIFIER id = DEREF_id(exp_decl_stmt_id(a));
-	    if ( IS_id_variable ( id ) ) {
+			if (IS_id_variable(id)) {
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+				DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		if ( ds & dspec_auto ) {
+				if (ds & dspec_auto) {
-		    /* Local variable */
+					/* Local variable */
+					EXP term =
-		    EXP term = DEREF_exp ( id_variable_term ( id ) ) ;
+					    DEREF_exp(id_variable_term(id));
-		    if ( !IS_NULL_exp ( term ) ) {
+					if (!IS_NULL_exp(term)) {
+						if (do_usage) {
+							dump_destr(id,
-			if ( do_usage ) dump_destr ( id, &stmt_loc ) ;
+								   &stmt_loc);
+						}
-			d-- ;
+						d--;
-		    }
+					}
-		}
+				}
-	    }
+			}
-	}
+		}
-	a = get_parent_stmt ( a ) ;
+		a = get_parent_stmt(a);
-    }
+	}
-    return ;
+	return;
 }
 /*
     PERFORM FLOW ANALYSIS ON A WHILE STATEMENT
     This routine performs flow analysis on the while statement e.
 */
-static VAR_INFO flow_while_stmt
+static VAR_INFO
-    PROTO_N ( ( e, use, flow ) )
-    PROTO_T ( EXP e X VAR_INFO use X int flow )
+flow_while_stmt(EXP e, VAR_INFO use, int flow)
 {
-    VAR_INFO ua ;
+	VAR_INFO ua;
-    EXP c = DEREF_exp ( exp_while_stmt_cond ( e ) ) ;
+	EXP c = DEREF_exp(exp_while_stmt_cond(e));
-    EXP a = DEREF_exp ( exp_while_stmt_body ( e ) ) ;
+	EXP a = DEREF_exp(exp_while_stmt_body(e));
-    IDENTIFIER blab = DEREF_id ( exp_while_stmt_break_lab ( e ) ) ;
+	IDENTIFIER blab = DEREF_id(exp_while_stmt_break_lab(e));
-    IDENTIFIER clab = DEREF_id ( exp_while_stmt_cont_lab ( e ) ) ;
+	IDENTIFIER clab = DEREF_id(exp_while_stmt_cont_lab(e));
-    unsigned cv = eval_const_cond ( c ) ;
+	unsigned cv = eval_const_cond(c);
-    if ( flow ) {
+	if (flow) {
-	use = flow_exp ( c, use ) ;
+		use = flow_exp(c, use);
-	flow_sequence_point () ;
+		flow_sequence_point();
-    }
+	}
-    ua = use ;
+	ua = use;
-    if ( cv != BOOL_TRUE ) {
+	if (cv != BOOL_TRUE) {
-	IGNORE flow_goto_stmt ( blab, use, 1 ) ;
+		IGNORE flow_goto_stmt(blab, use, 1);
-	if ( cv == BOOL_FALSE ) ua |= va_unreached ;
+		if (cv == BOOL_FALSE) {
+			ua |= va_unreached;
-    }
+		}
+	}
-    ua = flow_stmt ( a, ua, flow ) ;
+	ua = flow_stmt(a, ua, flow);
-    ua = flow_label_stmt ( clab, ua, flow ) ;
+	ua = flow_label_stmt(clab, ua, flow);
-    if ( flow ) {
+	if (flow) {
-	IGNORE flow_exp ( c, ua ) ;
+		IGNORE flow_exp(c, ua);
-	flow_sequence_point () ;
+		flow_sequence_point();
-    }
+	}
-    mark_vars ( crt_flow_vars, va_used_this ) ;
+	mark_vars(crt_flow_vars, va_used_this);
-    use = flow_label_stmt ( blab, ( use | va_unreached ), flow ) ;
+	use = flow_label_stmt(blab,(use | va_unreached), flow);
-    return ( use ) ;
+	return (use);
 }
 /*
     PERFORM FLOW ANALYSIS ON A DO STATEMENT
     This routine performs flow analysis on the do statement e.
 */
+static VAR_INFO
+flow_do_stmt(EXP e, VAR_INFO use, int flow)
+{
+	EXP c = DEREF_exp(exp_do_stmt_cond(e));
+	EXP a = DEREF_exp(exp_do_stmt_body(e));
+	IDENTIFIER blab = DEREF_id(exp_do_stmt_break_lab(e));
+	IDENTIFIER clab = DEREF_id(exp_do_stmt_cont_lab(e));
+	unsigned cv = eval_const_cond(c);
+	use = flow_stmt(a, use, flow);
+	use = flow_label_stmt(clab, use, flow);
+	if (flow) {
+		use = flow_exp(c, use);
+		flow_sequence_point();
+	}
+	mark_vars(crt_flow_vars, va_used_this);
+	if (cv == BOOL_TRUE) {
+		use |= va_unreached;
+	}
+	use = flow_label_stmt(blab, use, flow);
+	return (use);
+}
+/*
+    PERFORM FLOW ANALYSIS ON A SOLVE STATEMENT
-static VAR_INFO flow_do_stmt
+    This routine performs flow analysis on the solve statement e with
-    PROTO_N ( ( e, use, flow ) )
+    associated variables p.
+*/
+static VAR_INFO
-    PROTO_T ( EXP e X VAR_INFO use X int flow )
+flow_solve_stmt(EXP e, LIST(IDENTIFIER) p, VAR_INFO use, int flow)
+{
-    EXP c = DEREF_exp ( exp_do_stmt_cond ( e ) ) ;
+	if (!IS_NULL_list(p)) {
-    EXP a = DEREF_exp ( exp_do_stmt_body ( e ) ) ;
+		/* Scan through variables */
-    IDENTIFIER blab = DEREF_id ( exp_do_stmt_break_lab ( e ) ) ;
+		IDENTIFIER id = DEREF_id(HEAD_list(p));
-    IDENTIFIER clab = DEREF_id ( exp_do_stmt_cont_lab ( e ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    unsigned cv = eval_const_cond ( c ) ;
+		if ((ds & dspec_auto) && !(ds & dspec_done)) {
-    use = flow_stmt ( a, use, flow ) ;
+			start_variable(id, ds, va_none);
-    use = flow_label_stmt ( clab, use, flow ) ;
+			use = flow_solve_stmt(e, TAIL_list(p), use, flow);
-    if ( flow ) {
-	use = flow_exp ( c, use ) ;
+			end_variable(flow, 0);
-	flow_sequence_point () ;
+			return (use);
-    }
+		}
-    mark_vars ( crt_flow_vars, va_used_this ) ;
+		use = flow_solve_stmt(e, TAIL_list(p), use, flow);
-    if ( cv == BOOL_TRUE ) use |= va_unreached ;
+		return (use);
+	}
-    use = flow_label_stmt ( blab, use, flow ) ;
+	use = flow_stmt(e, use, flow);
-    return ( use ) ;
+	return (use);
+}
 /*
-    PERFORM FLOW ANALYSIS ON A SOLVE STATEMENT
+    PERFORM FLOW ANALYSIS ON A SWITCH STATEMENT
-    This routine performs flow analysis on the solve statement e with
-    associated variables p.
-*/
+    This routine performs flow analysis on the switch statement e.
+*/
-static VAR_INFO flow_solve_stmt
+static VAR_INFO
-    PROTO_N ( ( e, p, use, flow ) )
-    PROTO_T ( EXP e X LIST ( IDENTIFIER ) p X VAR_INFO use X int flow )
+flow_switch_stmt(EXP e, VAR_INFO use, int flow)
+{
-    if ( !IS_NULL_list ( p ) ) {
+	EXP a = DEREF_exp(exp_switch_stmt_body(e));
-	/* Scan through variables */
+	int exhaust = DEREF_int(exp_switch_stmt_exhaust(e));
-	IDENTIFIER id = DEREF_id ( HEAD_list ( p ) ) ;
+	LIST(IDENTIFIER) p = DEREF_list(exp_switch_stmt_case_labs(e));
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	IDENTIFIER dlab = DEREF_id(exp_switch_stmt_default_lab(e));
-	if ( ( ds & dspec_auto ) && !( ds & dspec_done ) ) {
+	IDENTIFIER blab = DEREF_id(exp_switch_stmt_break_lab(e));
+	if (flow) {
-	    start_variable ( id, ds, va_none ) ;
+		/* Deal with control statement */
-	    use = flow_solve_stmt ( e, TAIL_list ( p ), use, flow ) ;
+		EXP c = DEREF_exp(exp_switch_stmt_control(e));
-	    end_variable ( flow, 0 ) ;
+		use = flow_exp(c, use);
-	    return ( use ) ;
+		flow_sequence_point();
+	}
+	if (!IS_NULL_id(dlab)) {
+		/* Mark jumps to default statement */
+		dlab = DEREF_id(id_alias(dlab));
-	use = flow_solve_stmt ( e, TAIL_list ( p ), use, flow ) ;
+		IGNORE flow_goto_stmt(dlab, use, 1);
-	return ( use ) ;
+		exhaust = 1;
+	}
+	while (!IS_NULL_list(p)) {
+		/* Mark jumps to case statements */
+		IDENTIFIER clab = DEREF_id(HEAD_list(p));
+		clab = DEREF_id(id_alias(clab));
+		if (!EQ_id(clab, dlab)) {
+			/* Only mark each label once */
+			IGNORE flow_goto_stmt(clab, use, 1);
+			dlab = clab;
-    }
+		}
+		p = TAIL_list(p);
+	}
+	if (!exhaust) {
+		/* Break label is reached in non-exhaustive cases */
+		IGNORE flow_goto_stmt(blab, use, 1);
+	}
+	use = flow_stmt(a,(use | va_unreached), flow);
-    use = flow_stmt ( e, use, flow ) ;
+	use = flow_label_stmt(blab, use, flow);
-    return ( use ) ;
+	return (use);
+}
-/*
-    PERFORM FLOW ANALYSIS ON A SWITCH STATEMENT
-    This routine performs flow analysis on the switch statement e.
-*/
-static VAR_INFO flow_switch_stmt
-    PROTO_N ( ( e, use, flow ) )
-    PROTO_T ( EXP e X VAR_INFO use X int flow )
-{
-    EXP a = DEREF_exp ( exp_switch_stmt_body ( e ) ) ;
-    int exhaust = DEREF_int ( exp_switch_stmt_exhaust ( e ) ) ;
-    LIST ( IDENTIFIER ) p = DEREF_list ( exp_switch_stmt_case_labs ( e ) ) ;
-    IDENTIFIER dlab = DEREF_id ( exp_switch_stmt_default_lab ( e ) ) ;
-    IDENTIFIER blab = DEREF_id ( exp_switch_stmt_break_lab ( e ) ) ;
-    if ( flow ) {
-	/* Deal with control statement */
-	EXP c = DEREF_exp ( exp_switch_stmt_control ( e ) ) ;
-	use = flow_exp ( c, use ) ;
-	flow_sequence_point () ;
-    }
-    if ( !IS_NULL_id ( dlab ) ) {
-	/* Mark jumps to default statement */
-	dlab = DEREF_id ( id_alias ( dlab ) ) ;
-	IGNORE flow_goto_stmt ( dlab, use, 1 ) ;
-	exhaust = 1 ;
-    }
-    while ( !IS_NULL_list ( p ) ) {
-	/* Mark jumps to case statements */
-	IDENTIFIER clab = DEREF_id ( HEAD_list ( p ) ) ;
-	clab = DEREF_id ( id_alias ( clab ) ) ;
-	if ( !EQ_id ( clab, dlab ) ) {
-	    /* Only mark each label once */
-	    IGNORE flow_goto_stmt ( clab, use, 1 ) ;
-	    dlab = clab ;
-	}
-	p = TAIL_list ( p ) ;
-    }
-    if ( !exhaust ) {
-	/* Break label is reached in non-exhaustive cases */
-	IGNORE flow_goto_stmt ( blab, use, 1 ) ;
-    }
-    use = flow_stmt ( a, ( use | va_unreached ), flow ) ;
-    use = flow_label_stmt ( blab, use, flow ) ;
-    return ( use ) ;
-}
 /*
     PERFORM FLOW ANALYSIS ON A TRY BLOCK
     This routine performs flow analysis on the try block e.
 */
-static VAR_INFO flow_try_block
+static VAR_INFO
-    PROTO_N ( ( e, use, flow ) )
-    PROTO_T ( EXP e X VAR_INFO use X int flow )
+flow_try_block(EXP e, VAR_INFO use, int flow)
+{
-    VAR_INFO ua = ( use | va_unreached ) ;
+	VAR_INFO ua = (use | va_unreached);
-    EXP a = DEREF_exp ( exp_try_block_body ( e ) ) ;
+	EXP a = DEREF_exp(exp_try_block_body(e));
-    LIST ( EXP ) p = DEREF_list ( exp_try_block_handlers ( e ) ) ;
+	LIST(EXP) p = DEREF_list(exp_try_block_handlers(e));
-    EXP c = DEREF_exp ( exp_try_block_ellipsis ( e ) ) ;
+	EXP c = DEREF_exp(exp_try_block_ellipsis(e));
-    use = flow_stmt ( a, use, flow ) ;
+	use = flow_stmt(a, use, flow);
-    /* NOT YET IMPLEMENTED */
+	/* NOT YET IMPLEMENTED */
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP b = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP b = DEREF_exp(HEAD_list(p));
-	IGNORE flow_stmt ( b, ua, flow ) ;
+		IGNORE flow_stmt(b, ua, flow);
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    IGNORE flow_stmt ( c, ua, flow ) ;
+	IGNORE flow_stmt(c, ua, flow);
-    return ( use ) ;
+	return (use);
+}
 /*
     PERFORM FLOW ANALYSIS ON A DECLARATION STATEMENT
     This routine performs flow analysis on the declaration statement e.
 */
-static VAR_INFO flow_decl_stmt
+static VAR_INFO
+flow_decl_stmt(EXP e, VAR_INFO use, int flow)
+{
+	EXP a = DEREF_exp(exp_decl_stmt_body(e));
+	IDENTIFIER id = DEREF_id(exp_decl_stmt_id(e));
+	if (IS_id_variable(id)) {
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		if (ds & dspec_auto) {
+			/* Local variable */
+			EXP b = DEREF_exp(id_variable_init(id));
+			EXP d = DEREF_exp(id_variable_term(id));
+			if (!IS_NULL_exp(d)) {
+				no_destructors++;
+			}
+			if (!(ds & dspec_done)) {
+				start_variable(id, ds, va_none);
+			}
+			if (!IS_NULL_exp(b)) {
+				/* Initialiser expression */
+				if (flow) {
+					use = flow_alias_exp(b, use);
+				}
+				set_variable(id,(use | va_assign));
+				flow_sequence_point();
+			}
+			use = flow_stmt(a, use, flow);
+			if (flow) {
+				/* Destructor */
+				use = flow_exp(d, use);
+				flow_sequence_point();
+			}
+			if (!(ds & dspec_done)) {
+				end_variable(flow, 0);
+			}
+			if (!IS_NULL_exp(d)) {
+				no_destructors--;
+			}
+			return (use);
+		}
+	}
-    PROTO_N ( ( e, use, flow ) )
+	use = flow_stmt(a, use, flow);
+	return (use);
+}
+/*
+    PERFORM FLOW ANALYSIS ON A STATEMENT
+    This routine performs flow analysis on the statement e.
+*/
+static VAR_INFO
-    PROTO_T ( EXP e X VAR_INFO use X int flow )
+flow_stmt(EXP e, VAR_INFO use, int flow)
+{
-    EXP a = DEREF_exp ( exp_decl_stmt_body ( e ) ) ;
-    IDENTIFIER id = DEREF_id ( exp_decl_stmt_id ( e ) ) ;
-    if ( IS_id_variable ( id ) ) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	if ( ds & dspec_auto ) {
-	    /* Local variable */
+	/* Deal with statements */
-	    EXP b = DEREF_exp ( id_variable_init ( id ) ) ;
-	    EXP d = DEREF_exp ( id_variable_term ( id ) ) ;
-	    if ( !IS_NULL_exp ( d ) ) no_destructors++ ;
-	    if ( !( ds & dspec_done ) ) {
-		start_variable ( id, ds, va_none ) ;
+	VAR_INFO ua = (use & ~va_mask);
-	    }
-	    if ( !IS_NULL_exp ( b ) ) {
+	if (IS_NULL_exp(e)) {
-		/* Initialiser expression */
-		if ( flow ) use = flow_alias_exp ( b, use ) ;
-		set_variable ( id, ( use | va_assign ) ) ;
-		flow_sequence_point () ;
-	    }
-	    use = flow_stmt ( a, use, flow ) ;
-	    if ( flow ) {
-		/* Destructor */
-		use = flow_exp ( d, use ) ;
-		flow_sequence_point () ;
-	    }
-	    if ( !( ds & dspec_done ) ) end_variable ( flow, 0 ) ;
-	    if ( !IS_NULL_exp ( d ) ) no_destructors-- ;
-	    return ( use ) ;
+		return (ua);
+	}
+	}
-	default : {
+	case exp_location_tag: {
-	    /* Simple expressions */
+		/* Location expressions */
-	    if ( !( ua & va_unreached ) && flow ) {
+		EXP a = DEREF_exp(exp_location_arg(e));
-		ua = flow_exp ( e, ua ) ;
+		ua = flow_stmt(a, use, flow);
-		flow_sequence_point () ;
+		DEREF_loc(exp_location_end(e), stmt_loc);
-	    }
-	    break ;
+		break;
+	}
+	default:
+		/* Simple expressions */
+		if (!(ua & va_unreached) && flow) {
+			ua = flow_exp(e, ua);
+			flow_sequence_point();
-    }
+		}
+		break;
+	}
-    ua &= ~va_mask ;
+	ua &= ~va_mask;
-    return ( ua ) ;
+	return (ua);
+}
 /*
     PERFORM FLOW ANALYSIS ON A FUNCTION DEFINITION
     which defines the function id.  Full flow analysis is enabled if
     flow is true, otherwise a minimal scan sufficient to determine all
     implicit destructor calls is done.
 */
-void check_flow
+void
-    PROTO_N ( ( id, e, flow ) )
-    PROTO_T ( IDENTIFIER id X EXP e X int flow )
+check_flow(IDENTIFIER id, EXP e, int flow)
+{
-    VAR_INFO use ;
+	VAR_INFO use;
-    LIST ( IDENTIFIER ) pids ;
+	LIST(IDENTIFIER) pids;
-    if ( IS_id_function_etc ( id ) ) {
+	if (IS_id_function_etc(id)) {
-	TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
+		TYPE t = DEREF_type(id_function_etc_type(id));
-	while ( IS_type_templ ( t ) ) {
+		while (IS_type_templ(t)) {
-	    t = DEREF_type ( type_templ_defn ( t ) ) ;
+			t = DEREF_type(type_templ_defn(t));
-	}
-	if ( IS_id_mem_func ( id ) ) {
-	    /* Allow for 'this' parameter and class members */
-	    IDENTIFIER pid = this_param ( id, 0 ) ;
-	    if ( flow ) {
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-		CLASS_TYPE ct = parent_class ( id ) ;
-		NAMESPACE ns = DEREF_nspace ( ctype_member ( ct ) ) ;
-		MEMBER mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
-		mem = next_data_member ( mem, 0 ) ;
-		while ( !IS_NULL_member ( mem ) ) {
-		    IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
-		    start_variable ( mid, dspec_used, va_member ) ;
-		    if ( !IS_hashid_constr ( nm ) ) {
-			/* Members are set except in constructors */
-			set_variable ( mid, va_assign ) ;
-			set_variable ( mid, va_none ) ;
-		    }
-		    mem = DEREF_member ( member_next ( mem ) ) ;
-		    mem = next_data_member ( mem, 0 ) ;
+		}
+		if (IS_id_mem_func(id)) {
+			/* Allow for 'this' parameter and class members */
+			IDENTIFIER pid = this_param(id, 0);
+			if (flow) {
+				HASHID nm = DEREF_hashid(id_name(id));
+				CLASS_TYPE ct = parent_class(id);
+				NAMESPACE ns = DEREF_nspace(ctype_member(ct));
+				MEMBER mem =
+				    DEREF_member(nspace_ctype_first(ns));
+				mem = next_data_member(mem, 0);
+				while (!IS_NULL_member(mem)) {
+					IDENTIFIER mid =
+					    DEREF_id(member_id(mem));
+					start_variable(mid, dspec_used,
+						       va_member);
+					if (!IS_hashid_constr(nm)) {
+						/* Members are set except in
+						 * constructors */
+						set_variable(mid, va_assign);
+						set_variable(mid, va_none);
+					}
+					mem = DEREF_member(member_next(mem));
+					mem = next_data_member(mem, 0);
+				}
-		crt_flow_mems = crt_flow_vars ;
+				crt_flow_mems = crt_flow_vars;
-	    }
+			}
-	    if ( !IS_NULL_id ( pid ) ) {
+			if (!IS_NULL_id(pid)) {
-		start_variable ( pid, dspec_none, va_this ) ;
+				start_variable(pid, dspec_none, va_this);
-		set_variable ( pid, va_assign ) ;
+				set_variable(pid, va_assign);
-	    }
+			}
-	}
+		}
-	pids = DEREF_list ( type_func_pids ( t ) ) ;
+		pids = DEREF_list(type_func_pids(t));
-	while ( !IS_NULL_list ( pids ) ) {
+		while (!IS_NULL_list(pids)) {
-	    /* Set up parameter scopes */
+			/* Set up parameter scopes */
-	    IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+			IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	    if ( !IS_NULL_id ( pid ) ) {
+			if (!IS_NULL_id(pid)) {
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
+				DECL_SPEC ds = DEREF_dspec(id_storage(pid));
-		start_variable ( pid, ds, va_none ) ;
+				start_variable(pid, ds, va_none);
-		set_variable ( pid, va_assign ) ;
+				set_variable(pid, va_assign);
-	    }
+			}
-	    pids = TAIL_list ( pids ) ;
+			pids = TAIL_list(pids);
+		}
+	}
+	DEREF_loc(id_loc(id), stmt_loc);
+	flow_sequence_point();
+	use = flow_stmt(e, va_none, flow);
+	IGNORE flow_terminate(use, 2);
+	crt_flow_mems = NULL_list(VARIABLE);
+	while (!IS_NULL_list(crt_flow_vars)) {
+		/* End parameter and member scopes */
+		end_variable(flow, 2);
+	}
-    }
-    DEREF_loc ( id_loc ( id ), stmt_loc ) ;
-    flow_sequence_point () ;
-    use = flow_stmt ( e, va_none, flow ) ;
-    IGNORE flow_terminate ( use, 2 ) ;
-    crt_flow_mems = NULL_list ( VARIABLE ) ;
-    while ( !IS_NULL_list ( crt_flow_vars ) ) {
-	/* End parameter and member scopes */
-	end_variable ( flow, 2 ) ;
-    }
-    stmt_loc = crt_loc ;
+	stmt_loc = crt_loc;
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/construct/variable.c – Rev 2 → 7