WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/construct/function.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, 1998
     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.
 */
     CHECK A FUNCTION RETURN TYPE
     This routine checks whether the type t is a suitable function return
     type.  This can be void (unqualified) or a complete type.  def is
     true for a function definition or call, but false otherwise.
 */
-TYPE check_ret_type
+TYPE
-    PROTO_N ( ( t, err, def ) )
-    PROTO_T ( TYPE t X ERROR *err X int def )
+check_ret_type(TYPE t, ERROR *err, int def)
 {
-    CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC cv = DEREF_cv(type_qual(t));
-    cv &= cv_qual ;
+	cv &= cv_qual;
-    if ( IS_type_top_etc ( t ) ) {
+	if (IS_type_top_etc(t)) {
-	if ( cv != cv_none && !def ) {
+		if (cv != cv_none && !def) {
-	    /* Can't return 'cv void' */
+			/* Can't return 'cv void' */
-	    add_error ( err, ERR_dcl_fct_ret_void ( t ) ) ;
+			add_error(err, ERR_dcl_fct_ret_void(t));
-	    if ( ( cv & cv_volatile ) && IS_type_top ( t ) ) {
+			if ((cv & cv_volatile) && IS_type_top(t)) {
-		/* Map 'volatile void' to 'bottom' */
+				/* Map 'volatile void' to 'bottom' */
-		t = type_bottom ;
+				t = type_bottom;
-		cv &= ~cv_volatile ;
+				cv &= ~cv_volatile;
-		t = qualify_type ( t, cv, 0 ) ;
+				t = qualify_type(t, cv, 0);
-	    }
+			}
-	}
+		}
-    } else {
+	} else {
+		if (def) {
-	if ( def ) add_error ( err, check_incomplete ( t ) ) ;
+			add_error(err, check_incomplete(t));
-    }
+		}
+	}
-    if ( cv != cv_none && !def ) {
+	if (cv != cv_none && !def) {
-	/* Check for cv-qualified return types */
+		/* Check for cv-qualified return types */
-	add_error ( err, ERR_dcl_fct_cv_ret ( cv ) ) ;
+		add_error(err, ERR_dcl_fct_cv_ret(cv));
-    }
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     APPLY REFERENCE CONVERSIONS TO A LIST OF EXPRESSIONS
     This routine applies reference conversions to each element of the
     argument list args.
 */
-LIST ( EXP ) convert_args
+LIST(EXP)
-    PROTO_N ( ( args ) )
-    PROTO_T ( LIST ( EXP ) args )
+convert_args(LIST(EXP) args)
 {
-    LIST ( EXP ) p = args ;
+	LIST(EXP)p = args;
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP e = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP e = DEREF_exp(HEAD_list(p));
-	if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-	    e = convert_reference ( e, REF_ASSIGN ) ;
+			e = convert_reference(e, REF_ASSIGN);
-	    COPY_exp ( HEAD_list ( p ), e ) ;
+			COPY_exp(HEAD_list(p), e);
-	}
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( args ) ;
+	return (args);
 }
 /*
     FIND MINIMUM NUMBER OF ARGUMENTS FOR A FUNCTION
     This routine calculates the minimum number of arguments for the function
     type fn, taking default arguments and weak prototypes into account.
     The extra argument for member functions is included.
 */
-unsigned min_no_args
+unsigned
-    PROTO_N ( ( fn ) )
-    PROTO_T ( TYPE fn )
+min_no_args(TYPE fn)
+{
-    unsigned n = 0 ;
+	unsigned n = 0;
-    LIST ( TYPE ) ptypes ;
+	LIST(TYPE)ptypes;
-    LIST ( TYPE ) mtypes ;
+	LIST(TYPE)mtypes;
-    LIST ( IDENTIFIER ) p ;
+	LIST(IDENTIFIER)p;
-    while ( IS_type_templ ( fn ) ) {
+	while (IS_type_templ(fn)) {
-	fn = DEREF_type ( type_templ_defn ( fn ) ) ;
+		fn = DEREF_type(type_templ_defn(fn));
-    }
-    p = DEREF_list ( type_func_pids ( fn ) ) ;
-    ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
-    mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
-    if ( !EQ_list ( mtypes, ptypes ) ) {
-	/* Add one for member functions */
-	if ( !IS_NULL_list ( mtypes ) ) {
-	    mtypes = TAIL_list ( mtypes ) ;
-	    if ( EQ_list ( mtypes, ptypes ) ) n = 1 ;
+	}
+	p = DEREF_list(type_func_pids(fn));
+	ptypes = DEREF_list(type_func_ptypes(fn));
+	mtypes = DEREF_list(type_func_mtypes(fn));
+	if (!EQ_list(mtypes, ptypes)) {
+		/* Add one for member functions */
+		if (!IS_NULL_list(mtypes)) {
+			mtypes = TAIL_list(mtypes);
+			if (EQ_list(mtypes, ptypes)) {
+				n = 1;
-    }
+			}
+		}
+	}
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	/* Scan for default arguments */
+		/* Scan for default arguments */
-	IDENTIFIER id = DEREF_id ( HEAD_list ( p ) ) ;
+		IDENTIFIER id = DEREF_id(HEAD_list(p));
-	EXP e = DEREF_exp ( id_parameter_init ( id ) ) ;
+		EXP e = DEREF_exp(id_parameter_init(id));
-	if ( !IS_NULL_exp ( e ) ) break ;
+		if (!IS_NULL_exp(e)) {
+			break;
+		}
-	n++ ;
+		n++;
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( n ) ;
+	return (n);
+}
 /*
     CHECK FUNCTION DEFAULT ARGUMENTS
     This routine checks the default arguments for the function type fn,
     returning true if there is a default argument.  Missing default
     arguments are checked if chk is true.
 */
-int check_func_dargs
+int
-    PROTO_N ( ( fn, chk, clr ) )
-    PROTO_T ( TYPE fn X int chk X int clr )
+check_func_dargs(TYPE fn, int chk, int clr)
+{
-    int started = 0 ;
+	int started = 0;
-    unsigned tag = TAG_type ( fn ) ;
+	unsigned tag = TAG_type(fn);
-    while ( tag == type_templ_tag ) {
+	while (tag == type_templ_tag) {
-	fn = DEREF_type ( type_templ_defn ( fn ) ) ;
+		fn = DEREF_type(type_templ_defn(fn));
-	tag = TAG_type ( fn ) ;
+		tag = TAG_type(fn);
-    }
+	}
-    if ( tag == type_func_tag ) {
+	if (tag == type_func_tag) {
-	LIST ( IDENTIFIER ) pids = DEREF_list ( type_func_pids ( fn ) ) ;
+		LIST(IDENTIFIER)pids = DEREF_list(type_func_pids(fn));
-	while ( !IS_NULL_list ( pids ) ) {
+		while (!IS_NULL_list(pids)) {
-	    IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+			IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	    EXP a = DEREF_exp ( id_parameter_init ( pid ) ) ;
+			EXP a = DEREF_exp(id_parameter_init(pid));
-	    if ( IS_NULL_exp ( a ) ) {
+			if (IS_NULL_exp(a)) {
-		if ( started && !clr ) {
+				if (started && !clr) {
-		    /* Missing default arguments */
+					/* Missing default arguments */
-		    TYPE s ;
+					TYPE s;
-		    LOCATION loc ;
+					LOCATION loc;
-		    DEREF_loc ( id_loc ( pid ), loc ) ;
+					DEREF_loc(id_loc(pid), loc);
-		    report ( loc, ERR_dcl_fct_default_missing ( pid ) ) ;
+					report(loc, ERR_dcl_fct_default_missing(pid));
-		    s = DEREF_type ( id_parameter_type ( pid ) ) ;
+					s = DEREF_type(id_parameter_type(pid));
-		    MAKE_exp_value ( s, a ) ;
+					MAKE_exp_value(s, a);
-		    COPY_exp ( id_parameter_init ( pid ), a ) ;
+					COPY_exp(id_parameter_init(pid), a);
+				}
+			} else {
+				started = 1;
+				if (clr) {
+					/* Clear default argument */
+					COPY_exp(id_parameter_init(pid),
+						 NULL_exp);
+				} else {
+					if (!chk) {
+						break;
+					}
+				}
+			}
+			pids = TAIL_list(pids);
+		}
-	    } else {
-		started = 1 ;
-		if ( clr ) {
-		    /* Clear default argument */
-		    COPY_exp ( id_parameter_init ( pid ), NULL_exp ) ;
-		} else {
-		    if ( !chk ) break ;
-		}
-	    }
-	    pids = TAIL_list ( pids ) ;
+	}
-    }
-    return ( started ) ;
+	return (started);
+}
 /*
     CHECK A WEAK PROTOTYPE ARGUMENT
     This routine checks the expression a passed as an argument to a weak
     function parameter of type t.  It returns the composite of t and the
     type of a, adding any errors to err.
 */
-static TYPE check_weak_arg
+static TYPE
-    PROTO_N ( ( t, a, err ) )
-    PROTO_T ( TYPE t X EXP a X ERROR *err )
+check_weak_arg(TYPE t, EXP a, ERROR *err)
+{
-    ERROR err2 = NULL_err ;
+	ERROR err2 = NULL_err;
-    TYPE s = DEREF_type ( exp_type ( a ) ) ;
+	TYPE s = DEREF_type(exp_type(a));
-    if ( IS_exp_int_lit ( a ) && eq_type_offset ( s, t ) ) {
+	if (IS_exp_int_lit(a) && eq_type_offset(s, t)) {
-	/* Allow for integer literals */
+		/* Allow for integer literals */
-	NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(a));
-	if ( check_nat_range ( t, n ) == 0 ) return ( t ) ;
+		if (check_nat_range(t, n) == 0) {
+			return (t);
-    }
+		}
+	}
-    t = check_compatible ( t, s, 2, &err2, 1 ) ;
+	t = check_compatible(t, s, 2, &err2, 1);
-    if ( !IS_NULL_err ( err2 ) ) {
+	if (!IS_NULL_err(err2)) {
-	err2 = set_severity ( err2, OPT_whatever, 0 ) ;
+		err2 = set_severity(err2, OPT_whatever, 0);
-	add_error ( err, err2 ) ;
+		add_error(err, err2);
-    }
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     PERFORM WEAK PROTOTYPE ANALYSIS
     This routine performs weak prototype analysis for a call to the
     function id with the arguments args.  It is only called when the
     number of arguments matches the function type.
 */
-static void check_weak_args
+static void
-    PROTO_N ( ( id, args, n ) )
-    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args X unsigned n )
+check_weak_args(IDENTIFIER id, LIST(EXP) args, unsigned n)
 {
-    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+	TYPE fn = DEREF_type(id_function_etc_type(id));
-    if ( IS_type_func ( fn ) ) {
+	if (IS_type_func(fn)) {
-	int changed = 0 ;
+		int changed = 0;
-	int ell = DEREF_int ( type_func_ellipsis ( fn ) ) ;
+		int ell = DEREF_int(type_func_ellipsis(fn));
-	LIST ( TYPE ) p = DEREF_list ( type_func_ptypes ( fn ) ) ;
+		LIST(TYPE) p = DEREF_list(type_func_ptypes(fn));
-	LIST ( TYPE ) q = NULL_list ( TYPE ) ;
+		LIST(TYPE) q = NULL_list(TYPE);
-	LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+		LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);
-	if ( ell == FUNC_WEAK_ARGS ) changed = 1 ;
+		if (ell == FUNC_WEAK_ARGS) {
+			changed = 1;
+		}
-	while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-	    /* Check parameter types */
+			/* Check parameter types */
-	    TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+			TYPE s = DEREF_type(HEAD_list(p));
-	    if ( !IS_NULL_list ( args ) ) {
+			if (!IS_NULL_list(args)) {
-		ERROR err = NULL_err ;
+				ERROR err = NULL_err;
-		EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+				EXP a = DEREF_exp(HEAD_list(args));
-		TYPE t = check_weak_arg ( s, a, &err ) ;
+				TYPE t = check_weak_arg(s, a, &err);
-		if ( !IS_NULL_err ( err ) ) {
+				if (!IS_NULL_err(err)) {
-		    /* Report incompatible argument types */
+					/* Report incompatible argument types */
-		    PTR ( LOCATION ) loc = id_loc ( id ) ;
+					PTR(LOCATION)loc = id_loc(id);
+					ERROR err2 =
-		    ERROR err2 = ERR_expr_call_weak_arg ( n, loc ) ;
+					    ERR_expr_call_weak_arg(n, loc);
-		    err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+					err = concat_error(ERR_expr_call_func(id), err);
-		    err = concat_error ( err, err2 ) ;
+					err = concat_error(err, err2);
-		    report ( crt_loc, err ) ;
+					report(crt_loc, err);
-		}
+				}
-		if ( !EQ_type ( t, s ) ) {
+				if (!EQ_type(t, s)) {
-		    if ( changed ) changed = 1 ;
+					if (changed) {
+						changed = 1;
+					}
-		    s = t ;
+					s = t;
+				}
+				args = TAIL_list(args);
+				n++;
+			}
+			if (changed) {
+				CONS_type(s, q, q);
+			}
+			p = TAIL_list(p);
+		}
+		if (ell == FUNC_NO_PARAMS) {
+			/* Previous declaration was 'id()' */
+			LOCATION loc;
+			int par = CONTEXT_PARAMETER;
+			NAMESPACE ns = DEREF_nspace(type_func_pars(fn));
+			loc = decl_loc;
+			decl_loc = crt_loc;
+			push_namespace(ns);
+			while (!IS_NULL_list(args)) {
+				HASHID nm = lookup_anon();
+				EXP a = DEREF_exp(HEAD_list(args));
+				TYPE t = DEREF_type(exp_type(a));
+				IDENTIFIER pid = DEREF_id(hashid_id(nm));
+				pid = make_param_decl(dspec_none, t, pid, par);
+				init_param(pid, NULL_exp);
+				CONS_id(pid, pids, pids);
+				CONS_type(t, q, q);
+				args = TAIL_list(args);
+			}
+			IGNORE pop_namespace();
+			ell = FUNC_WEAK_ARGS;
+			decl_loc = loc;
+			changed = 2;
+		}
+		if (changed == 2) {
+			q = REVERSE_list(q);
+			fn = copy_typedef(id, fn, cv_none);
+			COPY_list(type_func_ptypes(fn), q);
+			COPY_list(type_func_mtypes(fn), q);
+			if (!IS_NULL_list(pids)) {
+				pids = REVERSE_list(pids);
+				COPY_list(type_func_pids(fn), pids);
+			}
+			COPY_int(type_func_ellipsis(fn), ell);
+			COPY_type(id_function_etc_type(id), fn);
+			COPY_loc(id_loc(id), crt_loc);
+			decl_func_type(id, fn, 0);
+		} else {
+			DESTROY_list(q, SIZE_type);
+		}
-		args = TAIL_list ( args ) ;
-		n++ ;
-	    }
-	    if ( changed ) CONS_type ( s, q, q ) ;
-	    p = TAIL_list ( p ) ;
-	}
-	if ( ell == FUNC_NO_PARAMS ) {
-	    /* Previous declaration was 'id ()' */
-	    LOCATION loc ;
-	    int par = CONTEXT_PARAMETER ;
-	    NAMESPACE ns = DEREF_nspace ( type_func_pars ( fn ) ) ;
-	    loc = decl_loc ;
-	    decl_loc = crt_loc ;
-	    push_namespace ( ns ) ;
-	    while ( !IS_NULL_list ( args ) ) {
-		HASHID nm = lookup_anon () ;
-		EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
-		TYPE t = DEREF_type ( exp_type ( a ) ) ;
-		IDENTIFIER pid = DEREF_id ( hashid_id ( nm ) ) ;
-		pid = make_param_decl ( dspec_none, t, pid, par ) ;
-		init_param ( pid, NULL_exp ) ;
-		CONS_id ( pid, pids, pids ) ;
-		CONS_type ( t, q, q ) ;
-		args = TAIL_list ( args ) ;
-	    }
-	    IGNORE pop_namespace () ;
-	    ell = FUNC_WEAK_ARGS ;
-	    decl_loc = loc ;
-	    changed = 2 ;
-	}
-	if ( changed == 2 ) {
-	    q = REVERSE_list ( q ) ;
-	    fn = copy_typedef ( id, fn, cv_none ) ;
-	    COPY_list ( type_func_ptypes ( fn ), q ) ;
-	    COPY_list ( type_func_mtypes ( fn ), q ) ;
-	    if ( !IS_NULL_list ( pids ) ) {
-		pids = REVERSE_list ( pids ) ;
-		COPY_list ( type_func_pids ( fn ), pids ) ;
-	    }
-	    COPY_int ( type_func_ellipsis ( fn ), ell ) ;
-	    COPY_type ( id_function_etc_type ( id ), fn ) ;
-	    COPY_loc ( id_loc ( id ), crt_loc ) ;
-	    decl_func_type ( id, fn, 0 ) ;
-	} else {
-	    DESTROY_list ( q, SIZE_type ) ;
+	}
-    }
-    return ;
+	return;
+}
 /*
     CHECK PRINTF AND SCANF ARGUMENTS
     This routine performs weak prototype analysis for a call to the
     printf-like or scanf-like function id with the arguments args.  p gives
     the parameter types deduced from the format string.
 */
-static void check_printf_args
+static void
-    PROTO_N ( ( id, p, args, n, pf ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TYPE ) p X LIST ( EXP ) args X
+check_printf_args(IDENTIFIER id, LIST(TYPE) p, LIST(EXP) args, unsigned n,
-	      unsigned n X int pf )
+		  int pf)
 {
-    unsigned np = LENGTH_list ( p ) + ( n - 1 ) ;
+	unsigned np = LENGTH_list(p) + (n - 1);
-    unsigned na = LENGTH_list ( args ) + ( n - 1 ) ;
+	unsigned na = LENGTH_list(args) + (n - 1);
-    if ( np != na ) {
+	if (np != na) {
-	/* Check number of parameters */
+		/* Check number of parameters */
-	ERROR err = ERR_expr_call_args_exact ( na, na, np ) ;
+		ERROR err = ERR_expr_call_args_exact(na, na, np);
-	err = set_severity ( err, OPT_weak, -1 ) ;
+		err = set_severity(err, OPT_weak, -1);
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+			err = concat_error(ERR_expr_call_func(id), err);
+		}
+		report(crt_loc, err);
+	}
-	report ( crt_loc, err ) ;
-    }
-    while ( !IS_NULL_list ( p ) && !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(p) && !IS_NULL_list(args)) {
-	/* Check parameter types */
+		/* Check parameter types */
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+		TYPE s = DEREF_type(HEAD_list(p));
-	EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+		EXP a = DEREF_exp(HEAD_list(args));
-	TYPE t = check_weak_arg ( s, a, &err ) ;
+		TYPE t = check_weak_arg(s, a, &err);
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    /* Report incompatible argument types */
+			/* Report incompatible argument types */
-	    PTR ( LOCATION ) loc = NULL_ptr ( LOCATION ) ;
+			PTR(LOCATION)loc = NULL_ptr(LOCATION);
-	    if ( !IS_NULL_id ( id ) ) loc = id_loc ( id ) ;
+			if (!IS_NULL_id(id)) {
+				loc = id_loc(id);
+			}
-	    err = concat_error ( err, ERR_expr_call_weak_arg ( n, loc ) ) ;
+			err = concat_error(err, ERR_expr_call_weak_arg(n, loc));
-	} else {
+		} else {
-	    /* Check that scanf arguments aren't const */
+			/* Check that scanf arguments aren't const */
-	    if ( !( pf & 1 ) && IS_type_ptr ( t ) ) {
+			if (!(pf & 1) && IS_type_ptr(t)) {
-		CV_SPEC cv ;
+				CV_SPEC cv;
-		t = DEREF_type ( type_ptr_sub ( t ) ) ;
+				t = DEREF_type(type_ptr_sub(t));
-		cv = DEREF_cv ( type_qual ( t ) ) ;
+				cv = DEREF_cv(type_qual(t));
-		if ( cv & cv_const ) {
+				if (cv & cv_const) {
-		    err = ERR_conv_qual_cast ( cv_const ) ;
+					err = ERR_conv_qual_cast(cv_const);
-		    err = set_severity ( err, OPT_weak, -1 ) ;
+					err = set_severity(err, OPT_weak, -1);
-		}
+				}
-	    }
+			}
-	}
+		}
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+				err = concat_error(ERR_expr_call_func(id), err);
-	    }
+			}
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
+		}
+		args = TAIL_list(args);
+		p = TAIL_list(p);
+		n++;
+	}
-	args = TAIL_list ( args ) ;
-	p = TAIL_list ( p ) ;
-	n++ ;
-    }
-    return ;
+	return;
+}
 /*
     APPLY ARGUMENT CONVERSIONS TO A LIST OF EXPRESSIONS
     functions are inherited.  The function return type is returned via pr.
     The identifier id is used in error reporting only, it is the function
     being called for named functions and the null identifier otherwise.
 */
-static LIST ( EXP ) cast_args
+static LIST(EXP)
-    PROTO_N ( ( id, fn, gr, args, pr, mem ) )
-    PROTO_T ( IDENTIFIER id X TYPE fn X GRAPH gr X LIST ( EXP ) args X
+cast_args(IDENTIFIER id, TYPE fn, GRAPH gr, LIST(EXP) args, TYPE *pr, int mem)
-	      TYPE *pr X int mem )
+{
-    int ell ;
+    int ell;
-    TYPE ret ;
+    TYPE ret;
-    int extra = 0 ;
+    int extra = 0;
-    unsigned n = 1 ;
+    unsigned n = 1;
-    LIST ( EXP ) q ;
+    LIST(EXP)q;
-    LIST ( TYPE ) p ;
+    LIST(TYPE)p;
-    LIST ( TYPE ) ptypes ;
+    LIST(TYPE)ptypes;
-    LIST ( TYPE ) mtypes ;
+    LIST(TYPE)mtypes;
-    ERROR err = NULL_err ;
+    ERROR err = NULL_err;
-    int printf_function = 0 ;
+    int printf_function = 0;
-    LIST ( IDENTIFIER ) pids ;
+    LIST(IDENTIFIER)pids;
-    OPTION weak = OPTION_OFF ;
+    OPTION weak = OPTION_OFF;
-    LIST ( TYPE ) ftypes = NULL_list ( TYPE ) ;
+    LIST(TYPE)ftypes = NULL_list(TYPE);
     /* Allow for template types */
-    if ( IS_type_templ ( fn ) ) {
+    if (IS_type_templ(fn)) {
-	int d ;
+	int d;
-	TOKEN sort = DEREF_tok ( type_templ_sort ( fn ) ) ;
+	TOKEN sort = DEREF_tok(type_templ_sort(fn));
-	pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
+	pids = DEREF_list(tok_templ_pids(sort));
-	force_template++ ;
+	force_template++;
-	d = save_token_args ( pids, NULL_list ( TOKEN ) ) ;
+	d = save_token_args(pids, NULL_list(TOKEN));
-	fn = DEREF_type ( type_templ_defn ( fn ) ) ;
+	fn = DEREF_type(type_templ_defn(fn));
-	args = cast_args ( id, fn, gr, args, &ret, mem ) ;
+	args = cast_args(id, fn, gr, args, &ret, mem);
-	*pr = expand_type ( ret, 2 ) ;
+	*pr = expand_type(ret, 2);
-	restore_token_args ( pids, d ) ;
+	restore_token_args(pids, d);
-	force_template-- ;
+	force_template--;
-	return ( args ) ;
+	return (args);
+    }
     /* Check function return type */
-    ret = DEREF_type ( type_func_ret ( fn ) ) ;
+    ret = DEREF_type(type_func_ret(fn));
-    ret = check_ret_type ( ret, &err, 1 ) ;
+    ret = check_ret_type(ret, &err, 1);
-    if ( !IS_NULL_err ( err ) ) {
+    if (!IS_NULL_err(err)) {
-	err = concat_error ( err, ERR_expr_call_ret () ) ;
+	err = concat_error(err, ERR_expr_call_ret());
-	if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	    err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+	    err = concat_error(ERR_expr_call_func(id), err);
+	}
-	report ( crt_loc, err ) ;
+	report(crt_loc, err);
+    }
-    ret = convert_qual_type ( ret ) ;
+    ret = convert_qual_type(ret);
-    *pr = ret ;
+    *pr = ret;
     /* Check number of arguments */
-    ell = DEREF_int ( type_func_ellipsis ( fn ) ) ;
+    ell = DEREF_int(type_func_ellipsis(fn));
-    ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
+    ptypes = DEREF_list(type_func_ptypes(fn));
-    mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
+    mtypes = DEREF_list(type_func_mtypes(fn));
-    if ( !EQ_list ( mtypes, ptypes ) ) {
+    if (!EQ_list(mtypes, ptypes)) {
-	if ( mem ) {
+	if (mem) {
 	    /* Member function */
-	    extra = 1 ;
+	    extra = 1;
 	} else {
-	    fn = copy_typedef ( NULL_id, fn, cv_none ) ;
+	    fn = copy_typedef(NULL_id, fn, cv_none);
-	    mtypes = ptypes ;
+	    mtypes = ptypes;
-	    COPY_list ( type_func_mtypes ( fn ), mtypes ) ;
+	    COPY_list(type_func_mtypes(fn), mtypes);
+	}
+    }
-    if ( match_no_args == 0 ) {
+    if (match_no_args == 0) {
 	/* Weren't checked in overload resolution */
-	unsigned na = LENGTH_list ( args ) ;
+	unsigned na = LENGTH_list(args);
-	unsigned npars = LENGTH_list ( mtypes ) ;
+	unsigned npars = LENGTH_list(mtypes);
-	if ( na != npars ) {
+	if (na != npars) {
-	    int more = 0 ;
+	    int more = 0;
-	    unsigned margs = min_no_args ( fn ) ;
+	    unsigned margs = min_no_args(fn);
-	    if ( ell & FUNC_VAR_PARAMS ) more = 1 ;
+	    if (ell & FUNC_VAR_PARAMS) {
+		    more = 1;
+	    }
-	    if ( na < margs || ( na > npars && !more ) ) {
+	    if (na < margs || (na > npars && !more)) {
 		/* Illegal number of arguments */
-		if ( extra ) {
+		if (extra) {
 		    /* Report actual numbers of passed arguments */
-		    na-- ;
+		    na--;
-		    npars-- ;
+		    npars--;
-		    margs-- ;
+		    margs--;
 		}
-		if ( more ) {
+		if (more) {
-		    err = ERR_expr_call_args_min ( na, na, margs ) ;
+		    err = ERR_expr_call_args_min(na, na, margs);
-		} else if ( npars == margs ) {
+		} else if (npars == margs) {
-		    err = ERR_expr_call_args_exact ( na, na, npars ) ;
+		    err = ERR_expr_call_args_exact(na, na, npars);
 		} else {
-		    err = ERR_expr_call_args_range ( na, na, margs, npars ) ;
+		    err = ERR_expr_call_args_range(na, na, margs, npars);
 		}
-		if ( ell & FUNC_NON_PROTO ) {
+		if (ell & FUNC_NON_PROTO) {
 		    /* Allowed for non-prototype functions */
-		    err = set_severity ( err, OPT_weak, -1 ) ;
+		    err = set_severity(err, OPT_weak, -1);
 		}
-		if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-		    if ( !IS_NULL_id ( id ) ) {
+		    if (!IS_NULL_id(id)) {
-			ERROR err2 = ERR_expr_call_func ( id ) ;
+			ERROR err2 = ERR_expr_call_func(id);
-			err = concat_error ( err2, err ) ;
+			err = concat_error(err2, err);
+		    }
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
 		}
+	    }
+	}
+    }
     /* Check function argument types */
-    p = mtypes ;
+    p = mtypes;
-    q = args ;
+    q = args;
-    pids = DEREF_list ( type_func_pids ( fn ) ) ;
+    pids = DEREF_list(type_func_pids(fn));
     /* Extra implicit argument */
-    if ( extra && !IS_NULL_list ( p ) && !IS_NULL_list ( q ) ) {
+    if (extra && !IS_NULL_list(p) && !IS_NULL_list(q)) {
-	EXP b = DEREF_exp ( HEAD_list ( q ) ) ;
+	EXP b = DEREF_exp(HEAD_list(q));
-	TYPE t = DEREF_type ( HEAD_list ( p ) ) ;
+	TYPE t = DEREF_type(HEAD_list(p));
-	if ( !IS_NULL_exp ( b ) && !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_exp(b) && !IS_NULL_type(t)) {
 	    /* Non-static member function called with object */
-	    TYPE u = t ;
+	    TYPE u = t;
-	    int temp = 1 ;
+	    int temp = 1;
-	    CLASS_TYPE cs, ct ;
+	    CLASS_TYPE cs, ct;
-	    TYPE s = DEREF_type ( exp_type ( b ) ) ;
+	    TYPE s = DEREF_type(exp_type(b));
-	    CV_SPEC qs = DEREF_cv ( type_qual ( s ) ) ;
+	    CV_SPEC qs = DEREF_cv(type_qual(s));
-	    CV_SPEC qt = DEREF_cv ( type_func_mqual ( fn ) ) ;
+	    CV_SPEC qt = DEREF_cv(type_func_mqual(fn));
 	    /* Check for temporary object */
-	    while ( IS_type_array ( s ) ) {
+	    while (IS_type_array(s)) {
-		s = DEREF_type ( type_array_sub ( s ) ) ;
+		s = DEREF_type(type_array_sub(s));
-		temp = 0 ;
-	    }
-	    while ( IS_type_ptr_etc ( s ) ) {
-		s = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
-		temp = 0 ;
+		temp = 0;
-	    }
-	    if ( temp ) {
-		TYPE ps ;
-		if ( !( qs & cv_lvalue ) ) {
-		    ERROR ferr = NULL_err ;
-		    b = make_temporary ( s, b, NULL_exp, 0, &ferr ) ;
-		    if ( !IS_NULL_err ( ferr ) ) report ( crt_loc, ferr ) ;
-		}
-		MAKE_type_ptr ( cv_none, s, ps ) ;
-		MAKE_exp_address ( ps, b, b ) ;
-	    }
-	    /* Check types for base class conversion */
-	    while ( IS_type_ptr_etc ( t ) ) {
-		t = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+	    }
+	    while (IS_type_ptr_etc(s)) {
+		s = DEREF_type(type_ptr_etc_sub(s));
+		temp = 0;
+	    }
+	    if (temp) {
+		TYPE ps;
+		if (!(qs & cv_lvalue)) {
+		    ERROR ferr = NULL_err;
+		    b = make_temporary(s, b, NULL_exp, 0, &ferr);
+		    if (!IS_NULL_err(ferr)) {
+			    report(crt_loc, ferr);
+		    }
+		}
+		MAKE_type_ptr(cv_none, s, ps);
+		MAKE_exp_address(ps, b, b);
+	    }
+	    /* Check types for base class conversion */
+	    while (IS_type_ptr_etc(t)) {
+		t = DEREF_type(type_ptr_etc_sub(t));
+	    }
-	    cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
+	    cs = DEREF_ctype(type_compound_defn(s));
-	    ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+	    ct = DEREF_ctype(type_compound_defn(t));
-	    if ( !eq_ctype ( cs, ct ) ) {
+	    if (!eq_ctype(cs, ct)) {
-		GRAPH gs = find_base_class ( cs, ct, 1 ) ;
+		GRAPH gs = find_base_class(cs, ct, 1);
-		if ( IS_NULL_graph ( gs ) ) {
+		if (IS_NULL_graph(gs)) {
-		    err = ERR_expr_ref_func_type ( cs ) ;
+		    err = ERR_expr_ref_func_type(cs);
 		} else {
-		    OFFSET off ;
+		    OFFSET off;
-		    err = check_ambig_base ( gs ) ;
+		    err = check_ambig_base(gs);
-		    if ( !IS_NULL_graph ( gr ) ) {
+		    if (!IS_NULL_graph(gr)) {
-			CLASS_TYPE cr = DEREF_ctype ( graph_head ( gr ) ) ;
+			CLASS_TYPE cr = DEREF_ctype(graph_head(gr));
-			if ( !eq_ctype ( cs, cr ) && !eq_ctype ( cr, ct ) ) {
+			if (!eq_ctype(cs, cr) && !eq_ctype(cr, ct)) {
 			    /* Inherited via intermediate base */
-			    GRAPH g1 = find_base_class ( cs, cr, 1 ) ;
+			    GRAPH g1 = find_base_class(cs, cr, 1);
-			    if ( !IS_NULL_graph ( g1 ) ) {
+			    if (!IS_NULL_graph(g1)) {
-				GRAPH g2 = find_base_class ( cr, ct, 1 ) ;
+				GRAPH g2 = find_base_class(cr, ct, 1);
-				if ( !IS_NULL_graph ( g2 ) ) {
+				if (!IS_NULL_graph(g2)) {
-				    if ( !IS_NULL_err ( err ) ) {
+				    if (!IS_NULL_err(err)) {
-					ERROR err2 ;
+					ERROR err2;
-					destroy_error ( err, 1 ) ;
+					destroy_error(err, 1);
-					err = check_ambig_base ( g1 ) ;
+					err = check_ambig_base(g1);
-					err2 = check_ambig_base ( g2 ) ;
+					err2 = check_ambig_base(g2);
-					err = concat_error ( err, err2 ) ;
+					err = concat_error(err, err2);
+				    }
-				    gs = DEREF_graph ( graph_top ( g2 ) ) ;
+				    gs = DEREF_graph(graph_top(g2));
-				    gs = find_subgraph ( g1, gs, g2 ) ;
+				    gs = find_subgraph(g1, gs, g2);
+				}
+			    }
 			}
 		    }
-		    if ( !IS_NULL_err ( err ) ) {
+		    if (!IS_NULL_err(err)) {
 			/* Report ambiguous bases */
-			ERROR err2 = ERR_class_member_lookup_func () ;
+			ERROR err2 = ERR_class_member_lookup_func();
-			err = concat_error ( err, err2 ) ;
+			err = concat_error(err, err2);
 		    }
-		    off = DEREF_off ( graph_off ( gs ) ) ;
+		    off = DEREF_off(graph_off(gs));
-		    b = make_base_cast ( u, b, off ) ;
+		    b = make_base_cast(u, b, off);
 		    /* Access should have been checked */
 		}
-		if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-		    if ( !IS_NULL_id ( id ) ) {
+		    if (!IS_NULL_id(id)) {
-			ERROR err2 = ERR_expr_call_func ( id ) ;
+			ERROR err2 = ERR_expr_call_func(id);
-			err = concat_error ( err2, err ) ;
+			err = concat_error(err2, err);
 		    }
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
 		}
 	    }
 	    /* Check type qualifiers */
-	    qs &= cv_qual ;
+	    qs &= cv_qual;
-	    qt &= cv_qual ;
+	    qt &= cv_qual;
+	    if (qs != qt) {
-	    if ( qs != qt ) MAKE_exp_cast ( u, CONV_QUAL, b, b ) ;
+		    MAKE_exp_cast(u, CONV_QUAL, b, b);
+	    }
-	    qs = ( qs & ~qt ) ;
+	    qs = (qs & ~qt);
-	    if ( qs != cv_none ) {
+	    if (qs != cv_none) {
-		if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-		    err = ERR_class_this_qual ( qs ) ;
+		    err = ERR_class_this_qual(qs);
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
 		} else {
-		    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		    HASHID nm = DEREF_hashid(id_name(id));
-		    if ( !IS_hashid_destr ( nm ) ) {
+		    if (!IS_hashid_destr(nm)) {
 			/* Allowed for destructors */
-			ERROR err2 ;
+			ERROR err2;
-			err = ERR_class_this_qual ( qs ) ;
+			err = ERR_class_this_qual(qs);
-			err2 = ERR_expr_call_func ( id ) ;
+			err2 = ERR_expr_call_func(id);
-			err = concat_error ( err2, err ) ;
+			err = concat_error(err2, err);
-			report ( crt_loc, err ) ;
+			report(crt_loc, err);
 		    }
 		}
 	    }
-	    COPY_exp ( HEAD_list ( q ), b ) ;
+	    COPY_exp(HEAD_list(q), b);
 	}
-	p = TAIL_list ( p ) ;
+	p = TAIL_list(p);
-	q = TAIL_list ( q ) ;
+	q = TAIL_list(q);
     }
     /* Normal arguments */
-    if ( ell & FUNC_NON_PROTO ) {
+    if (ell & FUNC_NON_PROTO) {
-	weak = option ( OPT_weak ) ;
+	weak = option(OPT_weak);
-	goto ellipsis_lab ;
+	goto ellipsis_lab;
+    }
-    while ( !IS_NULL_list ( p ) && !IS_NULL_list ( q ) ) {
+    while (!IS_NULL_list(p) && !IS_NULL_list(q)) {
-	EXP b = DEREF_exp ( HEAD_list ( q ) ) ;
+	EXP b = DEREF_exp(HEAD_list(q));
-	TYPE t = DEREF_type ( HEAD_list ( p ) ) ;
+	TYPE t = DEREF_type(HEAD_list(p));
-	OPTION opt = option ( OPT_conv_int_int_impl ) ;
+	OPTION opt = option(OPT_conv_int_int_impl);
+	if (IS_NULL_exp(b)) {
-	if ( IS_NULL_exp ( b ) ) b = make_error_exp ( 0 ) ;
+		b = make_error_exp(0);
+	}
-	if ( IS_exp_paren ( b ) ) {
+	if (IS_exp_paren(b)) {
 	    /* Parentheses suppress conversion warnings */
-	    b = DEREF_exp ( exp_paren_arg ( b ) ) ;
+	    b = DEREF_exp(exp_paren_arg(b));
-	    option ( OPT_conv_int_int_impl ) = OPTION_ALLOW ;
+	    option(OPT_conv_int_int_impl) = OPTION_ALLOW;
 	}
-	if ( IS_exp_string_lit ( b ) ) {
+	if (IS_exp_string_lit(b)) {
-	    if ( option ( OPT_printf_string ) ) {
+	    if (option(OPT_printf_string)) {
 		/* Check for printf and scanf strings */
-		int pf = is_printf_type ( t ) ;
+		int pf = is_printf_type(t);
-		if ( pf ) {
+		if (pf) {
-		    unsigned na = LENGTH_list ( q ) + 100 ;
+		    unsigned na = LENGTH_list(q) + 100;
-		    STRING fmt = DEREF_str ( exp_string_lit_str ( b ) ) ;
+		    STRING fmt = DEREF_str(exp_string_lit_str(b));
-		    ftypes = find_printf_args ( fmt, na, pf ) ;
+		    ftypes = find_printf_args(fmt, na, pf);
-		    printf_function = pf ;
+		    printf_function = pf;
+		}
+	    }
+	}
-	err = NULL_err ;
+	err = NULL_err;
-	b = init_assign ( t, cv_none, b, &err ) ;
+	b = init_assign(t, cv_none, b, &err);
-	if ( pass_complex_type ( t ) ) {
+	if (pass_complex_type(t)) {
 	    /* Create temporary variable */
-	    b = remove_temporary ( b, NULL_exp ) ;
+	    b = remove_temporary(b, NULL_exp);
-	    b = make_temporary ( t, b, NULL_exp, 0, &err ) ;
+	    b = make_temporary(t, b, NULL_exp, 0, &err);
-	    MAKE_type_ptr ( cv_none, t, t ) ;
+	    MAKE_type_ptr(cv_none, t, t);
-	    MAKE_exp_address ( t, b, b ) ;
+	    MAKE_exp_address(t, b, b);
 	}
-	if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	    err = init_error ( err, 0 ) ;
+	    err = init_error(err, 0);
-	    err = concat_error ( err, ERR_expr_call_arg ( n ) ) ;
+	    err = concat_error(err, ERR_expr_call_arg(n));
-	    if ( !IS_NULL_id ( id ) ) {
+	    if (!IS_NULL_id(id)) {
-		err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+		err = concat_error(ERR_expr_call_func(id), err);
 	    }
-	    report ( crt_loc, err ) ;
+	    report(crt_loc, err);
 	}
-	option ( OPT_conv_int_int_impl ) = opt ;
+	option(OPT_conv_int_int_impl) = opt;
-	n++ ;
+	n++;
-	COPY_exp ( HEAD_list ( q ), b ) ;
+	COPY_exp(HEAD_list(q), b);
-	pids = TAIL_list ( pids ) ;
+	pids = TAIL_list(pids);
-	p = TAIL_list ( p ) ;
+	p = TAIL_list(p);
-	q = TAIL_list ( q ) ;
+	q = TAIL_list(q);
     }
     /* Default arguments */
-    if ( !IS_NULL_list ( p ) ) {
+    if (!IS_NULL_list(p)) {
-	LIST ( EXP ) dargs = NULL_list ( EXP ) ;
+	LIST(EXP)dargs = NULL_list(EXP);
-	while ( !IS_NULL_list ( pids ) ) {
+	while (!IS_NULL_list(pids)) {
-	    IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+	    IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	    EXP e = DEREF_exp ( id_parameter_init ( pid ) ) ;
+	    EXP e = DEREF_exp(id_parameter_init(pid));
-	    if ( !IS_NULL_exp ( e ) ) {
+	    if (!IS_NULL_exp(e)) {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
+		TYPE t = DEREF_type(exp_type(e));
-		if ( pass_complex_type ( t ) ) {
+		if (pass_complex_type(t)) {
 		    /* Create temporary variable */
-		    EXP d = DEREF_exp ( id_parameter_term ( pid ) ) ;
+		    EXP d = DEREF_exp(id_parameter_term(pid));
-		    if ( !IS_NULL_exp ( d ) ) {
+		    if (!IS_NULL_exp(d)) {
-			d = copy_exp ( d, NULL_type, NULL_type ) ;
+			d = copy_exp(d, NULL_type, NULL_type);
 		    }
-		    err = NULL_err ;
+		    err = NULL_err;
-		    e = remove_temporary ( e, NULL_exp ) ;
+		    e = remove_temporary(e, NULL_exp);
-		    MAKE_exp_copy ( t, e, e ) ;
+		    MAKE_exp_copy(t, e, e);
-		    e = make_temporary ( t, e, d, 0, &err ) ;
+		    e = make_temporary(t, e, d, 0, &err);
-		    if ( !IS_NULL_err ( err ) ) {
+		    if (!IS_NULL_err(err)) {
-			err = concat_error ( err, ERR_expr_call_arg ( n ) ) ;
+			err = concat_error(err, ERR_expr_call_arg(n));
-			if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-			    ERROR err2 = ERR_expr_call_func ( id ) ;
+			    ERROR err2 = ERR_expr_call_func(id);
-			    err = concat_error ( err2, err ) ;
+			    err = concat_error(err2, err);
+			}
-			report ( crt_loc, err ) ;
+			report(crt_loc, err);
+		    }
-		    MAKE_type_ptr ( cv_none, t, t ) ;
+		    MAKE_type_ptr(cv_none, t, t);
-		    MAKE_exp_address ( t, e, e ) ;
+		    MAKE_exp_address(t, e, e);
 		} else {
-		    MAKE_exp_copy ( t, e, e ) ;
+		    MAKE_exp_copy(t, e, e);
 		}
-		CONS_exp ( e, dargs, dargs ) ;
+		CONS_exp(e, dargs, dargs);
-		n++ ;
+		n++;
 	    }
-	    pids = TAIL_list ( pids ) ;
+	    pids = TAIL_list(pids);
 	}
-	if ( !IS_NULL_list ( dargs ) ) {
+	if (!IS_NULL_list(dargs)) {
-	    dargs = REVERSE_list ( dargs ) ;
+	    dargs = REVERSE_list(dargs);
-	    args = APPEND_list ( args, dargs ) ;
+	    args = APPEND_list(args, dargs);
 	}
     }
     /* Ellipsis arguments */
-    ellipsis_lab : {
+    ellipsis_lab: {
-	unsigned wn = n ;
+	unsigned wn = n;
-	LIST ( EXP ) wq = q ;
+	LIST(EXP)wq = q;
-	while ( !IS_NULL_list ( q ) ) {
+	while (!IS_NULL_list(q)) {
-	    TYPE t, s ;
+	    TYPE t, s;
-	    EXP b = DEREF_exp ( HEAD_list ( q ) ) ;
+	    EXP b = DEREF_exp(HEAD_list(q));
+	    if (IS_NULL_exp(b)) {
-	    if ( IS_NULL_exp ( b ) ) b = make_error_exp ( 0 ) ;
+		    b = make_error_exp(0);
+	    }
-	    b = convert_lvalue ( b ) ;
+	    b = convert_lvalue(b);
-	    b = convert_none ( b ) ;
+	    b = convert_none(b);
-	    t = DEREF_type ( exp_type ( b ) ) ;
+	    t = DEREF_type(exp_type(b));
-	    err = NULL_err ;
+	    err = NULL_err;
-	    s = arg_promote_type ( t, &err ) ;
+	    s = arg_promote_type(t, &err);
-	    if ( !EQ_type ( s, t ) ) {
+	    if (!EQ_type(s, t)) {
-		b = init_assign ( s, cv_none, b, &err ) ;
+		b = init_assign(s, cv_none, b, &err);
 	    }
-	    if ( !IS_NULL_err ( err ) ) {
+	    if (!IS_NULL_err(err)) {
-		err = init_error ( err, 0 ) ;
+		err = init_error(err, 0);
-		err = concat_error ( err, ERR_expr_call_ellipsis ( n ) ) ;
+		err = concat_error(err, ERR_expr_call_ellipsis(n));
-		if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-		    err = concat_error ( ERR_expr_call_func ( id ), err ) ;
+		    err = concat_error(ERR_expr_call_func(id), err);
+		}
-		report ( crt_loc, err ) ;
+		report(crt_loc, err);
+	    }
-	    COPY_exp ( HEAD_list ( q ), b ) ;
+	    COPY_exp(HEAD_list(q), b);
-	    n++ ;
+	    n++;
-	    q = TAIL_list ( q ) ;
+	    q = TAIL_list(q);
+	}
-	if ( weak && !IS_NULL_id ( id ) ) {
+	if (weak && !IS_NULL_id(id)) {
 	    /* Perform weak prototype analysis */
-	    check_weak_args ( id, wq, wn ) ;
+	    check_weak_args(id, wq, wn);
+	}
-	if ( printf_function ) {
+	if (printf_function) {
 	    /* Check printf arguments */
-	    if ( option ( OPT_weak ) ) {
+	    if (option(OPT_weak)) {
-		check_printf_args ( id, ftypes, wq, wn, printf_function ) ;
+		check_printf_args(id, ftypes, wq, wn, printf_function);
+	    }
-	    DESTROY_list ( ftypes, SIZE_type ) ;
+	    DESTROY_list(ftypes, SIZE_type);
+	}
+    }
-    IGNORE check_value ( OPT_VAL_func_args, ( unsigned long ) ( n - 1 ) ) ;
+    IGNORE check_value(OPT_VAL_func_args,(unsigned long)(n - 1));
-    return ( args ) ;
+    return (args);
+}
 /*
     APPLY A NAMED FUNCTION TO A LIST OF EXPRESSIONS
     This routine applies the function id to the list of arguments args.
     Any qualifiers used to express id are passed in as qual, since these
     may suppress the virtual call mechanism.  gr gives the base class
     from which a member function is inherited.
 */
-EXP apply_func_id
+EXP
-    PROTO_N ( ( id, qual, gr, args ) )
-    PROTO_T ( IDENTIFIER id X QUALIFIER qual X GRAPH gr X LIST ( EXP ) args )
+apply_func_id(IDENTIFIER id, QUALIFIER qual, GRAPH gr, LIST(EXP)args)
 {
-    EXP e ;
+	EXP e;
-    TYPE fn ;
+	TYPE fn;
-    TYPE ret ;
+	TYPE ret;
-    DECL_SPEC ds ;
+	DECL_SPEC ds;
-    int throws = 1 ;
+	int throws = 1;
-    EXP virt = NULL_exp ;
+	EXP virt = NULL_exp;
-    IDENTIFIER fid = id ;
+	IDENTIFIER fid = id;
-    /* Check for non-functions */
+	/* Check for non-functions */
-    if ( !IS_id_function_etc ( id ) ) {
+	if (!IS_id_function_etc(id)) {
-	e = make_error_exp ( 0 ) ;
+		e = make_error_exp(0);
-	return ( e ) ;
+		return (e);
-    }
+	}
-    /* Check for inherited functions */
+	/* Check for inherited functions */
-    ds = DEREF_dspec ( id_storage ( id ) ) ;
+	ds = DEREF_dspec(id_storage(id));
-    if ( ds & dspec_inherit ) {
+	if (ds & dspec_inherit) {
-	id = DEREF_id ( id_alias ( id ) ) ;
+		id = DEREF_id(id_alias(id));
-	ds = DEREF_dspec ( id_storage ( id ) ) ;
+		ds = DEREF_dspec(id_storage(id));
-    }
+	}
-    /* Check for trivial functions */
+	/* Check for trivial functions */
-    if ( ds & dspec_trivial ) {
+	if (ds & dspec_trivial) {
-	e = apply_trivial_func ( id, args ) ;
+		e = apply_trivial_func(id, args);
-	if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-	    DESTROY_list ( args, SIZE_exp ) ;
+			DESTROY_list(args, SIZE_exp);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-    }
+	}
-    /* Convert the arguments */
+	/* Convert the arguments */
-    fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+	fn = DEREF_type(id_function_etc_type(id));
-    args = cast_args ( id, fn, gr, args, &ret, 1 ) ;
+	args = cast_args(id, fn, gr, args, &ret, 1);
-    /* Check for virtual function calls */
+	/* Check for virtual function calls */
-    if ( ds & dspec_virtual ) {
+	if (ds & dspec_virtual) {
-	if ( !( qual & qual_explicit ) ) {
+		if (!(qual & qual_explicit)) {
-	    EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+			EXP a = DEREF_exp(HEAD_list(args));
-	    int know = know_type ( a ) ;
+			int know = know_type(a);
-	    if ( know == 0 ) {
+			if (know == 0) {
-		if ( !IS_NULL_exp ( a ) ) {
+				if (!IS_NULL_exp(a)) {
-		    TYPE ta = DEREF_type ( exp_type ( a ) ) ;
+					TYPE ta = DEREF_type(exp_type(a));
-		    MAKE_exp_dummy ( ta, a, LINK_NONE, NULL_off, 1, virt ) ;
+					MAKE_exp_dummy(ta, a, LINK_NONE,
+						       NULL_off, 1, virt);
-		    COPY_exp ( HEAD_list ( args ), virt ) ;
+					COPY_exp(HEAD_list(args), virt);
-		}
+				}
-	    } else if ( know == 2 ) {
+			} else if (know == 2) {
-		/* Non-obvious case */
+				/* Non-obvious case */
-		report ( crt_loc, ERR_class_virtual_not ( id ) ) ;
+				report(crt_loc, ERR_class_virtual_not(id));
-	    }
+			}
-	}
+		}
-	if ( IS_NULL_exp ( virt ) ) {
+		if (IS_NULL_exp(virt)) {
-	    /* Explicit call of virtual function */
+			/* Explicit call of virtual function */
-	    if ( ds & dspec_pure ) {
+			if (ds & dspec_pure) {
-		/* Call of pure virtual function */
+				/* Call of pure virtual function */
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				HASHID nm = DEREF_hashid(id_name(id));
-		if ( IS_hashid_destr ( nm ) ) {
+				if (IS_hashid_destr(nm)) {
-		    /* Calling pure destructor is alright */
+					/* Calling pure destructor is alright */
-		    /* EMPTY */
+					/* EMPTY */
-		} else {
+				} else {
+					report(crt_loc,
-		    report ( crt_loc, ERR_class_abstract_call ( id ) ) ;
+					       ERR_class_abstract_call(id));
+				}
+			}
+			if (!(ds & dspec_used)) {
+				/* Mark explicit use */
+				reuse_id(id, suppress_usage);
+				ds = DEREF_dspec(id_storage(id));
+			}
+		}
-	    }
-	    if ( !( ds & dspec_used ) ) {
-		/* Mark explicit use */
-		reuse_id ( id, suppress_usage ) ;
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    }
-	}
-    }
-    if ( ( ds & dspec_friend ) && IS_NULL_exp ( virt ) ) {
-	/* Call can't throw an exception */
-	throws = 0 ;
-    }
-    /* Check for token applications */
-    if ( ds & dspec_token ) {
-	if ( ( qual & qual_mark ) && !( ds & dspec_reserve ) ) {
-	    /* Parenthesised - use function proper */
-	    /* EMPTY */
-	} else {
-	    TYPE form = DEREF_type ( id_function_etc_form ( id ) ) ;
-	    if ( !IS_NULL_type ( form ) && IS_type_token ( form ) ) {
-		IDENTIFIER ext = DEREF_id ( type_token_tok ( form ) ) ;
-		if ( !IS_NULL_id ( ext ) && IS_id_token ( ext ) ) {
-		    id = ext ;
-		}
-	    }
+	}
-    }
-    /* A function call is a side effect */
-    no_side_effects++ ;
-    /* Form the result */
-    MAKE_exp_func_id ( ret, id, args, virt, e ) ;
+	if ((ds & dspec_friend) && IS_NULL_exp(virt)) {
-    if ( pass_complex_type ( ret ) ) {
-	/* Allow for complex return types */
+		/* Call can't throw an exception */
-	EXP a ;
+		throws = 0;
-	MAKE_exp_dummy ( ret, NULL_exp, LINK_NONE, NULL_off, 0, a ) ;
-	if ( IS_id_stat_mem_func ( id ) ) {
-	    /* Insert as second parameter for static member functions */
-	    EXP b = DEREF_exp ( HEAD_list ( args ) ) ;
-	    COPY_exp ( HEAD_list ( args ), a ) ;
-	    CONS_exp ( b, args, args ) ;
-	} else {
-	    /* Insert as first parameter for other functions */
-	    CONS_exp ( a, args, args ) ;
+	}
-	COPY_list ( exp_func_id_args ( e ), args ) ;
-	COPY_unsigned ( exp_func_id_extra ( e ), 1 ) ;
-	COPY_type ( exp_type ( e ), type_void ) ;
-	MAKE_exp_constr ( ret, e, a, a, DEFAULT_USR, e ) ;
-    }
-    /* Check for exception violations */
-    if ( throws ) {
-	IGNORE check_func_throw ( fn, fid ) ;
-    }
-    return ( e ) ;
-}
-/*
-    APPLY A FUNCTION TO A LIST OF EXPRESSIONS
-    This routine applies the function expression a to the list of arguments
-    args.
-*/
-static EXP apply_func_exp
+	/* Check for token applications */
-    PROTO_N ( ( a, args ) )
+	if (ds & dspec_token) {
-    PROTO_T ( EXP a X LIST ( EXP ) args )
+		if ((qual & qual_mark) && !(ds & dspec_reserve)) {
-{
-    /* Find function type */
+			/* Parenthesised - use function proper */
-    EXP e ;
+			/* EMPTY */
-    TYPE ret ;
+		} else {
-    int mem = 0 ;
-    TYPE fn = DEREF_type ( exp_type ( a ) ) ;
+			TYPE form = DEREF_type(id_function_etc_form(id));
-    CV_SPEC cv = DEREF_cv ( type_qual ( fn ) ) ;
+			if (!IS_NULL_type(form) && IS_type_token(form)) {
-    if ( cv & cv_lvalue ) {
+				IDENTIFIER ext = DEREF_id(type_token_tok(form));
-	a = convert_lvalue ( a ) ;
+				if (!IS_NULL_id(ext) && IS_id_token(ext)) {
-	fn = DEREF_type ( exp_type ( a ) ) ;
+					id = ext;
-    }
+				}
-    switch ( TAG_type ( fn ) ) {
-	case type_ptr_tag : {
-	    fn = DEREF_type ( type_ptr_sub ( fn ) ) ;
-	    break ;
+			}
-	}
+		}
-	case type_ptr_mem_tag : {
-	    fn = DEREF_type ( type_ptr_mem_sub ( fn ) ) ;
-	    break ;
+	}
-    }
-    /* Convert the arguments */
-    match_no_args = 0 ;
-    if ( IS_exp_call ( a ) ) mem = 1 ;
-    args = cast_args ( NULL_id, fn, NULL_graph, args, &ret, mem ) ;
-    if ( mem ) {
-	/* Record pointer to function member argument */
-	EXP c = DEREF_exp ( HEAD_list ( args ) ) ;
-	TYPE t = DEREF_type ( exp_type ( c ) ) ;
-	MAKE_exp_dummy ( t, c, LINK_NONE, NULL_off, 1, c ) ;
-	COPY_exp ( exp_call_arg ( a ), c ) ;
-	COPY_exp ( HEAD_list ( args ), c ) ;
-    }
-    /* A function call is a side effect */
+	/* A function call is a side effect */
-    no_side_effects++ ;
+	no_side_effects++;
+	/* Form the result */
+	MAKE_exp_func_id(ret, id, args, virt, e);
+	if (pass_complex_type(ret)) {
+		/* Allow for complex return types */
+		EXP a;
+		MAKE_exp_dummy(ret, NULL_exp, LINK_NONE, NULL_off, 0, a);
+		if (IS_id_stat_mem_func(id)) {
+			/* Insert as second parameter for static member functions */
+			EXP b = DEREF_exp(HEAD_list(args));
+			COPY_exp(HEAD_list(args), a);
+			CONS_exp(b, args, args);
+		} else {
+			/* Insert as first parameter for other functions */
+			CONS_exp(a, args, args);
+		}
+		COPY_list(exp_func_id_args(e), args);
+		COPY_unsigned(exp_func_id_extra(e), 1);
+		COPY_type(exp_type(e), type_void);
+		MAKE_exp_constr(ret, e, a, a, DEFAULT_USR, e);
+	}
+	/* Check for exception violations */
+	if (throws) {
+		IGNORE check_func_throw(fn, fid);
+	}
+	return (e);
+}
+/*
+    APPLY A FUNCTION TO A LIST OF EXPRESSIONS
+    This routine applies the function expression a to the list of arguments
+    args.
+*/
+static EXP
+apply_func_exp(EXP a, LIST(EXP)args)
+{
+	/* Find function type */
+	EXP e;
+	TYPE ret;
+	int mem = 0;
+	TYPE fn = DEREF_type(exp_type(a));
+	CV_SPEC cv = DEREF_cv(type_qual(fn));
+	if (cv & cv_lvalue) {
+		a = convert_lvalue(a);
+		fn = DEREF_type(exp_type(a));
+	}
+	switch (TAG_type(fn)) {
+	case type_ptr_tag:
+		fn = DEREF_type(type_ptr_sub(fn));
+		break;
+	case type_ptr_mem_tag:
+		fn = DEREF_type(type_ptr_mem_sub(fn));
+		break;
+	}
+	/* Convert the arguments */
+	match_no_args = 0;
+	if (IS_exp_call(a)) {
+		mem = 1;
+	}
+	args = cast_args(NULL_id, fn, NULL_graph, args, &ret, mem);
+	if (mem) {
+		/* Record pointer to function member argument */
+		EXP c = DEREF_exp(HEAD_list(args));
+		TYPE t = DEREF_type(exp_type(c));
+		MAKE_exp_dummy(t, c, LINK_NONE, NULL_off, 1, c);
+		COPY_exp(exp_call_arg(a), c);
+		COPY_exp(HEAD_list(args), c);
+	}
+	/* A function call is a side effect */
+	no_side_effects++;
-    /* Form the result */
+	/* Form the result */
-    MAKE_exp_func ( ret, a, args, e ) ;
+	MAKE_exp_func(ret, a, args, e);
-    if ( pass_complex_type ( ret ) ) {
+	if (pass_complex_type(ret)) {
-	/* Allow for complex return types */
+		/* Allow for complex return types */
-	EXP b ;
+		EXP b;
-	MAKE_exp_dummy ( ret, NULL_exp, LINK_NONE, NULL_off, 0, b ) ;
+		MAKE_exp_dummy(ret, NULL_exp, LINK_NONE, NULL_off, 0, b);
-	CONS_exp ( b, args, args ) ;
+		CONS_exp(b, args, args);
-	COPY_list ( exp_func_args ( e ), args ) ;
+		COPY_list(exp_func_args(e), args);
-	COPY_unsigned ( exp_func_extra ( e ), 1 ) ;
+		COPY_unsigned(exp_func_extra(e), 1);
-	COPY_type ( exp_type ( e ), type_void ) ;
+		COPY_type(exp_type(e), type_void);
-	MAKE_exp_constr ( ret, e, b, b, DEFAULT_USR, e ) ;
+		MAKE_exp_constr(ret, e, b, b, DEFAULT_USR, e);
-    }
+	}
-    /* Check for exception violations */
+	/* Check for exception violations */
-    IGNORE check_func_throw ( fn, NULL_id ) ;
+	IGNORE check_func_throw(fn, NULL_id);
-    return ( e ) ;
+	return (e);
 }
 /*
     APPLY A TEMPLATE DEPENDENT FUNCTION
     This routine constructs the template dependent function call
     'a ( args )', or '( a ) ( args )' if is_paren is true.
 */
-static EXP call_func_templ
-    PROTO_N ( ( a, args, is_paren ) )
-    PROTO_T ( EXP a X LIST ( EXP ) args X int is_paren )
-{
-    EXP e ;
-    TYPE ret = type_templ_param ;
-    if ( is_paren ) a = make_paren_exp ( a ) ;
-    CONS_exp ( a, args, args ) ;
-    MAKE_exp_opn ( ret, lex_func_Hop, args, e ) ;
-    return ( e ) ;
-}
-/*
-    CONSTRUCT A FUNCTION CALL EXPRESSION
-    This routine constructs the function call expression 'a ( args )'.
-*/
-EXP make_func_exp
+static EXP
-    PROTO_N ( ( a, args, rescan ) )
-    PROTO_T ( EXP a X LIST ( EXP ) args X int rescan )
+call_func_templ(EXP a, LIST(EXP) args, int is_paren)
+{
-    EXP e ;
+	EXP e;
-    TYPE fn ;
+	TYPE ret = type_templ_param;
-    unsigned tag ;
+	if (is_paren) {
-    unsigned ftag ;
+		a = make_paren_exp(a);
+	}
-    int is_ptr = 0 ;
+	CONS_exp(a, args, args);
-    int is_ptr_mem = 0 ;
+	MAKE_exp_opn(ret, lex_func_Hop, args, e);
-    int is_paren = IS_exp_paren ( a ) ;
+	return (e);
+}
-    /* Do reference conversions */
+/*
-    a = convert_reference ( a, REF_FUNCTION ) ;
+    CONSTRUCT A FUNCTION CALL EXPRESSION
-    args = convert_args ( args ) ;
+    This routine constructs the function call expression 'a ( args )'.
+*/
+EXP
+make_func_exp(EXP a, LIST(EXP)args, int rescan)
+{
+	EXP e;
+	TYPE fn;
+	unsigned tag;
+	unsigned ftag;
+	int is_ptr = 0;
+	int is_ptr_mem = 0;
+	int is_paren = IS_exp_paren(a);
+	/* Do reference conversions */
+	a = convert_reference(a, REF_FUNCTION);
+	args = convert_args(args);
-    /* Map '&f' to 'f' */
+	/* Map '&f' to 'f' */
-    tag = TAG_exp ( a ) ;
+	tag = TAG_exp(a);
-    if ( tag == exp_address_tag ) {
+	if (tag == exp_address_tag) {
-	/* Non-member function */
+		/* Non-member function */
-	EXP b = DEREF_exp ( exp_address_arg ( a ) ) ;
+		EXP b = DEREF_exp(exp_address_arg(a));
-	if ( IS_exp_identifier_etc ( b ) ) {
+		if (IS_exp_identifier_etc(b)) {
-	    a = b ;
+			a = b;
-	    tag = TAG_exp ( a ) ;
+			tag = TAG_exp(a);
-	    is_paren = 1 ;
+			is_paren = 1;
-	}
+		}
-    } else if ( tag == exp_address_mem_tag ) {
+	} else if (tag == exp_address_mem_tag) {
-	/* Member function (which better eventually be static) */
+		/* Member function (which better eventually be static) */
-	EXP b = DEREF_exp ( exp_address_mem_arg ( a ) ) ;
+		EXP b = DEREF_exp(exp_address_mem_arg(a));
-	IDENTIFIER id = DEREF_id ( exp_member_id ( b ) ) ;
+		IDENTIFIER id = DEREF_id(exp_member_id(b));
-	if ( IS_id_function_etc ( id ) ) {
+		if (IS_id_function_etc(id)) {
-	    while ( !IS_NULL_id ( id ) ) {
+			while (!IS_NULL_id(id)) {
-		if ( IS_id_mem_func ( id ) ) {
+				if (IS_id_mem_func(id)) {
+					report(crt_loc,
-		    report ( crt_loc, ERR_over_match_call_mem ( id ) ) ;
+					       ERR_over_match_call_mem(id));
-		    break ;
+					break;
-		}
+				}
-		id = DEREF_id ( id_function_etc_over ( id ) ) ;
+				id = DEREF_id(id_function_etc_over(id));
-	    }
+			}
-	    a = b ;
+			a = b;
-	    tag = TAG_exp ( a ) ;
+			tag = TAG_exp(a);
-	    is_paren = 1 ;
+			is_paren = 1;
-	    is_ptr_mem = 1 ;
+			is_ptr_mem = 1;
-	}
+		}
-    }
+	}
-    /* Check function type */
+	/* Check function type */
-    fn = DEREF_type ( exp_type ( a ) ) ;
+	fn = DEREF_type(exp_type(a));
-    ftag = TAG_type ( fn ) ;
+	ftag = TAG_type(fn);
 #if LANGUAGE_CPP
-    if ( ftag == type_compound_tag ) {
+	if (ftag == type_compound_tag) {
-	/* Allow for overloading using 'operator ()' */
+		/* Allow for overloading using 'operator ()' */
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = function_overload ( a, args ) ;
+			e = function_overload(a, args);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
 #endif
-    if ( ftag == type_ptr_tag ) {
+	if (ftag == type_ptr_tag) {
-	/* Allow for pointers to functions */
+		/* Allow for pointers to functions */
-	fn = DEREF_type ( type_ptr_sub ( fn ) ) ;
+		fn = DEREF_type(type_ptr_sub(fn));
-	ftag = TAG_type ( fn ) ;
+		ftag = TAG_type(fn);
-	is_ptr = 1 ;
+		is_ptr = 1;
-    }
+	}
-    while ( ftag == type_templ_tag ) {
+	while (ftag == type_templ_tag) {
-	fn = DEREF_type ( type_templ_defn ( fn ) ) ;
+		fn = DEREF_type(type_templ_defn(fn));
-	ftag = TAG_type ( fn ) ;
+		ftag = TAG_type(fn);
-    }
+	}
-    if ( ftag != type_func_tag ) {
+	if (ftag != type_func_tag) {
-	if ( ftag == type_token_tag && is_templ_type ( fn ) ) {
+		if (ftag == type_token_tag && is_templ_type(fn)) {
-	    /* Allow for template types */
+			/* Allow for template types */
-	    e = call_func_templ ( a, args, is_paren ) ;
+			e = call_func_templ(a, args, is_paren);
-	    return ( e ) ;
-	}
-	if ( ftag != type_error_tag ) {
-	    /* Type should now be a function type */
-	    ERROR err ;
-	    if ( IS_exp_member ( a ) ) {
-		IDENTIFIER id = DEREF_id ( exp_member_id ( a ) ) ;
-		err = ERR_expr_prim_mem ( id ) ;
-	    } else {
-		err = ERR_expr_call_op ( fn ) ;
-	    }
-	    if ( ftag == type_ptr_mem_tag && in_ptr_mem_selector ) {
-		err = concat_error ( err, ERR_expr_mptr_oper_paren () ) ;
-	    }
-	    report ( crt_loc, err ) ;
-	}
-	e = make_error_exp ( 0 ) ;
-	return ( e ) ;
+			return (e);
-    }
-    /* Deal with named functions */
-    if ( !is_ptr ) {
-	switch ( tag ) {
-	    case exp_identifier_tag :
-	    case exp_member_tag :
-	    case exp_ambiguous_tag :
-	    case exp_undeclared_tag : {
-		/* Normal functions, 'f' */
-		int dep = 1 ;
-		DECL_SPEC ds ;
-		IDENTIFIER id ;
-		QUALIFIER qual ;
-		EXP extra = NULL_exp ;
-		NAMESPACE ns = NULL_nspace ;
-		int acc = crt_access_list.inherit ;
-		id = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
-		qual = DEREF_qual ( exp_identifier_etc_qual ( a ) ) ;
-		if ( rescan ) id = rescan_func_id ( id, qual ) ;
-		if ( dependent_call ( id, args ) ) {
-		    /* Call depends on template argument */
-		    e = call_func_templ ( a, args, is_paren ) ;
-		    return ( e ) ;
-		}
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
-		if ( ds & dspec_instance ) dep = 0 ;
-		if ( qual & qual_explicit ) dep = 0 ;
-		if ( is_paren ) qual |= qual_mark ;
-		switch ( TAG_id ( id ) ) {
-		    case id_mem_func_tag :
-		    case id_stat_mem_func_tag :
-		    mem_func_label : {
-			/* Add argument for member functions */
-			extra = make_this_ref ( &ns ) ;
-			CONS_exp ( extra, args, args ) ;
-			dep = 0 ;
-			break ;
-		    }
-		    case id_ambig_tag : {
-			/* Check for ambiguous member functions */
-			CLASS_TYPE ct = parent_class ( id ) ;
-			if ( !IS_NULL_ctype ( ct ) ) goto mem_func_label ;
-			break ;
-		    }
+		}
-		id = resolve_call ( id, args, qual, dep ) ;
-		switch ( TAG_id ( id ) ) {
-		    case id_function_tag : {
+		if (ftag != type_error_tag) {
-			/* Normal function call */
+			/* Type should now be a function type */
-			break ;
+			ERROR err;
-		    }
-		    case id_mem_func_tag : {
-			/* Member function call */
-			if ( is_ptr_mem ) {
+			if (IS_exp_member(a)) {
-			    fn = DEREF_type ( id_mem_func_type ( id ) ) ;
-			    COPY_type ( exp_type ( a ), fn ) ;
-			    a = make_ref_exp ( a, 1 ) ;
-			    fn = DEREF_type ( exp_type ( a ) ) ;
+				IDENTIFIER id = DEREF_id(exp_member_id(a));
-			    report ( crt_loc, ERR_expr_call_op ( fn ) ) ;
-			}
-			if ( IS_NULL_exp ( extra ) ) {
-			    /* No associated object */
-			    report ( crt_loc, ERR_expr_call_mem ( id ) ) ;
+				err = ERR_expr_prim_mem(id);
 			} else {
+				err = ERR_expr_call_op(fn);
+			}
+			if (ftag == type_ptr_mem_tag && in_ptr_mem_selector) {
+				err = concat_error(err,
+						   ERR_expr_mptr_oper_paren());
+			}
+			report(crt_loc, err);
+		}
+		e = make_error_exp(0);
+		return (e);
+	}
-			    /* Indicate inherited member function */
+	/* Deal with named functions */
+	if (!is_ptr) {
+		switch (tag) {
+		case exp_identifier_tag:
+		case exp_member_tag:
+		case exp_ambiguous_tag:
+		case exp_undeclared_tag: {
+			/* Normal functions, 'f' */
+			int dep = 1;
+			DECL_SPEC ds;
+			IDENTIFIER id;
+			QUALIFIER qual;
+			EXP extra = NULL_exp;
+			NAMESPACE ns = NULL_nspace;
-			    crt_access_list.inherit++ ;
+			int acc = crt_access_list.inherit;
+			id = DEREF_id(exp_identifier_etc_id(a));
+			qual = DEREF_qual(exp_identifier_etc_qual(a));
+			if (rescan) {
+				id = rescan_func_id(id, qual);
+			}
+			if (dependent_call(id, args)) {
+				/* Call depends on template argument */
+				e = call_func_templ(a, args, is_paren);
+				return (e);
+			}
+			ds = DEREF_dspec(id_storage(id));
+			if (ds & dspec_instance) {
+				dep = 0;
 			}
+			if (qual & qual_explicit) {
-			break ;
+				dep = 0;
+			}
+			if (is_paren) {
+				qual |= qual_mark;
-		    }
+			}
+			switch (TAG_id(id)) {
+			case id_mem_func_tag:
-		    case id_stat_mem_func_tag : {
+			case id_stat_mem_func_tag:
+mem_func_label:
-			/* Static member function call */
+				/* Add argument for member functions */
+				extra = make_this_ref(&ns);
+				CONS_exp(extra, args, args);
+				dep = 0;
+				break;
+			case id_ambig_tag: {
+				/* Check for ambiguous member functions */
+				CLASS_TYPE ct = parent_class(id);
-			if ( !IS_NULL_exp ( extra ) ) {
+				if (!IS_NULL_ctype(ct)) {
-			    COPY_exp ( HEAD_list ( args ), NULL_exp ) ;
+					goto mem_func_label;
+				}
+				break;
+			}
+			}
+			id = resolve_call(id, args, qual, dep);
+			switch (TAG_id(id)) {
+			case id_function_tag:
+				/* Normal function call */
-			break ;
+				break;
+			case id_mem_func_tag:
+				/* Member function call */
+				if (is_ptr_mem) {
+					fn = DEREF_type(id_mem_func_type(id));
+					COPY_type(exp_type(a), fn);
+					a = make_ref_exp(a, 1);
+					fn = DEREF_type(exp_type(a));
+					report(crt_loc, ERR_expr_call_op(fn));
+				}
+				if (IS_NULL_exp(extra)) {
+					/* No associated object */
+					report(crt_loc, ERR_expr_call_mem(id));
+				} else {
+					/* Indicate inherited member function */
+					crt_access_list.inherit++;
+				}
+				break;
+			case id_stat_mem_func_tag:
+				/* Static member function call */
+				if (!IS_NULL_exp(extra)) {
+					COPY_exp(HEAD_list(args), NULL_exp);
-		    }
+				}
+				break;
-		    default : {
+			default:
-			/* Non-function called */
+				/* Non-function called */
-			if ( in_template_decl ) {
+				if (in_template_decl) {
-			    e = call_func_templ ( a, args, is_paren ) ;
+					e = call_func_templ(a, args, is_paren);
+				} else {
+					e = make_id_exp(id);
+					if (eq_exp(e, a, 0)) {
+						e = make_error_exp(0);
+					} else {
+						e = make_func_exp(e, args, 0);
+					}
+				}
+				return (e);
+			}
+			use_func_id(id, 1, suppress_usage);
+			crt_access_list.inherit = acc;
+			if (resolved_kind == KIND_CONSTR) {
+				e = apply_constr(id, args);
 			} else {
-			    e = make_id_exp ( id ) ;
-			    if ( eq_exp ( e, a, 0 ) ) {
-				e = make_error_exp ( 0 ) ;
-			    } else {
-				e = make_func_exp ( e, args, 0 ) ;
+				e = apply_func_id(id, qual, NULL_graph, args);
-			    }
+			}
-			return ( e ) ;
+			return (e);
-		    }
-		}
-		use_func_id ( id, 1, suppress_usage ) ;
-		crt_access_list.inherit = acc ;
-		if ( resolved_kind == KIND_CONSTR ) {
-		    e = apply_constr ( id, args ) ;
-		} else {
-		    e = apply_func_id ( id, qual, NULL_graph, args ) ;
+		}
-		return ( e ) ;
-	    }
-	    case exp_call_tag : {
+		case exp_call_tag: {
-		/* Member function selectors */
+			/* Member function selectors */
-		EXP b = DEREF_exp ( exp_call_ptr ( a ) ) ;
+			EXP b = DEREF_exp(exp_call_ptr(a));
-		EXP c = DEREF_exp ( exp_call_arg ( a ) ) ;
+			EXP c = DEREF_exp(exp_call_arg(a));
-		tag = TAG_exp ( b ) ;
+			tag = TAG_exp(b);
-		if ( tag == exp_identifier_tag || tag == exp_member_tag ) {
+			if (tag == exp_identifier_tag ||
+			    tag == exp_member_tag) {
-		    /* Named function selector, 'c->f' */
+				/* Named function selector, 'c->f' */
-		    IDENTIFIER id ;
+				IDENTIFIER id;
-		    QUALIFIER qual ;
+				QUALIFIER qual;
-		    id = DEREF_id ( exp_identifier_etc_id ( b ) ) ;
+				id = DEREF_id(exp_identifier_etc_id(b));
-		    qual = DEREF_qual ( exp_identifier_etc_qual ( b ) ) ;
+				qual = DEREF_qual(exp_identifier_etc_qual(b));
-		    if ( rescan ) id = rescan_func_id ( id, qual_nested ) ;
+				if (rescan)id = rescan_func_id(id, qual_nested);
-		    if ( dependent_call ( id, args ) ) {
+				if (dependent_call(id, args)) {
-			e = call_func_templ ( a, args, is_paren ) ;
+					e = call_func_templ(a, args, is_paren);
-		    } else {
+				} else {
-			GRAPH gr = DEREF_graph ( exp_call_base ( a ) ) ;
+					GRAPH gr = DEREF_graph(exp_call_base(a));
+					if (is_paren) {
-			if ( is_paren ) qual |= qual_mark ;
+						qual |= qual_mark;
+					}
-			CONS_exp ( c, args, args ) ;
+					CONS_exp(c, args, args);
-			id = resolve_call ( id, args, qual, 0 ) ;
+					id = resolve_call(id, args, qual, 0);
-			use_func_id ( id, 1, suppress_usage ) ;
+					use_func_id(id, 1, suppress_usage);
-			if ( resolved_kind == KIND_CONSTR ) {
+					if (resolved_kind == KIND_CONSTR) {
-			    e = apply_constr ( id, args ) ;
+						e = apply_constr(id, args);
-			} else {
+					} else {
+						HASHID nm =
-			    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+						    DEREF_hashid(id_name(id));
-			    e = apply_func_id ( id, qual, gr, args ) ;
+						e = apply_func_id(id, qual, gr,
+								  args);
-			    if ( !IS_hashid_name_etc ( nm ) ) {
+						if (!IS_hashid_name_etc(nm)) {
-				/* Check for extra arguments */
+							/* Check for extra
+							 * arguments */
-				int v = EXTRA_CONSTR ;
+							int v = EXTRA_CONSTR;
+							CLASS_TYPE ct =
-				CLASS_TYPE ct = parent_class ( id ) ;
+							    parent_class(id);
-				if ( IS_hashid_destr ( nm ) ) {
+							if (IS_hashid_destr(nm)) {
-				    v = EXTRA_DESTR ;
+								v = EXTRA_DESTR;
+							}
+							e = add_constr_args(e, ct, v);
+						}
+					}
+				}
-				e = add_constr_args ( e, ct, v ) ;
-			    }
+				return (e);
+			}
-		    }
-		    return ( e ) ;
-		}
-		if ( tag == exp_undeclared_tag ) {
+			if (tag == exp_undeclared_tag) {
-		    /* Pseudo-destructor call, 'c->C::~C' */
+				/* Pseudo-destructor call, 'c->C::~C' */
-		    IDENTIFIER id = DEREF_id ( exp_undeclared_id ( b ) ) ;
+				IDENTIFIER id = DEREF_id(exp_undeclared_id(b));
-		    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				HASHID nm = DEREF_hashid(id_name(id));
-		    if ( !IS_NULL_list ( args ) ) {
+				if (!IS_NULL_list(args)) {
-			report ( crt_loc, ERR_expr_pseudo_args ( nm ) ) ;
+					report(crt_loc, ERR_expr_pseudo_args(nm));
-		    }
+				}
-		    e = trivial_destr ( c ) ;
+				e = trivial_destr(c);
-		    return ( e ) ;
+				return (e);
-		}
+			}
-		/* Pointer to member function selector, 'a.*f' */
+			/* Pointer to member function selector, 'a.*f' */
-		CONS_exp ( c, args, args ) ;
+			CONS_exp(c, args, args);
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    /* Form the result for function expressions */
+	/* Form the result for function expressions */
-    e = apply_func_exp ( a, args ) ;
+	e = apply_func_exp(a, args);
-    return ( e ) ;
+	return (e);
+}
 /*
     SHOULD A FUNCTION RETURN VALUE BE IGNORED?
     This routine checks whether a function consisting of 'return e ;'
     should be inlined.
 */
-static EXP check_inline_return
+static EXP
-    PROTO_N ( ( e, ret ) )
-    PROTO_T ( EXP e X TYPE ret )
+check_inline_return(EXP e, TYPE ret)
+{
-    if ( IS_NULL_exp ( e ) ) {
+	if (IS_NULL_exp(e)) {
-	/* No value returned */
+		/* No value returned */
-	MAKE_exp_value ( ret, e ) ;
+		MAKE_exp_value(ret, e);
-	return ( e ) ;
+		return (e);
-    }
+	}
-    if ( is_const_exp ( e, -1 ) ) {
+	if (is_const_exp(e, -1)) {
-	/* Constant expression returned */
+		/* Constant expression returned */
-	MAKE_exp_copy ( ret, e, e ) ;
+		MAKE_exp_copy(ret, e, e);
-	return ( e ) ;
+		return (e);
-    }
+	}
-    return ( NULL_exp ) ;
+	return (NULL_exp);
+}
 /*
     SHOULD A FUNCTION CALL BE INLINED?
     should be inlined by the producer.  This is generally done on the
     basis of code size rather than efficiency.  If so it returns the result
     expression.  Otherwise the null expression is returned.
 */
-EXP check_inline
+EXP
-    PROTO_N ( ( id, args, ret ) )
-    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args X TYPE ret )
+check_inline(IDENTIFIER id, LIST(EXP)args, TYPE ret)
+{
-    while ( !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(args)) {
-	/* Check argument list */
+		/* Check argument list */
-	EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+		EXP a = DEREF_exp(HEAD_list(args));
-	if ( !IS_NULL_exp ( a ) ) return ( NULL_exp ) ;
-	args = TAIL_list ( args ) ;
-    }
-    if ( IS_id_function_etc ( id ) ) {
-	/* Check function definition */
-	EXP e = DEREF_exp ( id_function_etc_defn ( id ) ) ;
-	if ( !IS_NULL_exp ( e ) && IS_exp_sequence ( e ) ) {
-	    LIST ( EXP ) p = DEREF_list ( exp_sequence_first ( e ) ) ;
-	    p = TAIL_list ( p ) ;
-	    if ( IS_NULL_list ( p ) ) {
+		if (!IS_NULL_exp(a)) {
-		/* Empty function definition */
-		e = check_inline_return ( NULL_exp, ret ) ;
-		return ( e ) ;
+			return (NULL_exp);
-	    }
-	    e = DEREF_exp ( HEAD_list ( p ) ) ;
-	    p = TAIL_list ( p ) ;
-	    if ( IS_NULL_list ( p ) ) {
-		if ( !IS_NULL_exp ( e ) && IS_exp_location ( e ) ) {
-		    /* Step over location marker */
-		    e = DEREF_exp ( exp_location_arg ( e ) ) ;
-		}
-		if ( !IS_NULL_exp ( e ) && IS_exp_return_stmt ( e ) ) {
-		    /* Single return statement */
-		    e = DEREF_exp ( exp_return_stmt_value ( e ) ) ;
-		    e = check_inline_return ( e, ret ) ;
-		    return ( e ) ;
+		}
-	    }
+		args = TAIL_list(args);
+	}
+	if (IS_id_function_etc(id)) {
+		/* Check function definition */
+		EXP e = DEREF_exp(id_function_etc_defn(id));
+		if (!IS_NULL_exp(e) && IS_exp_sequence(e)) {
+			LIST(EXP)p = DEREF_list(exp_sequence_first(e));
+			p = TAIL_list(p);
+			if (IS_NULL_list(p)) {
+				/* Empty function definition */
+				e = check_inline_return(NULL_exp, ret);
+				return (e);
+			}
+			e = DEREF_exp(HEAD_list(p));
+			p = TAIL_list(p);
+			if (IS_NULL_list(p)) {
+				if (!IS_NULL_exp(e) && IS_exp_location(e)) {
+					/* Step over location marker */
+					e = DEREF_exp(exp_location_arg(e));
-    }
+				}
+				if (!IS_NULL_exp(e) && IS_exp_return_stmt(e)) {
+					/* Single return statement */
+					e = DEREF_exp(exp_return_stmt_value(e));
+					e = check_inline_return(e, ret);
+					return (e);
+				}
+			}
+		}
+	}
-    return ( NULL_exp ) ;
+	return (NULL_exp);
+}
 /*
     CHECK FOR COMPLEX FUNCTION RETURN OR ARGUMENT TYPE
     is that such values are returned by means of a reference which is
     passed to the function as the first argument, and that such values
     are passed as arguments as a reference to a copy.
 */
-int pass_complex_type
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+pass_complex_type(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) && IS_type_compound ( t ) ) {
+	if (!IS_NULL_type(t) && IS_type_compound(t)) {
-	CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+		CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-	CLASS_INFO cj = ( ci & cinfo_trivial ) ;
+		CLASS_INFO cj = (ci & cinfo_trivial);
-	if ( cj != cinfo_trivial ) return ( 1 ) ;
+		if (cj != cinfo_trivial) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CHECK A FUNCTION RETURN OR PARAMETER TYPE
     This routine checks whether the type just constructed by the parser
     contains type definitions and so is not suitable for use as a function
     return or parameter type (as indicated by par).  The necessary
     information is stored in the global variable have_type_declaration.
 */
-void func_type_defn
+void
-    PROTO_N ( ( par ) )
-    PROTO_T ( int par )
+func_type_defn(int par)
 {
-    int td = have_type_declaration ;
+	int td = have_type_declaration;
-    if ( td == TYPE_DECL_NORMAL || td == TYPE_DECL_ANON ) {
+	if (td == TYPE_DECL_NORMAL || td == TYPE_DECL_ANON) {
-	if ( par ) {
+		if (par) {
-	    report ( crt_loc, ERR_dcl_fct_typedef_par () ) ;
+			report(crt_loc, ERR_dcl_fct_typedef_par());
-	} else {
+		} else {
-	    report ( crt_loc, ERR_dcl_fct_typedef_ret () ) ;
+			report(crt_loc, ERR_dcl_fct_typedef_ret());
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     CREATE A PARAMETER TYPE
     This routine creates the parameter type for a function or template
     parameter (as indicated by loc) declared with type t.  Thus functions
     and, for function parameters, arrays are converted to pointers.
 */
-TYPE make_param_type
+TYPE
-    PROTO_N ( ( t, loc ) )
-    PROTO_T ( TYPE t X int loc )
+make_param_type(TYPE t, int loc)
 {
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_func_tag : {
+	case type_func_tag: {
-	    /* Function parameters are adjusted to pointers */
+		/* Function parameters are adjusted to pointers */
-	    member_func_type ( NULL_ctype, id_parameter_tag, t ) ;
+		member_func_type(NULL_ctype, id_parameter_tag, t);
-	    check_weak_func ( t, 0 ) ;
+		check_weak_func(t, 0);
-	    MAKE_type_ptr ( cv_none, t, t ) ;
+		MAKE_type_ptr(cv_none, t, t);
-	    break ;
+		break;
 	}
-	case type_array_tag : {
+	case type_array_tag: {
-	    /* Array parameters are adjusted to pointers */
+		/* Array parameters are adjusted to pointers */
-	    if ( loc == CONTEXT_PARAMETER || loc == CONTEXT_WEAK_PARAM ) {
+		if (loc == CONTEXT_PARAMETER || loc == CONTEXT_WEAK_PARAM) {
-		t = DEREF_type ( type_array_sub ( t ) ) ;
+			t = DEREF_type(type_array_sub(t));
-		MAKE_type_ptr ( cv_none, t, t ) ;
+			MAKE_type_ptr(cv_none, t, t);
-	    }
+		}
-	    break ;
+		break;
+	}
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     CHECK A PARAMETER TYPE
     A parameter cannot include a type of the form pointer to unbound array
     or reference to unbound array.  This routine returns an error if the type
     t includes a type of this form.  Strictly the parameters of any function
     components should also be checked, but these will have already been
     handled by a previous check.
 */
-ERROR check_param_type
+ERROR
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
+check_param_type(IDENTIFIER id, TYPE t)
+{
-    TYPE s = t ;
+	TYPE s = t;
-    int state = 0 ;
+	int state = 0;
-    while ( !IS_NULL_type ( s ) ) {
+	while (!IS_NULL_type(s)) {
-	switch ( TAG_type ( s ) ) {
+		switch (TAG_type(s)) {
-	    case type_top_tag :
+		case type_top_tag:
-	    case type_bottom_tag : {
+		case type_bottom_tag: {
-		/* Void types */
+			/* Void types */
+			if (state) {
-		if ( state ) return ( NULL_err ) ;
+				return (NULL_err);
+			}
-		return ( ERR_dcl_fct_par_void ( id, t ) ) ;
+			return (ERR_dcl_fct_par_void(id, t));
-	    }
+		}
-	    case type_ptr_tag :
+		case type_ptr_tag:
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		/* Pointer and reference types */
+			/* Pointer and reference types */
-		s = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
+			s = DEREF_type(type_ptr_etc_sub(s));
-		state = 1 ;
+			state = 1;
-		break ;
+			break;
-	    }
+		}
-	    case type_array_tag : {
+		case type_array_tag: {
-		/* Array types */
+			/* Array types */
-		if ( state ) {
+			if (state) {
-		    NAT n = DEREF_nat ( type_array_size ( s ) ) ;
+				NAT n = DEREF_nat(type_array_size(s));
-		    if ( IS_NULL_nat ( n ) ) {
+				if (IS_NULL_nat(n)) {
-			return ( ERR_dcl_fct_par_array ( id, t ) ) ;
+					return (ERR_dcl_fct_par_array(id, t));
-		    }
+				}
+			}
+			s = DEREF_type(type_array_sub(s));
+			state = 0;
+			break;
+		}
+		default:
+			/* Other types */
+			return (NULL_err);
+		}
-		s = DEREF_type ( type_array_sub ( s ) ) ;
-		state = 0 ;
-		break ;
-	    }
-	    default : {
-		/* Other types */
-		return ( NULL_err ) ;
-	    }
+	}
-    }
-    return ( NULL_err ) ;
+	return (NULL_err);
+}
 /*
     ADJUST A FUNCTION LINKAGE
     This routine adjusts the function linkage specifier cv to include
     the current linkage specifier.
 */
-CV_SPEC func_linkage
+CV_SPEC
-    PROTO_N ( ( cv ) )
-    PROTO_T ( CV_SPEC cv )
+func_linkage(CV_SPEC cv)
+{
-    DECL_SPEC ln = crt_linkage ;
+	DECL_SPEC ln = crt_linkage;
-    if ( ln ) {
+	if (ln) {
-	if ( ln & dspec_c ) cv |= cv_c ;
+		if (ln & dspec_c) {
+			cv |= cv_c;
+		}
-	if ( ln & dspec_cpp ) cv |= cv_cpp ;
+		if (ln & dspec_cpp) {
+			cv |= cv_cpp;
-    }
+		}
+	}
-    return ( cv ) ;
+	return (cv);
+}
 /*
     CREATE A LIST OF FUNCTION PARAMETER TYPES
     This routine constructs the function type with parameter declarations
     given by the current namespace and const-volatile qualifiers cv.  The
     kind of function is given by ell, which is a combination of the
     FUNC_* values defined in function.h.  The function return type is
     usually filled in later (by inject_pre_type) but may be specified
     by r.  Note that function and array parameters have already been
     adjusted to pointers by make_param_decl.
 */
-TYPE make_func_type
+TYPE
-    PROTO_N ( ( r, ell, cv, ex ) )
-    PROTO_T ( TYPE r X int ell X CV_SPEC cv X LIST ( TYPE ) ex )
+make_func_type(TYPE r, int ell, CV_SPEC cv, LIST(TYPE) ex)
 {
-    int no_param = 0 ;
+	int no_param = 0;
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    LIST ( IDENTIFIER ) p1 ;
+	LIST(IDENTIFIER) p1;
-    IDENTIFIER id = NULL_id ;
+	IDENTIFIER id = NULL_id;
-    LIST ( TYPE ) q = NULL_list ( TYPE ) ;
+	LIST(TYPE) q = NULL_list(TYPE);
-    LIST ( IDENTIFIER ) p = NULL_list ( IDENTIFIER ) ;
+	LIST(IDENTIFIER) p = NULL_list(IDENTIFIER);
+	/* Get parameter declarations */
+	NAMESPACE ns = crt_namespace;
+	MEMBER mem = DEREF_member(nspace_last(ns));
+	/* Build up parameter type list (deleting cv-qualifiers) */
+	while (!IS_NULL_member(mem)) {
+		id = DEREF_id(member_id(mem));
+		if (!IS_NULL_id(id) && IS_id_parameter(id)) {
+			t = DEREF_type(id_parameter_type(id));
+			if ((ell & FUNC_WEAK) && !is_arg_promote(t)) {
+				DECL_SPEC ds;
+				t = arg_promote_type(t, KILL_err);
+				ds = DEREF_dspec(id_storage(id));
+				ds |= dspec_virtual;
+				COPY_dspec(id_storage(id), ds);
+			}
+			t = qualify_type(t, cv_none, 0);
+			CONS_type(t, q, q);
+			CONS_id(id, p, p);
+			no_param++;
+		}
+		mem = DEREF_member(member_next(mem));
+	}
-    /* Get parameter declarations */
+	/* Check for non-prototype functions */
+	if (IS_NULL_type(r)) {
+		if (ell & FUNC_NON_PROTO) {
+			report(crt_loc, ERR_dcl_fct_nonproto());
+			if (ell == FUNC_WEAK && no_param == 0) {
-    NAMESPACE ns = crt_namespace ;
+				/* Can't have 't weak ()' */
+				report(crt_loc, ERR_dcl_fct_par_weak());
+			}
+#if LANGUAGE_CPP
+			ell &= FUNC_ELLIPSIS;
+#endif
+		} else {
+			report(crt_loc, ERR_dcl_fct_proto());
+		}
+	}
+	/* Check for '( ... )' */
-    MEMBER mem = DEREF_member ( nspace_last ( ns ) ) ;
+	if (no_param == 0 && (ell & FUNC_ELLIPSIS)) {
+		report(crt_loc, ERR_dcl_fct_par_ellipsis());
+	}
-    /* Build up parameter type list (deleting cv-qualifiers) */
-    while ( !IS_NULL_member ( mem ) ) {
-	id = DEREF_id ( member_id ( mem ) ) ;
+	/* Check for '( void )' */
-	if ( !IS_NULL_id ( id ) && IS_id_parameter ( id ) ) {
+	if (no_param == 1 && !(ell & FUNC_ELLIPSIS)) {
-	    t = DEREF_type ( id_parameter_type ( id ) ) ;
+		/* Precisely one parameter (in t and id) */
-	    if ( ( ell & FUNC_WEAK ) && !is_arg_promote ( t ) ) {
-		DECL_SPEC ds ;
-		t = arg_promote_type ( t, KILL_err ) ;
+		if (IS_type_top(t)) {
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-		ds |= dspec_virtual ;
+			if (!IS_hashid_anon(nm)) {
-		COPY_dspec ( id_storage ( id ), ds ) ;
+				report(crt_loc, ERR_dcl_fct_par_empty());
-	    }
+			}
-	    t = qualify_type ( t, cv_none, 0 ) ;
+			DESTROY_list(q, SIZE_type);
-	    CONS_type ( t, q, q ) ;
+			DESTROY_list(p, SIZE_id);
-	    CONS_id ( id, p, p ) ;
+			q = NULL_list(TYPE);
-	    no_param++ ;
+			p = NULL_list(IDENTIFIER);
+		}
+	}
-	mem = DEREF_member ( member_next ( mem ) ) ;
-    }
-    /* Check for non-prototype functions */
+	/* Check for other void parameters */
-    if ( IS_NULL_type ( r ) ) {
-	if ( ell & FUNC_NON_PROTO ) {
-	    report ( crt_loc, ERR_dcl_fct_nonproto () ) ;
-	    if ( ell == FUNC_WEAK && no_param == 0 ) {
-		/* Can't have 't weak ()' */
-		report ( crt_loc, ERR_dcl_fct_par_weak () ) ;
-	    }
+	p1 = p;
-#if LANGUAGE_CPP
-	    ell &= FUNC_ELLIPSIS ;
+	while (!IS_NULL_list(p1)) {
-#endif
-	} else {
+		ERROR err;
-	    report ( crt_loc, ERR_dcl_fct_proto () ) ;
+		id = DEREF_id(HEAD_list(p1));
-	}
-    }
-    /* Check for '( ... )' */
-    if ( no_param == 0 && ( ell & FUNC_ELLIPSIS ) ) {
-	report ( crt_loc, ERR_dcl_fct_par_ellipsis () ) ;
+		t = DEREF_type(id_parameter_type(id));
-    }
-    /* Check for '( void )' */
+		err = check_param_type(id, t);
-    if ( no_param == 1 && !( ell & FUNC_ELLIPSIS ) ) {
-	/* Precisely one parameter (in t and id) */
-	if ( IS_type_top ( t ) ) {
+		if (!IS_NULL_err(err)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-	    if ( !IS_hashid_anon ( nm ) ) {
+			/* Void or other illegal parameter type */
-		report ( crt_loc, ERR_dcl_fct_par_empty () ) ;
+			report(crt_loc, err);
-	    }
+		}
-	    DESTROY_list ( q, SIZE_type ) ;
-	    DESTROY_list ( p, SIZE_id ) ;
-	    q = NULL_list ( TYPE ) ;
+		p1 = TAIL_list(p1);
-	    p = NULL_list ( IDENTIFIER ) ;
 	}
-    }
-    /* Check for other void parameters */
-    p1 = p ;
-    while ( !IS_NULL_list ( p1 ) ) {
-	ERROR err ;
-	id = DEREF_id ( HEAD_list ( p1 ) ) ;
-	t = DEREF_type ( id_parameter_type ( id ) ) ;
-	err = check_param_type ( id, t ) ;
-	if ( !IS_NULL_err ( err ) ) {
-	    /* Void or other illegal parameter type */
-	    report ( crt_loc, err ) ;
-	}
-	p1 = TAIL_list ( p1 ) ;
-    }
-    /* Construct the function type */
+	/* Construct the function type */
-    MAKE_type_func ( cv_none, r, q, ell, cv, q, ns, p, ex, t ) ;
+	MAKE_type_func(cv_none, r, q, ell, cv, q, ns, p, ex, t);
-    return ( t ) ;
+	return (t);
 }
 /*
     ADJUST MEMBER FUNCTION TYPES
     Each function type has two lists of parameter types, ptypes, which
     gives the actual declared parameters, and mtypes, which has an extra
     reference to class parameter for non-static member functions, or an
     extra null parameter for static member functions.  This routine sets
     the mtypes field of t from the ptypes field according to whether or not
     ct is the null class and the tag of an associated declaration, itag.
     Note that member function types always have C++ linkage.
 */
-void member_func_type
+void
-    PROTO_N ( ( ct, itag, t ) )
-    PROTO_T ( CLASS_TYPE ct X unsigned itag X TYPE t )
+member_func_type(CLASS_TYPE ct, unsigned itag, TYPE t)
 {
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    while ( tag == type_templ_tag ) {
+	while (tag == type_templ_tag) {
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-	tag = TAG_type ( t ) ;
+		tag = TAG_type(t);
-    }
+	}
-    if ( tag == type_func_tag ) {
+	if (tag == type_func_tag) {
-	CV_SPEC cv = DEREF_cv ( type_func_mqual ( t ) ) ;
+		CV_SPEC cv = DEREF_cv(type_func_mqual(t));
-	CV_SPEC qual = ( cv & cv_qual ) ;
+		CV_SPEC qual = (cv & cv_qual);
-	LIST ( TYPE ) ptypes = DEREF_list ( type_func_ptypes ( t ) ) ;
+		LIST(TYPE) ptypes = DEREF_list(type_func_ptypes(t));
-	LIST ( TYPE ) mtypes = DEREF_list ( type_func_mtypes ( t ) ) ;
+		LIST(TYPE) mtypes = DEREF_list(type_func_mtypes(t));
-	if ( IS_NULL_ctype ( ct ) ) {
+		if (IS_NULL_ctype(ct)) {
-	    /* Non-member functions */
+			/* Non-member functions */
-	    if ( qual && itag != id_type_alias_tag ) {
+			if (qual && itag != id_type_alias_tag) {
-		/* Can't have cv-qualifiers */
+				/* Can't have cv-qualifiers */
-		report ( crt_loc, ERR_dcl_fct_cv ( qual ) ) ;
+				report(crt_loc, ERR_dcl_fct_cv(qual));
-		cv &= ~cv_qual ;
+				cv &= ~cv_qual;
-		COPY_cv ( type_func_mqual ( t ), cv ) ;
+				COPY_cv(type_func_mqual(t), cv);
-	    }
+			}
-	    if ( !EQ_list ( ptypes, mtypes ) ) {
+			if (!EQ_list(ptypes, mtypes)) {
-		/* Set mtypes equal to ptypes */
+				/* Set mtypes equal to ptypes */
-		COPY_list ( type_func_mtypes ( t ), ptypes ) ;
+				COPY_list(type_func_mtypes(t), ptypes);
-	    }
+			}
-	} else {
+		} else {
-	    /* Member functions */
+			/* Member functions */
-	    if ( EQ_list ( ptypes, mtypes ) ) {
+			if (EQ_list(ptypes, mtypes)) {
-		/* Add extra argument to mtypes */
+				/* Add extra argument to mtypes */
-		TYPE r ;
+				TYPE r;
-		if ( itag == id_mem_func_tag ) {
+				if (itag == id_mem_func_tag) {
+					IDENTIFIER cid =
-		    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+					    DEREF_id(ctype_name(ct));
-		    cv = ( qual | cv_cpp ) ;
+					cv = (qual | cv_cpp);
-		    qual |= cv_lvalue ;
+					qual |= cv_lvalue;
-		    MAKE_type_compound ( qual, ct, r ) ;
+					MAKE_type_compound(qual, ct, r);
-		    COPY_id ( type_name ( r ), cid ) ;
+					COPY_id(type_name(r), cid);
-		    MAKE_type_ref ( cv_none, r, r ) ;
+					MAKE_type_ref(cv_none, r, r);
-		} else {
+				} else {
-		    if ( qual ) {
+					if (qual) {
-			/* Can't have cv-qualifiers */
+						/* Can't have cv-qualifiers */
+						report(crt_loc,
-			report ( crt_loc, ERR_dcl_fct_cv ( qual ) ) ;
+						       ERR_dcl_fct_cv(qual));
-		    }
+					}
-		    r = NULL_type ;
+					r = NULL_type;
-		    cv = cv_cpp ;
+					cv = cv_cpp;
-		}
+				}
-		CONS_type ( r, ptypes, mtypes ) ;
+				CONS_type(r, ptypes, mtypes);
-		COPY_list ( type_func_mtypes ( t ), mtypes ) ;
+				COPY_list(type_func_mtypes(t), mtypes);
-		COPY_cv ( type_func_mqual ( t ), cv ) ;
+				COPY_cv(type_func_mqual(t), cv);
-	    } else {
+			} else {
-		/* Don't check existing extra argument */
+				/* Don't check existing extra argument */
-		/* EMPTY */
+				/* EMPTY */
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     CHECK A NON-PROTOTYPE FUNCTION TYPE
     A parameter list can only be used in a function definition.  This
     routine checks the function type t with def being true for a function
     definition.
 */
-void check_weak_func
+void
-    PROTO_N ( ( t, def ) )
-    PROTO_T ( TYPE t X int def )
+check_weak_func(TYPE t, int def)
 {
-    int ell = DEREF_int ( type_func_ellipsis ( t ) ) ;
+	int ell = DEREF_int(type_func_ellipsis(t));
-    if ( ell == FUNC_PARAMS ) {
+	if (ell == FUNC_PARAMS) {
-	/* Have parameter list '( a1, a2, ..., an )' */
+		/* Have parameter list '( a1, a2, ..., an )' */
-	if ( def ) {
+		if (def) {
-	    LOCATION loc ;
+			LOCATION loc;
-	    LIST ( TYPE ) q = NULL_list ( TYPE ) ;
+			LIST(TYPE) q = NULL_list(TYPE);
-	    LIST ( IDENTIFIER ) p = DEREF_list ( type_func_pids ( t ) ) ;
+			LIST(IDENTIFIER) p = DEREF_list(type_func_pids(t));
-	    NAMESPACE ns = DEREF_nspace ( type_func_pars ( t ) ) ;
+			NAMESPACE ns = DEREF_nspace(type_func_pars(t));
-	    MEMBER mem = DEREF_member ( nspace_last ( ns ) ) ;
+			MEMBER mem = DEREF_member(nspace_last(ns));
-	    loc = decl_loc ;
+			loc = decl_loc;
-	    bad_crt_loc++ ;
+			bad_crt_loc++;
-	    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)) {
-		    if ( IS_id_weak_param ( id ) ) {
+					if (IS_id_weak_param(id)) {
-			/* Implicitly declare parameter */
+						/* Implicitly declare
+						 * parameter */
-			ERROR err ;
+						ERROR err;
-			TYPE s = type_sint ;
+						TYPE s = type_sint;
-			int par = CONTEXT_WEAK_PARAM ;
+						int par = CONTEXT_WEAK_PARAM;
-			DEREF_loc ( id_loc ( id ), decl_loc ) ;
+						DEREF_loc(id_loc(id), decl_loc);
-			id = make_param_decl ( dspec_none, s, id, par ) ;
+						id = make_param_decl(dspec_none, s, id, par);
-			init_param ( id, NULL_exp ) ;
+						init_param(id, NULL_exp);
-			err = ERR_dcl_fct_par_impl ( id ) ;
+						err = ERR_dcl_fct_par_impl(id);
-			if ( !IS_NULL_err ( err ) ) {
+						if (!IS_NULL_err(err)) {
-			    ERROR err2 = ERR_dcl_type_infer ( s ) ;
+							ERROR err2 = ERR_dcl_type_infer(s);
-			    err = concat_error ( err, err2 ) ;
+							err = concat_error(err, err2);
-			    report ( decl_loc, err ) ;
+							report(decl_loc, err);
-			}
+						}
-			CONS_id ( id, p, p ) ;
+						CONS_id(id, p, p);
-			CONS_type ( s, q, q ) ;
+						CONS_type(s, q, q);
-		    } else if ( IS_id_parameter ( id ) ) {
+					} else if (IS_id_parameter(id)) {
-			/* Add parameter to list */
+						/* Add parameter to list */
-			TYPE s = DEREF_type ( id_parameter_type ( id ) ) ;
+						TYPE s = DEREF_type(id_parameter_type(id));
-			if ( !is_arg_promote ( s ) ) {
+						if (!is_arg_promote(s)) {
-			    DECL_SPEC ds ;
+							DECL_SPEC ds;
-			    s = arg_promote_type ( s, KILL_err ) ;
+							s = arg_promote_type(s, KILL_err);
-			    ds = DEREF_dspec ( id_storage ( id ) ) ;
+							ds = DEREF_dspec(id_storage(id));
-			    ds |= dspec_virtual ;
+							ds |= dspec_virtual;
-			    COPY_dspec ( id_storage ( id ), ds ) ;
+							COPY_dspec(id_storage(id), ds);
-			}
+						}
-			s = qualify_type ( s, cv_none, 0 ) ;
+						s = qualify_type(s, cv_none, 0);
-			CONS_id ( id, p, p ) ;
+						CONS_id(id, p, p);
-			CONS_type ( s, q, q ) ;
+						CONS_type(s, q, q);
-		    }
+					}
+				}
+				mem = DEREF_member(member_next(mem));
+			}
+			COPY_list(type_func_ptypes(t), q);
+			COPY_list(type_func_mtypes(t), q);
+			COPY_list(type_func_pids(t), p);
+			bad_crt_loc--;
+			decl_loc = loc;
+			ell = FUNC_WEAK_PARAMS;
+		} else {
+			report(crt_loc, ERR_dcl_fct_weak());
+			ell = FUNC_NO_PARAMS;
+		}
+	} else if (ell == FUNC_NO_PARAMS) {
+		/* Have empty parameter list '()' */
+		if (def) {
+			ell = FUNC_WEAK_PARAMS;
+		}
-		mem = DEREF_member ( member_next ( mem ) ) ;
-	    }
-	    COPY_list ( type_func_ptypes ( t ), q ) ;
-	    COPY_list ( type_func_mtypes ( t ), q ) ;
-	    COPY_list ( type_func_pids ( t ), p ) ;
-	    bad_crt_loc-- ;
-	    decl_loc = loc ;
-	    ell = FUNC_WEAK_PARAMS ;
-	} else {
-	    report ( crt_loc, ERR_dcl_fct_weak () ) ;
-	    ell = FUNC_NO_PARAMS ;
+	}
-    } else if ( ell == FUNC_NO_PARAMS ) {
-	/* Have empty parameter list '()' */
-	if ( def ) ell = FUNC_WEAK_PARAMS ;
-    }
-    COPY_int ( type_func_ellipsis ( t ), ell ) ;
+	COPY_int(type_func_ellipsis(t), ell);
-    return ;
+	return;
+}
 /*
     CHECK THE FUNCTION COMPONENTS OF AN OBJECT TYPE
     This routine checks the function components of an object with the
     given identifier tag and type t.
 */
-void object_type
+void
-    PROTO_N ( ( t, tag ) )
-    PROTO_T ( TYPE t X unsigned tag )
+object_type(TYPE t, unsigned tag)
 {
-    int depth = 0 ;
+	int depth = 0;
-    if ( tag == id_type_alias_tag || tag == null_tag ) {
+	if (tag == id_type_alias_tag || tag == null_tag) {
-	/* Force errors in these cases */
+		/* Force errors in these cases */
-	depth = 2 ;
+		depth = 2;
-    }
+	}
-    while ( !IS_NULL_type ( t ) ) {
+	while (!IS_NULL_type(t)) {
-	ASSERT ( ORDER_type == 18 ) ;
+		ASSERT(ORDER_type == 18);
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_func_tag : {
+		case type_func_tag: {
-		/* Function types */
+			/* Function types */
-		LIST ( TYPE ) ex ;
+			LIST(TYPE) ex;
-		CV_SPEC cv = DEREF_cv ( type_func_mqual ( t ) ) ;
+			CV_SPEC cv = DEREF_cv(type_func_mqual(t));
-		/* Check function qualifiers */
+			/* Check function qualifiers */
-		CV_SPEC mq = ( cv & cv_qual ) ;
+			CV_SPEC mq = (cv & cv_qual);
-		CV_SPEC lq = ( cv & cv_language ) ;
+			CV_SPEC lq = (cv & cv_language);
-		if ( depth == 0 ) {
+			if (depth == 0) {
-		    if ( tag == id_mem_func_tag ) {
+				if (tag == id_mem_func_tag) {
-			/* Member functions have C++ linkage */
+					/* Member functions have C++ linkage */
-			lq = cv_cpp ;
+					lq = cv_cpp;
-		    } else {
+				} else {
-			if ( mq ) {
+					if (mq) {
-			    /* Can't have cv-qualifiers */
+						/* Can't have cv-qualifiers */
+						report(crt_loc,
-			    report ( crt_loc, ERR_dcl_fct_cv_decl ( mq ) ) ;
+						       ERR_dcl_fct_cv_decl(mq));
-			    mq = cv_none ;
+						mq = cv_none;
-			}
+					}
-			if ( tag == id_stat_mem_func_tag ) {
+					if (tag == id_stat_mem_func_tag) {
-			    /* Member functions have C++ linkage */
+						/* Member functions have C++
+						 * linkage */
-			    lq = cv_cpp ;
+						lq = cv_cpp;
+					}
+				}
+			}
+			if (lq == cv_none) {
+				lq = cv_lang;
+			}
+			COPY_cv(type_func_mqual(t), (mq | lq));
+			/* Check default arguments */
+			if (depth && check_func_dargs(t, 0, 0)) {
+				report(crt_loc, ERR_dcl_fct_default_bad());
+			}
+			/* Check exception specifiers */
+			ex = DEREF_list(type_func_except(t));
+			if (!EQ_list(ex, empty_type_set)) {
+				if (!EQ_list(ex, univ_type_set)) {
+					ulong n = (ulong)LENGTH_list(ex);
+					IGNORE check_value(OPT_VAL_exception_specs, n);
+				}
+				if (depth > 1) {
+					report(crt_loc, ERR_except_spec_bad());
+				}
+			}
-		    }
-		}
-		if ( lq == cv_none ) lq = cv_lang ;
-		COPY_cv ( type_func_mqual ( t ), ( mq | lq ) ) ;
-		/* Check default arguments */
-		if ( depth && check_func_dargs ( t, 0, 0 ) ) {
-		    report ( crt_loc, ERR_dcl_fct_default_bad () ) ;
-		}
-		/* Check exception specifiers */
-		ex = DEREF_list ( type_func_except ( t ) ) ;
-		if ( !EQ_list ( ex, empty_type_set ) ) {
-		    if ( !EQ_list ( ex, univ_type_set ) ) {
-			ulong n = ( ulong ) LENGTH_list ( ex ) ;
-			IGNORE check_value ( OPT_VAL_exception_specs, n ) ;
-		    }
-		    if ( depth > 1 ) {
-			report ( crt_loc, ERR_except_spec_bad () ) ;
-		    }
-		}
-		/* Recheck parameter types */
+			/* Recheck parameter types */
-		if ( depth > 1 ) {
+			if (depth > 1) {
-		    LIST ( TYPE ) p ;
+				LIST(TYPE)p;
-		    p = DEREF_list ( type_func_ptypes ( t ) ) ;
+				p = DEREF_list(type_func_ptypes(t));
-		    while ( !IS_NULL_list ( p ) ) {
+				while (!IS_NULL_list(p)) {
-			TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+					TYPE s = DEREF_type(HEAD_list(p));
-			s = find_func_type ( s ) ;
+					s = find_func_type(s);
-			if ( !IS_NULL_type ( s ) ) {
+					if (!IS_NULL_type(s)) {
-			    ex = DEREF_list ( type_func_except ( s ) ) ;
+						ex = DEREF_list(type_func_except(s));
-			    if ( !EQ_list ( ex, empty_type_set ) ) {
+						if (!EQ_list(ex, empty_type_set)) {
-				report ( crt_loc, ERR_except_spec_bad () ) ;
+							report(crt_loc, ERR_except_spec_bad());
-			    }
+						}
+					}
+					p = TAIL_list(p);
+				}
+			}
+			return;
+		}
-			p = TAIL_list ( p ) ;
+		case type_ptr_tag: {
+			t = DEREF_type(type_ptr_sub(t));
+			depth++;
+			break;
+		}
+		case type_ref_tag: {
+			t = DEREF_type(type_ref_sub(t));
+			break;
+		}
+		case type_ptr_mem_tag: {
+			t = DEREF_type(type_ptr_mem_sub(t));
+			depth++;
+			break;
+		}
+		case type_array_tag: {
+			t = DEREF_type(type_array_sub(t));
+			depth++;
+			break;
+		}
+		case type_templ_tag: {
+			t = DEREF_type(type_templ_defn(t));
+			break;
-		    }
+		}
+		default:
+			/* Other types */
+			return;
+		}
-		return ;
-	    }
-	    case type_ptr_tag : {
-		t = DEREF_type ( type_ptr_sub ( t ) ) ;
-		depth++ ;
-		break ;
-	    }
-	    case type_ref_tag : {
-		t = DEREF_type ( type_ref_sub ( t ) ) ;
-		break ;
-	    }
-	    case type_ptr_mem_tag : {
-		t = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
-		depth++ ;
-		break ;
-	    }
-	    case type_array_tag : {
-		t = DEREF_type ( type_array_sub ( t ) ) ;
-		depth++ ;
-		break ;
-	    }
-	    case type_templ_tag : {
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
-		break ;
-	    }
-	    default : {
-		/* Other types */
-		return ;
-	    }
+	}
-    }
-    return ;
+	return;
+}
 /*
     DECLARE A FUNCTION TYPE
     This routine checks the function or function typedef id of type t,
     including checking that if a default argument is given for a
     particular parameter one is also given for all subsequent parameters.
     The redeclaration case, where default arguments can be inherited
     from the previous declaration is dealt with by redecl_func_type.
 */
-void decl_func_type
+void
-    PROTO_N ( ( id, t, def ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X int def )
+decl_func_type(IDENTIFIER id, TYPE t, int def)
 {
-    NAMESPACE pns ;
+	NAMESPACE pns;
-    int is_templ = 0 ;
+	int is_templ = 0;
-    unsigned tag = TAG_id ( id ) ;
+	unsigned tag = TAG_id(id);
-    /* Step over template components */
+	/* Step over template components */
-    if ( IS_type_templ ( t ) ) {
+	if (IS_type_templ(t)) {
-	t = check_templ_params ( t, id ) ;
+		t = check_templ_params(t, id);
-	is_templ = 1 ;
+		is_templ = 1;
-    }
+	}
-    pns = DEREF_nspace ( type_func_pars ( t ) ) ;
+	pns = DEREF_nspace(type_func_pars(t));
-    COPY_id ( nspace_name ( pns ), id ) ;
+	COPY_id(nspace_name(pns), id);
-    /* Check default arguments */
+	/* Check default arguments */
-    IGNORE check_func_dargs ( t, 1, 0 ) ;
+	IGNORE check_func_dargs(t, 1, 0);
-    /* Check cv-qualifiers */
+	/* Check cv-qualifiers */
-    switch ( tag ) {
+	switch (tag) {
-	case id_function_tag :
+	case id_function_tag:
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag: {
-	    /* Allow for member functions */
+		/* Allow for member functions */
-	    CLASS_TYPE ct = parent_class ( id ) ;
+		CLASS_TYPE ct = parent_class(id);
-	    member_func_type ( ct, tag, t ) ;
+		member_func_type(ct, tag, t);
-	    /* Allow for overloading of template functions */
+		/* Allow for overloading of template functions */
-	    if ( is_templ ) {
+		if (is_templ) {
-		templ_func_decl ( id ) ;
+			templ_func_decl(id);
-	    } else {
+		} else {
-		IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
+			IDENTIFIER over = DEREF_id(id_function_etc_over(id));
-		if ( !IS_NULL_id ( over ) ) {
+			if (!IS_NULL_id(over)) {
-		    /* Overloads a template function */
+				/* Overloads a template function */
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( over ) ) ;
+				DECL_SPEC ds = DEREF_dspec(id_storage(over));
-		    if ( ds & dspec_template ) templ_func_decl ( id ) ;
+				if (ds & dspec_template) {
+					templ_func_decl(id);
+				}
+			}
+		}
+		break;
-	    }
+	}
+	default:
+		/* Allow for function typedefs */
+		member_func_type(NULL_ctype, tag, t);
-	    break ;
+		break;
+	}
-	default : {
-	    /* Allow for function typedefs */
-	    member_func_type ( NULL_ctype, tag, t ) ;
-	    break ;
-	}
-    }
-    UNUSED ( def ) ;
+	UNUSED(def);
-    return ;
+	return;
+}
 /*
     REDECLARE DEFAULT ARGUMENTS
     This routine checks and unifies the default arguments for the equal
     function types s and t.  It returns the number of default arguments
     added by this unification.
 */
-static unsigned redecl_func_dargs
+static unsigned
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( TYPE s X TYPE t )
+redecl_func_dargs(TYPE s, TYPE t)
+{
-    unsigned nargs = 0 ;
+    unsigned nargs = 0;
-    if ( IS_type_func ( s ) && IS_type_func ( t ) ) {
+    if (IS_type_func(s) && IS_type_func(t)) {
-	int started = 0 ;
+	int started = 0;
-	LIST ( IDENTIFIER ) ps = DEREF_list ( type_func_pids ( s ) ) ;
+	LIST(IDENTIFIER) ps = DEREF_list(type_func_pids(s));
-	LIST ( IDENTIFIER ) pt = DEREF_list ( type_func_pids ( t ) ) ;
+	LIST(IDENTIFIER) pt = DEREF_list(type_func_pids(t));
-	while ( !IS_NULL_list ( ps ) && !IS_NULL_list ( pt ) ) {
+	while (!IS_NULL_list(ps) && !IS_NULL_list(pt)) {
-	    ERROR err = NULL_err ;
+	    ERROR err = NULL_err;
-	    IDENTIFIER as = DEREF_id ( HEAD_list ( ps ) ) ;
+	    IDENTIFIER as = DEREF_id(HEAD_list(ps));
-	    IDENTIFIER at = DEREF_id ( HEAD_list ( pt ) ) ;
+	    IDENTIFIER at = DEREF_id(HEAD_list(pt));
-	    EXP ds = DEREF_exp ( id_parameter_init ( as ) ) ;
+	    EXP ds = DEREF_exp(id_parameter_init(as));
-	    EXP dt = DEREF_exp ( id_parameter_init ( at ) ) ;
+	    EXP dt = DEREF_exp(id_parameter_init(at));
-	    if ( IS_NULL_exp ( ds ) ) {
+	    if (IS_NULL_exp(ds)) {
 		/* No existing default argument */
-		if ( IS_NULL_exp ( dt ) ) {
+		if (IS_NULL_exp(dt)) {
-		    if ( started ) {
+		    if (started) {
 			/* Missing default arguments */
-			TYPE r = DEREF_type ( id_parameter_type ( at ) ) ;
+			TYPE r = DEREF_type(id_parameter_type(at));
-			err = ERR_dcl_fct_default_missing ( at ) ;
+			err = ERR_dcl_fct_default_missing(at);
-			MAKE_exp_value ( r, dt ) ;
+			MAKE_exp_value(r, dt);
-			COPY_exp ( id_parameter_init ( at ), dt ) ;
+			COPY_exp(id_parameter_init(at), dt);
-			COPY_exp ( id_parameter_init ( as ), dt ) ;
+			COPY_exp(id_parameter_init(as), dt);
+		    }
 		} else {
 		    /* New default argument */
-		    COPY_exp ( id_parameter_init ( as ), dt ) ;
+		    COPY_exp(id_parameter_init(as), dt);
-		    dt = DEREF_exp ( id_parameter_term ( at ) ) ;
+		    dt = DEREF_exp(id_parameter_term(at));
-		    COPY_exp ( id_parameter_term ( as ), dt ) ;
+		    COPY_exp(id_parameter_term(as), dt);
-		    nargs++ ;
+		    nargs++;
-		    started = 1 ;
+		    started = 1;
+		}
 	    } else {
 		/* Existing default argument */
-		if ( IS_NULL_exp ( dt ) ) {
+		if (IS_NULL_exp(dt)) {
 		    /* Inherited default argument */
-		    COPY_exp ( id_parameter_init ( at ), ds ) ;
+		    COPY_exp(id_parameter_init(at), ds);
-		    ds = DEREF_exp ( id_parameter_term ( as ) ) ;
+		    ds = DEREF_exp(id_parameter_term(as));
-		    COPY_exp ( id_parameter_term ( at ), ds ) ;
+		    COPY_exp(id_parameter_term(at), ds);
 		} else {
 		    /* Redefined default argument */
-		    PTR ( LOCATION ) sloc = id_loc ( as ) ;
+		    PTR(LOCATION)sloc = id_loc(as);
-		    if ( eq_exp ( ds, dt, 0 ) ) {
+		    if (eq_exp(ds, dt, 0)) {
-			err = ERR_dcl_fct_default_dup ( at, sloc ) ;
+			err = ERR_dcl_fct_default_dup(at, sloc);
 		    } else {
 			/* NOT YET IMPLEMENTED: dt uncompiled */
-			err = ERR_dcl_fct_default_redef ( at, sloc ) ;
+			err = ERR_dcl_fct_default_redef(at, sloc);
 		    }
-		    COPY_exp ( id_parameter_init ( as ), dt ) ;
+		    COPY_exp(id_parameter_init(as), dt);
-		    dt = DEREF_exp ( id_parameter_term ( at ) ) ;
+		    dt = DEREF_exp(id_parameter_term(at));
-		    COPY_exp ( id_parameter_term ( as ), dt ) ;
+		    COPY_exp(id_parameter_term(as), dt);
 		}
-		started = 1 ;
+		started = 1;
 	    }
-	    if ( !IS_NULL_err ( err ) ) {
+	    if (!IS_NULL_err(err)) {
 		/* Report any errors */
-		LOCATION loc ;
+		LOCATION loc;
-		DEREF_loc ( id_loc ( at ), loc ) ;
+		DEREF_loc(id_loc(at), loc);
-		report ( loc, err ) ;
+		report(loc, err);
 	    }
-	    ps = TAIL_list ( ps ) ;
+	    ps = TAIL_list(ps);
-	    pt = TAIL_list ( pt ) ;
+	    pt = TAIL_list(pt);
 	}
     }
-    return ( nargs ) ;
+    return (nargs);
 }
 /*
     REDECLARE A FUNCTION TYPE
     This routine deals with the compatible redeclaration of the function
     id of type s to have type t.  It unifies the parameter types, checking
     default arguments etc.  It also checks any exception specifications
     for the two declarations.  The parameter names in the returned type
     are those from t if def is true, and those from s otherwise.
 */
-TYPE redecl_func_type
+TYPE
-    PROTO_N ( ( id, s, t, def, dargs ) )
-    PROTO_T ( IDENTIFIER id X TYPE s X TYPE t X int def X int dargs )
+redecl_func_type(IDENTIFIER id, TYPE s, TYPE t, int def, int dargs)
 {
-    TYPE fs = s ;
+	TYPE fs = s;
-    TYPE ft = t ;
+	TYPE ft = t;
-    CV_SPEC qs, qt ;
+	CV_SPEC qs, qt;
-    NAMESPACE ns, nt ;
+	NAMESPACE ns, nt;
-    unsigned tag = TAG_id ( id ) ;
+	unsigned tag = TAG_id(id);
-    /* Check template components */
+	/* Check template components */
-    redecl_template ( &fs, &ft, id ) ;
+	redecl_template(&fs, &ft, id);
-    ns = DEREF_nspace ( type_func_pars ( fs ) ) ;
+	ns = DEREF_nspace(type_func_pars(fs));
-    nt = DEREF_nspace ( type_func_pars ( ft ) ) ;
+	nt = DEREF_nspace(type_func_pars(ft));
-    COPY_id ( nspace_name ( ns ), id ) ;
+	COPY_id(nspace_name(ns), id);
-    COPY_id ( nspace_name ( nt ), id ) ;
+	COPY_id(nspace_name(nt), id);
 #if LANGUAGE_C
-    /* Copy composite type information */
+	/* Copy composite type information */
-    if ( def ) {
+	if (def) {
-	TYPE ret = DEREF_type ( type_func_ret ( fs ) ) ;
+		TYPE ret = DEREF_type(type_func_ret(fs));
-	int ell = DEREF_int ( type_func_ellipsis ( fs ) ) ;
+		int ell = DEREF_int(type_func_ellipsis(fs));
-	LIST ( TYPE ) ptypes = DEREF_list ( type_func_ptypes ( fs ) ) ;
+		LIST(TYPE)ptypes = DEREF_list(type_func_ptypes(fs));
-	COPY_list ( type_func_ptypes ( ft ), ptypes ) ;
+		COPY_list(type_func_ptypes(ft), ptypes);
-	COPY_int ( type_func_ellipsis ( ft ), ell ) ;
+		COPY_int(type_func_ellipsis(ft), ell);
-	COPY_type ( type_func_ret ( ft ), ret ) ;
+		COPY_type(type_func_ret(ft), ret);
-    }
+	}
 #endif
-    /* Check default arguments */
+	/* Check default arguments */
-    if ( dargs && redecl_func_dargs ( fs, ft ) ) {
+	if (dargs && redecl_func_dargs(fs, ft)) {
-	if ( IS_type_templ ( t ) ) {
+		if (IS_type_templ(t)) {
-	    report ( decl_loc, ERR_dcl_fct_default_templ () ) ;
+			report(decl_loc, ERR_dcl_fct_default_templ());
-	}
+		}
-    }
+	}
-    /* Check exception specifications */
+	/* Check exception specifications */
-    if ( eq_except ( s, t ) != 2 ) {
+	if (eq_except(s, t) != 2) {
-	PTR ( LOCATION ) loc = id_loc ( id ) ;
+		PTR(LOCATION)loc = id_loc(id);
-	report ( decl_loc, ERR_except_spec_wrong ( id, loc ) ) ;
+		report(decl_loc, ERR_except_spec_wrong(id, loc));
-    }
+	}
-    /* Check cv-qualifiers */
+	/* Check cv-qualifiers */
-    switch ( tag ) {
+	switch (tag) {
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag: {
-	    /* Allow for member functions */
+		/* Allow for member functions */
-	    CLASS_TYPE ct = parent_class ( id ) ;
+		CLASS_TYPE ct = parent_class(id);
-	    member_func_type ( ct, tag, ft ) ;
+		member_func_type(ct, tag, ft);
-	    break ;
+		break;
 	}
-	default : {
+	default:
-	    /* Allow for function typedefs */
+		/* Allow for function typedefs */
-	    member_func_type ( NULL_ctype, tag, ft ) ;
+		member_func_type(NULL_ctype, tag, ft);
-	    break ;
+		break;
 	}
-    }
-    /* Check function qualifiers */
+	/* Check function qualifiers */
-    qs = DEREF_cv ( type_func_mqual ( fs ) ) ;
+	qs = DEREF_cv(type_func_mqual(fs));
-    qt = DEREF_cv ( type_func_mqual ( ft ) ) ;
+	qt = DEREF_cv(type_func_mqual(ft));
-    if ( qs != qt ) {
+	if (qs != qt) {
-	qs &= cv_language ;
+		qs &= cv_language;
-	qt &= cv_language ;
+		qt &= cv_language;
-	if ( qs != qt ) {
+		if (qs != qt) {
-	    /* Language specifiers don't match */
+			/* Language specifiers don't match */
-	    string ln = linkage_string ( dspec_none, qs ) ;
+			string ln = linkage_string(dspec_none, qs);
-	    report ( decl_loc, ERR_dcl_link_func ( ln ) ) ;
+			report(decl_loc, ERR_dcl_link_func(ln));
-	}
+		}
-    }
-    /* Select type to continue with */
-    if ( def ) {
-	LIST ( IDENTIFIER ) sids = DEREF_list ( type_func_pids ( fs ) ) ;
-	LIST ( IDENTIFIER ) tids = DEREF_list ( type_func_pids ( ft ) ) ;
-	if ( !EQ_list ( sids, tids ) ) {
-	    while ( !IS_NULL_list ( sids ) && !IS_NULL_list ( tids ) ) {
-		/* Identify parameters */
-		IDENTIFIER sid = DEREF_id ( HEAD_list ( sids ) ) ;
-		IDENTIFIER tid = DEREF_id ( HEAD_list ( tids ) ) ;
-		tid = chase_alias ( tid ) ;
-		sid = chase_alias ( sid ) ;
-		COPY_id ( id_alias ( sid ), tid ) ;
-		tids = TAIL_list ( tids ) ;
-		sids = TAIL_list ( sids ) ;
-	    }
+	}
+	/* Select type to continue with */
+	if (def) {
+		LIST(IDENTIFIER) sids = DEREF_list(type_func_pids(fs));
+		LIST(IDENTIFIER) tids = DEREF_list(type_func_pids(ft));
+		if (!EQ_list(sids, tids)) {
+			while (!IS_NULL_list(sids) && !IS_NULL_list(tids)) {
+				/* Identify parameters */
+				IDENTIFIER sid = DEREF_id(HEAD_list(sids));
+				IDENTIFIER tid = DEREF_id(HEAD_list(tids));
+				tid = chase_alias(tid);
+				sid = chase_alias(sid);
+				COPY_id(id_alias(sid), tid);
+				tids = TAIL_list(tids);
+				sids = TAIL_list(sids);
+			}
+		}
-	if ( IS_type_templ ( t ) ) {
+		if (IS_type_templ(t)) {
-	    /* Reset primary function template */
+			/* Reset primary function template */
-	    reset_primary_templ ( s, t ) ;
+			reset_primary_templ(s, t);
+		}
+		s = t;
+	}
-	s = t ;
-    }
-    return ( s ) ;
+	return (s);
+}
 /*
     FIND THE FUNCTION COMPONENT OF A TYPE
     This routine returns the function component of a function, pointer to
     function, or pointer to member function type.
 */
-TYPE find_func_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+find_func_type(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	unsigned tag = TAG_type ( t ) ;
+		unsigned tag = TAG_type(t);
-	if ( tag == type_ref_tag ) {
+		if (tag == type_ref_tag) {
-	    t = DEREF_type ( type_ref_sub ( t ) ) ;
+			t = DEREF_type(type_ref_sub(t));
+			tag = TAG_type(t);
+		}
+		if (tag == type_ptr_tag) {
+			t = DEREF_type(type_ptr_sub(t));
+			tag = TAG_type(t);
+		} else if (tag == type_ptr_mem_tag) {
+			t = DEREF_type(type_ptr_mem_sub(t));
-	    tag = TAG_type ( t ) ;
+			tag = TAG_type(t);
+		}
+		if (tag == type_func_tag) {
+			return (t);
+		}
+	}
-	if ( tag == type_ptr_tag ) {
-	    t = DEREF_type ( type_ptr_sub ( t ) ) ;
-	    tag = TAG_type ( t ) ;
-	} else if ( tag == type_ptr_mem_tag ) {
-	    t = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
-	    tag = TAG_type ( t ) ;
-	}
-	if ( tag == type_func_tag ) return ( t ) ;
-    }
-    return ( NULL_type ) ;
+	return (NULL_type);
+}
 /*
     STACK OF DECLARATOR LOCATIONS
     The location decl_loc refers to the current declarator.  This value
     needs to be stored during parameter declarations and this stack is
     used for this purpose.
 */
-static STACK ( LOCATION ) decl_locs = NULL_stack ( LOCATION ) ;
+static STACK(LOCATION) decl_locs = NULL_stack(LOCATION);
 /*
     BEGIN FUNCTION PARAMETER NAMESPACE
     This routine is called at the start of a list of function parameters to
     initialise the parameter namespace.  id gives the associated function
     name (or the null identifier).
 */
-void begin_param
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+begin_param(IDENTIFIER id)
-{
-    NAMESPACE ns = make_namespace ( id, nspace_param_tag, 0 ) ;
-    push_namespace ( ns ) ;
-    PUSH_loc ( decl_loc, decl_locs ) ;
-    return ;
-}
-/*
-    END FUNCTION PARAMETER NAMESPACE
-    This routine is called at the end of a list of function parameters.
-*/
-void end_param
-    PROTO_Z ()
+{
+	NAMESPACE ns = make_namespace(id, nspace_param_tag, 0);
-    IGNORE pop_namespace () ;
+	push_namespace(ns);
-    POP_loc ( decl_loc, decl_locs ) ;
+	PUSH_loc(decl_loc, decl_locs);
-    return ;
+	return;
+}
 /*
-    ADJUST A FUNCTION PARAMETER NAMESPACE
+    END FUNCTION PARAMETER NAMESPACE
-    This routine adjusts the parameter namespace of the dfunction type
+    This routine is called at the end of a list of function parameters.
-    t used in a function definition.
 */
-void adjust_param
+void
-    PROTO_N ( ( t ) )
+end_param(void)
-    PROTO_T ( TYPE t )
+{
+	IGNORE pop_namespace();
+	POP_loc(decl_loc, decl_locs);
+	return;
+}
+/*
+    ADJUST A FUNCTION PARAMETER NAMESPACE
+    This routine adjusts the parameter namespace of the dfunction type
+    t used in a function definition.
+*/
+void
+adjust_param(TYPE t)
+{
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    while ( IS_type_templ ( t ) ) {
+	while (IS_type_templ(t)) {
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-    }
+	}
-    ns = DEREF_nspace ( type_func_pars ( t ) ) ;
+	ns = DEREF_nspace(type_func_pars(t));
-    MODIFY_nspace_block_etc ( nspace_block_tag, ns ) ;
+	MODIFY_nspace_block_etc(nspace_block_tag, ns);
-    report ( crt_loc, ERR_dcl_fct_typedef () ) ;
+	report(crt_loc, ERR_dcl_fct_typedef());
-    return ;
+	return;
+}
 /*
     READ A LIST OF NON-PROTOTYPE FUNCTION PARAMETERS
     This routine reads a list of function parameters, returning true for
     a function definition.
 */
-int function_params
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+function_params(TYPE t)
+{
-    int def = 0 ;
+	int def = 0;
-    if ( IS_type_func ( t ) ) {
+	if (IS_type_func(t)) {
-	int func = have_func_declarator ;
+		int func = have_func_declarator;
-	int ell = DEREF_int ( type_func_ellipsis ( t ) ) ;
+		int ell = DEREF_int(type_func_ellipsis(t));
-	NAMESPACE ns = DEREF_nspace ( type_func_pars ( t ) ) ;
+		NAMESPACE ns = DEREF_nspace(type_func_pars(t));
-	in_weak_param++ ;
+		in_weak_param++;
-	push_namespace ( ns ) ;
+		push_namespace(ns);
-	while ( predict_dspec ( 0 ) ) {
+		while (predict_dspec(0)) {
-	    if ( !func ) {
+			if (!func) {
-		adjust_param ( t ) ;
+				adjust_param(t);
-		func = 1 ;
+				func = 1;
-	    }
+			}
-	    if ( ell != FUNC_NO_PARAMS && ell != FUNC_PARAMS ) {
+			if (ell != FUNC_NO_PARAMS && ell != FUNC_PARAMS) {
-		/* Can't have parameters with prototype */
+				/* Can't have parameters with prototype */
-		report ( crt_loc, ERR_dcl_fct_par_proto () ) ;
+				report(crt_loc, ERR_dcl_fct_par_proto());
-		ell = FUNC_PARAMS ;
+				ell = FUNC_PARAMS;
-	    }
+			}
-	    parse_decl ( NULL_type, dspec_none ) ;
+			parse_decl(NULL_type, dspec_none);
-	    def = 1 ;
+			def = 1;
-	}
+		}
-	if ( predict_func_defn () ) {
+		if (predict_func_defn()) {
-	    if ( !func ) adjust_param ( t ) ;
+			if (!func)adjust_param(t);
-	    def = 1 ;
+			def = 1;
+		}
+		check_weak_func(t, def);
+		IGNORE pop_namespace();
+		in_weak_param--;
+	}
-	check_weak_func ( t, def ) ;
-	IGNORE pop_namespace () ;
-	in_weak_param-- ;
-    }
-    return ( def ) ;
+	return (def);
+}
 /*
     MAIN FUNCTION
     This variable is used to hold the main function.
 */
-IDENTIFIER main_function = NULL_id ;
+IDENTIFIER main_function = NULL_id;
 /*
     CHECK THE TYPE OF THE MAIN FUNCTION
 	    int main ( int, char **, [extra parameters] ) ;
     is deemed to be unorthodox.
 */
-TYPE check_main
+TYPE
-    PROTO_N ( ( t, nm ) )
-    PROTO_T ( TYPE t X HASHID nm )
+check_main(TYPE t, HASHID nm)
+{
-    int ok = 0 ;
+    int ok = 0;
-    if ( IS_type_func ( t ) ) {
+    if (IS_type_func(t)) {
-	TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
+	TYPE r = DEREF_type(type_func_ret(t));
-	LIST ( TYPE ) p = DEREF_list ( type_func_ptypes ( t ) ) ;
+	LIST(TYPE) p = DEREF_list(type_func_ptypes(t));
-	int ell = DEREF_int ( type_func_ellipsis ( t ) ) ;
+	int ell = DEREF_int(type_func_ellipsis(t));
-	if ( !eq_type_unqual ( r, type_sint ) ) {
+	if (!eq_type_unqual(r, type_sint)) {
 	    /* Return type is wrong */
-	    ERROR err = ERR_basic_start_main_ret ( r, nm ) ;
+	    ERROR err = ERR_basic_start_main_ret(r, nm);
-	    report ( crt_loc, err ) ;
+	    report(crt_loc, err);
+	}
-	if ( IS_NULL_list ( p ) ) {
+	if (IS_NULL_list(p)) {
 	    /* Check for no parameter case */
-	    if ( !( ell & FUNC_ELLIPSIS ) ) ok = 2 ;
+	    if (!(ell & FUNC_ELLIPSIS)) {
+		    ok = 2;
+	    }
 	} else {
 	    /* Check for two parameter case */
-	    TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+	    TYPE s = DEREF_type(HEAD_list(p));
-	    if ( eq_type_unqual ( s, type_sint ) ) {
+	    if (eq_type_unqual(s, type_sint)) {
-		p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-		if ( !IS_NULL_list ( p ) ) {
+		if (!IS_NULL_list(p)) {
-		    s = DEREF_type ( HEAD_list ( p ) ) ;
+		    s = DEREF_type(HEAD_list(p));
-		    if ( IS_type_ptr ( s ) ) {
+		    if (IS_type_ptr(s)) {
-			s = DEREF_type ( type_ptr_sub ( s ) ) ;
+			s = DEREF_type(type_ptr_sub(s));
-			if ( IS_type_ptr ( s ) ) {
+			if (IS_type_ptr(s)) {
-			    s = DEREF_type ( type_ptr_sub ( s ) ) ;
+			    s = DEREF_type(type_ptr_sub(s));
-			    if ( eq_type_unqual ( s, type_char ) ) {
+			    if (eq_type_unqual(s, type_char)) {
-				p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
-				if ( IS_NULL_list ( p ) ) {
+				if (IS_NULL_list(p)) {
-				    if ( !( ell & FUNC_ELLIPSIS ) ) {
+				    if (!(ell & FUNC_ELLIPSIS)) {
-					ok = 2 ;
+					ok = 2;
 				    } else {
-					ok = 1 ;
+					ok = 1;
+				    }
 				} else {
-				    ok = 1 ;
+				    ok = 1;
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
-    if ( !ok ) {
+    if (!ok) {
 	/* Warn about unorthodox parameter types */
-	ERROR err = ERR_basic_start_main_proto ( t, nm ) ;
+	ERROR err = ERR_basic_start_main_proto(t, nm);
-	report ( crt_loc, err ) ;
+	report(crt_loc, err);
+    }
-    return ( t ) ;
+    return (t);
+}
 /*
     RECHECK THE MAIN FUNCTION
     This routine rechecks the main function id.  In particular 'main' can't
     be overloaded.
 */
-void recheck_main
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+recheck_main(IDENTIFIER id)
 {
-    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+	TYPE fn = DEREF_type(id_function_etc_type(id));
-    IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
+	IDENTIFIER over = DEREF_id(id_function_etc_over(id));
-    if ( !IS_NULL_id ( over ) || IS_type_templ ( fn ) ) {
+	if (!IS_NULL_id(over) || IS_type_templ(fn)) {
-	/* Can't overload 'main' */
+		/* Can't overload 'main' */
-	report ( decl_loc, ERR_basic_start_main_over ( id ) ) ;
+		report(decl_loc, ERR_basic_start_main_over(id));
-    }
+	}
-    main_function = id ;
+	main_function = id;
-    return ;
+	return;
 }
 /*
     CURRENT FUNCTION INFORMATION
     These variables are used to hold information concerning the current
     function, including its name, return type and exception specification.
 */
-IDENTIFIER crt_func_id = NULL_id ;
+IDENTIFIER crt_func_id = NULL_id;
-TYPE crt_func_return = NULL_type ;
+TYPE crt_func_return = NULL_type;
-int crt_func_complex = 0 ;
+int crt_func_complex = 0;
 /*
     NESTED FUNCTION STACK
     a member function definition).  These stacks are used to preserve
     information across nested functions.
 */
 static struct {
-    STACK ( IDENTIFIER ) id ;
+	STACK(IDENTIFIER)id;
-    STACK ( TYPE ) ret ;
+	STACK(TYPE)ret;
-    STACK ( int ) unreached ;
+	STACK(int)unreached;
-    STACK ( int ) declaration ;
+	STACK(int)declaration;
-    STACK ( int ) destructor ;
+	STACK(int)destructor;
-    STACK ( int ) handler ;
+	STACK(int)handler;
-    STACK ( STACK ( EXP ) ) loops ;
+	STACK(STACK(EXP))loops;
-    STACK ( NAMESPACE ) labels ;
+	STACK(NAMESPACE)labels;
-    STACK ( LIST ( EXP ) ) solves ;
+	STACK(LIST(EXP))solves;
-    STACK ( LIST ( EXP ) ) tries ;
+	STACK(LIST(EXP))tries;
-    STACK ( unsigned long ) opts ;
+	STACK(unsigned long)opts;
 } func_stack = {
-    NULL_stack ( IDENTIFIER ),
+	NULL_stack(IDENTIFIER),
-    NULL_stack ( TYPE ),
+	NULL_stack(TYPE),
-    NULL_stack ( int ),
+	NULL_stack(int),
-    NULL_stack ( int ),
+	NULL_stack(int),
-    NULL_stack ( int ),
+	NULL_stack(int),
-    NULL_stack ( int ),
+	NULL_stack(int),
-    NULL_stack ( STACK ( EXP ) ),
+	NULL_stack(STACK(EXP)),
-    NULL_stack ( NAMESPACE ),
+	NULL_stack(NAMESPACE),
-    NULL_stack ( LIST ( EXP ) ),
+	NULL_stack(LIST(EXP)),
-    NULL_stack ( LIST ( EXP ) ),
+	NULL_stack(LIST(EXP)),
-    NULL_stack ( unsigned long )
+	NULL_stack(unsigned long)
-} ;
+};
 /*
     BEGIN A FUNCTION DEFINITION
     This routine is called at the start of a function definition.  t gives
     the function type.
 */
-void begin_function
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+begin_function(IDENTIFIER id)
+{
-    TYPE t ;
+	TYPE t;
-    int ell ;
+	int ell;
-    TYPE ret ;
+	TYPE ret;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    NAMESPACE bns ;
+	NAMESPACE bns;
-    unsigned long n ;
+	unsigned long n;
-    LIST ( TYPE ) ex ;
+	LIST(TYPE) ex;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    LIST ( IDENTIFIER ) p ;
+	LIST(IDENTIFIER) p;
-    unsigned long npars = 0 ;
+	unsigned long npars = 0;
-    /* Check for previous definition */
+	/* Check for previous definition */
-    if ( IS_id_function_etc ( id ) ) {
+	if (IS_id_function_etc(id)) {
-	EXP e = DEREF_exp ( id_function_etc_defn ( id ) ) ;
+		EXP e = DEREF_exp(id_function_etc_defn(id));
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	t = DEREF_type ( id_function_etc_type ( id ) ) ;
+		t = DEREF_type(id_function_etc_type(id));
-	if ( IS_NULL_exp ( e ) ) {
+		if (IS_NULL_exp(e)) {
-	    /* Mark with dummy definition */
+			/* Mark with dummy definition */
-	    MAKE_exp_value ( t, e ) ;
+			MAKE_exp_value(t, e);
-	    COPY_exp ( id_function_etc_defn ( id ), e ) ;
+			COPY_exp(id_function_etc_defn(id), e);
+		} else {
+			/* Already defined */
+			PTR(LOCATION) loc = id_loc(id);
+			report(decl_loc, ERR_basic_odr_def_func(id, loc));
+		}
+		if ((ds & dspec_inline) && (ds & dspec_called)) {
+			report(decl_loc, ERR_dcl_fct_spec_inline_call(id));
+		}
 	} else {
-    /* Deal with the ellipsis parameter */
+	/* Deal with the ellipsis parameter */
-    if ( ell & FUNC_ELLIPSIS ) make_ellipsis_decl () ;
+	if (ell & FUNC_ELLIPSIS) {
+		make_ellipsis_decl();
+	}
-    /* Create dummy try block */
+	/* Create dummy try block */
-    start_try_check ( ex ) ;
+	start_try_check(ex);
-    return ;
+	return;
+}
 /*
     END A FUNCTION DEFINITION
     expression body gives the compound statement comprising the definition.
     Note that the parameters are in the outermost scope of body and so
     have already been taken out of scope.
 */
-EXP end_function
+EXP
-    PROTO_N ( ( id, body ) )
-    PROTO_T ( IDENTIFIER id X EXP body )
+end_function(IDENTIFIER id, EXP body)
+{
-    /* Check for errors in function */
+	/* Check for errors in function */
-    TYPE ret ;
+	TYPE ret;
-    int flow = 0 ;
+	int flow = 0;
-    unsigned long n ;
+	unsigned long n;
-    POP_ulong ( n, func_stack.opts ) ;
+	POP_ulong(n, func_stack.opts);
-    if ( option ( OPT_variable ) ) {
+	if (option(OPT_variable)) {
-	if ( n == number_errors ) flow = 1 ;
+		if (n == number_errors) {
+			flow = 1;
+		}
-	record_location-- ;
+		record_location--;
-    }
+	}
-    /* Check function body */
+	/* Check function body */
-    if ( !IS_NULL_exp ( body ) ) {
+	if (!IS_NULL_exp(body)) {
-	if ( !unreached_code ) {
+		if (!unreached_code) {
-	    /* Check for falling out of function */
+			/* Check for falling out of function */
-	    EXP e = fall_return_stmt () ;
+			EXP e = fall_return_stmt();
-	    body = add_compound_stmt ( body, e ) ;
+			body = add_compound_stmt(body, e);
-	}
+		}
-	unreached_code = 0 ;
+		unreached_code = 0;
-	set_parent_stmt ( body, NULL_exp ) ;
+		set_parent_stmt(body, NULL_exp);
-	if ( IS_exp_solve_stmt ( body ) ) {
+		if (IS_exp_solve_stmt(body)) {
-	    /* Analyse enclosing solve statement */
+			/* Analyse enclosing solve statement */
-	    body = solve_labels ( body ) ;
+			body = solve_labels(body);
-	} else if ( check_labels () ) {
+		} else if (check_labels()) {
-	    /* Construct enclosing solve statement */
+			/* Construct enclosing solve statement */
-	    EXP a ;
+			EXP a;
-	    MAKE_exp_solve_stmt ( type_void, body, a ) ;
+			MAKE_exp_solve_stmt(type_void, body, a);
-	    CONS_exp ( a, all_solve_stmts, all_solve_stmts ) ;
+			CONS_exp(a, all_solve_stmts, all_solve_stmts);
-	    set_parent_stmt ( body, a ) ;
+			set_parent_stmt(body, a);
-	    body = solve_labels ( a ) ;
+			body = solve_labels(a);
-	}
+		}
-	end_solve_stmts () ;
+		end_solve_stmts();
 #if LANGUAGE_CPP
-	if ( !IS_NULL_list ( all_try_blocks ) ) {
+		if (!IS_NULL_list(all_try_blocks)) {
-	    /* Check all try blocks */
+			/* Check all try blocks */
-	    end_try_blocks ( id ) ;
+			end_try_blocks(id);
-	}
+		}
 #endif
-	body = end_try_check ( id, body ) ;
+		body = end_try_check(id, body);
-	if ( flow || ( have_destructor && do_usage ) ) {
+		if (flow || (have_destructor && do_usage)) {
-	    /* Variable flow analysis */
+			/* Variable flow analysis */
-	    check_flow ( id, body, flow ) ;
+			check_flow(id, body, flow);
+		}
+	}
-    }
-    /* Define the function */
+	/* Define the function */
-    if ( IS_id_function_etc ( id ) ) {
+	if (IS_id_function_etc(id)) {
-	COPY_exp ( id_function_etc_defn ( id ), body ) ;
+		COPY_exp(id_function_etc_defn(id), body);
-	define_id ( id ) ;
+		define_id(id);
-	if ( !in_template_decl ) {
+		if (!in_template_decl) {
-	    compile_function ( id, 0 ) ;
+			compile_function(id, 0);
-	    free_nspace ( label_namespace ) ;
+			free_nspace(label_namespace);
+		}
+		if (do_dump) {
+			dump_undefine(id, &crt_loc, 0);
+		}
+	}
-	if ( do_dump ) dump_undefine ( id, &crt_loc, 0 ) ;
-    }
-    /* Restore old function data */
+	/* Restore old function data */
-    POP_id ( crt_func_id, func_stack.id ) ;
+	POP_id(crt_func_id, func_stack.id);
-    POP_type ( ret, func_stack.ret ) ;
+	POP_type(ret, func_stack.ret);
-    POP_int ( unreached_code, func_stack.unreached ) ;
+	POP_int(unreached_code, func_stack.unreached);
-    POP_int ( in_declaration, func_stack.declaration ) ;
+	POP_int(in_declaration, func_stack.declaration);
-    POP_int ( have_destructor, func_stack.destructor ) ;
+	POP_int(have_destructor, func_stack.destructor);
-    POP_int ( in_func_handler, func_stack.handler ) ;
+	POP_int(in_func_handler, func_stack.handler);
-    POP_stack ( crt_loop_stack, func_stack.loops ) ;
+	POP_stack(crt_loop_stack, func_stack.loops);
-    POP_nspace ( label_namespace, func_stack.labels ) ;
+	POP_nspace(label_namespace, func_stack.labels);
-    POP_list ( all_solve_stmts, func_stack.solves ) ;
+	POP_list(all_solve_stmts, func_stack.solves);
-    POP_list ( all_try_blocks, func_stack.tries ) ;
+	POP_list(all_try_blocks, func_stack.tries);
-    POP_ulong ( n, func_stack.opts ) ;
+	POP_ulong(n, func_stack.opts);
-    crt_option_value ( OPT_VAL_nested_class ) = n ;
+	crt_option_value(OPT_VAL_nested_class) = n;
-    POP_ulong ( n, func_stack.opts ) ;
+	POP_ulong(n, func_stack.opts);
-    crt_option_value ( OPT_VAL_statement_depth ) = n ;
+	crt_option_value(OPT_VAL_statement_depth) = n;
-    crt_func_complex = pass_complex_type ( ret ) ;
+	crt_func_complex = pass_complex_type(ret);
-    crt_func_return = ret ;
+	crt_func_return = ret;
-    block_namespace = NULL_nspace ;
+	block_namespace = NULL_nspace;
-    suppress_variable = 0 ;
+	suppress_variable = 0;
-    unreached_last = 0 ;
+	unreached_last = 0;
-    return ( body ) ;
+	return (body);
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/producers/common/construct/function.c – Rev 5 → 6