WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/construct/identifier.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.
 */
     This flag may be set to true to indicate that the parser is in a sizeof
     expression or similar so that any usages should not be included.
 */
-int suppress_usage = 0 ;
+int suppress_usage = 0;
 /*
     MARK AN IDENTIFIER AS BEING USED
     This routine marks the identifier id as having been used and checks
     any access controls.
 */
-void use_id
+void
-    PROTO_N ( ( id, suppress ) )
-    PROTO_T ( IDENTIFIER id X int suppress )
+use_id(IDENTIFIER id, int suppress)
+{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    if ( acc ) check_access ( id, acc ) ;
+	if (acc)check_access(id, acc);
+	/* Check usage */
+	if (ds & dspec_main) {
+		HASHID nm = DEREF_hashid(id_name(id));
+		switch (TAG_hashid(nm)) {
+		case hashid_name_tag:
+			/* Can't take the address of 'main' */
+			report(crt_loc, ERR_basic_start_main_addr(id));
+			break;
+		case hashid_constr_tag:
+			/* Can't take the address of a constructor */
+			report(crt_loc, ERR_class_ctor_addr(id));
+			break;
+		case hashid_destr_tag:
+			/* Can't take the address of a destructor */
+			report(crt_loc, ERR_class_dtor_addr(id));
+			break;
+		}
+	}
-    /* Check usage */
-    if ( ds & dspec_main ) {
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-	switch ( TAG_hashid ( nm ) ) {
-	    case hashid_name_tag : {
-		/* Can't take the address of 'main' */
-		report ( crt_loc, ERR_basic_start_main_addr ( id ) ) ;
-		break ;
-	    }
-	    case hashid_constr_tag : {
-		/* Can't take the address of a constructor */
-		report ( crt_loc, ERR_class_ctor_addr ( id ) ) ;
-		break ;
-	    }
-	    case hashid_destr_tag : {
-		/* Can't take the address of a destructor */
-		report ( crt_loc, ERR_class_dtor_addr ( id ) ) ;
-		break ;
-	    }
-	}
-    }
-    /* Mark use */
-    if ( !( ds & dspec_used ) ) {
-	if ( !suppress ) {
-	    ds |= dspec_used ;
-	    COPY_dspec ( id_storage ( id ), ds ) ;
-	}
-	if ( ds & ( dspec_inherit | dspec_alias | dspec_extern ) ) {
-	    /* Check for inheritance */
-	    IDENTIFIER uid = DEREF_id ( id_alias ( id ) ) ;
-	    if ( !EQ_id ( uid, id ) ) {
-		ds = DEREF_dspec ( id_storage ( uid ) ) ;
-		if ( ds & dspec_used ) {
-		    if ( do_usage ) dump_use ( id, &crt_loc, 1 ) ;
-		    return ;
-		}
-		if ( !suppress ) {
-		    ds |= dspec_used ;
-		    COPY_dspec ( id_storage ( uid ), ds ) ;
-		}
-	    }
-	}
-	if ( !( ds & dspec_defn ) && ( ds & dspec_instance ) ) {
-	    /* Define template instance */
-	    if ( !suppress ) define_template ( id, 0 ) ;
-	}
-    }
-    if ( do_usage ) dump_use ( id, &crt_loc, 1 ) ;
-    return ;
-}
-/*
-    MARK A FUNCTION IDENTIFIER AS BEING USED
-    This routine marks the function identifier id as having been called
-    and checks any access controls.  In addition certain checks are applied
-    to the first call of an identifier.  expl is true for explicit calls.
-*/
-void use_func_id
-    PROTO_N ( ( id, expl, suppress ) )
-    PROTO_T ( IDENTIFIER id X int expl X int suppress )
-{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-    DECL_SPEC acc = ( ds & dspec_access ) ;
-    if ( acc ) check_access ( id, acc ) ;
-    if ( !( ds & dspec_called ) ) {
 	/* Mark use */
-	if ( !suppress ) {
-	    if ( !( ds & dspec_virtual ) ) ds |= dspec_used ;
-	    ds |= dspec_called ;
-	    COPY_dspec ( id_storage ( id ), ds ) ;
-	}
-	/* Check for inheritance */
-	if ( ds & ( dspec_inherit | dspec_alias | dspec_extern ) ) {
-	    IDENTIFIER uid = DEREF_id ( id_alias ( id ) ) ;
-	    if ( !EQ_id ( uid, id ) ) {
-		ds = DEREF_dspec ( id_storage ( uid ) ) ;
-		if ( ds & dspec_called ) {
+	if (!(ds & dspec_used)) {
-		    if ( do_usage ) dump_call ( id, &crt_loc, expl ) ;
-		    return ;
-		}
-		if ( !suppress ) {
+		if (!suppress) {
-		    if ( !( ds & dspec_virtual ) ) ds |= dspec_used ;
-		    ds |= dspec_called ;
+			ds |= dspec_used;
-		    COPY_dspec ( id_storage ( uid ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
+		}
-	    }
+		if (ds & (dspec_inherit | dspec_alias | dspec_extern)) {
-	}
-	/* Check usage */
+			/* Check for inheritance */
+			IDENTIFIER uid = DEREF_id(id_alias(id));
-	if ( ds & dspec_main ) {
+			if (!EQ_id(uid, id)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				ds = DEREF_dspec(id_storage(uid));
-	    if ( IS_hashid_name ( nm ) ) {
+				if (ds & dspec_used) {
-		/* Can't call 'main' */
+					if (do_usage) {
-		report ( crt_loc, ERR_basic_start_main_call ( id ) ) ;
+						dump_use(id, &crt_loc, 1);
-	    }
+					}
+					return;
-	}
+				}
-	if ( !( ds & dspec_defn ) && !suppress ) {
+				if (!suppress) {
-	    if ( ds & dspec_implicit ) {
+					ds |= dspec_used;
-		/* Define implicitly declared function */
-		implicit_defn ( id, DEFAULT_USR ) ;
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
+					COPY_dspec(id_storage(uid), ds);
-	    } else if ( ds & dspec_instance ) {
-		/* Define template function */
+				}
-		if ( !( ds & dspec_virtual ) ) {
-		    define_template ( id, 0 ) ;
+			}
-		    ds = DEREF_dspec ( id_storage ( id ) ) ;
+		}
-	    }
-	    if ( ( ds & dspec_inline ) && !( ds & dspec_defn ) ) {
+		if (!(ds & dspec_defn) && (ds & dspec_instance)) {
-		/* An inline function called before it is defined */
+			/* Define template instance */
+			if (!suppress) {
-		report ( crt_loc, ERR_dcl_fct_spec_inline_call ( id ) ) ;
+				define_template(id, 0);
-	    }
+			}
+		}
+	}
+	if (do_usage) {
+		dump_use(id, &crt_loc, 1);
+	}
+	return;
+}
+/*
+    MARK A FUNCTION IDENTIFIER AS BEING USED
+    This routine marks the function identifier id as having been called
+    and checks any access controls.  In addition certain checks are applied
+    to the first call of an identifier.  expl is true for explicit calls.
+*/
+void
+use_func_id(IDENTIFIER id, int expl, int suppress)
+{
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
+	DECL_SPEC acc = (ds & dspec_access);
+	if (acc) {
+		check_access(id, acc);
+	}
+	if (!(ds & dspec_called)) {
+		/* Mark use */
+		if (!suppress) {
+			if (!(ds & dspec_virtual)) {
+				ds |= dspec_used;
+			}
+			ds |= dspec_called;
+			COPY_dspec(id_storage(id), ds);
+		}
+		/* Check for inheritance */
+		if (ds & (dspec_inherit | dspec_alias | dspec_extern)) {
+			IDENTIFIER uid = DEREF_id(id_alias(id));
+			if (!EQ_id(uid, id)) {
+				ds = DEREF_dspec(id_storage(uid));
+				if (ds & dspec_called) {
+					if (do_usage) {
+						dump_call(id, &crt_loc, expl);
+					}
+					return;
+				}
+				if (!suppress) {
+					if (!(ds & dspec_virtual)) {
+						ds |= dspec_used;
+					}
+					ds |= dspec_called;
+					COPY_dspec(id_storage(uid), ds);
+				}
+			}
+		}
+		/* Check usage */
+		if (ds & dspec_main) {
+			HASHID nm = DEREF_hashid(id_name(id));
+			if (IS_hashid_name(nm)) {
+				/* Can't call 'main' */
+				report(crt_loc, ERR_basic_start_main_call(id));
+			}
+		}
+		if (!(ds & dspec_defn) && !suppress) {
+			if (ds & dspec_implicit) {
+				/* Define implicitly declared function */
+				implicit_defn(id, DEFAULT_USR);
+				ds = DEREF_dspec(id_storage(id));
+			} else if (ds & dspec_instance) {
+				/* Define template function */
+				if (!(ds & dspec_virtual)) {
+					define_template(id, 0);
+					ds = DEREF_dspec(id_storage(id));
-    }
+				}
+			}
+			if ((ds & dspec_inline) && !(ds & dspec_defn)) {
+				/* An inline function called before it is
+				 * defined */
+				report(crt_loc,
+				       ERR_dcl_fct_spec_inline_call(id));
+			}
+		}
+	}
+	if (do_usage) {
-    if ( do_usage ) dump_call ( id, &crt_loc, expl ) ;
+		dump_call(id, &crt_loc, expl);
+	}
-    return ;
+	return;
+}
 /*
     MARK A VIRTUAL FUNCTION AS BEING USED
     used because the actual function called can only be determined at
     run-time.  If subsequently it is found that the function called can
     be determined statically then this routine is called to mark that
     function as having been used.  It is also used in certain similar
     situations.
 */
-void reuse_id
+void
-    PROTO_N ( ( id, suppress ) )
-    PROTO_T ( IDENTIFIER id X int suppress )
+reuse_id(IDENTIFIER id, int suppress)
 {
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( !( ds & dspec_used ) && !suppress ) {
+	if (!(ds & dspec_used) && !suppress) {
-	ds |= dspec_used ;
+		ds |= dspec_used;
-	COPY_dspec ( id_storage ( id ), ds ) ;
+		COPY_dspec(id_storage(id), ds);
-	if ( !( ds & dspec_defn ) ) {
+		if (!(ds & dspec_defn)) {
-	    if ( ds & dspec_implicit ) {
+			if (ds & dspec_implicit) {
-		/* Define implicitly declared function */
+				/* Define implicitly declared function */
-		implicit_defn ( id, DEFAULT_USR ) ;
+				implicit_defn(id, DEFAULT_USR);
-	    } else if ( ds & dspec_instance ) {
+			} else if (ds & dspec_instance) {
-		/* Instantiate template functions */
+				/* Instantiate template functions */
-		define_template ( id, 0 ) ;
+				define_template(id, 0);
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
+}
 /*
     DEFINE AN IDENTIFIER ALIAS
     This routine is called if the function or variable id is defined
     (excluding tentative definitions).  It passes the definition on to
     any alias of id.
 */
-void define_id
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+define_id(IDENTIFIER id)
 {
-    IDENTIFIER lid = DEREF_id ( id_alias ( id ) ) ;
+	IDENTIFIER lid = DEREF_id(id_alias(id));
-    if ( !EQ_id ( lid, id ) ) {
+	if (!EQ_id(lid, id)) {
-	/* Check for previous definition */
+		/* Check for previous definition */
-	LOCATION loc ;
+		LOCATION loc;
-	DECL_SPEC ds ;
+		DECL_SPEC ds;
-	DEREF_loc ( id_loc ( id ), loc ) ;
+		DEREF_loc(id_loc(id), loc);
-	ds = DEREF_dspec ( id_storage ( lid ) ) ;
+		ds = DEREF_dspec(id_storage(lid));
-	if ( ds & dspec_defn ) {
+		if (ds & dspec_defn) {
-	    EXP e = DEREF_exp ( id_variable_etc_init ( lid ) ) ;
+			EXP e = DEREF_exp(id_variable_etc_init(lid));
-	    if ( IS_NULL_exp ( e ) || !IS_exp_zero ( e ) ) {
+			if (IS_NULL_exp(e) || !IS_exp_zero(e)) {
-		/* Exclude previous tentative definitions */
+				/* Exclude previous tentative definitions */
-		PTR ( LOCATION ) ploc = id_loc ( lid ) ;
+				PTR(LOCATION)ploc = id_loc(lid);
-		ERROR err = ERR_basic_odr_def ( lid, ploc ) ;
+				ERROR err = ERR_basic_odr_def(lid, ploc);
-		if ( ds & dspec_c ) {
+				if (ds & dspec_c) {
-		    /* Explain C linkage identifications */
+					/* Explain C linkage identifications */
-		    HASHID nm = DEREF_hashid ( id_name ( lid ) ) ;
+					HASHID nm = DEREF_hashid(id_name(lid));
+					ERROR err2 =
-		    ERROR err2 = ERR_dcl_link_redecl ( nm, ploc ) ;
+					    ERR_dcl_link_redecl(nm, ploc);
-		    err = concat_error ( err, err2 ) ;
+					err = concat_error(err, err2);
-		}
+				}
-		report ( loc, err ) ;
+				report(loc, err);
-	    }
+			}
-	}
+		}
-	/* Copy definition */
+		/* Copy 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));
-	    COPY_exp ( id_function_etc_defn ( lid ), e ) ;
+			COPY_exp(id_function_etc_defn(lid), e);
-	} else if ( IS_id_variable_etc ( id ) ) {
+		} else if (IS_id_variable_etc(id)) {
-	    TYPE t = DEREF_type ( id_variable_etc_type ( id ) ) ;
+			TYPE t = DEREF_type(id_variable_etc_type(id));
-	    EXP e = DEREF_exp ( id_variable_etc_init ( id ) ) ;
+			EXP e = DEREF_exp(id_variable_etc_init(id));
-	    EXP d = DEREF_exp ( id_variable_etc_term ( id ) ) ;
+			EXP d = DEREF_exp(id_variable_etc_term(id));
-	    COPY_exp ( id_variable_etc_init ( lid ), e ) ;
+			COPY_exp(id_variable_etc_init(lid), e);
-	    COPY_exp ( id_variable_etc_term ( lid ), d ) ;
+			COPY_exp(id_variable_etc_term(lid), d);
-	    COPY_type ( id_variable_etc_type ( lid ), t ) ;
+			COPY_type(id_variable_etc_type(lid), t);
-	}
+		}
-	/* Record definition */
+		/* Record definition */
-	ds |= dspec_defn ;
+		ds |= dspec_defn;
-	COPY_dspec ( id_storage ( lid ), ds ) ;
+		COPY_dspec(id_storage(lid), ds);
-	DEREF_loc ( id_loc ( lid ), loc ) ;
+		DEREF_loc(id_loc(lid), loc);
-    }
+	}
-    return ;
+	return;
 }
 /*
     FIND THE END OF A LIST OF IDENTIFIER ALIASES
     In most cases the alias of an identifier is its underlying meaning,
     however for function parameters it is possible to have vast lists
     of identifiers arising from redeclarations all linked by their alias
     field.  This routine scans down such a list until it finds an identifier
     which is its own alias.
 */
-IDENTIFIER chase_alias
+IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+chase_alias(IDENTIFIER id)
+{
-    while ( !IS_NULL_id ( id ) ) {
+	while (!IS_NULL_id(id)) {
-	IDENTIFIER lid = DEREF_id ( id_alias ( id ) ) ;
+		IDENTIFIER lid = DEREF_id(id_alias(id));
-	if ( EQ_id ( lid, id ) ) break ;
+		if (EQ_id(lid, id)) {
+			break;
+		}
-	id = lid ;
+		id = lid;
-    }
+	}
-    return ( id ) ;
+	return (id);
+}
 /*
     CURRENT IDENTIFIER QUALIFIER
     This variable is set to describe how the current identifier is
     qualified.
 */
-QUALIFIER crt_id_qualifier = qual_none ;
+QUALIFIER crt_id_qualifier = qual_none;
-int crt_templ_qualifier = 0 ;
+int crt_templ_qualifier = 0;
 /*
     CHECK AN IDENTIFIER NAME
     This routine checks whether the identifier name id is suitable for use
     in the context given by loc.  The namespace qualifiers used in describing
     id will be given by crt_id_qualifier.  The routine returns true for
     legal identifiers.
 */
-ERROR check_id_name
+ERROR
-    PROTO_N ( ( id, loc ) )
-    PROTO_T ( IDENTIFIER id X int loc )
+check_id_name(IDENTIFIER id, int loc)
 {
-    /* Check on namespace component */
+	/* Check on namespace component */
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    switch ( cq ) {
+	switch (cq) {
-	case qual_none : {
+	case qual_none: {
-	    /* No namespace specifier */
+		/* No namespace specifier */
-	    if ( in_template_decl && is_templ_alias ( id ) ) {
+		if (in_template_decl && is_templ_alias(id)) {
-		/* Check for hiding of template parameters */
+			/* Check for hiding of template parameters */
-		err = ERR_temp_local_hide ( id ) ;
+			err = ERR_temp_local_hide(id);
-		if ( !IS_NULL_err ( err ) ) return ( err ) ;
+			if (!IS_NULL_err(err)) {
+				return (err);
-	    }
+			}
+		}
-	    if ( crt_templ_qualifier ) goto qualifier_lab ;
+		if (crt_templ_qualifier) {
+			goto qualifier_lab;
+		}
-	    break ;
+		break;
 	}
-	case qual_nested :
+	case qual_nested:
-	qualifier_lab : {
+qualifier_lab:
-	    /* Nested namespace specifier */
+		/* Nested namespace specifier */
-	    if ( loc == CONTEXT_PARAMETER || loc == CONTEXT_TEMPL_PARAM ) {
+		if (loc == CONTEXT_PARAMETER || loc == CONTEXT_TEMPL_PARAM) {
-		err = ERR_dcl_meaning_id ( cq, id ) ;
+			err = ERR_dcl_meaning_id(cq, id);
-		if ( !IS_NULL_err ( err ) ) return ( err ) ;
+			if (!IS_NULL_err(err)) {
+				return (err);
-	    }
+			}
-	    break ;
-	}
+		}
+		break;
-	case qual_full :
+	case qual_full:
-	case qual_top : {
+	case qual_top:
-	    /* Namespace specifier beginning with '::' */
+		/* Namespace specifier beginning with '::' */
-	    err = ERR_dcl_meaning_full ( cq, id ) ;
+		err = ERR_dcl_meaning_full(cq, id);
-	    if ( !IS_NULL_err ( err ) ) return ( err ) ;
+		if (!IS_NULL_err(err)) {
-	    goto qualifier_lab ;
+			return (err);
-	}
+		}
+		goto qualifier_lab;
-    }
+	}
-    /* Check on name component */
+	/* Check on name component */
-    if ( loc != CONTEXT_FUNCTION && loc != CONTEXT_FUNC_MEMBER ) {
+	if (loc != CONTEXT_FUNCTION && loc != CONTEXT_FUNC_MEMBER) {
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		HASHID nm = DEREF_hashid(id_name(id));
-	switch ( TAG_hashid ( nm ) ) {
+		switch (TAG_hashid(nm)) {
-	    case hashid_constr_tag : {
+		case hashid_constr_tag:
-		/* A constructor must be a member function */
+			/* A constructor must be a member function */
-		err = ERR_class_mem_ctor ( id ) ;
+			err = ERR_class_mem_ctor(id);
-		break ;
+			break;
-	    }
-	    case hashid_destr_tag : {
+		case hashid_destr_tag:
-		/* A destructor must be a member function */
+			/* A destructor must be a member function */
-		err = ERR_class_dtor_func ( nm ) ;
+			err = ERR_class_dtor_func(nm);
-		break ;
+			break;
-	    }
-	    case hashid_conv_tag :
+		case hashid_conv_tag:
-	    case hashid_op_tag : {
+		case hashid_op_tag:
-		/* These must be functions */
+			/* These must be functions */
-		err = ERR_dcl_meaning_id ( cq, id ) ;
+			err = ERR_dcl_meaning_id(cq, id);
-		break ;
+			break;
-	    }
+		}
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     DECLARE AN IMPLICIT FUNCTION
     This routine declares a function named id in the current scope with
     declaration specifiers ds, return type ret (which may be the null type),
     parameter types p (terminated by the null type), and function kind ell.
     It is used to declare implicit functions.
 */
-IDENTIFIER declare_func
+IDENTIFIER
-    PROTO_N ( ( ds, id, ret, p, ell, ex ) )
-    PROTO_T ( DECL_SPEC ds X IDENTIFIER id X TYPE ret X TYPE *p X
+declare_func(DECL_SPEC ds, IDENTIFIER id, TYPE ret, TYPE *p, int ell,
-	      int ell X LIST ( TYPE ) ex )
+	     LIST(TYPE) ex)
+{
-    /* Save certain information */
+	/* Save certain information */
-    TYPE t ;
+	TYPE t;
-    CV_SPEC cv ;
+	CV_SPEC cv;
-    DECL_SPEC acc = crt_access ;
+	DECL_SPEC acc = crt_access;
-    int td = have_type_declaration ;
+	int td = have_type_declaration;
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    int tq = crt_templ_qualifier ;
+	int tq = crt_templ_qualifier;
-    crt_access = dspec_public ;
+	crt_access = dspec_public;
-    crt_id_qualifier = qual_none ;
+	crt_id_qualifier = qual_none;
-    crt_templ_qualifier = 0 ;
+	crt_templ_qualifier = 0;
-    have_type_declaration = TYPE_DECL_NONE ;
+	have_type_declaration = TYPE_DECL_NONE;
-    /* Declare parameters */
+	/* Declare parameters */
-    decl_loc = crt_loc ;
+	decl_loc = crt_loc;
-    begin_param ( id ) ;
+	begin_param(id);
-    while ( !IS_NULL_type ( *p ) ) {
+	while (!IS_NULL_type(*p)) {
-	HASHID nm = lookup_anon () ;
+		HASHID nm = lookup_anon();
-        IDENTIFIER pid = DEREF_id ( hashid_id ( nm ) ) ;
+		IDENTIFIER pid = DEREF_id(hashid_id(nm));
-        pid = make_param_decl ( dspec_none, *p, pid, CONTEXT_PARAMETER ) ;
+		pid = make_param_decl(dspec_none, *p, pid, CONTEXT_PARAMETER);
-        init_param ( pid, NULL_exp ) ;
+		init_param(pid, NULL_exp);
-	p++ ;
+		p++;
-    }
+	}
-    if ( IS_NULL_type ( ret ) ) ret = type_inferred ;
+	if (IS_NULL_type(ret)) {
+		ret = type_inferred;
+	}
-    cv = func_linkage ( cv_none ) ;
+	cv = func_linkage(cv_none);
-    t = make_func_type ( ret, ell, cv, ex ) ;
+	t = make_func_type(ret, ell, cv, ex);
-    end_param () ;
+	end_param();
-    /* Declare the function */
+	/* Declare the function */
-    if ( in_class_defn ) {
+	if (in_class_defn) {
 #if LANGUAGE_CPP
-	if ( ds & dspec_friend ) {
+		if (ds & dspec_friend) {
-	    id = make_friend_decl ( ds, t, id, 0, 1 ) ;
+			id = make_friend_decl(ds, t, id, 0, 1);
-	} else {
+		} else {
-	    id = make_func_mem_decl ( ds, t, id, 0 ) ;
+			id = make_func_mem_decl(ds, t, id, 0);
-	}
+		}
 #else
-	id = make_member_decl ( ds, t, id, 0 ) ;
+		id = make_member_decl(ds, t, id, 0);
 #endif
-    } else {
+	} else {
-	id = make_func_decl ( ds, t, id, 0 ) ;
+		id = make_func_decl(ds, t, id, 0);
-    }
+	}
-    if ( do_dump ) {
+	if (do_dump) {
-	dump_implicit = 1 ;
+		dump_implicit = 1;
-	dump_declare ( id, &decl_loc, 0 ) ;
+		dump_declare(id, &decl_loc, 0);
-    }
+	}
-    have_type_declaration = td ;
+	have_type_declaration = td;
-    crt_templ_qualifier = tq ;
+	crt_templ_qualifier = tq;
-    crt_id_qualifier = cq ;
+	crt_id_qualifier = cq;
-    crt_access = acc ;
+	crt_access = acc;
-    return ( id ) ;
+	return (id);
+}
 /*
     IMPLICITLY DECLARE AN IDENTIFIER
     This routine implicitly declares an identifier id, either as a local
     variable, if fn is false, or as a function.  fn will be 2 in the cases
     where C allows an implicit function declaration.  The routine returns
     the corresponding identifier expression.
 */
-EXP implicit_id_exp
+EXP
-    PROTO_N ( ( id, fn ) )
-    PROTO_T ( IDENTIFIER id X int fn )
+implicit_id_exp(IDENTIFIER id, int fn)
 {
-    EXP e ;
+	EXP e;
-    ERROR err ;
+	ERROR err;
-    LOCATION loc ;
+	LOCATION loc;
-    DECL_SPEC ds ;
+	DECL_SPEC ds;
-    IDENTIFIER pid ;
+	IDENTIFIER pid;
-    DECL_SPEC cl = crt_linkage ;
+	DECL_SPEC cl = crt_linkage;
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    int tq = crt_templ_qualifier ;
+	int tq = crt_templ_qualifier;
-    NAMESPACE cns = crt_namespace ;
+	NAMESPACE cns = crt_namespace;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+	NAMESPACE ns = DEREF_nspace(id_parent(id));
-    /* Check for implicit function declarations */
+	/* Check for implicit function declarations */
-    if ( fn == 2 && option ( OPT_func_impl ) == OPTION_DISALLOW ) fn = 1 ;
+	if (fn == 2 && option(OPT_func_impl) == OPTION_DISALLOW) {
+		fn = 1;
+	}
-    /* Allow for template dependent declarations */
+	/* Allow for template dependent declarations */
-    if ( in_template_decl && is_templ_nspace ( cns ) ) {
+	if (in_template_decl && is_templ_nspace(cns)) {
-	int opt = OPT_templ_undecl ;
+		int opt = OPT_templ_undecl;
-	OPTION sev = option ( opt ) ;
+		OPTION sev = option(opt);
-	if ( sev != OPTION_ALLOW ) {
+		if (sev != OPTION_ALLOW) {
-	    /* Implicit declarations for dependent identifiers */
+			/* Implicit declarations for dependent identifiers */
-	    if ( dependent_id ( id ) ) {
+			if (dependent_id(id)) {
-		opt = OPT_none ;
+				opt = OPT_none;
-		sev = OPTION_ALLOW ;
+				sev = OPTION_ALLOW;
-	    }
+			}
-	}
+		}
-	if ( sev != OPTION_DISALLOW ) {
+		if (sev != OPTION_DISALLOW) {
-	    if ( sev != OPTION_ALLOW && fn != 2 ) {
+			if (sev != OPTION_ALLOW && fn != 2) {
-		if ( cq == qual_none ) {
+				if (cq == qual_none) {
-		    err = ERR_lookup_unqual_undef ( nm ) ;
+					err = ERR_lookup_unqual_undef(nm);
-		} else {
+				} else {
-		    err = ERR_lookup_qual_undef ( nm, ns ) ;
+					err = ERR_lookup_qual_undef(nm, ns);
-		}
+				}
-		err = set_severity ( err, opt, 0 ) ;
+				err = set_severity(err, opt, 0);
-		report ( crt_loc, err ) ;
+				report(crt_loc, err);
-	    }
+			}
-	    MAKE_exp_undeclared ( type_templ_param, id, cq, e ) ;
+			MAKE_exp_undeclared(type_templ_param, id, cq, e);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-	if ( cq == qual_none ) ns = NULL_nspace ;
+		if (cq == qual_none) {
+			ns = NULL_nspace;
-    }
+		}
+	}
-    /* Check for previous declaration */
+	/* Check for previous declaration */
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	OPTION sev = option ( OPT_decl_unify ) ;
+		OPTION sev = option(OPT_decl_unify);
-	if ( sev != OPTION_OFF ) {
+		if (sev != OPTION_OFF) {
-	    LIST ( IDENTIFIER ) p ;
+			LIST(IDENTIFIER)p;
-	    NAMESPACE pns = nonblock_namespace ;
+			NAMESPACE pns = nonblock_namespace;
-	    p = DEREF_list ( nspace_named_etc_extra ( pns ) ) ;
+			p = DEREF_list(nspace_named_etc_extra(pns));
-	    pid = unify_extern ( id, NULL_type, pns, p ) ;
+			pid = unify_extern(id, NULL_type, pns, p);
-	    if ( !IS_NULL_id ( pid ) ) {
+			if (!IS_NULL_id(pid)) {
-		if ( sev != OPTION_ON ) {
+				if (sev != OPTION_ON) {
-		    err = ERR_lookup_unqual_vis ( pid ) ;
+					err = ERR_lookup_unqual_vis(pid);
-		    err = set_severity ( err, OPT_decl_unify, 0 ) ;
+					err = set_severity(err, OPT_decl_unify,
+);
-		    report ( crt_loc, err ) ;
+					report(crt_loc, err);
-		}
+				}
-		e = make_id_exp ( pid ) ;
+				e = make_id_exp(pid);
-		return ( e ) ;
+				return (e);
-	    }
+			}
-	}
+		}
-	ns = cns ;
+		ns = cns;
-    }
+	}
-    /* Rescan identifier */
+	/* Rescan identifier */
-    pid = search_id ( ns, nm, 0, 0 ) ;
+	pid = search_id(ns, nm, 0, 0);
-    if ( !IS_NULL_id ( pid ) ) {
+	if (!IS_NULL_id(pid)) {
-	switch ( TAG_id ( pid ) ) {
+		switch (TAG_id(pid)) {
-	    case id_variable_tag :
+		case id_variable_tag:
-	    case id_function_tag : {
+		case id_function_tag: {
-		e = make_id_exp ( pid ) ;
+			e = make_id_exp(pid);
-		return ( e ) ;
+			return (e);
-	    }
+		}
-	}
+		}
-    }
+	}
-    /* Find namespace for declaration */
+	/* Find namespace for declaration */
-    crt_linkage = dspec_c ;
+	crt_linkage = dspec_c;
-    crt_id_qualifier = qual_none ;
+	crt_id_qualifier = qual_none;
-    crt_templ_qualifier = 0 ;
+	crt_templ_qualifier = 0;
-    push_namespace ( ns ) ;
+	push_namespace(ns);
-    bad_crt_loc++ ;
+	bad_crt_loc++;
-    loc = crt_loc ;
+	loc = crt_loc;
-    if ( crt_state_depth == 0 ) {
+	if (crt_state_depth == 0) {
-	/* Find identifier location */
+		/* Find identifier location */
-	IDENTIFIER uid = underlying_id ( id ) ;
+		IDENTIFIER uid = underlying_id(id);
-	DEREF_loc ( id_loc ( uid ), crt_loc ) ;
+		DEREF_loc(id_loc(uid), crt_loc);
-    }
+	}
-    if ( fn ) {
+	if (fn) {
-	/* Implicit functions declarations */
+		/* Implicit functions declarations */
-	int ell ;
+		int ell;
-	TYPE ret = type_sint ;
+		TYPE ret = type_sint;
-	TYPE pars = NULL_type ;
+		TYPE pars = NULL_type;
 #if LANGUAGE_CPP
-	/* Type is 'int ( ... )' in C++ */
+		/* Type is 'int ( ... )' in C++ */
-	ell = FUNC_ELLIPSIS ;
+		ell = FUNC_ELLIPSIS;
+		if (fn == 1) {
-	if ( fn == 1 ) ret = type_error ;
+			ret = type_error;
+		}
 #else
-	/* Type is 'int ()' in C */
+		/* Type is 'int ()' in C */
-	ell = FUNC_NO_PARAMS ;
+		ell = FUNC_NO_PARAMS;
 #endif
-	ds = ( dspec_extern | dspec_ignore ) ;
+		ds = (dspec_extern | dspec_ignore);
-	id = declare_func ( ds, id, ret, &pars, ell, empty_type_set ) ;
+		id = declare_func(ds, id, ret, &pars, ell, empty_type_set);
-    } else {
+	} else {
-	/* Other implicit declarations */
+		/* Other implicit declarations */
-	decl_loc = crt_loc ;
+		decl_loc = crt_loc;
-	id = make_object_decl ( dspec_none, type_error, id, 0 ) ;
+		id = make_object_decl(dspec_none, type_error, id, 0);
-	IGNORE init_object ( id, NULL_exp ) ;
+		IGNORE init_object(id, NULL_exp);
-    }
-    /* Report error */
-    crt_linkage = cl ;
-    crt_templ_qualifier = tq ;
-    crt_id_qualifier = cq ;
-    if ( fn == 2 ) {
-	pid = DEREF_id ( id_alias ( id ) ) ;
-	ds = DEREF_dspec ( id_storage ( pid ) ) ;
-	if ( ds & dspec_temp ) {
-	    /* Implicit declaration already reported */
-	    err = NULL_err ;
-	} else {
-	    err = ERR_expr_call_undecl ( id ) ;
-	    if ( !IS_NULL_err ( err ) ) {
-		ds |= dspec_temp ;
-		COPY_dspec ( id_storage ( pid ), ds ) ;
-	    }
+	}
+	/* Report error */
+	crt_linkage = cl;
+	crt_templ_qualifier = tq;
+	crt_id_qualifier = cq;
+	if (fn == 2) {
+		pid = DEREF_id(id_alias(id));
+		ds = DEREF_dspec(id_storage(pid));
+		if (ds & dspec_temp) {
+			/* Implicit declaration already reported */
+			err = NULL_err;
+		} else {
+			err = ERR_expr_call_undecl(id);
+			if (!IS_NULL_err(err)) {
+				ds |= dspec_temp;
+				COPY_dspec(id_storage(pid), ds);
+			}
+		}
-    } else if ( cq == qual_none ) {
+	} else if (cq == qual_none) {
-	err = ERR_lookup_unqual_undef ( nm ) ;
+		err = ERR_lookup_unqual_undef(nm);
-    } else {
+	} else {
-	err = ERR_lookup_qual_undef ( nm, ns ) ;
+		err = ERR_lookup_qual_undef(nm, ns);
-    }
+	}
-    report ( crt_loc, err ) ;
+	report(crt_loc, err);
-    /* Construct the result */
+	/* Construct the result */
-    crt_loc = loc ;
+	crt_loc = loc;
-    bad_crt_loc-- ;
+	bad_crt_loc--;
-    IGNORE pop_namespace () ;
+	IGNORE pop_namespace();
-    e = make_id_exp ( id ) ;
+	e = make_id_exp(id);
-    return ( e ) ;
+	return (e);
 }
 /*
     LIST OF MEANINGS
     This list is built up by list_ambiguous to give all the meanings of
     its ambiguous identifier which match its type argument.
 */
-static LIST ( IDENTIFIER ) ambig_meanings = NULL_list ( IDENTIFIER ) ;
+static LIST(IDENTIFIER) ambig_meanings = NULL_list(IDENTIFIER);
 /*
     LIST MEANINGS OF AN AMBIGUOUS IDENTIFIER
     This routine adds all meanings of the ambiguous identifier id to the
     error list err.
 */
-static unsigned list_ambiguous
+static unsigned
-    PROTO_N ( ( id, n, err, type, rec ) )
-    PROTO_T ( IDENTIFIER id X unsigned n X ERROR *err X int type X int rec )
+list_ambiguous(IDENTIFIER id, unsigned n, ERROR *err, int type, int rec)
+{
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_ambig_tag : {
+		case id_ambig_tag: {
-		/* Ambiguous identifiers */
+			/* Ambiguous identifiers */
-		LIST ( IDENTIFIER ) p = DEREF_list ( id_ambig_ids ( id ) ) ;
+			LIST(IDENTIFIER) p = DEREF_list(id_ambig_ids(id));
-		rec = DEREF_int ( id_ambig_over ( id ) ) ;
+			rec = DEREF_int(id_ambig_over(id));
-		while ( !IS_NULL_list ( p ) ) {
+			while (!IS_NULL_list(p)) {
-		    id = DEREF_id ( HEAD_list ( p ) ) ;
+				id = DEREF_id(HEAD_list(p));
-		    n = list_ambiguous ( id, n, err, type, rec ) ;
+				n = list_ambiguous(id, n, err, type, rec);
-		    p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
+			}
+			break;
+		}
+		case id_function_tag:
+		case id_mem_func_tag:
+		case id_stat_mem_func_tag: {
+			/* Functions */
+			if (rec) {
+				IDENTIFIER over;
+				over = DEREF_id(id_function_etc_over(id));
+				n = list_ambiguous(over, n, err, type, rec);
+			}
+			goto default_lab;
+		}
+		case id_class_name_tag:
+		case id_class_alias_tag:
+		case id_enum_name_tag:
+		case id_enum_alias_tag:
+		case id_type_alias_tag: {
+			/* Types */
+			type = 0;
+			goto default_lab;
+		}
-		break ;
+		default:
-	    }
+default_lab: {
-	    case id_function_tag :
+		     /* Other identifiers */
-	    case id_mem_func_tag :
+		     PTR(LOCATION) loc = id_loc(id);
+		     n++;
-	    case id_stat_mem_func_tag : {
+		     add_error(err, ERR_fail_list_item(n, id, loc));
-		/* Functions */
+		     break;
-		if ( rec ) {
+	     }
+		}
-		    IDENTIFIER over ;
+		if (type == 0) {
-		    over = DEREF_id ( id_function_etc_over ( id ) ) ;
+			/* Add to list of meanings */
-		    n = list_ambiguous ( over, n, err, type, rec ) ;
+			CONS_id(id, ambig_meanings, ambig_meanings);
+		}
-		goto default_lab ;
-	    }
-	    case id_class_name_tag :
-	    case id_class_alias_tag :
-	    case id_enum_name_tag :
-	    case id_enum_alias_tag :
-	    case id_type_alias_tag : {
-		/* Types */
-		type = 0 ;
-		goto default_lab ;
-	    }
-	    default :
-	    default_lab : {
-		/* Other identifiers */
-		PTR ( LOCATION ) loc = id_loc ( id ) ;
-		n++ ;
-		add_error ( err, ERR_fail_list_item ( n, id, loc ) ) ;
-		break ;
-	    }
-	}
-	if ( type == 0 ) {
-	    /* Add to list of meanings */
-	    CONS_id ( id, ambig_meanings, ambig_meanings ) ;
+	}
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     REPORT AN AMBIGUOUS IDENTIFIER
     This routine reports the identifier id as being ambiguous.  Overloaded
     functions count as a single identifier unless rec is true.  It returns
     one of the possible meanings.  Only types are considered if type is
     true.  If there is exactly one possible meaning or force is true the
     first meaning is returned.  Otherwise the null identifier is returned.
 */
-IDENTIFIER report_ambiguous
+IDENTIFIER
-    PROTO_N ( ( id, type, rec, force ) )
-    PROTO_T ( IDENTIFIER id X int type X int rec X int force )
+report_ambiguous(IDENTIFIER id, int type, int rec, int force)
 {
-    ERROR err, err2 ;
+	ERROR err, err2;
-    LIST ( IDENTIFIER ) p ;
+	LIST(IDENTIFIER) p;
-    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+	NAMESPACE ns = DEREF_nspace(id_parent(id));
-    /* List all meanings */
+	/* List all meanings */
-    if ( !IS_NULL_nspace ( ns ) && IS_nspace_ctype ( ns ) ) {
+	if (!IS_NULL_nspace(ns) && IS_nspace_ctype(ns)) {
-	err = ERR_lookup_ambig_mem ( id ) ;
+		err = ERR_lookup_ambig_mem(id);
-    } else {
+	} else {
-	err = ERR_lookup_ambig_id ( id ) ;
+		err = ERR_lookup_ambig_id(id);
-    }
+	}
-    err2 = ERR_lookup_ambig_list () ;
+	err2 = ERR_lookup_ambig_list();
-    if ( !IS_NULL_err ( err2 ) ) {
+	if (!IS_NULL_err(err2)) {
-	unsigned n = 0 ;
+		unsigned n = 0;
-	err = concat_error ( err, err2 ) ;
+		err = concat_error(err, err2);
-	n = list_ambiguous ( id, n, &err, type, rec ) ;
+		n = list_ambiguous(id, n, &err, type, rec);
-	err = concat_error ( err, ERR_fail_list_end ( n ) ) ;
+		err = concat_error(err, ERR_fail_list_end(n));
-    }
+	}
-    report ( crt_loc, err ) ;
+	report(crt_loc, err);
-    /* Check for resolved meaning */
+	/* Check for resolved meaning */
-    id = NULL_id ;
+	id = NULL_id;
-    p = ambig_meanings ;
+	p = ambig_meanings;
-    if ( !IS_NULL_list ( p ) ) {
+	if (!IS_NULL_list(p)) {
-	if ( IS_NULL_list ( TAIL_list ( p ) ) || force ) {
+		if (IS_NULL_list(TAIL_list(p)) || force) {
-	    id = DEREF_id ( HEAD_list ( p ) ) ;
+			id = DEREF_id(HEAD_list(p));
-	}
+		}
-	DESTROY_list ( p, SIZE_id ) ;
+		DESTROY_list(p, SIZE_id);
-	ambig_meanings = NULL_list ( IDENTIFIER ) ;
+		ambig_meanings = NULL_list(IDENTIFIER);
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     FIND THE DECLARATION SPECIFIER FOR AN AMBIGUOUS IDENTIFIER
     This routine finds the declaration specifier for an ambiguous identifier
     given by the list of cases pids.  This consists of various properties
     which all the cases share.
 */
-DECL_SPEC find_ambig_dspec
+DECL_SPEC
-    PROTO_N ( ( pids ) )
-    PROTO_T ( LIST ( IDENTIFIER ) pids )
+find_ambig_dspec(LIST(IDENTIFIER) pids)
+{
-    DECL_SPEC ds = ( dspec_implicit | dspec_template ) ;
+	DECL_SPEC ds = (dspec_implicit | dspec_template);
-    while ( !IS_NULL_list ( pids ) ) {
+	while (!IS_NULL_list(pids)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	if ( !IS_NULL_id ( pid ) ) {
+		if (!IS_NULL_id(pid)) {
-	    DECL_SPEC pds = DEREF_dspec ( id_storage ( pid ) ) ;
+			DECL_SPEC pds = DEREF_dspec(id_storage(pid));
-	    ds &= pds ;
+			ds &= pds;
-	}
-	pids = TAIL_list ( pids ) ;
-    }
-    return ( ds ) ;
-}
-/*
-    CREATE AN IDENTIFIER EXPRESSION
-    This routine creates an expression corresponding to the identifier id.
-    Note that static member functions are identifier expressions if they
-    are not overloaded, but member expression otherwise.  They are sorted
-    out properly during overload resolution (see resolve_cast).
-*/
-EXP make_id_exp
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
-{
-    EXP e ;
-    unsigned tag = TAG_id ( id ) ;
-    QUALIFIER cq = crt_id_qualifier ;
-    switch ( tag ) {
-	case id_variable_tag :
-	case id_parameter_tag : {
-	    /* Variables and parameters */
-	    TYPE t ;
-	    DECL_SPEC ds ;
-	    use_id ( id, 0 ) ;
-	    ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    if ( ds & dspec_auto ) {
-		/* Check use of automatic variable */
-		NAMESPACE ns = crt_namespace ;
-		switch ( TAG_nspace ( ns ) ) {
-		    case nspace_block_tag :
-		    case nspace_dummy_tag : {
-			if ( really_in_function_defn > 1 ) {
-			    /* Used in nested function */
-			    IDENTIFIER fid ;
-			    ns = DEREF_nspace ( id_parent ( id ) ) ;
-			    fid = DEREF_id ( nspace_name ( ns ) ) ;
-			    if ( !EQ_id ( fid, crt_func_id ) ) {
-				ERROR err = ERR_class_local_auto ( id ) ;
-				report ( crt_loc, err ) ;
-			    }
-			}
-			break ;
-		    }
-		    case nspace_param_tag :
-		    case nspace_templ_tag : {
-			/* Used in default argument */
-			if ( in_default_arg ) {
-			    ERROR err = ERR_dcl_fct_default_param ( id ) ;
-			    report ( crt_loc, err ) ;
-			}
-			break ;
-		    }
-		    default : {
-			/* Used in local class */
-			ERROR err = ERR_class_local_auto ( id ) ;
-			report ( crt_loc, err ) ;
-			break ;
-		    }
-		}
-	    }
-	    t = DEREF_type ( id_variable_etc_type ( id ) ) ;
-	    if ( ( ds & dspec_extern ) && cv_extern ) {
-		CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
-		t = qualify_type ( t, ( cv | cv_extern ), 0 ) ;
-		used_extern_volatile = 1 ;
-	    }
-	    MAKE_exp_identifier ( t, id, cq, e ) ;
-	    break ;
-	}
-	case id_stat_member_tag : {
-	    /* Static data members */
-	    TYPE t ;
-	    DECL_SPEC ds ;
-	    use_id ( id, suppress_usage ) ;
-	    ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    if ( ds & dspec_inherit ) id = DEREF_id ( id_alias ( id ) ) ;
-	    t = DEREF_type ( id_stat_member_type ( id ) ) ;
-	    if ( ( ds & dspec_extern ) && cv_extern ) {
-		CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
-		t = qualify_type ( t, ( cv | cv_extern ), 0 ) ;
-		used_extern_volatile = 1 ;
-	    }
-	    MAKE_exp_identifier ( t, id, cq, e ) ;
-	    break ;
-	}
-	case id_function_tag : {
-	    /* Normal functions */
-	    TYPE t = DEREF_type ( id_function_type ( id ) ) ;
-	    MAKE_exp_identifier ( t, id, cq, e ) ;
-	    break ;
-	}
-	case id_stat_mem_func_tag : {
-	    /* Static member functions */
-	    TYPE t = DEREF_type ( id_stat_mem_func_type ( id ) ) ;
-	    IDENTIFIER over = DEREF_id ( id_stat_mem_func_over ( id ) ) ;
-	    if ( IS_NULL_id ( over ) ) {
-		MAKE_exp_identifier ( t, id, cq, e ) ;
-	    } else {
-		MAKE_exp_member ( t, id, cq, e ) ;
-	    }
-	    break ;
-	}
-	case id_mem_func_tag : {
-	    /* Non-static member functions */
-	    TYPE t = DEREF_type ( id_mem_func_type ( id ) ) ;
-	    MAKE_exp_member ( t, id, cq, e ) ;
-	    break ;
-	}
-	case id_member_tag : {
-	    /* Non-static members */
-	    TYPE t = DEREF_type ( id_member_type ( id ) ) ;
-	    MAKE_exp_member ( t, id, cq, e ) ;
-	    break ;
-	}
-	case id_enumerator_tag : {
-	    /* Enumerators */
-	    NAT n ;
-	    TYPE t ;
-	    use_id ( id, 0 ) ;
-	    e = DEREF_exp ( id_enumerator_value ( id ) ) ;
-	    DECONS_exp_int_lit ( t, n, tag, e ) ;
-	    MAKE_exp_int_lit ( t, n, tag, e ) ;
-	    break ;
-	}
-	case id_token_tag : {
-	    /* Tokens */
-	    TOKEN tok = DEREF_tok ( id_token_sort ( id ) ) ;
-	    switch ( TAG_tok ( tok ) ) {
-		case tok_exp_tag :
-		case tok_nat_tag :
-		case tok_snat_tag :
-		case tok_stmt_tag : {
-		    /* Expression tokens */
-		    use_id ( id, 0 ) ;
-		    id = DEREF_id ( id_token_alt ( id ) ) ;
-		    e = apply_exp_token ( id, NULL_list ( TOKEN ), 0 ) ;
-		    break ;
-		}
-		default : {
-		    /* Other tokens */
-		    goto default_lab ;
+		}
-	    }
-	    break ;
+		pids = TAIL_list(pids);
+	}
-	case id_class_name_tag :
-	case id_enum_name_tag :
-	case id_class_alias_tag :
-	case id_enum_alias_tag :
-	case id_type_alias_tag : {
-	    /* Type names */
-	    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
-	    report ( crt_loc, ERR_expr_prim_type ( id ) ) ;
-	    MAKE_exp_value ( t, e ) ;
-	    break ;
-	}
-	case id_ambig_tag : {
-	    /* Ambiguous identifiers */
-	    MAKE_exp_ambiguous ( type_error, id, cq, e ) ;
-	    break ;
-	}
-	default :
-	default_lab : {
-	    /* Undefined identifiers */
-	    if ( cq == qual_none && in_template_decl ) {
-		/* Create a dummy identifier */
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-		NAMESPACE ns = nonblock_namespace ;
-		MAKE_id_undef ( nm, dspec_none, ns, crt_loc, id ) ;
-	    }
-	    MAKE_exp_undeclared ( type_error, id, cq, e ) ;
-	    break ;
-	}
-    }
-    return ( e ) ;
+	return (ds);
+}
 /*
-    FIND THE THIS PARAMETER OF A FUNCTION
+    CREATE AN IDENTIFIER EXPRESSION
-    This routine returns the 'this' parameter of the member function fn.
+    This routine creates an expression corresponding to the identifier id.
+    Note that static member functions are identifier expressions if they
+    are not overloaded, but member expression otherwise.  They are sorted
-    If use is true then the parameter is marked as used.
+    out properly during overload resolution (see resolve_cast).
 */
-IDENTIFIER this_param
+EXP
-    PROTO_N ( ( fn, use ) )
-    PROTO_T ( IDENTIFIER fn X int use )
+make_id_exp(IDENTIFIER id)
+{
+	EXP e;
+	unsigned tag = TAG_id(id);
+	QUALIFIER cq = crt_id_qualifier;
+	switch (tag) {
+	case id_variable_tag:
+	case id_parameter_tag: {
+		/* Variables and parameters */
+		TYPE t;
+		DECL_SPEC ds;
+		use_id(id, 0);
+		ds = DEREF_dspec(id_storage(id));
+		if (ds & dspec_auto) {
+			/* Check use of automatic variable */
+			NAMESPACE ns = crt_namespace;
+			switch (TAG_nspace(ns)) {
+			case nspace_block_tag:
+			case nspace_dummy_tag: {
+				if (really_in_function_defn > 1) {
+					/* Used in nested function */
+					IDENTIFIER fid;
+					ns = DEREF_nspace(id_parent(id));
+					fid = DEREF_id(nspace_name(ns));
+					if (!EQ_id(fid, crt_func_id)) {
+						ERROR err =
+						    ERR_class_local_auto(id);
+						report(crt_loc, err);
+					}
+				}
+				break;
+			}
+			case nspace_param_tag:
+			case nspace_templ_tag: {
+				/* Used in default argument */
+				if (in_default_arg) {
+					ERROR err =
+					    ERR_dcl_fct_default_param(id);
+					report(crt_loc, err);
+				}
+				break;
+			}
+			default: {
+				/* Used in local class */
+				ERROR err = ERR_class_local_auto(id);
+				report(crt_loc, err);
+				break;
+			}
+			}
+		}
+		t = DEREF_type(id_variable_etc_type(id));
+		if ((ds & dspec_extern) && cv_extern) {
+			CV_SPEC cv = DEREF_cv(type_qual(t));
+			t = qualify_type(t,(cv | cv_extern), 0);
+			used_extern_volatile = 1;
+		}
+		MAKE_exp_identifier(t, id, cq, e);
+		break;
+	}
+	case id_stat_member_tag: {
+		/* Static data members */
+		TYPE t;
+		DECL_SPEC ds;
+		use_id(id, suppress_usage);
+		ds = DEREF_dspec(id_storage(id));
+		if (ds & dspec_inherit) {
+			id = DEREF_id(id_alias(id));
+		}
+		t = DEREF_type(id_stat_member_type(id));
+		if ((ds & dspec_extern) && cv_extern) {
+			CV_SPEC cv = DEREF_cv(type_qual(t));
+			t = qualify_type(t,(cv | cv_extern), 0);
+			used_extern_volatile = 1;
+		}
+		MAKE_exp_identifier(t, id, cq, e);
+		break;
+	}
+	case id_function_tag: {
+		/* Normal functions */
+		TYPE t = DEREF_type(id_function_type(id));
+		MAKE_exp_identifier(t, id, cq, e);
+		break;
+	}
+	case id_stat_mem_func_tag: {
+		/* Static member functions */
+		TYPE t = DEREF_type(id_stat_mem_func_type(id));
+		IDENTIFIER over = DEREF_id(id_stat_mem_func_over(id));
+		if (IS_NULL_id(over)) {
+			MAKE_exp_identifier(t, id, cq, e);
+		} else {
+			MAKE_exp_member(t, id, cq, e);
+		}
+		break;
+	}
+	case id_mem_func_tag: {
+		/* Non-static member functions */
+		TYPE t = DEREF_type(id_mem_func_type(id));
+		MAKE_exp_member(t, id, cq, e);
+		break;
+	}
+	case id_member_tag: {
+		/* Non-static members */
+		TYPE t = DEREF_type(id_member_type(id));
+		MAKE_exp_member(t, id, cq, e);
+		break;
+	}
+	case id_enumerator_tag: {
+		/* Enumerators */
+		NAT n;
+		TYPE t;
+		use_id(id, 0);
+		e = DEREF_exp(id_enumerator_value(id));
+		DECONS_exp_int_lit(t, n, tag, e);
+		MAKE_exp_int_lit(t, n, tag, e);
+		break;
+	}
+	case id_token_tag: {
+		/* Tokens */
+		TOKEN tok = DEREF_tok(id_token_sort(id));
+		switch (TAG_tok(tok)) {
+		case tok_exp_tag:
+		case tok_nat_tag:
+		case tok_snat_tag:
+		case tok_stmt_tag:
+			/* Expression tokens */
+			use_id(id, 0);
+			id = DEREF_id(id_token_alt(id));
+			e = apply_exp_token(id, NULL_list(TOKEN), 0);
+			break;
+		default:
+			/* Other tokens */
+			goto default_lab;
+		}
+		break;
+	}
+	case id_class_name_tag:
+	case id_enum_name_tag:
+	case id_class_alias_tag:
+	case id_enum_alias_tag:
+	case id_type_alias_tag: {
+		/* Type names */
+		TYPE t = DEREF_type(id_class_name_etc_defn(id));
+		report(crt_loc, ERR_expr_prim_type(id));
+		MAKE_exp_value(t, e);
+		break;
+	}
+	case id_ambig_tag: {
+		/* Ambiguous identifiers */
+		MAKE_exp_ambiguous(type_error, id, cq, e);
+		break;
+	}
+	default:
+default_lab:
+		/* Undefined identifiers */
+		if (cq == qual_none && in_template_decl) {
+			/* Create a dummy identifier */
+			HASHID nm = DEREF_hashid(id_name(id));
+			NAMESPACE ns = nonblock_namespace;
+			MAKE_id_undef(nm, dspec_none, ns, crt_loc, id);
+		}
+		MAKE_exp_undeclared(type_error, id, cq, e);
+		break;
+	}
+	return (e);
+}
+/*
+    FIND THE THIS PARAMETER OF A FUNCTION
+    This routine returns the 'this' parameter of the member function fn.
+    If use is true then the parameter is marked as used.
+*/
+IDENTIFIER
+this_param(IDENTIFIER fn, int use)
+{
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    IDENTIFIER pid ;
+	IDENTIFIER pid;
-    HASHID nm = KEYWORD ( lex_this_Hname ) ;
+	HASHID nm = KEYWORD(lex_this_Hname);
-    TYPE t = DEREF_type ( id_mem_func_type ( fn ) ) ;
+	TYPE t = DEREF_type(id_mem_func_type(fn));
-    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));
-    pid = search_id ( ns, nm, 0, 0 ) ;
+	pid = search_id(ns, nm, 0, 0);
-    if ( !IS_NULL_id ( pid ) && use ) {
+	if (!IS_NULL_id(pid) && use) {
-	/* Mark parameter as used */
+		/* Mark parameter as used */
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(pid));
-	ds |= dspec_used ;
+		ds |= dspec_used;
-	COPY_dspec ( id_storage ( pid ), ds ) ;
+		COPY_dspec(id_storage(pid), ds);
-    }
+	}
-    return ( pid ) ;
+	return (pid);
+}
 /*
     CREATE A THIS EXPRESSION
     This routine deals with the 'this' expression.  This is only in scope
     in the definition of a non-static member function.   Note that the
     current value of 'this' is given by the address of the dummy parameter
     with name given by lex_this_Hname.
 */
-EXP make_this_exp
+EXP
-    PROTO_Z ()
+make_this_exp(void)
 {
-    EXP e ;
+	EXP e;
-    TYPE t ;
+	TYPE t;
-    IDENTIFIER fn = crt_func_id ;
+	IDENTIFIER fn = crt_func_id;
-    if ( in_function_defn && IS_id_mem_func ( fn ) ) {
+	if (in_function_defn && IS_id_mem_func(fn)) {
-	/* The current value of 'this' is returned */
+		/* The current value of 'this' is returned */
-        IDENTIFIER pid = this_param ( fn, 1 ) ;
+		IDENTIFIER pid = this_param(fn, 1);
-	if ( in_default_arg ) {
+		if (in_default_arg) {
-	    /* Can't use 'this' in default argument */
+			/* Can't use 'this' in default argument */
-	    ERROR err = ERR_dcl_fct_default_param ( pid ) ;
+			ERROR err = ERR_dcl_fct_default_param(pid);
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
+		}
+		e = DEREF_exp(id_parameter_init(pid));
+		t = DEREF_type(exp_type(e));
+		MAKE_exp_copy(t, e, e);
+	} else {
+		/* Must be inside a non-static member function */
+		report(crt_loc, ERR_expr_prim_this());
+		e = make_error_exp(0);
+	}
-	e = DEREF_exp ( id_parameter_init ( pid ) ) ;
-	t = DEREF_type ( exp_type ( e ) ) ;
-	MAKE_exp_copy ( t, e, e ) ;
-    } else {
-	/* Must be inside a non-static member function */
-	report ( crt_loc, ERR_expr_prim_this () ) ;
-	e = make_error_exp ( 0 ) ;
-    }
-    return ( e ) ;
+	return (e);
+}
 /*
     CREATE A THIS EXPRESSION
     This routine creates an expression corresponding to the 'this' parameter
     of a member function.  The parent class namespace is assigned to pns.
     The null expression is returned if we are outside of a member function.
 */
-EXP make_this_ref
+EXP
-    PROTO_N ( ( pns ) )
-    PROTO_T ( NAMESPACE *pns )
+make_this_ref(NAMESPACE *pns)
 {
-    IDENTIFIER fn = crt_func_id ;
+	IDENTIFIER fn = crt_func_id;
-    if ( in_function_defn && IS_id_mem_func ( fn ) ) {
+	if (in_function_defn && IS_id_mem_func(fn)) {
-	EXP e ;
+		EXP e;
-        IDENTIFIER pid = this_param ( fn, 1 ) ;
+		IDENTIFIER pid = this_param(fn, 1);
-	TYPE t = DEREF_type ( id_parameter_type ( pid ) ) ;
+		TYPE t = DEREF_type(id_parameter_type(pid));
-	MAKE_exp_identifier ( t, pid, qual_none, e ) ;
+		MAKE_exp_identifier(t, pid, qual_none, e);
-	*pns = DEREF_nspace ( id_parent ( fn ) ) ;
+		*pns = DEREF_nspace(id_parent(fn));
-	return ( e ) ;
+		return (e);
-    }
+	}
-    return ( NULL_exp ) ;
+	return (NULL_exp);
+}
 /*
     DECLARE A THIS PARAMETER
     This routine declares the dummy extra parameter for the non-static
     member function given by the identifier fn.  The type of this parameter
     is the first element of the corresponding mtypes list (see
     member_func_type).  An expression giving the address of the parameter
     is stored in its default argument position.  This gives the value of
     the 'this' expression.
 */
-EXP make_this_decl
+EXP
-    PROTO_N ( ( fn ) )
-    PROTO_T ( IDENTIFIER fn )
+make_this_decl(IDENTIFIER fn)
+{
-    /* Look up identifier */
+	/* Look up identifier */
-    EXP e ;
+	EXP e;
-    TYPE t ;
+	TYPE t;
-    IDENTIFIER pid ;
+	IDENTIFIER pid;
-    LIST ( TYPE ) mtypes ;
+	LIST(TYPE) mtypes;
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    HASHID nm = KEYWORD ( lex_this_Hname ) ;
+	HASHID nm = KEYWORD(lex_this_Hname);
-    MEMBER mem = search_member ( ns, nm, 1 ) ;
+	MEMBER mem = search_member(ns, nm, 1);
-    IDENTIFIER qid = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER qid = DEREF_id(member_id(mem));
-    DECL_SPEC ds = ( dspec_auto | dspec_defn | dspec_implicit ) ;
+	DECL_SPEC ds = (dspec_auto | dspec_defn | dspec_implicit);
-    /* Construct the type of the parameter */
+	/* Construct the type of the parameter */
-    TYPE f = DEREF_type ( id_mem_func_type ( fn ) ) ;
+	TYPE f = DEREF_type(id_mem_func_type(fn));
-    while ( IS_type_templ ( f ) ) {
+	while (IS_type_templ(f)) {
-	f = DEREF_type ( type_templ_defn ( f ) ) ;
+		f = DEREF_type(type_templ_defn(f));
-    }
+	}
-    mtypes = DEREF_list ( type_func_mtypes ( f ) ) ;
+	mtypes = DEREF_list(type_func_mtypes(f));
-    t = DEREF_type ( HEAD_list ( mtypes ) ) ;
+	t = DEREF_type(HEAD_list(mtypes));
-    /* Declare parameter */
-    MAKE_id_parameter ( nm, ds, ns, crt_loc, t, pid ) ;
-    if ( !IS_NULL_id ( qid ) ) {
-	qid = DEREF_id ( id_alias ( qid ) ) ;
-	COPY_id ( id_alias ( pid ), qid ) ;
-    }
-    COPY_id ( hashid_cache ( nm ), pid ) ;
-    COPY_id ( member_id ( mem ), pid ) ;
+	/* Declare parameter */
+	MAKE_id_parameter(nm, ds, ns, crt_loc, t, pid);
+	if (!IS_NULL_id(qid)) {
+		qid = DEREF_id(id_alias(qid));
+		COPY_id(id_alias(pid), qid);
+	}
+	COPY_id(hashid_cache(nm), pid);
+	COPY_id(member_id(mem), pid);
-    /* Construct the 'this' expression */
+	/* Construct the 'this' expression */
-    t = DEREF_type ( type_ref_sub ( t ) ) ;
+	t = DEREF_type(type_ref_sub(t));
-    t = rvalue_type ( t ) ;
+	t = rvalue_type(t);
-    if ( option ( OPT_this_lvalue ) == OPTION_ALLOW ) {
+	if (option(OPT_this_lvalue) == OPTION_ALLOW) {
-	MAKE_type_ptr ( cv_lvalue, t, t ) ;
+		MAKE_type_ptr(cv_lvalue, t, t);
-	MAKE_exp_identifier ( t, pid, qual_none, e ) ;
+		MAKE_exp_identifier(t, pid, qual_none, e);
-    } else {
+	} else {
-	MAKE_type_ptr ( cv_none, t, t ) ;
+		MAKE_type_ptr(cv_none, t, t);
-	MAKE_exp_identifier ( t, pid, qual_none, e ) ;
+		MAKE_exp_identifier(t, pid, qual_none, e);
-	MAKE_exp_contents ( t, e, e ) ;
+		MAKE_exp_contents(t, e, e);
-    }
+	}
-    COPY_exp ( id_parameter_init ( pid ), e ) ;
+	COPY_exp(id_parameter_init(pid), e);
-    return ( e ) ;
+	return (e);
+}
 /*
     CHECK FOR THIS EXPRESSIONS
     This routine checks whether the expression e is a 'this' expression.
 */
-int is_this_exp
+int
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+is_this_exp(EXP e)
+{
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	unsigned tag = TAG_exp ( e ) ;
+		unsigned tag = TAG_exp(e);
-	if ( tag == exp_indir_tag ) {
+		if (tag == exp_indir_tag) {
-	    e = DEREF_exp ( exp_indir_ptr ( e ) ) ;
+			e = DEREF_exp(exp_indir_ptr(e));
-	    tag = TAG_exp ( e ) ;
+			tag = TAG_exp(e);
-	}
+		}
-	if ( tag == exp_copy_tag ) {
+		if (tag == exp_copy_tag) {
-	    e = DEREF_exp ( exp_copy_arg ( e ) ) ;
+			e = DEREF_exp(exp_copy_arg(e));
-	    tag = TAG_exp ( e ) ;
+			tag = TAG_exp(e);
-	}
+		}
-	if ( tag == exp_contents_tag ) {
+		if (tag == exp_contents_tag) {
-	    e = DEREF_exp ( exp_contents_ptr ( e ) ) ;
+			e = DEREF_exp(exp_contents_ptr(e));
-	    tag = TAG_exp ( e ) ;
+			tag = TAG_exp(e);
-	}
+		}
-	if ( tag == exp_copy_tag ) {
+		if (tag == exp_copy_tag) {
-	    e = DEREF_exp ( exp_copy_arg ( e ) ) ;
+			e = DEREF_exp(exp_copy_arg(e));
-	    tag = TAG_exp ( e ) ;
+			tag = TAG_exp(e);
-	}
+		}
-	if ( tag == exp_identifier_tag ) {
+		if (tag == exp_identifier_tag) {
-	    IDENTIFIER id = DEREF_id ( exp_identifier_id ( e ) ) ;
+			IDENTIFIER id = DEREF_id(exp_identifier_id(e));
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    if ( EQ_KEYWORD ( nm, lex_this_Hname ) ) return ( 1 ) ;
+			if (EQ_KEYWORD(nm, lex_this_Hname)) {
+				return (1);
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     FIND THE ELLIPSIS PARAMETER OF A FUNCTION
     This routine returns the ellipsis parameter of the function fn.
 */
-IDENTIFIER ellipsis_param
+IDENTIFIER
-    PROTO_N ( ( fn ) )
-    PROTO_T ( IDENTIFIER fn )
+ellipsis_param(IDENTIFIER fn)
+{
-    int ell ;
+	int ell;
-    TYPE t = DEREF_type ( id_function_etc_type ( fn ) ) ;
+	TYPE t = DEREF_type(id_function_etc_type(fn));
-    while ( IS_type_templ ( t ) ) {
+	while (IS_type_templ(t)) {
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-    }
+	}
-    ell = DEREF_int ( type_func_ellipsis ( t ) ) ;
+	ell = DEREF_int(type_func_ellipsis(t));
-    if ( ell & FUNC_ELLIPSIS ) {
+	if (ell & FUNC_ELLIPSIS) {
-	HASHID nm = KEYWORD ( lex_ellipsis_Hexp ) ;
+		HASHID nm = KEYWORD(lex_ellipsis_Hexp);
-	NAMESPACE ns = DEREF_nspace ( type_func_pars ( t ) ) ;
+		NAMESPACE ns = DEREF_nspace(type_func_pars(t));
-	IDENTIFIER pid = search_id ( ns, nm, 0, 0 ) ;
+		IDENTIFIER pid = search_id(ns, nm, 0, 0);
-	return ( pid ) ;
+		return (pid);
-    }
+	}
-    return ( NULL_id ) ;
+	return (NULL_id);
+}
 /*
     FIND ELLIPSIS TYPE
     This routine returns the type of the dummy ellipsis parameter.  If
     force is true then an error is reported if this type has not been
     declared.
 */
-static TYPE find_ellipsis_type
+static TYPE
-    PROTO_N ( ( force ) )
-    PROTO_T ( int force )
+find_ellipsis_type(int force)
 {
-    TYPE t = type_ellipsis ;
+	TYPE t = type_ellipsis;
-    if ( IS_NULL_type ( t ) ) {
+	if (IS_NULL_type(t)) {
-	/* Look up token if not already defined */
+		/* Look up token if not already defined */
-	IDENTIFIER tid = get_special ( TOK_va_t, 1 ) ;
+		IDENTIFIER tid = get_special(TOK_va_t, 1);
-	if ( !IS_NULL_id ( tid ) && IS_id_token ( tid ) ) {
+		if (!IS_NULL_id(tid) && IS_id_token(tid)) {
-	    tid = DEREF_id ( id_token_alt ( tid ) ) ;
+			tid = DEREF_id(id_token_alt(tid));
-	    if ( IS_id_class_name_etc ( tid ) ) {
+			if (IS_id_class_name_etc(tid)) {
-		t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
+				t = DEREF_type(id_class_name_etc_defn(tid));
-		type_ellipsis = t ;
+				type_ellipsis = t;
-	    }
+			}
-	}
+		}
-	if ( IS_NULL_type ( t ) ) {
+		if (IS_NULL_type(t)) {
-	    if ( force ) {
+			if (force) {
-		/* Report if ellipsis type is undefined */
+				/* Report if ellipsis type is undefined */
-		HASHID nm = KEYWORD ( lex_ellipsis_Hexp ) ;
+				HASHID nm = KEYWORD(lex_ellipsis_Hexp);
+				report(crt_loc,
-		report ( crt_loc, ERR_lib_builtin ( NULL_string, nm ) ) ;
+				       ERR_lib_builtin(NULL_string, nm));
-	    }
+			}
-	    t = type_error ;
+			t = type_error;
+		}
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     DECLARE AN ELLIPSIS PARAMETER
     This routine declares the dummy extra parameter representing the
     ellipsis component of the function id.
 */
+void
-void make_ellipsis_decl
+make_ellipsis_decl(void)
-    PROTO_Z ()
 {
-    IDENTIFIER pid ;
+	IDENTIFIER pid;
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    TYPE t = find_ellipsis_type ( 0 ) ;
+	TYPE t = find_ellipsis_type(0);
-    HASHID nm = KEYWORD ( lex_ellipsis_Hexp ) ;
+	HASHID nm = KEYWORD(lex_ellipsis_Hexp);
-    MEMBER mem = search_member ( ns, nm, 1 ) ;
+	MEMBER mem = search_member(ns, nm, 1);
-    IDENTIFIER qid = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER qid = DEREF_id(member_id(mem));
-    DECL_SPEC ds = ( dspec_auto | dspec_defn | dspec_implicit ) ;
+	DECL_SPEC ds = (dspec_auto | dspec_defn | dspec_implicit);
-    MAKE_id_parameter ( nm, ds, ns, crt_loc, t, pid ) ;
+	MAKE_id_parameter(nm, ds, ns, crt_loc, t, pid);
-    if ( !IS_NULL_id ( qid ) ) {
+	if (!IS_NULL_id(qid)) {
-	qid = DEREF_id ( id_alias ( qid ) ) ;
+		qid = DEREF_id(id_alias(qid));
-	COPY_id ( id_alias ( pid ), qid ) ;
+		COPY_id(id_alias(pid), qid);
-    }
+	}
-    COPY_id ( hashid_cache ( nm ), pid ) ;
+	COPY_id(hashid_cache(nm), pid);
-    COPY_id ( member_id ( mem ), pid ) ;
+	COPY_id(member_id(mem), pid);
-    return ;
+	return;
+}
 /*
     CREATE AN ELLIPSIS EXPRESSION
     expression '...'.  This can only be used in a function definition
     which has an ellipsis type, in which case it is an rvalue of type
     type_ellipsis.
 */
+EXP
-EXP make_ellipsis_exp
+make_ellipsis_exp(void)
-    PROTO_Z ()
+{
-    EXP e ;
+	EXP e;
-    if ( in_function_defn ) {
+	if (in_function_defn) {
-	IDENTIFIER pid = ellipsis_param ( crt_func_id ) ;
+		IDENTIFIER pid = ellipsis_param(crt_func_id);
-	if ( !IS_NULL_id ( pid ) ) {
+		if (!IS_NULL_id(pid)) {
-	    /* Form result */
+			/* Form result */
-	    TYPE t = find_ellipsis_type ( 1 ) ;
+			TYPE t = find_ellipsis_type(1);
-	    report ( crt_loc, ERR_expr_call_ell_exp () ) ;
+			report(crt_loc, ERR_expr_call_ell_exp());
-	    MAKE_exp_identifier ( t, pid, qual_none, e ) ;
+			MAKE_exp_identifier(t, pid, qual_none, e);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
-    report ( crt_loc, ERR_expr_call_ell_func () ) ;
+	report(crt_loc, ERR_expr_call_ell_func());
-    e = make_error_exp ( 0 ) ;
+	e = make_error_exp(0);
-    return ( e ) ;
+	return (e);
+}

Subversion Repositories tendra.SVN

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