WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/construct/redeclare.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
     The current linkage specifier is handled by means of this global
     variable.  The default, of no linkage being given, is interpreted
     according to the source language.
 */
-DECL_SPEC crt_linkage = dspec_none ;
+DECL_SPEC crt_linkage = dspec_none;
-DECL_SPEC new_linkage = dspec_none ;
+DECL_SPEC new_linkage = dspec_none;
 /*
     FIND A LINKAGE SPECIFIER
     This routine translates the string literal expression e into a linkage
     specifier.  The only recognised strings are "C" and "C++".
 */
-DECL_SPEC find_linkage
+DECL_SPEC
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+find_linkage(EXP e)
+{
-    STRING s = DEREF_str ( exp_string_lit_str ( e ) ) ;
+	STRING s = DEREF_str(exp_string_lit_str(e));
-    unsigned kind = DEREF_unsigned ( str_simple_kind ( s ) ) ;
+	unsigned kind = DEREF_unsigned(str_simple_kind(s));
-    /* Can only occur in namespace scope */
+	/* Can only occur in namespace scope */
-    if ( in_function_defn || in_class_defn ) {
+	if (in_function_defn || in_class_defn) {
-	report ( crt_loc, ERR_dcl_link_scope () ) ;
+		report(crt_loc, ERR_dcl_link_scope());
-    }
+	}
-    /* Check the linkage string */
+	/* Check the linkage string */
-    if ( kind == STRING_NONE ) {
+	if (kind == STRING_NONE) {
-	char *t = strlit ( DEREF_string ( str_simple_text ( s ) ) ) ;
+		char *t = strlit(DEREF_string(str_simple_text(s)));
-	unsigned long len = DEREF_ulong ( str_simple_len ( s ) ) ;
+		unsigned long len = DEREF_ulong(str_simple_len(s));
-	if ( len == 1 && streq ( t, "C" ) ) {
+		if (len == 1 && streq(t, "C")) {
-	    return ( dspec_c ) ;
+			return (dspec_c);
-	}
+		}
-	if ( len == 3 && streq ( t, "C++" ) ) {
+		if (len == 3 && streq(t, "C++")) {
-	    return ( dspec_cpp ) ;
+			return (dspec_cpp);
-	}
+		}
-    }
+	}
-    /* Report unknown strings */
+	/* Report unknown strings */
-    report ( crt_loc, ERR_dcl_link_unknown ( s ) ) ;
+	report(crt_loc, ERR_dcl_link_unknown(s));
-    return ( crt_linkage ) ;
+	return (crt_linkage);
 }
 /*
     FIND A LINKAGE STRING
     This routine returns the string corresponding to the linkage specifiers
     given by ds and cv.
 */
-string linkage_string
+string
-    PROTO_N ( ( ds, cv ) )
-    PROTO_T ( DECL_SPEC ds X CV_SPEC cv )
+linkage_string(DECL_SPEC ds, CV_SPEC cv)
 {
-    CONST char *str ;
+	CONST char *str;
-    if ( ( ds & dspec_c ) || ( cv & cv_c ) ) {
+	if ((ds & dspec_c) || (cv & cv_c)) {
-	str = "C" ;
+		str = "C";
-    } else {
+	} else {
-	str = "C++" ;
+		str = "C++";
-    }
+	}
-    return ( ustrlit ( str ) ) ;
+	return (ustrlit(str));
 }
 /*
     ADJUST DECLARATION SPECIFIER FOR LANGUAGE
     This routine adds the current language specifier to the declaration
     specifier ds.  mem is true for a member declaration (which always
     has C++ linkage).  ds may contain a language specifier from a
     previous declaration, otherwise it is deduced from crt_linkage.
 */
-DECL_SPEC adjust_linkage
+DECL_SPEC
-    PROTO_N ( ( ds, mem ) )
-    PROTO_T ( DECL_SPEC ds X int mem )
+adjust_linkage(DECL_SPEC ds, int mem)
+{
-    DECL_SPEC rs = ( ds & ~dspec_language ) ;
+	DECL_SPEC rs = (ds & ~dspec_language);
-    if ( mem ) {
+	if (mem) {
-	/* Members have C++ linkage */
+		/* Members have C++ linkage */
-	rs |= dspec_cpp ;
+		rs |= dspec_cpp;
-    } else if ( rs & dspec_linkage ) {
+	} else if (rs & dspec_linkage) {
-	/* Only applies to objects with linkage */
+		/* Only applies to objects with linkage */
-	DECL_SPEC ln = ( ds | crt_linkage ) ;
+		DECL_SPEC ln = (ds | crt_linkage);
-	if ( ln & dspec_c ) {
+		if (ln & dspec_c) {
-	    rs |= dspec_c ;
+			rs |= dspec_c;
-	} else {
+		} else {
-	    rs |= dspec_cpp ;
+			rs |= dspec_cpp;
+		}
+	}
-    }
-    return ( rs ) ;
+	return (rs);
+}
 /*
     CHECK C LINKAGE DECLARATIONS
     This routine checks the identifier id declared with C linkage.  Objects
     with C linkage in different namespaces are actually the same.
 */
-void c_linkage
+void
-    PROTO_N ( ( id, def ) )
-    PROTO_T ( IDENTIFIER id X int def )
+c_linkage(IDENTIFIER id, int def)
+{
-    TYPE t = NULL_type ;
+    TYPE t = NULL_type;
-    unsigned tag = TAG_id ( id ) ;
+    unsigned tag = TAG_id(id);
-    if ( tag == id_function_tag ) {
+    if (tag == id_function_tag) {
 	/* Template functions can't have C linkage */
-	t = DEREF_type ( id_function_type ( id ) ) ;
+	t = DEREF_type(id_function_type(id));
-	if ( IS_type_templ ( t ) ) {
+	if (IS_type_templ(t)) {
-	    report ( decl_loc, ERR_temp_decl_linkage () ) ;
+	    report(decl_loc, ERR_temp_decl_linkage());
+	}
-    } else if ( tag == id_variable_tag ) {
+    } else if (tag == id_variable_tag) {
-	t = DEREF_type ( id_variable_type ( id ) ) ;
+	t = DEREF_type(id_variable_type(id));
+    }
-    if ( !IS_NULL_type ( t ) ) {
+    if (!IS_NULL_type(t)) {
-	NAMESPACE ns = c_namespace ;
+	NAMESPACE ns = c_namespace;
-	if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	    HASHID nm = DEREF_hashid(id_name(id));
-	    MEMBER mem = search_member ( ns, nm, 1 ) ;
+	    MEMBER mem = search_member(ns, nm, 1);
-	    IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
+	    IDENTIFIER pid = DEREF_id(member_id(mem));
-	    if ( !IS_NULL_id ( pid ) && !EQ_id ( id, pid ) ) {
+	    if (!IS_NULL_id(pid) && !EQ_id(id, pid)) {
-		NAMESPACE cns = DEREF_nspace ( id_parent ( id ) ) ;
+		NAMESPACE cns = DEREF_nspace(id_parent(id));
-		NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
+		NAMESPACE pns = DEREF_nspace(id_parent(pid));
-		if ( !EQ_nspace ( cns, pns ) ) {
+		if (!EQ_nspace(cns, pns)) {
-		    DECL_SPEC cl = crt_linkage ;
+		    DECL_SPEC cl = crt_linkage;
-		    QUALIFIER cq = crt_id_qualifier ;
+		    QUALIFIER cq = crt_id_qualifier;
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		    DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		    crt_linkage = ( ds & dspec_language ) ;
+		    crt_linkage = (ds & dspec_language);
-		    crt_id_qualifier = qual_none ;
+		    crt_id_qualifier = qual_none;
-		    pid = redecl_id ( ds, t, pid, 3, -1 ) ;
+		    pid = redecl_id(ds, t, pid, 3, -1);
-		    if ( !IS_NULL_id ( pid ) ) {
+		    if (!IS_NULL_id(pid)) {
 			/* Set up alias */
-			if ( IS_id_function ( pid ) ) {
+			if (IS_id_function(pid)) {
-			    TYPE s = DEREF_type ( id_function_type ( pid ) ) ;
+			    TYPE s = DEREF_type(id_function_type(pid));
-			    s = redecl_func_type ( pid, s, t, def, 0 ) ;
+			    s = redecl_func_type(pid, s, t, def, 0);
-			    COPY_type ( id_function_type ( pid ), s ) ;
+			    COPY_type(id_function_type(pid), s);
+			}
-			ds |= dspec_alias ;
+			ds |= dspec_alias;
-			COPY_dspec ( id_storage ( id ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
-			pid = DEREF_id ( id_alias ( pid ) ) ;
+			pid = DEREF_id(id_alias(pid));
-			COPY_id ( id_alias ( id ), pid ) ;
+			COPY_id(id_alias(id), pid);
+			if (do_dump) {
-			if ( do_dump ) dump_alias ( id, pid, &decl_loc ) ;
+				dump_alias(id, pid, &decl_loc);
+			}
-			id = pid ;
+			id = pid;
+		    }
-		    crt_id_qualifier = cq ;
+		    crt_id_qualifier = cq;
-		    crt_linkage = cl ;
+		    crt_linkage = cl;
+		}
+	    }
-	    COPY_id ( member_id ( mem ), id ) ;
+	    COPY_id(member_id(mem), id);
+	}
+    }
-    return ;
+    return;
+}
 /*
     FIND A PREVIOUS DECLARATION
     If a declaration in block scope is declared extern then it has external
     linkage unless the declaration matches a visible declaration of namespace
     scope.  This routine finds such a declaration for the identifier id
     of type t.
 */
-IDENTIFIER find_previous
+IDENTIFIER
-    PROTO_N ( ( t, id ) )
-    PROTO_T ( TYPE t X IDENTIFIER id )
+find_previous(TYPE t, IDENTIFIER id)
+{
-    if ( crt_id_qualifier == qual_none ) {
+	if (crt_id_qualifier == qual_none) {
-	NAMESPACE ns = nonblock_namespace ;
+		NAMESPACE ns = nonblock_namespace;
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		HASHID nm = DEREF_hashid(id_name(id));
-	IDENTIFIER pid = find_extern_id ( nm, ns, 0 ) ;
+		IDENTIFIER pid = find_extern_id(nm, ns, 0);
-	if ( !IS_NULL_id ( pid ) ) {
+		if (!IS_NULL_id(pid)) {
-	    TYPE s ;
+			TYPE s;
-	    DECL_SPEC st ;
+			DECL_SPEC st;
-	    switch ( TAG_id ( pid ) ) {
+			switch (TAG_id(pid)) {
-		case id_variable_tag : {
+			case id_variable_tag:
-		    /* Variables may be redeclared */
+				/* Variables may be redeclared */
-		    s = DEREF_type ( id_variable_type ( pid ) ) ;
+				s = DEREF_type(id_variable_type(pid));
-		    break ;
+				break;
-		}
-		case id_function_tag : {
+			case id_function_tag: {
-		    /* Functions may be redeclared */
+				/* Functions may be redeclared */
 #if LANGUAGE_CPP
-		    int eq = 0 ;
+				int eq = 0;
-		    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+				LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);
-		    pid = resolve_func ( pid, t, 0, 0, pids, &eq ) ;
+				pid = resolve_func(pid, t, 0, 0, pids, &eq);
-		    if ( IS_NULL_id ( pid ) ) return ( NULL_id ) ;
+				if (IS_NULL_id(pid)) {
+					return (NULL_id);
+				}
-		    if ( !IS_id_function ( pid ) ) return ( NULL_id ) ;
+				if (!IS_id_function(pid)) {
+					return (NULL_id);
+				}
 #endif
-		    s = DEREF_type ( id_function_type ( pid ) ) ;
+				s = DEREF_type(id_function_type(pid));
-		    break ;
+				break;
+			}
+			default:
+				/* Nothing else can be redeclared */
+				return (NULL_id);
+			}
+			st = DEREF_dspec(id_storage(pid));
+			if (st & dspec_linkage) {
+				/* Previous declaration must have linkage */
+				s = type_composite(s, t, 0, 0, KILL_err, 0);
+				if (!IS_NULL_type(s)) {
+					return (pid);
+				}
+			}
+		}
-		default : {
-		    /* Nothing else can be redeclared */
-		    return ( NULL_id ) ;
-		}
-	    }
-	    st = DEREF_dspec ( id_storage ( pid ) ) ;
-	    if ( st & dspec_linkage ) {
-		/* Previous declaration must have linkage */
-		s = type_composite ( s, t, 0, 0, KILL_err, 0 ) ;
-		if ( !IS_NULL_type ( s ) ) return ( pid ) ;
-	    }
+	}
-    }
-    return ( NULL_id ) ;
+	return (NULL_id);
+}
 /*
     UNIFY AN EXTERNAL IDENTIFIER
     extern in a block, against conflicts with the namespace ns into
     which it is injected.  p gives all the other extern block identifiers
     declared before id.  The routine returns any previous identifier.
 */
-IDENTIFIER unify_extern
+IDENTIFIER
-    PROTO_N ( ( id, t, ns, p ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X NAMESPACE ns X LIST ( IDENTIFIER ) p )
+unify_extern(IDENTIFIER id, TYPE t, NAMESPACE ns, LIST(IDENTIFIER) p)
+{
-    IDENTIFIER pid = NULL_id ;
+	IDENTIFIER pid = NULL_id;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+	LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	/* Check other block externs */
+		/* Check other block externs */
-	IDENTIFIER bid = DEREF_id ( HEAD_list ( p ) ) ;
+		IDENTIFIER bid = DEREF_id(HEAD_list(p));
-	HASHID bnm = DEREF_hashid ( id_name ( bid ) ) ;
+		HASHID bnm = DEREF_hashid(id_name(bid));
-	if ( EQ_hashid ( bnm, nm ) ) {
+		if (EQ_hashid(bnm, nm)) {
-	    bid = DEREF_id ( id_alias ( bid ) ) ;
+			bid = DEREF_id(id_alias(bid));
-	    CONS_id ( bid, pids, pids ) ;
+			CONS_id(bid, pids, pids);
-	}
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
-    if ( !IS_NULL_nspace ( ns ) ) {
-	/* Check actual namespace */
-	MEMBER mem = search_member ( ns, nm, 0 ) ;
-	if ( !IS_NULL_member ( mem ) ) {
-	    IDENTIFIER bid = DEREF_id ( member_id ( mem ) ) ;
-	    if ( !IS_NULL_id ( bid ) ) {
-		bid = DEREF_id ( id_alias ( bid ) ) ;
-		CONS_id ( bid, pids, pids ) ;
-	    }
+	}
-    }
-    if ( !IS_NULL_list ( pids ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	/* Match found */
+		/* Check actual namespace */
-	if ( IS_NULL_type ( t ) ) {
+		MEMBER mem = search_member(ns, nm, 0);
-	    if ( IS_NULL_list ( TAIL_list ( pids ) ) ) {
+		if (!IS_NULL_member(mem)) {
-		pid = DEREF_id ( HEAD_list ( pids ) ) ;
+			IDENTIFIER bid = DEREF_id(member_id(mem));
-		DESTROY_list ( pids, SIZE_id ) ;
+			if (!IS_NULL_id(bid)) {
-	    } else {
-		DECL_SPEC ds ;
-		pids = REVERSE_list ( pids ) ;
+				bid = DEREF_id(id_alias(bid));
-		ds = find_ambig_dspec ( pids ) ;
+				CONS_id(bid, pids, pids);
-		MAKE_id_ambig ( nm, ds, ns, crt_loc, pids, 1, pid ) ;
-	    }
+			}
+		}
-	} else {
+	}
-	    LIST ( IDENTIFIER ) qids ;
+	if (!IS_NULL_list(pids)) {
-	    DECL_SPEC cl = crt_linkage ;
+		/* Match found */
-	    QUALIFIER cq = crt_id_qualifier ;
+		if (IS_NULL_type(t)) {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    crt_linkage = ( ds & dspec_language ) ;
-	    crt_id_qualifier = qual_none ;
+			if (IS_NULL_list(TAIL_list(pids))) {
-	    DEREF_loc ( id_loc ( id ), decl_loc ) ;
+				pid = DEREF_id(HEAD_list(pids));
-	    pids = REVERSE_list ( pids ) ;
+				DESTROY_list(pids, SIZE_id);
-	    qids = pids ;
+			} else {
-	    while ( !IS_NULL_list ( qids ) ) {
+				DECL_SPEC ds;
-		IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
+				pids = REVERSE_list(pids);
-		qid = DEREF_id ( id_alias ( qid ) ) ;
+				ds = find_ambig_dspec(pids);
-		if ( IS_type_func ( t ) ) {
-		    /* Check function redeclaration */
+				MAKE_id_ambig(nm, ds, ns, crt_loc, pids, 1,
-		    IDENTIFIER over = NULL_id ;
+					      pid);
-		    unsigned tag = TAG_id ( id ) ;
+			}
-		    qid = redecl_func ( ds, t, qid, tag, &over, -1 ) ;
 		} else {
+			LIST(IDENTIFIER) qids;
+			DECL_SPEC cl = crt_linkage;
+			QUALIFIER cq = crt_id_qualifier;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
+			crt_linkage = (ds & dspec_language);
+			crt_id_qualifier = qual_none;
+			DEREF_loc(id_loc(id), decl_loc);
+			pids = REVERSE_list(pids);
+			qids = pids;
+			while (!IS_NULL_list(qids)) {
+				IDENTIFIER qid = DEREF_id(HEAD_list(qids));
+				qid = DEREF_id(id_alias(qid));
+				if (IS_type_func(t)) {
+					/* Check function redeclaration */
+					IDENTIFIER over = NULL_id;
+					unsigned tag = TAG_id(id);
+					qid = redecl_func(ds, t, qid, tag,
+							  &over, -1);
+				} else {
-		    /* Check variable redeclaration */
+					/* Check variable redeclaration */
-		    qid = redecl_id ( ds, t, qid, 0, -1 ) ;
+					qid = redecl_id(ds, t, qid, 0, -1);
-		}
+				}
-		if ( !IS_NULL_id ( qid ) ) pid = qid ;
+				if (!IS_NULL_id(qid)) {
+					pid = qid;
+				}
-		qids = TAIL_list ( qids ) ;
+				qids = TAIL_list(qids);
-	    }
+			}
-	    DESTROY_list ( pids, SIZE_id ) ;
+			DESTROY_list(pids, SIZE_id);
-	    crt_id_qualifier = cq ;
+			crt_id_qualifier = cq;
-	    crt_linkage = cl ;
+			crt_linkage = cl;
+		}
+	}
-    }
-    return ( pid ) ;
+	return (pid);
+}
 /*
     UNIFY A BLOCK DECLARATION WITH A PREVIOUS DECLARATION
     This routine is used to unify the external block declaration id of
     type t with its previous declaration pid (as returned by find_previous).
     def is true is id is a function definition.  The routine returns id.
     If there is no previous declaration then one is created and added to
     the extra identifier list of the enclosing non-block namespace.
 */
-IDENTIFIER unify_previous
+IDENTIFIER
-    PROTO_N ( ( id, t, pid, def ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X IDENTIFIER pid X int def )
+unify_previous(IDENTIFIER id, TYPE t, IDENTIFIER pid, int def)
 {
-    /* Unify external linkage */
+	/* Unify external linkage */
-    if ( IS_NULL_id ( pid ) ) {
+	if (IS_NULL_id(pid)) {
-	LIST ( IDENTIFIER ) p ;
+		LIST(IDENTIFIER) p;
-	NAMESPACE ns = nonblock_namespace ;
+		NAMESPACE ns = nonblock_namespace;
-	p = DEREF_list ( nspace_named_etc_extra ( ns ) ) ;
+		p = DEREF_list(nspace_named_etc_extra(ns));
-	pid = unify_extern ( id, t, ns, p ) ;
+		pid = unify_extern(id, t, ns, p);
-	if ( IS_NULL_id ( pid ) ) {
+		if (IS_NULL_id(pid)) {
-	    if ( !is_templ_depend ( t ) ) {
+			if (!is_templ_depend(t)) {
-		/* Declare new external object */
+				/* Declare new external object */
-		DECL_SPEC ds ;
+				DECL_SPEC ds;
-		pid = copy_id ( id, 0 ) ;
+				pid = copy_id(id, 0);
-		ds = DEREF_dspec ( id_storage ( pid ) ) ;
+				ds = DEREF_dspec(id_storage(pid));
-		if ( !( ds & dspec_linkage ) ) ds |= dspec_extern ;
+				if (!(ds & dspec_linkage)) {
+					ds |= dspec_extern;
+				}
-		ds &= ~dspec_alias ;
+				ds &= ~dspec_alias;
-		COPY_dspec ( id_storage ( pid ), ds ) ;
+				COPY_dspec(id_storage(pid), ds);
-		COPY_nspace ( id_parent ( pid ), ns ) ;
+				COPY_nspace(id_parent(pid), ns);
-		COPY_id ( id_alias ( pid ), pid ) ;
+				COPY_id(id_alias(pid), pid);
-		CONS_id ( pid, p, p ) ;
+				CONS_id(pid, p, p);
-		COPY_list ( nspace_named_etc_extra ( ns ), p ) ;
+				COPY_list(nspace_named_etc_extra(ns), p);
-	    }
+			}
-	    /* Check object type */
+			/* Check object type */
-	    if ( !is_global_type ( t ) ) {
+			if (!is_global_type(t)) {
-		report ( crt_loc, ERR_basic_link_none ( t, id ) ) ;
+				report(crt_loc, ERR_basic_link_none(t, id));
-	    }
+			}
-	}
+		}
-    }
+	}
-    /* Alias id to be pid */
+	/* Alias id to be pid */
-    if ( !IS_NULL_id ( pid ) ) {
+	if (!IS_NULL_id(pid)) {
-	if ( IS_id_function_etc ( pid ) ) {
+		if (IS_id_function_etc(pid)) {
-	    TYPE s = DEREF_type ( id_function_etc_type ( pid ) ) ;
+			TYPE s = DEREF_type(id_function_etc_type(pid));
-	    s = redecl_func_type ( pid, s, t, def, 0 ) ;
+			s = redecl_func_type(pid, s, t, def, 0);
-	    COPY_type ( id_function_etc_type ( pid ), s ) ;
+			COPY_type(id_function_etc_type(pid), s);
+		}
+		pid = DEREF_id(id_alias(pid));
+		COPY_id(id_alias(id), pid);
+	}
-	pid = DEREF_id ( id_alias ( pid ) ) ;
-	COPY_id ( id_alias ( id ), pid ) ;
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     UNIFY A DECLARATION WITH A PREVIOUS BLOCK DECLARATION
     This routine is used to unify the external declaration id of type
     t with any previous external block declaration of the same object.
     def is true if id is a function definition.  The routine returns id.
 */
-IDENTIFIER unify_subsequent
+IDENTIFIER
-    PROTO_N ( ( id, t, def ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X int def )
+unify_subsequent(IDENTIFIER id, TYPE t, int def)
+{
-    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+	NAMESPACE ns = DEREF_nspace(id_parent(id));
-    if ( IS_nspace_named_etc ( ns ) ) {
+	if (IS_nspace_named_etc(ns)) {
-	LIST ( IDENTIFIER ) p ;
+		LIST(IDENTIFIER) p;
-	p = DEREF_list ( nspace_named_etc_extra ( ns ) ) ;
+		p = DEREF_list(nspace_named_etc_extra(ns));
-	if ( !IS_NULL_list ( p ) ) {
+		if (!IS_NULL_list(p)) {
-	    IDENTIFIER pid = unify_extern ( id, t, NULL_nspace, p ) ;
+			IDENTIFIER pid = unify_extern(id, t, NULL_nspace, p);
-	    if ( !IS_NULL_id ( pid ) ) {
+			if (!IS_NULL_id(pid)) {
-		/* Alias id to be pid */
+				/* Alias id to be pid */
-		if ( IS_id_function_etc ( pid ) ) {
+				if (IS_id_function_etc(pid)) {
-		    TYPE s = DEREF_type ( id_function_etc_type ( pid ) ) ;
+					TYPE s = DEREF_type(id_function_etc_type(pid));
-		    s = redecl_func_type ( pid, s, t, def, 0 ) ;
+					s = redecl_func_type(pid, s, t, def, 0);
-		    COPY_type ( id_function_etc_type ( pid ), s ) ;
+					COPY_type(id_function_etc_type(pid), s);
+				}
+				pid = DEREF_id(id_alias(pid));
+				COPY_id(id_alias(id), pid);
+			}
+		}
-		pid = DEREF_id ( id_alias ( pid ) ) ;
-		COPY_id ( id_alias ( id ), pid ) ;
-	    }
 	}
-    }
-    return ( id ) ;
+	return (id);
 }
 /*
     CHECK FOR CLASS-LIKE TYPEDEF NAMES
     This routine checks whether the typedef name id behaves like a class
     or an object with respect to name hiding.  It is not entirely clear
     whether it is just original class and enumeration names or all class
     and enumeration names (including those introduced using typedef)
     which behave in this way.
 */
-int is_tagged_type
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_tagged_type(IDENTIFIER id)
+{
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_class_name_tag :
+	case id_class_name_tag:
-	case id_enum_name_tag : {
+	case id_enum_name_tag:
-	    /* Original class and enumeration names */
+		/* Original class and enumeration names */
-	    return ( 1 ) ;
+		return (1);
+	case id_class_alias_tag:
+	case id_enum_alias_tag:
+	case id_type_alias_tag:
+		/* Type aliases */
+		return (0);
+	}
-	case id_class_alias_tag :
-	case id_enum_alias_tag :
-	case id_type_alias_tag : {
-	    /* Type aliases */
-	    return ( 0 ) ;
+	return (0);
-	}
-    }
-    return ( 0 ) ;
+}
 /*
     REPORT AN OVERLOADIN ERROR
     This routine reports the overloading error err for the function id
     which cannot be overloaded for the reason corresponding to reason.
     It returns the severity of the error.
 */
-static int overload_error
+static int
-    PROTO_N ( ( id, err, reason ) )
-    PROTO_T ( IDENTIFIER id X ERROR err X int reason )
+overload_error(IDENTIFIER id, ERROR err, int reason)
+{
-    int sev = ERROR_NONE ;
+	int sev = ERROR_NONE;
-    switch ( reason ) {
+	switch (reason) {
-	case 1 : {
+	case 1:
-	    /* Two functions with C linkage */
+		/* Two functions with C linkage */
-	    err = concat_error ( err, ERR_dcl_link_over () ) ;
+		err = concat_error(err, ERR_dcl_link_over());
+		break;
+	case 2:
+		/* Two functions with indistinguishable parameters */
+		err = concat_error(err, ERR_over_load_pars());
+		break;
+	case 3: {
+		/* Two objects with C linkage */
+		PTR(LOCATION)loc = id_loc(id);
+		HASHID nm = DEREF_hashid(id_name(id));
+		err = concat_error(err, ERR_dcl_link_redecl(nm, loc));
-	    break ;
+		break;
+	}
-	case 2 : {
-	    /* Two functions with indistinguishable parameters */
-	    err = concat_error ( err, ERR_over_load_pars () ) ;
-	    break ;
+	}
-	case 3 : {
-	    /* Two objects with C linkage */
-	    PTR ( LOCATION ) loc = id_loc ( id ) ;
+	if (!IS_NULL_err(err)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		sev = DEREF_int(err_severity(err));
-	    err = concat_error ( err, ERR_dcl_link_redecl ( nm, loc ) ) ;
-	    break ;
+		report(decl_loc, err);
+	}
-    }
-    if ( !IS_NULL_err ( err ) ) {
-	sev = DEREF_int ( err_severity ( err ) ) ;
-	report ( decl_loc, err ) ;
-    }
-    return ( sev ) ;
+	return (sev);
+}
 /*
     REDECLARE AN OBJECT IDENTIFIER
     redeclared identifier will be marked as defined according to whether
     the redeclaration is a definition.  Whether the initial declaration
     was a definition may be determined from the initialiser expression.
 */
-IDENTIFIER redecl_id
+IDENTIFIER
-    PROTO_N ( ( ds, t, id, reason, def ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int reason X int def )
+redecl_id(DECL_SPEC ds, TYPE t, IDENTIFIER id, int reason, int def)
+{
-    TYPE s ;
+	TYPE s;
-    DECL_SPEC ln ;
+	DECL_SPEC ln;
-    PTR ( TYPE ) pt ;
+	PTR(TYPE) pt;
-    int changed = 0 ;
+	int changed = 0;
-    int is_member = 0 ;
+	int is_member = 0;
-    int is_function = 0 ;
+	int is_function = 0;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    DECL_SPEC ds_old, ln_old ;
+	DECL_SPEC ds_old, ln_old;
+	}
-    }
-    /* Check previous type */
+	/* Mark whether this declaration is a definition */
-    s = DEREF_type ( pt ) ;
+	if (def >= 0) {
-    s = check_compatible ( s, t, 0, &err, 1 ) ;
-    if ( !IS_NULL_err ( err ) ) {
+		if (ds & dspec_defn) {
-	/* Incompatible declaration */
+			ds_old |= dspec_defn;
-	PTR ( LOCATION ) loc = id_loc ( id ) ;
+		} else {
-	err = concat_error ( err, ERR_basic_link_decl_type ( id, loc ) ) ;
-	if ( ( ds | ds_old ) & dspec_token ) {
+			ds_old &= ~dspec_defn;
-	    /* Allow for interface declarations */
-	    err = set_severity ( err, OPT_interf_incompat, -1 ) ;
-	}
+		}
-	if ( overload_error ( id, err, reason ) == ERROR_SERIOUS ) {
-	    return ( NULL_id ) ;
+	}
-    }
-    if ( is_function ) {
-	/* Sanity check for error types */
-	if ( type_tag ( s ) != type_func_tag ) return ( NULL_id ) ;
-    } else {
-	if ( type_tag ( s ) == type_func_tag ) return ( NULL_id ) ;
-    }
-    if ( def >= 0 ) COPY_type ( pt, s ) ;
-    /* Check for redeclaration of aliases */
+	/* Compatible redeclaration */
-    if ( ( ds | ds_old ) & dspec_alias ) {
-	PTR ( LOCATION ) loc = id_loc ( id ) ;
-	report ( decl_loc, ERR_dcl_nspace_udecl_redecl ( id, loc ) ) ;
-    }
-    /* Check for inconsistent linkage */
-    if ( ln != ln_old ) {
-	ERROR err1 ;
-	DECL_SPEC ln_new ;
-	PTR ( LOCATION ) loc = id_loc ( id ) ;
-	if ( ln_old == dspec_static ) {
-	    err1 = ERR_dcl_stc_internal ( id, loc ) ;
-	} else {
-	    err1 = ERR_dcl_stc_external ( id, loc ) ;
+	COPY_dspec(id_storage(id), ds_old);
-	    if ( is_member ) {
+	if (changed) {
-		/* Members have external linkage */
-		ERROR err2 = ERR_basic_link_mem_extern ( id ) ;
-		err1 = concat_error ( err2, err1 ) ;
+		update_tag(id, 0);
-	    }
+	}
-	if ( reason == 3 ) {
-	    /* Identification of objects with C linkage */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-	    ERROR err2 = ERR_dcl_link_redecl ( nm, loc ) ;
-	    err1 = concat_error ( err1, err2 ) ;
-	}
-	if ( def == -1 && option ( OPT_link_internal ) == OPTION_OFF ) {
-	    ln_new = dspec_extern ;
-	} else {
-	    ln_new = dspec_static ;
-	}
-	ds_old = ( ln_new | ( ds_old & ~dspec_linkage ) ) ;
-	report ( decl_loc, err1 ) ;
-	changed = 1 ;
-    }
-    /* Check language specifier */
-    ln = crt_linkage ;
-    if ( ln != dspec_none ) {
-	/* Check against the current language */
-	ln_old = ( ds_old & dspec_language ) ;
-	if ( ( ds_old & dspec_extern ) && ln != ln_old ) {
-	    /* Report inconsistent linkage */
-	    if ( !is_member ) {
-		/* Should this only apply to functions? */
-		PTR ( LOCATION ) loc = id_loc ( id ) ;
-		string lang = linkage_string ( ln_old, cv_none ) ;
-		report ( decl_loc, ERR_dcl_link_lang ( id, lang, loc ) ) ;
-		ds_old = adjust_linkage ( ds_old, is_member ) ;
-		changed = 1 ;
-	    }
-	}
-    }
-    /* Check for inline specifier */
-    if ( ds & dspec_inline ) {
-	ds_old |= dspec_inline ;
-	changed = 1 ;
-    }
-    /* Mark whether this declaration is a definition */
-    if ( def >= 0 ) {
-	if ( ds & dspec_defn ) {
-	    ds_old |= dspec_defn ;
-	} else {
-	    ds_old &= ~dspec_defn ;
-	}
-    }
-    /* Compatible redeclaration */
-    COPY_dspec ( id_storage ( id ), ds_old ) ;
-    if ( changed ) update_tag ( id, 0 ) ;
-    return ( id ) ;
+	return (id);
+}
 /*
     REDECLARE A FUNCTION IDENTIFIER
     This routine is similar to redecl_id except that it allows for function
     overloading.  As before it returns id if this is a redeclaration of an
     existing function, and the null identifier otherwise.  However in the
     latter case any functions overloaded by the declaration are returned
     via over.
 */
-IDENTIFIER redecl_func
+IDENTIFIER
-    PROTO_N ( ( ds, t, id, tag, over, def ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X unsigned tag X
+redecl_func(DECL_SPEC ds, TYPE t, IDENTIFIER id, unsigned tag,
-	      IDENTIFIER *over X int def )
+	    IDENTIFIER *over, int def)
 {
-    int reason = 0 ;
+	int reason = 0;
-    IDENTIFIER fid = id ;
+	IDENTIFIER fid = id;
 #if LANGUAGE_CPP
-    if ( IS_id_function_etc ( fid ) ) {
+	if (IS_id_function_etc(fid)) {
-	DECL_SPEC ds_old ;
+		DECL_SPEC ds_old;
-	*over = fid ;
+		*over = fid;
-	/* Scan through overloaded functions for a match */
+		/* Scan through overloaded functions for a match */
-	while ( !IS_NULL_id ( fid ) ) {
+		while (!IS_NULL_id(fid)) {
-	    int m ;
+			int m;
-	    TYPE s ;
+			TYPE s;
-	    int mq = 1 ;
+			int mq = 1;
-	    if ( ( ds & dspec_extern ) && crt_linkage == dspec_c ) {
+			if ((ds & dspec_extern) && crt_linkage == dspec_c) {
-		/* Two functions with C linkage are the same */
+				/* Two functions with C linkage are the same */
-		ds_old = DEREF_dspec ( id_storage ( fid ) ) ;
+				ds_old = DEREF_dspec(id_storage(fid));
-		if ( ( ds_old & dspec_c ) && IS_id_function ( fid ) ) {
+				if ((ds_old & dspec_c) && IS_id_function(fid)) {
-		    reason = 1 ;
+					reason = 1;
-		    break ;
+					break;
-		}
+				}
-	    }
+			}
-	    /* Two functions with the same parameters are the same */
+			/* Two functions with the same parameters are the
+			 * same */
-	    s = DEREF_type ( id_function_etc_type ( fid ) ) ;
+			s = DEREF_type(id_function_etc_type(fid));
-	    if ( tag == id_stat_mem_func_tag ) mq = 0 ;
+			if (tag == id_stat_mem_func_tag) {
+				mq = 0;
+			}
-	    if ( IS_id_stat_mem_func ( fid ) ) mq = 0 ;
+			if (IS_id_stat_mem_func(fid)) {
+				mq = 0;
+			}
-	    m = eq_func_type ( t, s, mq, 0 ) ;
+			m = eq_func_type(t, s, mq, 0);
-	    if ( m ) {
+			if (m) {
-		/* Function types basically match */
+				/* Function types basically match */
-		if ( m == 1 ) {
+				if (m == 1) {
-		    /* Return types don't match */
+					/* Return types don't match */
-		    reason = 2 ;
+					reason = 2;
-		}
+				}
-		break ;
+				break;
-	    }
+			}
-	    fid = DEREF_id ( id_function_etc_over ( fid ) ) ;
+			fid = DEREF_id(id_function_etc_over(fid));
-	}
+		}
-	if ( IS_NULL_id ( fid ) ) {
+		if (IS_NULL_id(fid)) {
-	    /* No match found */
+			/* No match found */
-	    IDENTIFIER tid = find_template ( id, 0 ) ;
+			IDENTIFIER tid = find_template(id, 0);
-	    if ( !IS_NULL_id ( tid ) ) {
+			if (!IS_NULL_id(tid)) {
-		/* Must have match with template specialisation */
+				/* Must have match with template
+				 * specialisation */
-		report ( decl_loc, ERR_temp_spec_type ( t, id ) ) ;
+				report(decl_loc, ERR_temp_spec_type(t, id));
-		return ( NULL_id ) ;
+				return (NULL_id);
-	    }
+			}
-	    if ( crt_id_qualifier != qual_none ) {
+			if (crt_id_qualifier != qual_none) {
-		/* Must have match with qualified identifier */
+				/* Must have match with qualified identifier */
-		if ( def == -2 && tag == id_function_tag ) {
+				if (def == -2 && tag == id_function_tag) {
-		    /* Allow for name injection */
+					/* Allow for name injection */
-		    /* EMPTY */
+					/* EMPTY */
-		} else {
+				} else {
+					report(decl_loc,
-		    report ( decl_loc, ERR_basic_link_unmatch ( t, id ) ) ;
+					       ERR_basic_link_unmatch(t, id));
-		}
+				}
-		return ( NULL_id ) ;
+				return (NULL_id);
-	    }
+			}
+			if (reason == 0) {
-	    if ( reason == 0 ) return ( NULL_id ) ;
+				return (NULL_id);
+			}
-	    fid = id ;
+			fid = id;
-	}
+		}
-	/* Match found */
+		/* Match found */
-	ds_old = DEREF_dspec ( id_storage ( fid ) ) ;
+		ds_old = DEREF_dspec(id_storage(fid));
-	if ( ( ds_old & dspec_implicit ) && !( ds & dspec_implicit ) ) {
+		if ((ds_old & dspec_implicit) && !(ds & dspec_implicit)) {
-	    if ( IS_id_mem_func ( fid ) ) {
+			if (IS_id_mem_func(fid)) {
-		/* Matches implicitly declared member function */
+				/* Matches implicitly declared member
+				 * function */
-		report ( decl_loc, ERR_class_special_decl ( fid ) ) ;
+				report(decl_loc, ERR_class_special_decl(fid));
-		return ( NULL_id ) ;
+				return (NULL_id);
-	    }
+			}
-	}
+		}
-	if ( ds_old & dspec_inherit ) {
+		if (ds_old & dspec_inherit) {
-	    /* Inherited functions (including aliases) are hidden */
+			/* Inherited functions (including aliases) are hidden */
-	    return ( NULL_id ) ;
+			return (NULL_id);
+		}
+		/* *over = NULL_id ; */
+	}
-	/* *over = NULL_id ; */
-    }
 #else
-    /* Don't check overloading in C */
+	/* Don't check overloading in C */
-    *over = NULL_id ;
+	*over = NULL_id;
-    UNUSED ( tag ) ;
+	UNUSED(tag);
 #endif
-    /* Redeclare id */
+	/* Redeclare id */
-    fid = redecl_id ( ds, t, fid, reason, def ) ;
+	fid = redecl_id(ds, t, fid, reason, def);
-    if ( !IS_NULL_id ( fid ) ) {
+	if (!IS_NULL_id(fid)) {
-	TYPE form = DEREF_type ( id_function_etc_form ( id ) ) ;
+		TYPE form = DEREF_type(id_function_etc_form(id));
-	if ( def >= 0 ) {
+		if (def >= 0) {
-	    /* Allow for default arguments etc. */
+			/* Allow for default arguments etc. */
-	    TYPE s = DEREF_type ( id_function_etc_type ( fid ) ) ;
+			TYPE s = DEREF_type(id_function_etc_type(fid));
-	    s = redecl_func_type ( fid, s, t, def, 1 ) ;
+			s = redecl_func_type(fid, s, t, def, 1);
-	    COPY_type ( id_function_etc_type ( fid ), s ) ;
+			COPY_type(id_function_etc_type(fid), s);
-	}
+		}
-	if ( !IS_NULL_type ( form ) && IS_type_token ( form ) ) {
+		if (!IS_NULL_type(form) && IS_type_token(form)) {
-	    IDENTIFIER ext = DEREF_id ( type_token_tok ( form ) ) ;
+			IDENTIFIER ext = DEREF_id(type_token_tok(form));
-	    if ( !IS_NULL_id ( ext ) && IS_id_token ( ext ) ) {
+			if (!IS_NULL_id(ext) && IS_id_token(ext)) {
-		/* Check for tokenised functions */
+				/* Check for tokenised functions */
-		ds = DEREF_dspec ( id_storage ( ext ) ) ;
+				ds = DEREF_dspec(id_storage(ext));
-		ds |= dspec_explicit ;
+				ds |= dspec_explicit;
-		COPY_dspec ( id_storage ( ext ), ds ) ;
+				COPY_dspec(id_storage(ext), ds);
-		if ( def ) {
+				if (def) {
-		    /* Check for token definitions */
+					/* Check for token definitions */
-		    IGNORE define_func_token ( ext, fid ) ;
+					IGNORE define_func_token(ext, fid);
-		    if ( ds & dspec_pure ) {
+					if (ds & dspec_pure) {
+						report(decl_loc,
-			report ( decl_loc, ERR_token_def_not ( ext ) ) ;
+						       ERR_token_def_not(ext));
-		    }
+					}
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ( fid ) ;
+	return (fid);
 }
 /*
     REDECLARE AN INHERITED OR ALIASED MEMBER
     This routine is used to allow for declarations of class members to
     override any inherited value of the member.  id gives the inherited
     value, mem is true for a member declaration, fn is true for a function
     declaration or a declaration which can't coexist with a function
     declaration.  The null identifier is returned to indicate that id is
     to be overridden.
 */
-IDENTIFIER redecl_inherit
+IDENTIFIER
-    PROTO_N ( ( id, qual, mem, fn ) )
-    PROTO_T ( IDENTIFIER id X QUALIFIER qual X int mem X int fn )
+redecl_inherit(IDENTIFIER id, QUALIFIER qual, int mem, int fn)
 {
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( ds & dspec_alias ) {
+		if (ds & dspec_alias) {
-	    if ( fn && IS_id_function_etc ( id ) ) {
+			if (fn && IS_id_function_etc(id)) {
-		/* Everything is a function */
+				/* Everything is a function */
-		return ( id ) ;
+				return (id);
-	    }
+			}
-	    if ( mem && IS_id_class_name ( id ) ) {
+			if (mem && IS_id_class_name(id)) {
-		/* Allow for injected type names */
+				/* Allow for injected type names */
-		if ( ds & dspec_implicit ) return ( id ) ;
+				if (ds & dspec_implicit) {
+					return (id);
-	    }
+				}
+			}
-	    if ( qual == qual_none ) {
+			if (qual == qual_none) {
-		/* New declaration */
+				/* New declaration */
-		PTR ( LOCATION ) loc = id_loc ( id ) ;
+				PTR(LOCATION) loc = id_loc(id);
+				report(decl_loc,
-		report ( decl_loc, ERR_dcl_nspace_udecl_multi ( id, loc ) ) ;
+				       ERR_dcl_nspace_udecl_multi(id, loc));
-		return ( NULL_id ) ;
+				return (NULL_id);
-	    }
+			}
-	}
+		}
-	if ( ds & dspec_inherit ) {
+		if (ds & dspec_inherit) {
-	    NAMESPACE ns ;
+			NAMESPACE ns;
+			if (mem) {
-	    if ( mem ) return ( NULL_id ) ;
+				return (NULL_id);
+			}
-	    ns = DEREF_nspace ( id_parent ( id ) ) ;
+			ns = DEREF_nspace(id_parent(id));
-	    id = DEREF_id ( id_alias ( id ) ) ;
+			id = DEREF_id(id_alias(id));
-	    report ( decl_loc, ERR_lookup_qual_decl ( id, ns ) ) ;
+			report(decl_loc, ERR_lookup_qual_decl(id, ns));
-	}
+		}
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     COPY AN IDENTIFIER
     This routine creates a copy of the identifier id.  If type is 1
     then any type components in id are copied using copy_typedef, if it
     is 2 they are further expanded using expand_type.
 */
-IDENTIFIER copy_id
+IDENTIFIER
-    PROTO_N ( ( id, type ) )
-    PROTO_T ( IDENTIFIER id X int type )
+copy_id(IDENTIFIER id, int type)
+{
-    TYPE t ;
+	TYPE t;
-    ulong no ;
+	ulong no;
-    ulong dno ;
+	ulong dno;
-    HASHID nm ;
+	HASHID nm;
-    unsigned tag ;
+	unsigned tag;
-    LOCATION loc ;
+	LOCATION loc;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    DECL_SPEC ds ;
+	DECL_SPEC ds;
-    IDENTIFIER lid ;
+	IDENTIFIER lid;
-    IDENTIFIER cid = id ;
+	IDENTIFIER cid = id;
-    /* Examine various cases */
+	/* Examine various cases */
-    if ( IS_NULL_id ( cid ) ) return ( NULL_id ) ;
+	if (IS_NULL_id(cid)) {
+		return (NULL_id);
+	}
-    tag = TAG_id ( cid ) ;
+	tag = TAG_id(cid);
-    switch ( tag ) {
+	switch (tag) {
-	case id_class_name_tag :
+	case id_class_name_tag:
-	case id_class_alias_tag :
+	case id_class_alias_tag:
-	case id_enum_name_tag :
+	case id_enum_name_tag:
-	case id_enum_alias_tag :
+	case id_enum_alias_tag:
-	case id_type_alias_tag : {
+	case id_type_alias_tag: {
-	    /* Types */
+		/* Types */
-	    BASE_TYPE bt ;
+		BASE_TYPE bt;
-	    DECONS_id_class_name_etc ( nm, ds, ns, loc, lid, no,
+		DECONS_id_class_name_etc(nm, ds, ns, loc, lid, no, dno, t, bt,
-				       dno, t, bt, cid ) ;
+					 cid);
-	    if ( type ) {
+		if (type) {
-		t = copy_typedef ( cid, t, cv_none ) ;
+			t = copy_typedef(cid, t, cv_none);
-		if ( type == 2 ) {
+			if (type == 2) {
-		    t = expand_type ( t, 1 ) ;
+				t = expand_type(t, 1);
-		    if ( tag == id_class_name_tag ) {
+				if (tag == id_class_name_tag) {
-			/* Name already copied by copy_class */
+					/* Name already copied by copy_class */
-			CLASS_TYPE ct ;
+					CLASS_TYPE ct;
-			while ( IS_type_templ ( t ) ) {
+					while (IS_type_templ(t)) {
-			    t = DEREF_type ( type_templ_defn ( t ) ) ;
+						t = DEREF_type(type_templ_defn(t));
-			}
+					}
-			ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+					ct = DEREF_ctype(type_compound_defn(t));
-			cid = DEREF_id ( ctype_name ( ct ) ) ;
+					cid = DEREF_id(ctype_name(ct));
-			if ( !EQ_id ( cid, id ) ) {
+					if (!EQ_id(cid, id)) {
-			    COPY_hashid ( id_name ( cid ), nm ) ;
+						COPY_hashid(id_name(cid), nm);
-			    COPY_dspec ( id_storage ( cid ), ds ) ;
+						COPY_dspec(id_storage(cid), ds);
-			    COPY_nspace ( id_parent ( cid ), ns ) ;
+						COPY_nspace(id_parent(cid), ns);
-			    COPY_loc ( id_loc ( cid ), loc ) ;
+						COPY_loc(id_loc(cid), loc);
-			    break ;
+						break;
+					}
+				}
+				if (tag != id_enum_name_tag) {
+					/* Find type alias tag */
+					unsigned ta = type_tag(t);
+					if (ta == type_compound_tag) {
+						tag = id_class_alias_tag;
+					} else if (ta == type_enumerate_tag) {
+						tag = id_enum_alias_tag;
+					} else {
+						tag = id_type_alias_tag;
+					}
+				}
+			}
+		}
+		MAKE_id_class_name_etc(tag, nm, ds, ns, loc, t, cid);
+		COPY_btype(id_class_name_etc_rep(cid), bt);
+		break;
+	}
+	case id_variable_tag:
+	case id_parameter_tag:
+	case id_stat_member_tag: {
+		/* Objects */
+		EXP a, b;
+		DECONS_id_variable_etc(nm, ds, ns, loc, lid, no, dno, t,
+				       a, b, cid);
+		if (type) {
+			t = copy_typedef(cid, t, cv_none);
+			if (type == 2) {
+				t = expand_type(t, 1);
+			}
+		}
+		MAKE_id_variable_etc(tag, nm, ds, ns, loc, t, cid);
+		COPY_exp(id_variable_etc_init(cid), a);
+		COPY_exp(id_variable_etc_term(cid), b);
+		break;
+	}
+	case id_function_tag:
+	case id_mem_func_tag:
+	case id_stat_mem_func_tag: {
+		/* Functions */
+		EXP a;
+		TYPE form;
+		IDENTIFIER over;
+		LIST(CLASS_TYPE)fr;
+		DECONS_id_function_etc(nm, ds, ns, loc, lid, no, dno, t,
+				       over, form, fr, a, cid);
+		if (type) {
+			t = copy_typedef(cid, t, cv_none);
+			if (type == 2) {
+				t = expand_type(t, 1);
+			}
-		    }
+		}
+		MAKE_id_function_etc(tag, nm, ds, ns, loc, t, over, cid);
+		COPY_type(id_function_etc_form(cid), form);
-		    if ( tag != id_enum_name_tag ) {
+		COPY_exp(id_function_etc_defn(cid), a);
+		if (type == 2) {
-			/* Find type alias tag */
+			/* Copy friend classes */
-			unsigned ta = type_tag ( t ) ;
+			while (!IS_NULL_list(fr)) {
+				TYPE r = NULL_type;
-			if ( ta == type_compound_tag ) {
+				CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));
-			    tag = id_class_alias_tag ;
+				cr = expand_ctype(cr, 2, &r);
-			} else if ( ta == type_enumerate_tag ) {
+				friend_function(cr, cid, 0);
-			    tag = id_enum_alias_tag ;
+				fr = TAIL_list(fr);
+			}
-			} else {
+		} else {
+			COPY_list(id_function_etc_chums(cid), fr);
+		}
+		break;
+	}
+	case id_member_tag: {
+		/* Members */
+		GRAPH gr;
+		OFFSET off;
+		DECONS_id_member(nm, ds, ns, loc, lid, no, dno, t, off, gr,
+				 cid);
+		if (type) {
+			t = copy_typedef(cid, t, cv_none);
+			if (type == 2) {
+				if (IS_hashid_anon(nm)) {
+					/* Allow for anonymous bitfields */
+					expand_anon_bitfield = 1;
+				}
-			    tag = id_type_alias_tag ;
+				t = expand_type(t, 1);
+				expand_anon_bitfield = 0;
+			}
-		    }
-		}
-	    }
-	    MAKE_id_class_name_etc ( tag, nm, ds, ns, loc, t, cid ) ;
-	    COPY_btype ( id_class_name_etc_rep ( cid ), bt ) ;
-	    break ;
-	}
-	case id_variable_tag :
-	case id_parameter_tag :
-	case id_stat_member_tag : {
-	    /* Objects */
-	    EXP a, b ;
-	    DECONS_id_variable_etc ( nm, ds, ns, loc, lid, no, dno, t,
-				     a, b, cid ) ;
-	    if ( type ) {
-		t = copy_typedef ( cid, t, cv_none ) ;
-		if ( type == 2 ) t = expand_type ( t, 1 ) ;
-	    }
-	    MAKE_id_variable_etc ( tag, nm, ds, ns, loc, t, cid ) ;
-	    COPY_exp ( id_variable_etc_init ( cid ), a ) ;
-	    COPY_exp ( id_variable_etc_term ( cid ), b ) ;
-	    break ;
-	}
-	case id_function_tag :
-	case id_mem_func_tag :
-	case id_stat_mem_func_tag : {
-	    /* Functions */
-	    EXP a ;
-	    TYPE form ;
-	    IDENTIFIER over ;
-	    LIST ( CLASS_TYPE ) fr ;
-	    DECONS_id_function_etc ( nm, ds, ns, loc, lid, no, dno, t,
-				     over, form, fr, a, cid ) ;
-	    if ( type ) {
-		t = copy_typedef ( cid, t, cv_none ) ;
-		if ( type == 2 ) t = expand_type ( t, 1 ) ;
-	    }
-	    MAKE_id_function_etc ( tag, nm, ds, ns, loc, t, over, cid ) ;
-	    COPY_type ( id_function_etc_form ( cid ), form ) ;
-	    COPY_exp ( id_function_etc_defn ( cid ), a ) ;
-	    if ( type == 2 ) {
-		/* Copy friend classes */
-		while ( !IS_NULL_list ( fr ) ) {
-		    TYPE r = NULL_type ;
-		    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fr ) ) ;
-		    cr = expand_ctype ( cr, 2, &r ) ;
-		    friend_function ( cr, cid, 0 ) ;
-		    fr = TAIL_list ( fr ) ;
+		}
-	    } else {
+		MAKE_id_member(nm, ds, ns, loc, t, cid);
-		COPY_list ( id_function_etc_chums ( cid ), fr ) ;
+		COPY_graph(id_member_base(cid), gr);
-	    }
+		COPY_off(id_member_off(cid), off);
-	    break ;
+		break;
 	}
-	case id_member_tag : {
+	case id_enumerator_tag: {
-	    /* Members */
+		/* Enumerators */
-	    GRAPH gr ;
+		EXP a;
-	    OFFSET off ;
+		ERROR err = NULL_err;
-	    DECONS_id_member ( nm, ds, ns, loc, lid, no, dno, t, off,
+		DECONS_id_enumerator(nm, ds, ns, loc, lid, no, dno, t, a, cid);
-			       gr, cid ) ;
-	    if ( type ) {
+		if (type == 2) {
-		t = copy_typedef ( cid, t, cv_none ) ;
+			/* Copy enumerator value */
-		if ( type == 2 ) {
+			TYPE s = expand_type(t, 1);
-		    if ( IS_hashid_anon ( nm ) ) {
+			a = copy_exp(a, t, s);
-			/* Allow for anonymous bitfields */
+			IGNORE make_nat_exp(a, &err);
-			expand_anon_bitfield = 1 ;
+			t = s;
-		    }
+		}
+		MAKE_id_enumerator(nm, ds, ns, loc, t, a, cid);
-		    t = expand_type ( t, 1 ) ;
+		if (!IS_NULL_err(err)) {
+			err = concat_error(err, ERR_dcl_enum_const(cid));
-		    expand_anon_bitfield = 0 ;
+			report(crt_loc, err);
+		}
-	    }
-	    MAKE_id_member ( nm, ds, ns, loc, t, cid ) ;
-	    COPY_graph ( id_member_base ( cid ), gr ) ;
-	    COPY_off ( id_member_off ( cid ), off ) ;
-	    break ;
+		break;
 	}
-	case id_enumerator_tag : {
+	case id_token_tag: {
-	    /* Enumerators */
+		/* Tokens */
-	    EXP a ;
+		TOKEN sort;
-	    ERROR err = NULL_err ;
+		IDENTIFIER alt;
-	    DECONS_id_enumerator ( nm, ds, ns, loc, lid, no, dno,
+		DECONS_id_token(nm, ds, ns, loc, lid, no, dno, sort, alt, cid);
-				   t, a, cid ) ;
-	    if ( type == 2 ) {
+		if (type == 2) {
-		/* Copy enumerator value */
+			/* Expand token sort */
-		TYPE s = expand_type ( t, 1 ) ;
+			sort = expand_sort(sort, 1, 1);
-		a = copy_exp ( a, t, s ) ;
-		IGNORE make_nat_exp ( a, &err ) ;
-		t = s ;
-	    }
+		}
-	    MAKE_id_enumerator ( nm, ds, ns, loc, t, a, cid ) ;
+		MAKE_id_token(nm, ds, ns, loc, sort, alt, cid);
-	    if ( !IS_NULL_err ( err ) ) {
-		err = concat_error ( err, ERR_dcl_enum_const ( cid ) ) ;
-		report ( crt_loc, err ) ;
-	    }
-	    break ;
+		break;
 	}
-	case id_token_tag : {
-	    /* Tokens */
-	    TOKEN sort ;
+	default:
-	    IDENTIFIER alt ;
-	    DECONS_id_token ( nm, ds, ns, loc, lid, no, dno,
-			      sort, alt, cid ) ;
-	    if ( type == 2 ) {
-		/* Expand token sort */
+		/* Don't copy other identifiers */
-		sort = expand_sort ( sort, 1, 1 ) ;
-	    }
-	    MAKE_id_token ( nm, ds, ns, loc, sort, alt, cid ) ;
-	    break ;
+		return (cid);
+	}
-	default : {
+	if (type != 2) {
-	    /* Don't copy other identifiers */
+		COPY_id(id_alias(cid), lid);
-	    return ( cid ) ;
+		COPY_ulong(id_no(cid), no);
+		COPY_ulong(id_dump(cid), dno);
+	}
-    }
-    if ( type != 2 ) {
-	COPY_id ( id_alias ( cid ), lid ) ;
-	COPY_ulong ( id_no ( cid ), no ) ;
-	COPY_ulong ( id_dump ( cid ), dno ) ;
-    }
-    return ( cid ) ;
+	return (cid);
+}
 /*
     CREATE AN IDENTIFIER ALIAS
     This routine creates an alias for the identifier id in the namespace
     ns.  fn gives a list of function which the alias will overload if
     it is a function.
 */
-IDENTIFIER alias_id
+IDENTIFIER
-    PROTO_N ( ( id, ns, fn, rec ) )
-    PROTO_T ( IDENTIFIER id X NAMESPACE ns X IDENTIFIER fn X int rec )
+alias_id(IDENTIFIER id, NAMESPACE ns, IDENTIFIER fn, int rec)
 {
-    IDENTIFIER cid = copy_id ( id, 1 ) ;
+	IDENTIFIER cid = copy_id(id, 1);
-    if ( !EQ_id ( cid, id ) ) {
+	if (!EQ_id(cid, id)) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( cid ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(cid));
-	DECL_SPEC acc = ( ds & dspec_access ) ;
+		DECL_SPEC acc = (ds & dspec_access);
-	if ( acc ) {
+		if (acc) {
-	    IDENTIFIER sid = DEREF_id ( nspace_name ( ns ) ) ;
+			IDENTIFIER sid = DEREF_id(nspace_name(ns));
-	    immediate_access ( sid, cid ) ;
+			immediate_access(sid, cid);
-	}
+		}
-	ds = ( ( ds & ~dspec_access ) | dspec_alias | crt_access ) ;
+		ds = ((ds & ~dspec_access) | dspec_alias | crt_access);
-	COPY_dspec ( id_storage ( cid ), ds ) ;
+		COPY_dspec(id_storage(cid), ds);
-	COPY_nspace ( id_parent ( cid ), ns ) ;
+		COPY_nspace(id_parent(cid), ns);
+		if (do_dump) {
-	if ( do_dump ) dump_alias ( cid, id, &crt_loc ) ;
+			dump_alias(cid, id, &crt_loc);
+		}
-	if ( IS_id_function_etc ( cid ) ) {
+		if (IS_id_function_etc(cid)) {
-	    /* Deal with overloaded functions */
+			/* Deal with overloaded functions */
-	    IDENTIFIER over ;
+			IDENTIFIER over;
-	    if ( rec ) {
+			if (rec) {
-		over = DEREF_id ( id_function_etc_over ( cid ) ) ;
+				over = DEREF_id(id_function_etc_over(cid));
-		if ( IS_NULL_id ( over ) ) {
+				if (IS_NULL_id(over)) {
-		    over = fn ;
+					over = fn;
-		} else {
+				} else {
-		    over = alias_id ( over, ns, fn, rec ) ;
+					over = alias_id(over, ns, fn, rec);
-		}
+				}
-	    } else {
+			} else {
-		over = fn ;
+				over = fn;
-	    }
+			}
-	    COPY_id ( id_function_etc_over ( cid ), over ) ;
+			COPY_id(id_function_etc_over(cid), over);
-	}
+		}
-    }
+	}
-    return ( cid ) ;
+	return (cid);
 }
 /*
     DUMMY DECLARATION SPECIFIER
     This value is used as a dummy declaration specifier in the adjusting
     of overloaded functions.
 */
-#define dspec_mark	( ( DECL_SPEC ) 0x7fffffff )
+#define dspec_mark	((DECL_SPEC)0x7fffffff)
 /*
     REMOVE HIDDEN FUNCTIONS
     This routine adjusts the set of overloaded functions id by removing
     any with storage field equal to dspec_mark.
 */
-static IDENTIFIER remove_functions
+static IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+remove_functions(IDENTIFIER id)
+{
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
+		IDENTIFIER over = DEREF_id(id_function_etc_over(id));
-	over = remove_functions ( over ) ;
+		over = remove_functions(over);
-	if ( ds == dspec_mark ) {
+		if (ds == dspec_mark) {
-	    id = over ;
+			id = over;
-	} else {
+		} else {
-	    COPY_id ( id_function_etc_over ( id ), over ) ;
+			COPY_id(id_function_etc_over(id), over);
+		}
+	}
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     COMPARE HIDING FUNCTIONS
     This routine compares two functions id and over, one declared in the
     normal fashion and the other by a using-declaration.  It returns
     true if the former overrides the latter.
 */
-static int compare_functions
+static int
-    PROTO_N ( ( id, over, mem ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER over X int mem )
+compare_functions(IDENTIFIER id, IDENTIFIER over, int mem)
 {
-    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
+	TYPE t = DEREF_type(id_function_etc_type(id));
-    TYPE s = DEREF_type ( id_function_etc_type ( over ) ) ;
+	TYPE s = DEREF_type(id_function_etc_type(over));
-    int eq = eq_func_type ( t, s, 1, 0 ) ;
+	int eq = eq_func_type(t, s, 1, 0);
-    if ( eq ) {
+	if (eq) {
-	/* Equal parameter types */
+		/* Equal parameter types */
+		if (mem) {
-	if ( mem ) return ( 1 ) ;
+			return (1);
-    }
+		}
+	}
-    if ( eq >= 2 ) {
+	if (eq >= 2) {
-	/* Equal types */
+		/* Equal types */
-	PTR ( LOCATION ) loc = id_loc ( over ) ;
+		PTR(LOCATION)loc = id_loc(over);
-	report ( crt_loc, ERR_dcl_nspace_udecl_multi ( over, loc ) ) ;
+		report(crt_loc, ERR_dcl_nspace_udecl_multi(over, loc));
-	return ( 1 ) ;
+		return (1);
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     MARK HIDDEN FUNCTIONS
     This routine marks any functions which hide, or are hidden by, id in
     its set of overloaded functions.  mem is true for member functions.
     Any hidden function is marked by setting its storage field to the
     value dspec_mark.
 */
-static int mark_functions
+static int
-    PROTO_N ( ( id, mem ) )
-    PROTO_T ( IDENTIFIER id X int mem )
+mark_functions(IDENTIFIER id, int mem)
+{
-    int ret = 0 ;
+    int ret = 0;
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+    DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ds != dspec_mark ) {
+    if (ds != dspec_mark) {
-	IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
+	IDENTIFIER over = DEREF_id(id_function_etc_over(id));
-	while ( !IS_NULL_id ( over ) ) {
+	while (!IS_NULL_id(over)) {
-	    DECL_SPEC pds = DEREF_dspec ( id_storage ( over ) ) ;
+	    DECL_SPEC pds = DEREF_dspec(id_storage(over));
-	    if ( pds != dspec_mark ) {
+	    if (pds != dspec_mark) {
-		if ( ds & dspec_alias ) {
+		if (ds & dspec_alias) {
-		    if ( pds & dspec_alias ) {
+		    if (pds & dspec_alias) {
 			/* Both are using declarations */
-			IDENTIFIER a = DEREF_id ( id_alias ( id ) ) ;
+			IDENTIFIER a = DEREF_id(id_alias(id));
-			IDENTIFIER b = DEREF_id ( id_alias ( over ) ) ;
+			IDENTIFIER b = DEREF_id(id_alias(over));
-			if ( EQ_id ( a, b ) ) {
+			if (EQ_id(a, b)) {
 			    /* Duplicate declarations */
-			    if ( mem ) {
+			    if (mem) {
-				ERROR err ;
+				ERROR err;
-				PTR ( LOCATION ) loc = id_loc ( over ) ;
+				PTR(LOCATION) loc = id_loc(over);
-				err = ERR_class_mem_redecl ( over, loc ) ;
+				err = ERR_class_mem_redecl(over, loc);
-				report ( crt_loc, err ) ;
+				report(crt_loc, err);
+			    }
-			    COPY_dspec ( id_storage ( over ), dspec_mark ) ;
+			    COPY_dspec(id_storage(over), dspec_mark);
-			    ret++ ;
+			    ret++;
+			}
 		    } else {
 			/* The first is a using declaration */
-			if ( compare_functions ( id, over, mem ) ) {
+			if (compare_functions(id, over, mem)) {
-			    COPY_dspec ( id_storage ( id ), dspec_mark ) ;
+			    COPY_dspec(id_storage(id), dspec_mark);
-			    ret++ ;
+			    ret++;
+			}
+		    }
-		} else if ( pds & dspec_alias ) {
+		} else if (pds & dspec_alias) {
 		    /* The second is a using declaration */
-		    if ( compare_functions ( id, over, mem ) ) {
+		    if (compare_functions(id, over, mem)) {
-			COPY_dspec ( id_storage ( over ), dspec_mark ) ;
+			COPY_dspec(id_storage(over), dspec_mark);
-			ret++ ;
+			ret++;
-			break ;
+			break;
+		    }
+		}
+	    }
-	    over = DEREF_id ( id_function_etc_over ( over ) ) ;
+	    over = DEREF_id(id_function_etc_over(over));
+	}
+    }
-    return ( ret ) ;
+    return (ret);
+}
 /*
     HANDLE HIDDEN FUNCTIONS WITH USING DECLARATIONS
     of member functions is somewhat complex.  It is implemented by this
     routine which adjusts the declarations of the overloaded functions id
     up to the existing declarations over.  mem is true for member functions.
 */
-IDENTIFIER hide_functions
+IDENTIFIER
-    PROTO_N ( ( id, over, mem ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER over X int mem )
+hide_functions(IDENTIFIER id, IDENTIFIER over, int mem)
+{
-    if ( !IS_NULL_id ( over ) ) {
+	if (!IS_NULL_id(over)) {
-	int marked = 0 ;
+		int marked = 0;
-	IDENTIFIER pid = id ;
+		IDENTIFIER pid = id;
-	while ( !EQ_id ( pid, over ) ) {
+		while (!EQ_id(pid, over)) {
-	    marked += mark_functions ( pid, mem ) ;
+			marked += mark_functions(pid, mem);
+			pid = DEREF_id(id_function_etc_over(pid));
+		}
+		if (marked) {
+			id = remove_functions(id);
+		}
+		pid = id;
+		while (!IS_NULL_id(pid)) {
+			/* Mark template functions */
+			DECL_SPEC ds = DEREF_dspec(id_storage(pid));
+			if (ds & dspec_template) {
+				templ_func_decl(id);
+				break;
+			}
-	    pid = DEREF_id ( id_function_etc_over ( pid ) ) ;
+			pid = DEREF_id(id_function_etc_over(pid));
+		}
+	}
-	if ( marked ) id = remove_functions ( id ) ;
-	pid = id ;
-	while ( !IS_NULL_id ( pid ) ) {
-	    /* Mark template functions */
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
-	    if ( ds & dspec_template ) {
-		templ_func_decl ( id ) ;
-		break ;
-	    }
-	    pid = DEREF_id ( id_function_etc_over ( pid ) ) ;
-	}
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     CHECK THE VISIBILITY OF AN IDENTIFIER
     A member name in a using declaration should be visible from a direct
     base class.  This routine checks whether the member id meets this
     criterion by comparing it with its look-up in the direct base
     classes, pid.
 */
-static int using_visible
+static int
-    PROTO_N ( ( id, pid ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER pid )
+using_visible(IDENTIFIER id, IDENTIFIER pid)
 {
-    while ( !IS_NULL_id ( pid ) ) {
+	while (!IS_NULL_id(pid)) {
-	IDENTIFIER qid = DEREF_id ( id_alias ( pid ) ) ;
+		IDENTIFIER qid = DEREF_id(id_alias(pid));
-	if ( EQ_id ( qid, id ) ) return ( 1 ) ;
+		if (EQ_id(qid, id)) {
+			return (1);
+		}
-	switch ( TAG_id ( pid ) ) {
+		switch (TAG_id(pid)) {
-	    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:
-		/* Check overloaded functions */
+			/* Check overloaded functions */
-		pid = DEREF_id ( id_function_etc_over ( pid ) ) ;
+			pid = DEREF_id(id_function_etc_over(pid));
-		break ;
+			break;
-	    }
-	    case id_ambig_tag : {
+		case id_ambig_tag: {
-		/* Check ambiguous identifiers */
+			/* Check ambiguous identifiers */
-		LIST ( IDENTIFIER ) pids ;
+			LIST(IDENTIFIER)pids;
-		pids = DEREF_list ( id_ambig_ids ( pid ) ) ;
+			pids = DEREF_list(id_ambig_ids(pid));
-		while ( !IS_NULL_list ( pids ) ) {
+			while (!IS_NULL_list(pids)) {
-		    pid = DEREF_id ( HEAD_list ( pids ) ) ;
+				pid = DEREF_id(HEAD_list(pids));
-		    if ( using_visible ( id, pid ) ) return ( 1 ) ;
+				if (using_visible(id, pid)) {
+					return (1);
+				}
-		    pids = TAIL_list ( pids ) ;
+				pids = TAIL_list(pids);
-		}
+			}
-		return ( 0 ) ;
+			return (0);
-	    }
+		}
-	    default : {
+		default:
-		/* Other identifiers */
+			/* Other identifiers */
-		return ( 0 ) ;
+			return (0);
-	    }
+		}
 	}
-    }
-    return ( 0 ) ;
+	return (0);
 }
 /*
     PROCESS A CLASS USING DECLARATION
     This routine processes a using-declaration of the identifier id in
     the case when this declaration is a member-declaration.
+	}
-    }
-    /* Find inherited member */
+	/* Check declarations */
+	nm = DEREF_hashid(id_name(id));
-    id = search_subfield ( cns, gr, id ) ;
+	mem = search_member(cns, nm, 1);
+	type = is_tagged_type(id);
+	if (type) {
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		if (ds & dspec_template) {
+			pid = DEREF_id(member_id(mem));
+		} else {
+			pid = type_member(mem, 3);
+		}
+	} else {
+		pid = DEREF_id(member_id(mem));
+		if (!IS_id_nspace_name_etc(id)) {
+			if (!IS_NULL_id(pid) && is_tagged_type(pid)) {
+				/* Allow hiding of non-template classes */
+				DECL_SPEC ds = DEREF_dspec(id_storage(pid));
+				if (!(ds & dspec_template)) {
+					pid = NULL_id;
+				}
+			}
+		}
+	}
+	if (!IS_NULL_id(pid)) {
+		IDENTIFIER qid = DEREF_id(id_alias(pid));
+		if (EQ_id(id, qid)) {
+			/* Redeclaration of existing meaning */
+			if (EQ_id(id, pid)) {
+				report(crt_loc, ERR_dcl_nspace_udecl_mem(id));
+			}
+			return (pid);
+		}
+		if (IS_id_function_etc(id) && IS_id_function_etc(pid)) {
+			/* Both new and old meanings are functions */
+			/* EMPTY */
+		} else {
+			/* Invalid redeclaration */
+			PTR(LOCATION) loc = id_loc(pid);
+			ERROR err = ERR_dcl_nspace_udecl_multi(pid, loc);
+			report(crt_loc, err);
+			pid = NULL_id;
+		}
+	}
+	/* Create the alias */
-    aid = alias_id ( id, cns, pid, 1 ) ;
+	id = alias_id(id, cns, pid, 1);
-    if ( !IS_NULL_id ( pid ) ) {
+	if (!IS_NULL_id(pid)) {
-	/* Deal with function hiding */
+		/* Deal with function hiding */
-	aid = hide_functions ( aid, pid, 1 ) ;
+		id = hide_functions(id, pid, 0);
-    }
+	}
-    adjust_access ( id, crt_access, 1 ) ;
-    if ( type ) {
+	if (type) {
-	set_type_member ( mem, aid ) ;
+		set_type_member(mem, id);
-    } else {
+	} else {
-	set_member ( mem, aid ) ;
+		set_member(mem, id);
-    }
+	}
-    return ( aid ) ;
+	return (id);
+}
 /*
-    PROCESS A NAMESPACE USING DECLARATION
+    PROCESS A USING DECLARATION
-    This routine processes a using-declaration of the identifier id in
+    This routine processes a using-declaration of the identifier id.  Note
-    the case when this declaration is not a member-declaration.
+    that this includes the access declarations used to modify access to
+    class members.
 */
-static IDENTIFIER using_name
+IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+using_identifier(IDENTIFIER id)
+{
+	/* Identifier must be qualified */
-    int type ;
+	MEMBER mem;
-    HASHID nm ;
+	HASHID unm;
-    MEMBER mem ;
+	IDENTIFIER cid;
-    IDENTIFIER pid ;
+	IDENTIFIER uid = id;
-    /* Check the identifier */
-    NAMESPACE cns = crt_namespace ;
-    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+	NAMESPACE uns = DEREF_nspace(id_parent(uid));
-    if ( IS_nspace_ctype ( ns ) ) {
-	/* id denotes a class member */
-	report ( crt_loc, ERR_dcl_nspace_udecl_id ( id ) ) ;
-	switch ( TAG_id ( id ) ) {
-	    case id_member_tag :
-	    case id_stat_member_tag :
-	    case id_mem_func_tag :
+	uid = constr_name(uns, uid);
-	    case id_stat_mem_func_tag : {
-		/* Don't even try in these cases */
-		return ( NULL_id ) ;
-	    }
-	}
-    }
-    /* Check declarations */
-    nm = DEREF_hashid ( id_name ( id ) ) ;
+	unm = DEREF_hashid(id_name(uid));
-    mem = search_member ( cns, nm, 1 ) ;
-    type = is_tagged_type ( id ) ;
-    if ( type ) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	if ( ds & dspec_template ) {
+	if (crt_id_qualifier == qual_none) {
-	    pid = DEREF_id ( member_id ( mem ) ) ;
+		report(crt_loc, ERR_dcl_nspace_udecl_unqual());
-	} else {
+		return (uid);
-	    pid = type_member ( mem, 3 ) ;
-	}
-    } else {
-	pid = DEREF_id ( member_id ( mem ) ) ;
-	if ( !IS_id_nspace_name_etc ( id ) ) {
-	    if ( !IS_NULL_id ( pid ) && is_tagged_type ( pid ) ) {
-		/* Allow hiding of non-template classes */
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
-		if ( !( ds & dspec_template ) ) pid = NULL_id ;
-	    }
+	}
-    }
+	/* Report undefined and ambiguous identifiers */
-    if ( !IS_NULL_id ( pid ) ) {
+	switch (TAG_id(uid)) {
+	case id_ambig_tag: {
+		/* Introduce all the ambiguous meanings */
-	IDENTIFIER qid = DEREF_id ( id_alias ( pid ) ) ;
+		LIST(IDENTIFIER) pids = DEREF_list(id_ambig_ids(uid));
-	if ( EQ_id ( id, qid ) ) {
+		while (!IS_NULL_list(pids)) {
+			IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	    /* Redeclaration of existing meaning */
+			IGNORE using_identifier(pid);
-	    if ( EQ_id ( id, pid ) ) {
+			pids = TAIL_list(pids);
+		}
-		report ( crt_loc, ERR_dcl_nspace_udecl_mem ( id ) ) ;
+		uid = find_qual_id(crt_namespace, unm, 0, 0);
+		return (uid);
-	    }
+	}
+	case id_undef_tag:
+		/* Report undeclared identifiers */
+		report(crt_loc, ERR_lookup_qual_undef(unm, uns));
-	    return ( pid ) ;
+		return (uid);
+	}
-	if ( IS_id_function_etc ( id ) && IS_id_function_etc ( pid ) ) {
-	    /* Both new and old meanings are functions */
+	/* Can have constructors or destructors */
-	    /* EMPTY */
+	switch (TAG_hashid(unm)) {
-	} else {
+	case hashid_constr_tag:
-	    /* Invalid redeclaration */
+	case hashid_destr_tag:
-	    PTR ( LOCATION ) loc = id_loc ( pid ) ;
-	    ERROR err = ERR_dcl_nspace_udecl_multi ( pid, loc ) ;
+		report(crt_loc, ERR_dcl_nspace_udecl_constr(uid));
-	    report ( crt_loc, err ) ;
-	    pid = NULL_id ;
+		return (uid);
+	}
-    }
-    /* Create the alias */
-    id = alias_id ( id, cns, pid, 1 ) ;
-    if ( !IS_NULL_id ( pid ) ) {
-	/* Deal with function hiding */
+	/* Check for hidden type names */
-	id = hide_functions ( id, pid, 0 ) ;
+	mem = search_member(uns, unm, 0);
-    }
-    if ( type ) {
-	set_type_member ( mem, id ) ;
+	cid = type_member(mem, 1);
-    } else {
-	set_member ( mem, id ) ;
-    }
-    return ( id ) ;
-}
-/*
-    PROCESS A USING DECLARATION
-    This routine processes a using-declaration of the identifier id.  Note
-    that this includes the access declarations used to modify access to
-    class members.
-*/
-IDENTIFIER using_identifier
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
-{
-    /* Identifier must be qualified */
-    MEMBER mem ;
-    HASHID unm ;
-    IDENTIFIER cid ;
-    IDENTIFIER uid = id ;
-    NAMESPACE uns = DEREF_nspace ( id_parent ( uid ) ) ;
-    uid = constr_name ( uns, uid ) ;
-    unm = DEREF_hashid ( id_name ( uid ) ) ;
-    if ( crt_id_qualifier == qual_none ) {
-	report ( crt_loc, ERR_dcl_nspace_udecl_unqual () ) ;
-	return ( uid ) ;
-    }
-    /* Report undefined and ambiguous identifiers */
-    switch ( TAG_id ( uid ) ) {
+	if (EQ_id(cid, uid)) {
-	case id_ambig_tag : {
-	    /* Introduce all the ambiguous meanings */
-	    LIST ( IDENTIFIER ) pids = DEREF_list ( id_ambig_ids ( uid ) ) ;
-	    while ( !IS_NULL_list ( pids ) ) {
-		IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
-		IGNORE using_identifier ( pid ) ;
-		pids = TAIL_list ( pids ) ;
+		cid = NULL_id;
-	    }
-	    uid = find_qual_id ( crt_namespace, unm, 0, 0 ) ;
-	    return ( uid ) ;
-	}
-	case id_undef_tag : {
-	    /* Report undeclared identifiers */
-	    report ( crt_loc, ERR_lookup_qual_undef ( unm, uns ) ) ;
-	    return ( uid ) ;
-	}
-    }
-    /* Can have constructors or destructors */
-    switch ( TAG_hashid ( unm ) ) {
-	case hashid_constr_tag :
-	case hashid_destr_tag : {
-	    report ( crt_loc, ERR_dcl_nspace_udecl_constr ( uid ) ) ;
-	    return ( uid ) ;
 	}
-    }
-    /* Check for hidden type names */
-    mem = search_member ( uns, unm, 0 ) ;
-    cid = type_member ( mem, 1 ) ;
-    if ( EQ_id ( cid, uid ) ) cid = NULL_id ;
-    /* Process the declaration */
+	/* Process the declaration */
-    if ( in_class_defn ) {
+	if (in_class_defn) {
-	if ( !IS_NULL_id ( cid ) ) {
+		if (!IS_NULL_id(cid)) {
-	    IGNORE using_member ( cid, 1 ) ;
+			IGNORE using_member(cid, 1);
-	}
+		}
-	uid = using_member ( uid, 0 ) ;
+		uid = using_member(uid, 0);
-    } else {
+	} else {
-	if ( !IS_NULL_id ( cid ) ) {
+		if (!IS_NULL_id(cid)) {
-	    cid = DEREF_id ( id_alias ( cid ) ) ;
+			cid = DEREF_id(id_alias(cid));
-	    IGNORE using_name ( cid ) ;
+			IGNORE using_name(cid);
-	}
+		}
-	uid = DEREF_id ( id_alias ( uid ) ) ;
+		uid = DEREF_id(id_alias(uid));
-	uid = using_name ( uid ) ;
+		uid = using_name(uid);
-    }
+	}
-    if ( IS_NULL_id ( uid ) ) {
+	if (IS_NULL_id(uid)) {
-	uid = id ;
+		uid = id;
-    } else {
+	} else {
-	/* Check for hiding */
+		/* Check for hiding */
-	if ( option ( OPT_decl_hide ) ) {
+		if (option(OPT_decl_hide)) {
-	    switch ( TAG_id ( id ) ) {
+			switch (TAG_id(id)) {
-		case id_variable_tag :
+			case id_variable_tag:
-		case id_function_tag : {
+			case id_function_tag:
-		    check_hiding ( uid ) ;
+				check_hiding(uid);
-		    break ;
+				break;
-		}
+			}
-	    }
+		}
 	}
-    }
-    return ( uid ) ;
+	return (uid);
 }
 /*
     PROCESS A USING TYPENAME DECLARATION
     This routine processes a using-declaration involving the type t
     declared using typename.
 */
-void using_typename
+void
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+using_typename(TYPE t)
 {
-    UNUSED ( t ) ;
+	UNUSED(t);
-    return ;
+	return;
 }
 /*
     REDECLARE AN IDENTIFIER
     This routine redeclares the identifier id in the namespace ns.
 */
-IDENTIFIER redeclare_id
+IDENTIFIER
-    PROTO_N ( ( ns, id ) )
-    PROTO_T ( NAMESPACE ns X IDENTIFIER id )
+redeclare_id(NAMESPACE ns, IDENTIFIER id)
 {
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    int cl = is_tagged_type ( id ) ;
+	int cl = is_tagged_type(id);
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    MEMBER mem = search_member ( ns, nm, 1 ) ;
+	MEMBER mem = search_member(ns, nm, 1);
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( cl ) {
+	if (cl) {
-	old_id = type_member ( mem, 3 ) ;
+		old_id = type_member(mem, 3);
-    } else {
+	} else {
-	old_id = DEREF_id ( member_id ( mem ) ) ;
+		old_id = DEREF_id(member_id(mem));
-    }
+	}
-    if ( !IS_NULL_id ( old_id ) ) {
+	if (!IS_NULL_id(old_id)) {
-	PTR ( LOCATION ) loc = id_loc ( old_id ) ;
+		PTR(LOCATION) loc = id_loc(old_id);
-	report ( crt_loc, ERR_basic_odr_decl ( old_id, loc ) ) ;
+		report(crt_loc, ERR_basic_odr_decl(old_id, loc));
-    }
+	}
-    if ( cl ) {
+	if (cl) {
-	set_type_member ( mem, id ) ;
+		set_type_member(mem, id);
-    } else {
+	} else {
-	set_member ( mem, id ) ;
+		set_member(mem, id);
-    }
+	}
-    ds |= dspec_reserve ;
+	ds |= dspec_reserve;
-    COPY_dspec ( id_storage ( id ), ds ) ;
+	COPY_dspec(id_storage(id), ds);
-    COPY_nspace ( id_parent ( id ), ns ) ;
+	COPY_nspace(id_parent(id), ns);
-    return ( id ) ;
+	return (id);
+}
 /*
     CHECK ANONYMOUS UNION MEMBER
     This routine checks whether the identifier id is member of an
     anonymous union.
 */
-int is_anon_member
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_anon_member(IDENTIFIER id)
 {
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ds & dspec_reserve ) {
+	if (ds & dspec_reserve) {
-	IDENTIFIER pid = DEREF_id ( id_alias ( id ) ) ;
+		IDENTIFIER pid = DEREF_id(id_alias(id));
-	if ( !EQ_id ( pid, id ) ) {
+		if (!EQ_id(pid, id)) {
-	    TYPE s = DEREF_type ( id_variable_etc_type ( pid ) ) ;
+			TYPE s = DEREF_type(id_variable_etc_type(pid));
-	    if ( IS_type_compound ( s ) ) {
+			if (IS_type_compound(s)) {
-		TYPE t = DEREF_type ( id_variable_etc_type ( id ) ) ;
+				TYPE t = DEREF_type(id_variable_etc_type(id));
-		if ( !eq_type ( s, t ) ) return ( 1 ) ;
+				if (!eq_type(s, t)) {
+					return (1);
-	    }
+				}
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     REDECLARE A MEMBER OF AN ANONYMOUS UNION
     This routine redeclares the member id of an anonymous union.  The
     remaining arguments are as in redecl_anon_union.
 */
-static IDENTIFIER redecl_anon_member
+static IDENTIFIER
-    PROTO_N ( ( id, ct, ds, obj ) )
-    PROTO_T ( IDENTIFIER id X CLASS_TYPE ct X DECL_SPEC ds X IDENTIFIER obj )
+redecl_anon_member(IDENTIFIER id, CLASS_TYPE ct, DECL_SPEC ds, IDENTIFIER obj)
+{
-    IDENTIFIER pid = NULL_id ;
+	IDENTIFIER pid = NULL_id;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    if ( !IS_hashid_anon ( nm ) ) {
+	if (!IS_hashid_anon(nm)) {
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_member_tag : {
+		case id_member_tag: {
-		/* Redeclare a type member */
+			/* Redeclare a type member */
-		TYPE t = DEREF_type ( id_member_type ( id ) ) ;
+			TYPE t = DEREF_type(id_member_type(id));
-		DEREF_loc ( id_loc ( id ), crt_loc ) ;
+			DEREF_loc(id_loc(id), crt_loc);
-		if ( IS_id_member ( obj ) ) {
+			if (IS_id_member(obj)) {
-		    NAMESPACE cns = crt_namespace ;
+				NAMESPACE cns = crt_namespace;
-		    OFFSET off1 = DEREF_off ( id_member_off ( id ) ) ;
+				OFFSET off1 = DEREF_off(id_member_off(id));
-		    OFFSET off2 = DEREF_off ( id_member_off ( obj ) ) ;
+				OFFSET off2 = DEREF_off(id_member_off(obj));
-		    id = find_id ( nm ) ;
+				id = find_id(nm);
-		    id = constr_name ( cns, id ) ;
+				id = constr_name(cns, id);
-		    id = make_member_decl ( ds, t, id, 0 ) ;
+				id = make_member_decl(ds, t, id, 0);
-		    MAKE_off_plus ( off2, off1, off1 ) ;
+				MAKE_off_plus(off2, off1, off1);
-		    COPY_off ( id_member_off ( id ), off1 ) ;
+				COPY_off(id_member_off(id), off1);
-		} else {
+			} else {
-		    id = make_object_decl ( ds, t, id, 0 ) ;
+				id = make_object_decl(ds, t, id, 0);
-		    obj = DEREF_id ( id_alias ( obj ) ) ;
+				obj = DEREF_id(id_alias(obj));
-		    COPY_id ( id_alias ( id ), obj ) ;
+				COPY_id(id_alias(id), obj);
+			}
+			pid = id;
+			break;
+		}
-		pid = id ;
-		break ;
-	    }
-	    case id_class_name_tag : {
+		case id_class_name_tag: {
-		/* Redeclare a class name */
+			/* Redeclare a class name */
-		int templ = 0 ;
+			int templ = 0;
-		CLASS_TYPE cs ;
+			CLASS_TYPE cs;
-		TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
+			TYPE t = DEREF_type(id_class_name_defn(id));
-		while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		    templ = 1 ;
+				templ = 1;
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
+			}
+			cs = DEREF_ctype(type_compound_defn(t));
+			if (!eq_ctype(ct, cs)) {
+				NAMESPACE cns = crt_namespace;
+				if (templ) {
+					/* Shouldn't be a template class */
+					LOCATION loc;
+					DEREF_loc(id_loc(id), loc);
+					report(loc, ERR_temp_decl_bad());
+				}
+				pid = redeclare_id(cns, id);
+			}
+			break;
+		}
+		case id_enum_name_tag:
+		case id_class_alias_tag:
+		case id_enum_alias_tag:
+		case id_type_alias_tag:
+		case id_enumerator_tag: {
+			/* Redeclare other identifiers */
+			NAMESPACE cns = crt_namespace;
+			pid = redeclare_id(cns, id);
+			break;
+		}
-		cs = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		if ( !eq_ctype ( ct, cs ) ) {
-		    NAMESPACE cns = crt_namespace ;
-		    if ( templ ) {
-			/* Shouldn't be a template class */
-			LOCATION loc ;
-			DEREF_loc ( id_loc ( id ), loc ) ;
-			report ( loc, ERR_temp_decl_bad () ) ;
-		    }
-		    pid = redeclare_id ( cns, id ) ;
+		}
-		break ;
-	    }
-	    case id_enum_name_tag :
-	    case id_class_alias_tag :
-	    case id_enum_alias_tag :
-	    case id_type_alias_tag :
-	    case id_enumerator_tag : {
-		/* Redeclare other identifiers */
-		NAMESPACE cns = crt_namespace ;
-		pid = redeclare_id ( cns, id ) ;
-		break ;
-	    }
+	}
-    }
-    return ( pid ) ;
+	return (pid);
+}
 /*
     REDECLARE AN ANONYMOUS UNION
     The routine returns false if there are no members to redeclare.  The
     redeclared members are added to the extra field of the namespace given
     by ct.
 */
-int redecl_anon_union
+int
-    PROTO_N ( ( ct, ds, obj ) )
-    PROTO_T ( CLASS_TYPE ct X DECL_SPEC ds X IDENTIFIER obj )
+redecl_anon_union(CLASS_TYPE ct, DECL_SPEC ds, IDENTIFIER obj)
+{
-    int ok = 0 ;
+	int ok = 0;
-    MEMBER mem ;
+	MEMBER mem;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    LOCATION old_loc ;
+	LOCATION old_loc;
-    bad_crt_loc++ ;
+	bad_crt_loc++;
-    old_loc = crt_loc ;
+	old_loc = crt_loc;
-    ds |= dspec_reserve ;
+	ds |= dspec_reserve;
-    crt_id_qualifier = qual_none ;
+	crt_id_qualifier = qual_none;
-    crt_templ_qualifier = 0 ;
+	crt_templ_qualifier = 0;
-    ns = DEREF_nspace ( ctype_member ( ct ) ) ;
+	ns = DEREF_nspace(ctype_member(ct));
-    mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
+	mem = DEREF_member(nspace_ctype_first(ns));
-    while ( !IS_NULL_member ( mem ) ) {
+	while (!IS_NULL_member(mem)) {
-	IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER id = DEREF_id(member_id(mem));
-	IDENTIFIER aid = DEREF_id ( member_alt ( mem ) ) ;
+		IDENTIFIER aid = DEREF_id(member_alt(mem));
-	if ( !IS_NULL_id ( aid ) && !EQ_id ( aid, id ) ) {
+		if (!IS_NULL_id(aid) && !EQ_id(aid, id)) {
-	    aid = redecl_anon_member ( aid, ct, ds, obj ) ;
+			aid = redecl_anon_member(aid, ct, ds, obj);
-	    if ( !IS_NULL_id ( aid ) ) ok = 1 ;
+			if (!IS_NULL_id(aid)) {
+				ok = 1;
+			}
+		}
+		if (!IS_NULL_id(id)) {
+			id = redecl_anon_member(id, ct, ds, obj);
+			if (!IS_NULL_id(id)) {
+				ok = 1;
+			}
+		}
+		mem = DEREF_member(member_next(mem));
+	}
-	if ( !IS_NULL_id ( id ) ) {
-	    id = redecl_anon_member ( id, ct, ds, obj ) ;
-	    if ( !IS_NULL_id ( id ) ) ok = 1 ;
-	}
-	mem = DEREF_member ( member_next ( mem ) ) ;
-    }
-    crt_loc = old_loc ;
+	crt_loc = old_loc;
-    bad_crt_loc-- ;
+	bad_crt_loc--;
-    return ( ok ) ;
+	return (ok);
+}

Subversion Repositories tendra.SVN

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