WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/namespace.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.
 */
     being defined) and the stack of all enclosing namespaces.  Another stack
     of namespaces, which will be a superset of the first, gives the list
     of locations to be searched during name look-up.
 */
-NAMESPACE crt_namespace = NULL_nspace ;
+NAMESPACE crt_namespace = NULL_nspace;
-NAMESPACE last_namespace = NULL_nspace ;
+NAMESPACE last_namespace = NULL_nspace;
-NAMESPACE qual_namespace = NULL_nspace ;
+NAMESPACE qual_namespace = NULL_nspace;
-STACK ( NAMESPACE ) namespace_stack = NULL_stack ( NAMESPACE ) ;
+STACK(NAMESPACE) namespace_stack = NULL_stack(NAMESPACE);
-STACK ( NAMESPACE ) crt_nspace_stack = NULL_stack ( NAMESPACE ) ;
+STACK(NAMESPACE) crt_nspace_stack = NULL_stack(NAMESPACE);
-STACK ( NAMESPACE ) local_nspace_stack = NULL_stack ( NAMESPACE ) ;
+STACK(NAMESPACE) local_nspace_stack = NULL_stack(NAMESPACE);
 /*
     STANDARD NAMESPACES
     proto_scope option is true, function prototype namespace) enclosing
     the current namespace are maintained in nonblock_namespace and
     nonclass_namespace respectively.
 */
-NAMESPACE global_namespace = NULL_nspace ;
+NAMESPACE global_namespace = NULL_nspace;
-NAMESPACE token_namespace = NULL_nspace ;
+NAMESPACE token_namespace = NULL_nspace;
-NAMESPACE c_namespace = NULL_nspace ;
+NAMESPACE c_namespace = NULL_nspace;
-NAMESPACE nonblock_namespace = NULL_nspace ;
+NAMESPACE nonblock_namespace = NULL_nspace;
-NAMESPACE nonclass_namespace = NULL_nspace ;
+NAMESPACE nonclass_namespace = NULL_nspace;
-static NAMESPACE scope_namespace = NULL_nspace ;
+static NAMESPACE scope_namespace = NULL_nspace;
 /*
     STANDARD NAMESPACE IDENTIFIERS
     The identifier local_namespace_id is used as the name for all unnamed
     namespaces defined within the current translation unit.
 */
-static IDENTIFIER local_namespace_id = NULL_id ;
+static IDENTIFIER local_namespace_id = NULL_id;
 /*
     NAME LOOK-UP CACHE FLAG
     This flag is set to indicate that name look-up should be cached
     whenever possible.  It is switched off temporarily in field selectors
     as an optimisation.
 */
-int cache_lookup = 1 ;
+int cache_lookup = 1;
-int old_cache_lookup = 1 ;
+int old_cache_lookup = 1;
 /*
     CREATE A STANDARD NAMESPACE
     This routine creates a global namespace of size sz with a dummy name
     given by s.
 */
-NAMESPACE make_global_nspace
+NAMESPACE
-    PROTO_N ( ( s, sz ) )
-    PROTO_T ( CONST char *s X int sz )
+make_global_nspace(CONST char *s, int sz)
+{
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    string u = ustrlit ( s ) ;
+	string u = ustrlit(s);
-    NAMESPACE ns = NULL_nspace ;
+	NAMESPACE ns = NULL_nspace;
-    DECL_SPEC ds = ( dspec_defn | dspec_extern ) ;
+	DECL_SPEC ds = (dspec_defn | dspec_extern);
-    HASHID nm = lookup_name ( u, hash ( u ), 1, lex_identifier ) ;
+	HASHID nm = lookup_name(u, hash(u), 1, lex_identifier);
-    MAKE_id_nspace_name ( nm, ds, NULL_nspace, crt_loc, ns, id ) ;
+	MAKE_id_nspace_name(nm, ds, NULL_nspace, crt_loc, ns, id);
-    ns = make_namespace ( id, nspace_global_tag, sz ) ;
+	ns = make_namespace(id, nspace_global_tag, sz);
-    COPY_nspace ( id_nspace_name_defn ( id ), ns ) ;
+	COPY_nspace(id_nspace_name_defn(id), ns);
-    return ( ns ) ;
+	return (ns);
+}
 /*
     INITIALISE STANDARD NAMESPACES
     This routine initialises the standard namespaces above.
 */
-void init_namespace
+void
-    PROTO_Z ()
+init_namespace(void)
+{
-    string s = ustrlit ( "<local>" ) ;
+	string s = ustrlit("<local>");
-    HASHID nm = lookup_name ( s, hash ( s ), 1, lex_identifier ) ;
+	HASHID nm = lookup_name(s, hash(s), 1, lex_identifier);
-    local_namespace_id = DEREF_id ( hashid_id ( nm ) ) ;
+	local_namespace_id = DEREF_id(hashid_id(nm));
-    global_namespace = make_global_nspace ( "<global>", 50 ) ;
+	global_namespace = make_global_nspace("<global>", 50);
 #if LANGUAGE_CPP
-    c_namespace = make_global_nspace ( "<c>", 50 ) ;
+	c_namespace = make_global_nspace("<c>", 50);
 #endif
-    token_namespace = make_global_nspace ( "<token>", 50 ) ;
+	token_namespace = make_global_nspace("<token>", 50);
-    scope_namespace = make_global_nspace ( "<scope>", 50 ) ;
+	scope_namespace = make_global_nspace("<scope>", 50);
-    last_namespace = global_namespace ;
+	last_namespace = global_namespace;
-    old_cache_lookup = cache_lookup ;
+	old_cache_lookup = cache_lookup;
-    return ;
+	return;
+}
 /*
     DOES ONE NAMESPACE CONTAIN ANOTHER?
     This routine checks whether the namespace ns contains the definition
     of the namespace pns.
 */
-int is_subnspace
+int
-    PROTO_N ( ( ns, pns ) )
-    PROTO_T ( NAMESPACE ns X NAMESPACE pns )
+is_subnspace(NAMESPACE ns, NAMESPACE pns)
+{
-    if ( EQ_nspace ( ns, pns ) ) return ( 1 ) ;
+	if (EQ_nspace(ns, pns)) {
+		return (1);
+	}
-    while ( !IS_NULL_nspace ( pns ) ) {
+	while (!IS_NULL_nspace(pns)) {
-	pns = DEREF_nspace ( nspace_parent ( pns ) ) ;
+		pns = DEREF_nspace(nspace_parent(pns));
-	if ( EQ_nspace ( ns, pns ) ) return ( 1 ) ;
+		if (EQ_nspace(ns, pns)) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     FIND THE JOIN OF TWO NAMESPACES
     This routine finds the join of the namespaces ns and nt, that is to
     say the smallest namespace which contains both ns and nt.  A using
     directive for nt in ns causes the members of nt to be treated as
     members of the join namespace for the purposes of unqualified name
     look-up.
 */
-static NAMESPACE join_namespace
+static NAMESPACE
-    PROTO_N ( ( ns, nt ) )
-    PROTO_T ( NAMESPACE ns X NAMESPACE nt )
+join_namespace(NAMESPACE ns, NAMESPACE nt)
 {
-    while ( !EQ_nspace ( ns, nt ) ) {
+	while (!EQ_nspace(ns, nt)) {
-	if ( IS_NULL_nspace ( ns ) ) return ( NULL_nspace ) ;
+		if (IS_NULL_nspace(ns)) {
+			return (NULL_nspace);
+		}
-	if ( IS_NULL_nspace ( nt ) ) return ( NULL_nspace ) ;
+		if (IS_NULL_nspace(nt)) {
+			return (NULL_nspace);
+		}
-	if ( is_subnspace ( ns, nt ) ) return ( ns ) ;
+		if (is_subnspace(ns, nt)) {
+			return (ns);
+		}
-	if ( is_subnspace ( nt, ns ) ) return ( nt ) ;
+		if (is_subnspace(nt, ns)) {
+			return (nt);
+		}
-	ns = DEREF_nspace ( nspace_parent ( ns ) ) ;
+		ns = DEREF_nspace(nspace_parent(ns));
-	nt = DEREF_nspace ( nspace_parent ( nt ) ) ;
+		nt = DEREF_nspace(nspace_parent(nt));
-    }
+	}
-    return ( ns ) ;
+	return (ns);
 }
 /*
     UNCACHE A NAMESPACE
     This routine clears the cached name look-ups for all the names
     accessible from the namespace ns.
 */
-void uncache_namespace
+void
-    PROTO_N ( ( ns, add ) )
-    PROTO_T ( NAMESPACE ns X int add )
+uncache_namespace(NAMESPACE ns, int add)
 {
-    if ( !IS_NULL_nspace ( ns ) && cache_lookup ) {
+	if (!IS_NULL_nspace(ns) && cache_lookup) {
-	MEMBER mem ;
+		MEMBER mem;
-	LIST ( NAMESPACE ) uns ;
+		LIST(NAMESPACE) uns;
-	/* Clear cache fields for all members */
+		/* Clear cache fields for all members */
-	if ( IS_nspace_named_etc ( ns ) ) {
+		if (IS_nspace_named_etc(ns)) {
-	    mem = DEREF_member ( nspace_named_etc_first ( ns ) ) ;
+			mem = DEREF_member(nspace_named_etc_first(ns));
-	} else {
+		} else {
-	    mem = DEREF_member ( nspace_last ( ns ) ) ;
+			mem = DEREF_member(nspace_last(ns));
-	}
+		}
-	while ( !IS_NULL_member ( mem ) ) {
+		while (!IS_NULL_member(mem)) {
-	    IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+			IDENTIFIER id = DEREF_id(member_id(mem));
-	    if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				HASHID nm = DEREF_hashid(id_name(id));
+				if (!add) {
-		if ( !add ) id = NULL_id ;
+					id = NULL_id;
+				}
-		COPY_id ( hashid_cache ( nm ), id ) ;
+				COPY_id(hashid_cache(nm), id);
-	    }
+			}
-	    mem = DEREF_member ( member_next ( mem ) ) ;
+			mem = DEREF_member(member_next(mem));
-	}
+		}
-	/* Recursively clear all used namespaces */
+		/* Recursively clear all used namespaces */
-	uns = DEREF_list ( nspace_use ( ns ) ) ;
+		uns = DEREF_list(nspace_use(ns));
-	if ( !IS_NULL_list ( uns ) ) {
+		if (!IS_NULL_list(uns)) {
-	    LIST ( NAMESPACE ) lns = uns ;
+			LIST(NAMESPACE) lns = uns;
-	    COPY_list ( nspace_use ( ns ), NULL_list ( NAMESPACE ) ) ;
+			COPY_list(nspace_use(ns), NULL_list(NAMESPACE));
-	    while ( !IS_NULL_list ( lns ) ) {
+			while (!IS_NULL_list(lns)) {
-		NAMESPACE pns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+				NAMESPACE pns = DEREF_nspace(HEAD_list(lns));
-		uncache_namespace ( pns, 0 ) ;
+				uncache_namespace(pns, 0);
-		lns = TAIL_list ( lns ) ;
+				lns = TAIL_list(lns);
-	    }
+			}
-	    COPY_list ( nspace_use ( ns ), uns ) ;
+			COPY_list(nspace_use(ns), uns);
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     ADD A NAMESPACE TO THE LOOK-UP LIST
     This routine adds the namespace ns to the look-up namespace list.  Note
     that this is automatically called by push_namespace.
 */
+void
+add_namespace(NAMESPACE ns)
+{
+	PUSH_nspace(ns, namespace_stack);
+	uncache_namespace(ns, 1);
+	return;
+}
+/*
+    REMOVE A NAMESPACE FROM THE LOOK-UP LIST
-void add_namespace
+    This routine removes the top namespace from the look-up namespace list.
-    PROTO_N ( ( ns ) )
+    Note that this is automatically called by pop_namespace.
+*/
+void
-    PROTO_T ( NAMESPACE ns )
+remove_namespace(void)
+{
+	NAMESPACE ns;
-    PUSH_nspace ( ns, namespace_stack ) ;
+	POP_nspace(ns, namespace_stack);
-    uncache_namespace ( ns, 1 ) ;
+	uncache_namespace(ns, 0);
-    return ;
+	return;
+}
 /*
-    REMOVE A NAMESPACE FROM THE LOOK-UP LIST
+    PUSH A NAMESPACE
-    This routine removes the top namespace from the look-up namespace list.
-    Note that this is automatically called by pop_namespace.
-*/
-void remove_namespace
+    This routine pushes the namespace ns onto the namespace stack.
+*/
+void
-    PROTO_Z ()
+store_namespace(NAMESPACE ns)
+{
-    NAMESPACE ns ;
-    POP_nspace ( ns, namespace_stack ) ;
-    uncache_namespace ( ns, 0 ) ;
-    return ;
-}
-/*
-    PUSH A NAMESPACE
-    This routine pushes the namespace ns onto the namespace stack.
-*/
-void store_namespace
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
-{
-    NAMESPACE cns = crt_namespace ;
+	NAMESPACE cns = crt_namespace;
-    switch ( TAG_nspace ( ns ) ) {
+	switch (TAG_nspace(ns)) {
-	case nspace_named_tag :
+	case nspace_named_tag:
-	case nspace_unnamed_tag :
+	case nspace_unnamed_tag:
-	case nspace_global_tag : {
+	case nspace_global_tag:
-	    /* Record named namespaces */
+		/* Record named namespaces */
-	    nonblock_namespace = ns ;
+		nonblock_namespace = ns;
-	    nonclass_namespace = ns ;
+		nonclass_namespace = ns;
-	    break ;
+		break;
-	}
-	case nspace_param_tag : {
+	case nspace_param_tag:
-	    /* Deal with function prototype scopes */
+		/* Deal with function prototype scopes */
-	    if ( option ( OPT_proto_scope ) ) {
+		if (option(OPT_proto_scope)) {
-		nonclass_namespace = ns ;
+			nonclass_namespace = ns;
-	    }
+		}
-	    break ;
+		break;
-	}
-	case nspace_block_tag : {
+	case nspace_block_tag:
-	    /* A block is a non-class namespace */
+		/* A block is a non-class namespace */
-	    nonclass_namespace = ns ;
+		nonclass_namespace = ns;
-	    break ;
+		break;
 	}
-    }
-    COPY_nspace ( nspace_parent ( ns ), cns ) ;
+	COPY_nspace(nspace_parent(ns), cns);
-    PUSH_nspace ( cns, crt_nspace_stack ) ;
+	PUSH_nspace(cns, crt_nspace_stack);
-    crt_namespace = ns ;
+	crt_namespace = ns;
-    return ;
+	return;
+}
 /*
     POP A NAMESPACE
     This routine removes a namespace from the namespace stack.
 */
-NAMESPACE restore_namespace
+NAMESPACE
-    PROTO_Z ()
+restore_namespace(void)
+{
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    int fb = EQ_nspace ( ns, nonblock_namespace ) ;
+	int fb = EQ_nspace(ns, nonblock_namespace);
-    int fc = EQ_nspace ( ns, nonclass_namespace ) ;
+	int fc = EQ_nspace(ns, nonclass_namespace);
-    int fa = ( fb || fc ) ;
+	int fa = (fb || fc);
-    if ( fa ) {
+	if (fa) {
-	/* Check for enclosing namespaces */
+		/* Check for enclosing namespaces */
-	LIST ( NAMESPACE ) lns = LIST_stack ( crt_nspace_stack ) ;
+		LIST(NAMESPACE) lns = LIST_stack(crt_nspace_stack);
-	while ( fa && !IS_NULL_list ( lns ) ) {
+		while (fa && !IS_NULL_list(lns)) {
-	    NAMESPACE pns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+			NAMESPACE pns = DEREF_nspace(HEAD_list(lns));
-	    switch ( TAG_nspace ( pns ) ) {
+			switch (TAG_nspace(pns)) {
-		case nspace_named_tag :
+			case nspace_named_tag:
-		case nspace_unnamed_tag :
+			case nspace_unnamed_tag:
-		case nspace_global_tag : {
+			case nspace_global_tag:
-		    if ( fb ) {
+				if (fb) {
-			/* Non-block namespace found */
+					/* Non-block namespace found */
-			nonblock_namespace = pns ;
+					nonblock_namespace = pns;
-			fa = fc ;
+					fa = fc;
-			fb = 0 ;
+					fb = 0;
-		    }
+				}
-		    goto nonclass_namespace_lab ;
+				goto nonclass_namespace_lab;
-		}
-		case nspace_param_tag : {
+			case nspace_param_tag:
-		    /* Deal with function prototype scopes */
+				/* Deal with function prototype scopes */
-		    if ( !option ( OPT_proto_scope ) ) break ;
+				if (!option(OPT_proto_scope)) {
-		    goto nonclass_namespace_lab ;
+					break;
-		}
+				}
+				goto nonclass_namespace_lab;
-		case nspace_block_tag :
+			case nspace_block_tag:
-		nonclass_namespace_lab : {
+nonclass_namespace_lab:
-		    if ( fc ) {
+				if (fc) {
-			/* Non-class namespace found */
+					/* Non-class namespace found */
-			nonclass_namespace = pns ;
+					nonclass_namespace = pns;
-			fa = fb ;
+					fa = fb;
-			fc = 0 ;
+					fc = 0;
-		    }
+				}
-		    break ;
+				break;
+			}
+			lns = TAIL_list(lns);
+		}
-	    }
-	    lns = TAIL_list ( lns ) ;
+	}
-    }
-    POP_nspace ( crt_namespace, crt_nspace_stack ) ;
+	POP_nspace(crt_namespace, crt_nspace_stack);
-    return ( ns ) ;
+	return (ns);
+}
 /*
     SET CURRENT NAMESPACE
     This routine makes the namespace ns into the current namespace, pushing
     the previous namespace onto the stack.
 */
-void push_namespace
+void
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+push_namespace(NAMESPACE ns)
+{
-    store_namespace ( ns ) ;
+	store_namespace(ns);
-    add_namespace ( ns ) ;
+	add_namespace(ns);
-    return ;
+	return;
+}
 /*
     RESTORE PREVIOUS NAMESPACE
     This routine restores the current namespace to its previous value by
     popping it from the stack.  It returns the removed namespace.
 */
-NAMESPACE pop_namespace
+NAMESPACE
-    PROTO_Z ()
+pop_namespace(void)
+{
-    NAMESPACE ns = restore_namespace () ;
+	NAMESPACE ns = restore_namespace();
-    remove_namespace () ;
+	remove_namespace();
-    return ( ns ) ;
+	return (ns);
+}
 /*
     RECALCULATE NAMESPACES
     This routine forces the recalculation of nonblock_namespace and
     nonclass_namespace by pushing and immediately popping the global
     namespace.
 */
+void
-void update_namespace
+update_namespace(void)
-    PROTO_Z ()
+{
-    NAMESPACE ns = global_namespace ;
+	NAMESPACE ns = global_namespace;
-    if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	store_namespace ( ns ) ;
+		store_namespace(ns);
-	IGNORE restore_namespace () ;
+		IGNORE restore_namespace();
-    }
+	}
-    return ;
+	return;
+}
 /*
     CREATE A NAMESPACE
     This routine creates a namespace named id of type tag.  If tag is
     indicates a small namespace then sz will be zero.  Otherwise sz gives
     the size of hash table to be created.
 */
-NAMESPACE make_namespace
+NAMESPACE
-    PROTO_N ( ( id, tag, sz ) )
-    PROTO_T ( IDENTIFIER id X unsigned tag X int sz )
+make_namespace(IDENTIFIER id, unsigned tag, int sz)
 {
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    NAMESPACE pns ;
+	NAMESPACE pns;
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	pns = DEREF_nspace ( id_parent ( id ) ) ;
+		pns = DEREF_nspace(id_parent(id));
-    } else {
+	} else {
-	pns = crt_namespace ;
+		pns = crt_namespace;
-    }
+	}
-    if ( sz == 0 ) {
+	if (sz == 0) {
-	/* Small namespace */
+		/* Small namespace */
-	MAKE_nspace_block_etc ( tag, id, pns, ns ) ;
+		MAKE_nspace_block_etc(tag, id, pns, ns);
-    } else {
+	} else {
-	/* Large namespace */
+		/* Large namespace */
-	PTR ( MEMBER ) ptr ;
+		PTR(MEMBER) ptr;
-	SIZE ( MEMBER ) psz ;
+		SIZE(MEMBER) psz;
-	unsigned long i, n = ( unsigned long ) sz ;
+		unsigned long i, n = (unsigned long)sz;
-	/* Allocate namespace hash table */
+		/* Allocate namespace hash table */
-	psz = SCALE ( SIZE_member, n ) ;
+		psz = SCALE(SIZE_member, n);
-	ptr = MAKE_ptr ( psz ) ;
+		ptr = MAKE_ptr(psz);
-	MAKE_nspace_named_etc ( tag, id, pns, n, ptr, ns ) ;
+		MAKE_nspace_named_etc(tag, id, pns, n, ptr, ns);
-	/* Initialise hash table entries */
+		/* Initialise hash table entries */
-	for ( i = 0 ; i < n ; i++ ) {
+		for (i = 0; i < n; i++) {
-	    COPY_member ( ptr, NULL_member ) ;
+			COPY_member(ptr, NULL_member);
-	    ptr = STEP_ptr ( ptr, SIZE_member ) ;
+			ptr = STEP_ptr(ptr, SIZE_member);
+		}
+	}
-    }
-    return ( ns ) ;
+	return (ns);
+}
 /*
     USE A NAMESPACE
     This routine creates a using directive for the namespace ns in
     the namespace cns.  nt gives the join of cns and ns.  The routine
     returns zero to indicate that ns has already been used from cns.
 */
-int use_namespace
+int
-    PROTO_N ( ( ns, cns, nt ) )
-    PROTO_T ( NAMESPACE ns X NAMESPACE cns X NAMESPACE nt )
+use_namespace(NAMESPACE ns, NAMESPACE cns, NAMESPACE nt)
 {
-    if ( !EQ_nspace ( cns, ns ) ) {
+	if (!EQ_nspace(cns, ns)) {
-	LIST ( NAMESPACE ) p = DEREF_list ( nspace_use ( cns ) ) ;
+		LIST(NAMESPACE) p = DEREF_list(nspace_use(cns));
-	LIST ( NAMESPACE ) r = DEREF_list ( nspace_join ( cns ) ) ;
+		LIST(NAMESPACE) r = DEREF_list(nspace_join(cns));
-	LIST ( NAMESPACE ) q = p ;
+		LIST(NAMESPACE) q = p;
-	while ( !IS_NULL_list ( q ) ) {
+		while (!IS_NULL_list(q)) {
-	    NAMESPACE qns = DEREF_nspace ( HEAD_list ( q ) ) ;
+			NAMESPACE qns = DEREF_nspace(HEAD_list(q));
-	    if ( EQ_nspace ( qns, ns ) ) return ( 0 ) ;
+			if (EQ_nspace(qns, ns)) {
+				return (0);
+			}
-	    q = TAIL_list ( q ) ;
+			q = TAIL_list(q);
-	}
+		}
-	CONS_nspace ( nt, r, r ) ;
+		CONS_nspace(nt, r, r);
-	COPY_list ( nspace_join ( cns ), r ) ;
+		COPY_list(nspace_join(cns), r);
-	CONS_nspace ( ns, p, p ) ;
+		CONS_nspace(ns, p, p);
-	COPY_list ( nspace_use ( cns ), p ) ;
+		COPY_list(nspace_use(cns), p);
-	return ( 1 ) ;
+		return (1);
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     LIST OF JOIN NAMESPACES
     During unqualified name look-up any using-directives are treated as
     dummy using-directive into the join namespace.  This list is used
     to keep track of all the join namespaces which have using-directives
     injected in this way.
 */
-static LIST ( NAMESPACE ) join_nspaces = NULL_list ( NAMESPACE ) ;
+static LIST(NAMESPACE) join_nspaces = NULL_list(NAMESPACE);
 /*
     CLEAR LIST OF JOIN NAMESPACES
     This routine removes any dummy using-directives from the list of join
     namespaces above.
 */
-static void clear_join_nspaces
+static void
-    PROTO_Z ()
+clear_join_nspaces(void)
+{
-    LIST ( NAMESPACE ) lns = join_nspaces ;
+	LIST(NAMESPACE) lns = join_nspaces;
-    while ( !IS_NULL_list ( lns ) ) {
+	while (!IS_NULL_list(lns)) {
-	NAMESPACE ns ;
+		NAMESPACE ns;
-	NAMESPACE dns ;
+		NAMESPACE dns;
-	LIST ( NAMESPACE ) p ;
+		LIST(NAMESPACE) p;
-	DESTROY_CONS_nspace ( destroy, ns, lns, lns ) ;
+		DESTROY_CONS_nspace(destroy, ns, lns, lns);
-	p = DEREF_list ( nspace_use ( ns ) ) ;
+		p = DEREF_list(nspace_use(ns));
-	if ( !IS_NULL_list ( p ) ) {
+		if (!IS_NULL_list(p)) {
-	    DESTROY_CONS_nspace ( destroy, dns, p, p ) ;
+			DESTROY_CONS_nspace(destroy, dns, p, p);
-	    UNUSED ( dns ) ;
+			UNUSED(dns);
-	    COPY_list ( nspace_use ( ns ), p ) ;
+			COPY_list(nspace_use(ns), p);
+		}
+		p = DEREF_list(nspace_join(ns));
+		if (!IS_NULL_list(p)) {
+			DESTROY_CONS_nspace(destroy, dns, p, p);
+			UNUSED(dns);
+			COPY_list(nspace_join(ns), p);
+		}
+	}
-	p = DEREF_list ( nspace_join ( ns ) ) ;
-	if ( !IS_NULL_list ( p ) ) {
-	    DESTROY_CONS_nspace ( destroy, dns, p, p ) ;
-	    UNUSED ( dns ) ;
-	    COPY_list ( nspace_join ( ns ), p ) ;
-	}
-    }
-    join_nspaces = NULL_list ( NAMESPACE ) ;
+	join_nspaces = NULL_list(NAMESPACE);
-    return ;
+	return;
+}
 /*
     BEGIN A NAMESPACE DEFINITION
     This routine begins the definition of a namespace named id (or an
     anonymous namespace if anon is true).  Note that there may be multiple
     definitions of a namespace, the effect of the later definitions being
     to add elements to the existing namespace.  Only original namespace
     names, and not namespace aliases, can be used in these namespace
     extensions.
 */
-void begin_namespace
+void
-    PROTO_N ( ( id, anon ) )
-    PROTO_T ( IDENTIFIER id X int anon )
+begin_namespace(IDENTIFIER id, int anon)
 {
-    HASHID nm ;
+	HASHID nm;
-    MEMBER mem ;
+	MEMBER mem;
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    NAMESPACE ns = NULL_nspace ;
+	NAMESPACE ns = NULL_nspace;
-    NAMESPACE cns = crt_namespace ;
+	NAMESPACE cns = crt_namespace;
-    unsigned tag = nspace_named_tag ;
+	unsigned tag = nspace_named_tag;
-    /* Find name for anonymous namespaces */
+	/* Find name for anonymous namespaces */
-    if ( anon ) {
+	if (anon) {
-	id = local_namespace_id ;
+		id = local_namespace_id;
-	tag = nspace_unnamed_tag ;
+		tag = nspace_unnamed_tag;
-    }
+	}
-    nm = DEREF_hashid ( id_name ( id ) ) ;
+	nm = DEREF_hashid(id_name(id));
-    /* 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_nspace_scope () ) ;
+		report(crt_loc, ERR_dcl_nspace_scope());
-    }
+	}
-    /* Look up namespace name */
+	/* Look up namespace name */
-    mem = search_member ( cns, nm, 1 ) ;
+	mem = search_member(cns, nm, 1);
-    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)) {
-	/* Check for redeclarations */
+		/* Check for redeclarations */
-	old_id = redecl_inherit ( old_id, qual_none, in_class_defn, 2 ) ;
+		old_id = redecl_inherit(old_id, qual_none, in_class_defn, 2);
-	switch ( TAG_id ( old_id ) ) {
+		switch (TAG_id(old_id)) {
-	    case id_nspace_name_tag : {
+		case id_nspace_name_tag:
-		/* Previously defined namespace */
+			/* Previously defined namespace */
-		ns = DEREF_nspace ( id_nspace_name_defn ( old_id ) ) ;
+			ns = DEREF_nspace(id_nspace_name_defn(old_id));
-		break ;
+			break;
-	    }
-	    case id_nspace_alias_tag : {
+		case id_nspace_alias_tag: {
-		/* Previously defined namespace alias */
+			/* Previously defined namespace alias */
-		IDENTIFIER ns_id ;
+			IDENTIFIER ns_id;
-		ns = DEREF_nspace ( id_nspace_alias_defn ( old_id ) ) ;
+			ns = DEREF_nspace(id_nspace_alias_defn(old_id));
-		ns_id = DEREF_id ( nspace_name ( ns ) ) ;
+			ns_id = DEREF_id(nspace_name(ns));
-		if ( !IS_id_nspace_name ( ns_id ) ) {
+			if (!IS_id_nspace_name(ns_id)) {
-		    /* Alias for class namespace */
+				/* Alias for class namespace */
-		    ns = NULL_nspace ;
+				ns = NULL_nspace;
-		    goto default_lab ;
+				goto default_lab;
-		}
+			}
-		report ( crt_loc, ERR_dcl_nspace_def_orig ( ns_id, old_id ) ) ;
+			report(crt_loc, ERR_dcl_nspace_def_orig(ns_id, old_id));
-		break ;
+			break;
-	    }
+		}
-	    default :
+		default:
-	    default_lab : {
+default_lab: {
-		/* Other previously defined identifier */
+		     /* Other previously defined identifier */
-		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));
-		break ;
+		     break;
-	    }
+	     }
-	}
+		}
-    }
+	}
-    /* Construct the namespace if necessary */
+	/* Construct the namespace if necessary */
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	DECL_SPEC ds = ( dspec_defn | dspec_extern ) ;
+		DECL_SPEC ds = (dspec_defn | dspec_extern);
-	MAKE_id_nspace_name ( nm, ds, cns, decl_loc, ns, id ) ;
+		MAKE_id_nspace_name(nm, ds, cns, decl_loc, ns, id);
-	ns = make_namespace ( id, tag, 50 ) ;
+		ns = make_namespace(id, tag, 50);
-	COPY_nspace ( id_nspace_name_defn ( id ), ns ) ;
+		COPY_nspace(id_nspace_name_defn(id), ns);
-	set_member ( mem, id ) ;
+		set_member(mem, id);
-	if ( anon ) {
+		if (anon) {
-	    /* Anonymous namespaces are implicitly used */
+			/* Anonymous namespaces are implicitly used */
-	    IGNORE use_namespace ( ns, cns, cns ) ;
+			IGNORE use_namespace(ns, cns, cns);
+			if (do_dump) {
-	    if ( do_dump ) dump_using ( ns, cns, &decl_loc ) ;
+				dump_using(ns, cns, &decl_loc);
+			}
-	}
+		}
-    }
+	}
-    /* Adjust the current namespace */
+	/* Adjust the current namespace */
+	if (do_dump) {
-    if ( do_dump ) dump_declare ( id, &decl_loc, 1 ) ;
+		dump_declare(id, &decl_loc, 1);
+	}
-    push_namespace ( ns ) ;
+	push_namespace(ns);
-    cns = DEREF_nspace ( id_parent ( id ) ) ;
+	cns = DEREF_nspace(id_parent(id));
-    COPY_nspace ( nspace_parent ( ns ), cns ) ;
+	COPY_nspace(nspace_parent(ns), cns);
-    return ;
+	return;
+}
 /*
     END A NAMESPACE DEFINITION
     This routine ends the definition of the current namespace.
 */
-void end_namespace
+void
-    PROTO_N ( ( anon ) )
-    PROTO_T ( int anon )
+end_namespace(int anon)
 {
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    clear_decl_blocks () ;
+	clear_decl_blocks();
-    ns = pop_namespace () ;
+	ns = pop_namespace();
-    if ( do_dump ) {
+	if (do_dump) {
-	IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
+		IDENTIFIER id = DEREF_id(nspace_name(ns));
-	dump_undefine ( id, &crt_loc, 0 ) ;
+		dump_undefine(id, &crt_loc, 0);
-    }
+	}
-    UNUSED ( anon ) ;
+	UNUSED(anon);
-    return ;
+	return;
 }
 /*
     PROCESS A TARGET DEPENDENT DECLARATION SEQUENCE
     This routine is called in the processing of target dependent
     preprocessing directives within declaration sequences.  The directive
     involved is given by dir, while c gives the associated condition for
     '#if' and '#elif'.
 */
-void target_decl
+void
-    PROTO_N ( ( dir, c ) )
-    PROTO_T ( int dir X EXP c )
+target_decl(int dir, EXP c)
 {
-    if ( !IS_NULL_exp ( c ) ) {
+	if (!IS_NULL_exp(c)) {
-	report ( crt_loc, ERR_cpp_cond_if_ti_decl ( dir ) ) ;
+		report(crt_loc, ERR_cpp_cond_if_ti_decl(dir));
-    }
+	}
-    return ;
+	return;
 }
 /*
     BEGIN A DECLARATION BLOCK
     A declaration block is a technique for partitioning the external
     declarations into subsets.  These subsets have no significance within
     the language, but are useful for indicating, for example, those
     identifiers which form part of a certain API.  This routine starts
     a declaration block named id.
 */
-void begin_decl_block
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+begin_decl_block(IDENTIFIER id)
 {
-    NAMESPACE cns = nonblock_namespace ;
+	NAMESPACE cns = nonblock_namespace;
-    NAMESPACE sns = scope_namespace ;
+	NAMESPACE sns = scope_namespace;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    MEMBER mem = search_member ( sns, nm, 1 ) ;
+	MEMBER mem = search_member(sns, nm, 1);
-    id = DEREF_id ( member_id ( mem ) ) ;
+	id = DEREF_id(member_id(mem));
-    if ( IS_NULL_id ( id ) ) {
+	if (IS_NULL_id(id)) {
-	/* Create dummy namespace identifier */
+		/* Create dummy namespace identifier */
-	NAMESPACE bns = NULL_nspace ;
+		NAMESPACE bns = NULL_nspace;
-	DECL_SPEC ds = ( dspec_defn | dspec_extern ) ;
+		DECL_SPEC ds = (dspec_defn | dspec_extern);
-	MAKE_id_nspace_name ( nm, ds, cns, crt_loc, bns, id ) ;
+		MAKE_id_nspace_name(nm, ds, cns, crt_loc, bns, id);
-	bns = make_namespace ( id, nspace_block_tag, 0 ) ;
+		bns = make_namespace(id, nspace_block_tag, 0);
-	COPY_nspace ( id_nspace_name_defn ( id ), bns ) ;
+		COPY_nspace(id_nspace_name_defn(id), bns);
-	COPY_id ( member_id ( mem ), id ) ;
+		COPY_id(member_id(mem), id);
-    }
+	}
-    if ( do_dump ) {
+	if (do_dump) {
-	/* Output scope to dump file */
+		/* Output scope to dump file */
-	NAMESPACE bns = DEREF_nspace ( id_nspace_name_defn ( id ) ) ;
+		NAMESPACE bns = DEREF_nspace(id_nspace_name_defn(id));
-	dump_begin_scope ( id, bns, cns, &crt_loc ) ;
+		dump_begin_scope(id, bns, cns, &crt_loc);
-    }
+	}
-    if ( !IS_NULL_nspace ( cns ) ) {
+	if (!IS_NULL_nspace(cns)) {
-	/* Add to current namespace */
+		/* Add to current namespace */
-	STACK ( IDENTIFIER ) pids = DEREF_stack ( nspace_set ( cns ) ) ;
+		STACK(IDENTIFIER)pids = DEREF_stack(nspace_set(cns));
-	PUSH_id ( id, pids ) ;
+		PUSH_id(id, pids);
-	COPY_stack ( nspace_set ( cns ), pids ) ;
+		COPY_stack(nspace_set(cns), pids);
-    }
+	}
-    return ;
+	return;
+}
 /*
     END A DECLARATION BLOCK
     This routine ends a declaration block named id or the current
     declaration block if id is the null identifier.  If there is no
     current declaration block and force is true then an error is
     raised.  The routine returns true if a declaration block is ended.
 */
-int end_decl_block
+int
-    PROTO_N ( ( id, force ) )
-    PROTO_T ( IDENTIFIER id X int force )
+end_decl_block(IDENTIFIER id, int force)
 {
-    int res = 0 ;
+	int res = 0;
-    NAMESPACE cns = nonblock_namespace ;
+	NAMESPACE cns = nonblock_namespace;
-    if ( !IS_NULL_nspace ( cns ) ) {
+	if (!IS_NULL_nspace(cns)) {
-	/* Add to current namespace */
+		/* Add to current namespace */
-	STACK ( IDENTIFIER ) pids = DEREF_stack ( nspace_set ( cns ) ) ;
+		STACK(IDENTIFIER) pids = DEREF_stack(nspace_set(cns));
-	if ( IS_NULL_stack ( pids ) ) {
+		if (IS_NULL_stack(pids)) {
-	    if ( force ) {
+			if (force) {
-		/* Stack shouldn't be empty */
+				/* Stack shouldn't be empty */
-		report ( crt_loc, ERR_pragma_dblock_end () ) ;
+				report(crt_loc, ERR_pragma_dblock_end());
-	    }
+			}
-	} else {
+		} else {
-	    IDENTIFIER pid ;
+			IDENTIFIER pid;
-	    POP_id ( pid, pids ) ;
+			POP_id(pid, pids);
-	    COPY_stack ( nspace_set ( cns ), pids ) ;
+			COPY_stack(nspace_set(cns), pids);
-	    if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		/* Check block name if given */
+				/* Check block name if given */
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				HASHID nm = DEREF_hashid(id_name(id));
-		HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
+				HASHID pnm = DEREF_hashid(id_name(pid));
-		if ( !EQ_hashid ( nm, pnm ) ) {
+				if (!EQ_hashid(nm, pnm)) {
+					report(crt_loc,
-		    report ( crt_loc, ERR_pragma_dblock_name ( pnm ) ) ;
+					       ERR_pragma_dblock_name(pnm));
-		}
+				}
-	    }
+			}
-	    if ( do_dump ) {
+			if (do_dump) {
-		/* Output scope to dump file */
+				/* Output scope to dump file */
+				NAMESPACE bns =
-		NAMESPACE bns = DEREF_nspace ( id_nspace_name_defn ( pid ) ) ;
+				    DEREF_nspace(id_nspace_name_defn(pid));
-		dump_end_scope ( pid, bns, &crt_loc ) ;
+				dump_end_scope(pid, bns, &crt_loc);
-	    }
+			}
-	    res = 1 ;
+			res = 1;
-	}
+		}
-    }
+	}
-    return ( res ) ;
+	return (res);
 }
 /*
     END ALL DECLARATION BLOCKS
     This routine ends all the declaration blocks associated with the
     current namespace.  This is called at the end of a namespace definition
     and at the end of the input file.
 */
+void
-void clear_decl_blocks
+clear_decl_blocks(void)
-    PROTO_Z ()
+{
-    while ( end_decl_block ( NULL_id, 0 ) ) ;
+	while (end_decl_block(NULL_id, 0));
-    return ;
+	return;
+}
 /*
     FIND A NAMESPACE
     This routine finds the namespace corresponding to the identifier id,
     returning the null namespace if id does not represent a class or a
     namespace.
 */
-NAMESPACE find_namespace
+NAMESPACE
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+find_namespace(IDENTIFIER id)
 {
-    NAMESPACE ns = NULL_nspace ;
+	NAMESPACE ns = NULL_nspace;
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_nspace_name_tag :
+		case id_nspace_name_tag:
-	    case id_nspace_alias_tag : {
+		case id_nspace_alias_tag:
-		/* Explicitly named namespaces */
+			/* Explicitly named namespaces */
-		ns = DEREF_nspace ( id_nspace_name_etc_defn ( id ) ) ;
+			ns = DEREF_nspace(id_nspace_name_etc_defn(id));
-		break ;
+			break;
-	    }
-	    case id_class_name_tag :
+		case id_class_name_tag:
-	    case id_class_alias_tag : {
+		case id_class_alias_tag: {
-		/* Class namespaces */
+			/* Class namespaces */
-		TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+			TYPE t = DEREF_type(id_class_name_etc_defn(id));
-		if ( IS_type_compound ( t ) ) {
+			if (IS_type_compound(t)) {
+				CLASS_TYPE ct =
-		    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				    DEREF_ctype(type_compound_defn(t));
-		    complete_class ( ct, 1 ) ;
+				complete_class(ct, 1);
-		    ns = DEREF_nspace ( ctype_member ( ct ) ) ;
+				ns = DEREF_nspace(ctype_member(ct));
-		} else {
+			} else {
-		    CLASS_TYPE ct = find_class ( id ) ;
+				CLASS_TYPE ct = find_class(id);
-		    if ( !IS_NULL_ctype ( ct ) ) {
+				if (!IS_NULL_ctype(ct)) {
-			complete_class ( ct, 1 ) ;
+					complete_class(ct, 1);
-			ns = DEREF_nspace ( ctype_member ( ct ) ) ;
+					ns = DEREF_nspace(ctype_member(ct));
-		    }
+				}
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-    }
+	}
-    return ( ns ) ;
+	return (ns);
 }
 /*
     LOOK UP A NAMESPACE NAME
     This routine looks up the identifier id as a namespace name in a
     namespace alias or namespace directive.
 */
-NAMESPACE find_nspace_id
+NAMESPACE
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+find_nspace_id(IDENTIFIER id)
+{
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    if ( IS_id_nspace_name_etc ( id ) ) {
+	if (IS_id_nspace_name_etc(id)) {
-	ns = DEREF_nspace ( id_nspace_name_etc_defn ( id ) ) ;
+		ns = DEREF_nspace(id_nspace_name_etc_defn(id));
-    } else {
+	} else {
-	if ( crt_templ_qualifier == 0 ) {
+		if (crt_templ_qualifier == 0) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    if ( crt_id_qualifier == qual_none ) {
+			if (crt_id_qualifier == qual_none) {
-		IDENTIFIER nid = find_type_id ( nm, 2 ) ;
+				IDENTIFIER nid = find_type_id(nm, 2);
-		if ( !IS_NULL_id ( nid ) ) id = nid ;
+				if (!IS_NULL_id(nid)) {
+					id = nid;
+				}
-	    } else {
+			} else {
-		NAMESPACE pns = DEREF_nspace ( id_parent ( id ) ) ;
+				NAMESPACE pns = DEREF_nspace(id_parent(id));
-		IDENTIFIER nid = find_qual_id ( pns, nm, 0, 2 ) ;
+				IDENTIFIER nid = find_qual_id(pns, nm, 0, 2);
-		if ( !IS_NULL_id ( nid ) ) id = nid ;
+				if (!IS_NULL_id(nid)) {
+					id = nid;
-	    }
+				}
+			}
-	}
+		}
-	ns = find_namespace ( id ) ;
+		ns = find_namespace(id);
-	if ( IS_NULL_nspace ( ns ) ) {
+		if (IS_NULL_nspace(ns)) {
-	    /* Invalid namespace identifier */
+			/* Invalid namespace identifier */
-	    report ( crt_loc, ERR_dcl_nspace_undef ( id ) ) ;
+			report(crt_loc, ERR_dcl_nspace_undef(id));
-	    return ( NULL_nspace ) ;
+			return (NULL_nspace);
+		}
+	}
-    }
-    use_id ( id, 0 ) ;
+	use_id(id, 0);
-    return ( ns ) ;
+	return (ns);
+}
 /*
     CONSTRUCT A NAMESPACE ALIAS
     This routine sets up id as an alias for the namespace ns.  A namespace
     alias may be consistently redefined any number of times.
 */
-void alias_namespace
+void
-    PROTO_N ( ( id, ns ) )
-    PROTO_T ( IDENTIFIER id X NAMESPACE ns )
+alias_namespace(IDENTIFIER id, NAMESPACE ns)
+{
-    MEMBER mem ;
+	MEMBER mem;
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    NAMESPACE cns = crt_namespace ;
+	NAMESPACE cns = crt_namespace;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    DECL_SPEC ds = ( dspec_defn | dspec_extern ) ;
+	DECL_SPEC ds = (dspec_defn | dspec_extern);
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	/* Invalid namespace identifier */
+		/* Invalid namespace identifier */
-	begin_namespace ( id, 0 ) ;
+		begin_namespace(id, 0);
-	end_namespace ( 0 ) ;
+		end_namespace(0);
-	return ;
+		return;
-    }
+	}
-    if ( IS_nspace_ctype ( ns ) ) {
+	if (IS_nspace_ctype(ns)) {
-	/* Can't have a class namespace */
+		/* Can't have a class namespace */
-	report ( crt_loc, ERR_dcl_nspace_alias_class ( ns ) ) ;
+		report(crt_loc, ERR_dcl_nspace_alias_class(ns));
-    }
+	}
-    /* Look up namespace alias name */
+	/* Look up namespace alias name */
-    mem = search_member ( cns, nm, 1 ) ;
+	mem = search_member(cns, nm, 1);
-    old_id = DEREF_id ( member_id ( mem ) ) ;
+	old_id = DEREF_id(member_id(mem));
-    /* Check for redeclarations */
+	/* Check for redeclarations */
-    if ( !IS_NULL_id ( old_id ) ) {
+	if (!IS_NULL_id(old_id)) {
-	old_id = redecl_inherit ( old_id, qual_none, in_class_defn, 2 ) ;
+		old_id = redecl_inherit(old_id, qual_none, in_class_defn, 2);
-	switch ( TAG_id ( old_id ) ) {
+		switch (TAG_id(old_id)) {
-	    case id_nspace_name_tag : {
+		case id_nspace_name_tag: {
-		/* Previously defined namespace name */
+			/* Previously defined namespace name */
-		ERROR err ;
+			ERROR err;
-		NAMESPACE old_ns ;
+			NAMESPACE old_ns;
-		PTR ( LOCATION ) loc = id_loc ( old_id ) ;
+			PTR(LOCATION) loc = id_loc(old_id);
-		old_ns = DEREF_nspace ( id_nspace_name_defn ( old_id ) ) ;
+			old_ns = DEREF_nspace(id_nspace_name_defn(old_id));
-		report ( crt_loc, ERR_dcl_nspace_alias_bad ( old_id, loc ) ) ;
+			report(crt_loc, ERR_dcl_nspace_alias_bad(old_id, loc));
-		if ( EQ_nspace ( ns, old_ns ) ) {
+			if (EQ_nspace(ns, old_ns)) {
-		    /* No further action if consistent */
+				/* No further action if consistent */
-		    return ;
+				return;
-		}
+			}
-		/* Hide namespace name with namespace alias */
+			/* Hide namespace name with namespace alias */
-		err = ERR_dcl_nspace_alias_redef ( old_id, loc ) ;
+			err = ERR_dcl_nspace_alias_redef(old_id, loc);
-		report ( crt_loc, err ) ;
+			report(crt_loc, err);
-		break ;
+			break;
-	    }
+		}
-	    case id_nspace_alias_tag : {
+		case id_nspace_alias_tag: {
-		/* Previously defined namespace alias */
+			/* Previously defined namespace alias */
-		NAMESPACE old_ns ;
+			NAMESPACE old_ns;
-		old_ns = DEREF_nspace ( id_nspace_alias_defn ( old_id ) ) ;
+			old_ns = DEREF_nspace(id_nspace_alias_defn(old_id));
-		if ( !EQ_nspace ( ns, old_ns ) ) {
+			if (!EQ_nspace(ns, old_ns)) {
-		    /* Inconsistent alias redefinition */
+				/* Inconsistent alias redefinition */
-		    ERROR err ;
+				ERROR err;
-		    PTR ( LOCATION ) loc = id_loc ( old_id ) ;
+				PTR(LOCATION) loc = id_loc(old_id);
-		    err = ERR_dcl_nspace_alias_redef ( old_id, loc ) ;
+				err = ERR_dcl_nspace_alias_redef(old_id, loc);
-		    report ( crt_loc, err ) ;
+				report(crt_loc, err);
-		    COPY_nspace ( id_nspace_alias_defn ( old_id ), ns ) ;
+				COPY_nspace(id_nspace_alias_defn(old_id), ns);
-		}
+			}
-		return ;
+			return;
-	    }
+		}
-	    default : {
+		default: {
-		/* Other previously defined identifier */
+			/* Other previously defined identifier */
-		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));
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-    }
+	}
-    /* Set up the namespace alias */
+	/* Set up the namespace alias */
-    MAKE_id_nspace_alias ( nm, ds, cns, decl_loc, ns, id ) ;
+	MAKE_id_nspace_alias(nm, ds, cns, decl_loc, ns, id);
-    set_member ( mem, id ) ;
+	set_member(mem, id);
-    return ;
+	return;
 }
 /*
     PROCESS A USING NAMESPACE DIRECTIVE
     This routine processes a using namespace directive for the namespace ns.
 */
-void using_namespace
+void
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+using_namespace(NAMESPACE ns)
 {
-    if ( !IS_NULL_nspace ( ns ) ) {
+	if (!IS_NULL_nspace(ns)) {
-	if ( IS_nspace_ctype ( ns ) ) {
+		if (IS_nspace_ctype(ns)) {
-	    /* Namespace designates a class */
+			/* Namespace designates a class */
-	    report ( crt_loc, ERR_dcl_nspace_udir_class ( ns ) ) ;
+			report(crt_loc, ERR_dcl_nspace_udir_class(ns));
-	} else {
+		} else {
-	    NAMESPACE cns = crt_namespace ;
+			NAMESPACE cns = crt_namespace;
-	    NAMESPACE jns = join_namespace ( ns, cns ) ;
+			NAMESPACE jns = join_namespace(ns, cns);
-	    if ( IS_NULL_nspace ( jns ) ) jns = global_namespace ;
+			if (IS_NULL_nspace(jns)) {
+				jns = global_namespace;
+			}
-	    if ( !use_namespace ( ns, cns, jns ) ) {
+			if (!use_namespace(ns, cns, jns)) {
-		/* Namespace already used */
+				/* Namespace already used */
-		report ( crt_loc, ERR_dcl_nspace_udir_dup ( ns ) ) ;
+				report(crt_loc, ERR_dcl_nspace_udir_dup(ns));
-	    }
+			}
-	    uncache_namespace ( ns, 0 ) ;
+			uncache_namespace(ns, 0);
+			if (do_dump) {
-	    if ( do_dump ) dump_using ( ns, cns, &crt_loc ) ;
+				dump_using(ns, cns, &crt_loc);
+			}
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     ADD A NESTED NAMESPACE
     This routine adds the namespace ns to the look-up stack.  If ns is
     a nested namespace then the enclosing namespaces are also added.
     It returns true if the stack is changed.
 */
-int add_nested_nspace
+int
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+add_nested_nspace(NAMESPACE ns)
+{
-    int res = 0 ;
+	int res = 0;
-    if ( !IS_NULL_nspace ( ns ) && !EQ_nspace ( ns, crt_namespace ) ) {
+	if (!IS_NULL_nspace(ns) && !EQ_nspace(ns, crt_namespace)) {
-	switch ( TAG_nspace ( ns ) ) {
+		switch (TAG_nspace(ns)) {
-	    case nspace_named_tag :
+		case nspace_named_tag:
-	    case nspace_unnamed_tag :
+		case nspace_unnamed_tag:
-	    case nspace_ctype_tag : {
+		case nspace_ctype_tag: {
-		IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
+			IDENTIFIER id = DEREF_id(nspace_name(ns));
-		if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		    NAMESPACE pns = DEREF_nspace ( id_parent ( id ) ) ;
+				NAMESPACE pns = DEREF_nspace(id_parent(id));
-		    IGNORE add_nested_nspace ( pns ) ;
+				IGNORE add_nested_nspace(pns);
+			}
+			add_namespace(ns);
+			res = 1;
+			break;
+		}
+		}
-		add_namespace ( ns ) ;
-		res = 1 ;
-		break ;
-	    }
+	}
-    }
-    return ( res ) ;
+	return (res);
+}
 /*
     REMOVE A NESTED NAMESPACE
     This routine removes the namespace ns from the look-up stack.  If
     ns is a namespace class then the enclosing namespaces are also
     removed.  It returns true if the stack is changed.
 */
-int remove_nested_nspace
+int
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+remove_nested_nspace(NAMESPACE ns)
+{
-    int res = 0 ;
+	int res = 0;
-    if ( !IS_NULL_nspace ( ns ) && !EQ_nspace ( ns, crt_namespace ) ) {
+	if (!IS_NULL_nspace(ns) && !EQ_nspace(ns, crt_namespace)) {
-	switch ( TAG_nspace ( ns ) ) {
+		switch (TAG_nspace(ns)) {
-	    case nspace_named_tag :
+		case nspace_named_tag:
-	    case nspace_unnamed_tag :
+		case nspace_unnamed_tag:
-	    case nspace_ctype_tag : {
+		case nspace_ctype_tag: {
-		IDENTIFIER id ;
+			IDENTIFIER id;
-		remove_namespace () ;
+			remove_namespace();
-		id = DEREF_id ( nspace_name ( ns ) ) ;
+			id = DEREF_id(nspace_name(ns));
-		if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		    NAMESPACE pns = DEREF_nspace ( id_parent ( id ) ) ;
+				NAMESPACE pns = DEREF_nspace(id_parent(id));
-		    IGNORE remove_nested_nspace ( pns ) ;
+				IGNORE remove_nested_nspace(pns);
+			}
+			res = 1;
+			break;
+		}
+		}
-		res = 1 ;
-		break ;
-	    }
 	}
-    }
-    return ( res ) ;
+	return (res);
 }
 /*
     BEGIN THE LOOK-UP SCOPE FOR A DECLARATOR
     This routine is called immediately after the declarator id given with
     identifier qualifiers idtype and qns to set the name look-up
     appropriately.  Thus for example, in 'int C::a = b ;', b is looked up
     in the scope of C.
 */
-void begin_declarator
+void
-    PROTO_N ( ( id, idtype, qns, scan ) )
-    PROTO_T ( IDENTIFIER id X QUALIFIER idtype X NAMESPACE qns X int scan )
+begin_declarator(IDENTIFIER id, QUALIFIER idtype, NAMESPACE qns, int scan)
 {
-    NAMESPACE ns = NULL_nspace ;
+	NAMESPACE ns = NULL_nspace;
-    if ( idtype != qual_none ) {
+	if (idtype != qual_none) {
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
+		ns = DEREF_nspace(id_parent(id));
-	if ( !IS_NULL_nspace ( ns ) && !IS_nspace_ctype ( ns ) ) {
+		if (!IS_NULL_nspace(ns) && !IS_nspace_ctype(ns)) {
-	    if ( !IS_NULL_nspace ( qns ) && !EQ_nspace ( qns, ns ) ) {
+			if (!IS_NULL_nspace(qns) && !EQ_nspace(qns, ns)) {
-		/* Should have an immediate member */
+				/* Should have an immediate member */
-		report ( crt_loc, ERR_lookup_qual_decl ( id, qns ) ) ;
+				report(crt_loc, ERR_lookup_qual_decl(id, qns));
-		ns = qns ;
+				ns = qns;
-	    }
+			}
-	}
+		}
-	if ( add_nested_nspace ( ns ) && scan ) {
+		if (add_nested_nspace(ns) && scan) {
-	    /* Rescan identifier if stack has changed */
+			/* Rescan identifier if stack has changed */
-	    RESCAN_LEXER ;
+			RESCAN_LEXER;
+		}
+	}
+	PUSH_nspace(ns, local_nspace_stack);
+	if (crt_state_depth == 0) {
+		id = underlying_id(id);
+		DEREF_loc(id_loc(id), decl_loc);
+	} else {
+		decl_loc = crt_loc;
+	}
-    }
-    PUSH_nspace ( ns, local_nspace_stack ) ;
-    if ( crt_state_depth == 0 ) {
-	id = underlying_id ( id ) ;
-	DEREF_loc ( id_loc ( id ), decl_loc ) ;
-    } else {
-	decl_loc = crt_loc ;
-    }
-    return ;
+	return;
+}
 /*
     END THE LOOK-UP SCOPE FOR A DECLARATOR
     This routine is called at the end of the initialiser or definition
     of the declarator id to reset the name look-up.
 */
-void end_declarator
+void
-    PROTO_N ( ( id, scan ) )
-    PROTO_T ( IDENTIFIER id X int scan )
+end_declarator(IDENTIFIER id, int scan)
 {
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    POP_nspace ( ns, local_nspace_stack ) ;
+	POP_nspace(ns, local_nspace_stack);
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    IDENTIFIER cid = DEREF_id ( hashid_cache ( nm ) ) ;
+			IDENTIFIER cid = DEREF_id(hashid_cache(nm));
-	    if ( !EQ_id ( id, cid ) ) {
+			if (!EQ_id(id, cid)) {
-		/* Look-up may have changed */
+				/* Look-up may have changed */
-		COPY_id ( hashid_cache ( nm ), NULL_id ) ;
+				COPY_id(hashid_cache(nm), NULL_id);
-		if ( scan ) {
+				if (scan) {
-		    /* Rescan identifier if look-up has changed */
+					/* Rescan identifier if look-up has
+					 * changed */
-		    RESCAN_LEXER ;
+					RESCAN_LEXER;
+				}
+			}
+		}
-	    }
-	}
-    } else {
+	} else {
-	if ( remove_nested_nspace ( ns ) && scan ) {
+		if (remove_nested_nspace(ns) && scan) {
-	    /* Rescan identifier if stack has changed */
+			/* Rescan identifier if stack has changed */
-	    RESCAN_LEXER ;
+			RESCAN_LEXER;
-	}
+		}
-    }
+	}
-    return ;
+	return;
+}
 /*
     SET A NAMESPACE MEMBER
     This routine sets the identifier id to be a namespace member as
     indicated by mem.  It also sets the look-up cache to id if appropriate.
 */
-void set_member
+void
-    PROTO_N ( ( mem, id ) )
-    PROTO_T ( MEMBER mem X IDENTIFIER id )
+set_member(MEMBER mem, IDENTIFIER id)
 {
-    if ( !IS_NULL_member ( mem ) ) {
+	if (!IS_NULL_member(mem)) {
-	HASHID nm ;
+		HASHID nm;
-	IDENTIFIER cid ;
+		IDENTIFIER cid;
-	LIST ( NAMESPACE ) lns ;
+		LIST(NAMESPACE) lns;
-	/* Check any previous definition */
+		/* Check any previous definition */
-	IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER pid = DEREF_id(member_id(mem));
-	if ( !IS_NULL_id ( pid ) ) {
+		if (!IS_NULL_id(pid)) {
-	    if ( IS_id_token ( pid ) ) {
+			if (IS_id_token(pid)) {
-		IGNORE unify_id ( pid, id, 1 ) ;
+				IGNORE unify_id(pid, id, 1);
-	    } else if ( IS_id_token ( id ) ) {
+			} else if (IS_id_token(id)) {
-		if ( unify_id ( id, pid, 0 ) ) return ;
+				if (unify_id(id, pid, 0)) {
+					return;
-	    }
+				}
+			}
-	}
+		}
-	/* Check look-up cache */
+		/* Check look-up cache */
-	cid = NULL_id ;
+		cid = NULL_id;
-	nm = DEREF_hashid ( id_name ( id ) ) ;
+		nm = DEREF_hashid(id_name(id));
-	lns = LIST_stack ( namespace_stack ) ;
+		lns = LIST_stack(namespace_stack);
-	if ( !IS_NULL_list ( lns ) ) {
+		if (!IS_NULL_list(lns)) {
-	    /* Check for current namespace */
+			/* Check for current namespace */
-	    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+			NAMESPACE ns = DEREF_nspace(id_parent(id));
-	    NAMESPACE pns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+			NAMESPACE pns = DEREF_nspace(HEAD_list(lns));
-	    if ( EQ_nspace ( ns, pns ) ) {
+			if (EQ_nspace(ns, pns)) {
-		/* Check for unambiguous look-up */
+				/* Check for unambiguous look-up */
-		lns = DEREF_list ( nspace_use ( ns ) ) ;
+				lns = DEREF_list(nspace_use(ns));
-		if ( IS_NULL_list ( lns ) ) cid = id ;
+				if (IS_NULL_list(lns)) {
+					cid = id;
-	    }
+				}
+			}
-	}
+		}
-	COPY_id ( hashid_cache ( nm ), cid ) ;
+		COPY_id(hashid_cache(nm), cid);
-	/* Set member identifier */
+		/* Set member identifier */
-	COPY_id ( member_id ( mem ), id ) ;
+		COPY_id(member_id(mem), id);
-    }
+	}
-    return ;
+	return;
 }
 /*
     SET A NAMESPACE TYPE MEMBER
     This routine sets the type identifier id to be a namespace member
     as indicated by mem.  Note that in C this just sets the alt field
     of mem, whereas in C++ it may also set the id field.
 */
-void set_type_member
+void
-    PROTO_N ( ( mem, id ) )
-    PROTO_T ( MEMBER mem X IDENTIFIER id )
+set_type_member(MEMBER mem, IDENTIFIER id)
 {
-    if ( !IS_NULL_member ( mem ) ) {
+	if (!IS_NULL_member(mem)) {
 #if LANGUAGE_CPP
-	IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER mid = DEREF_id(member_id(mem));
-	if ( IS_NULL_id ( mid ) ) {
+		if (IS_NULL_id(mid)) {
-	    /* No object of the same name */
+			/* No object of the same name */
-	    set_member ( mem, id ) ;
+			set_member(mem, id);
-	} else {
+		} else {
-	    /* Hidden by object of the same name */
+			/* Hidden by object of the same name */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( mid ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(mid));
-	    if ( ( ds & dspec_inherit ) && !( ds & dspec_alias ) ) {
+			if ((ds & dspec_inherit) && !(ds & dspec_alias)) {
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
+				ds = DEREF_dspec(id_storage(id));
-		if ( !( ds & dspec_inherit ) ) {
+				if (!(ds & dspec_inherit)) {
-		    /* An uninherited type overrrides an inherited object */
+					/* An uninherited type overrrides an
+					 * inherited object */
-		    COPY_id ( member_id ( mem ), id ) ;
+					COPY_id(member_id(mem), id);
+				}
+			}
+			COPY_id(hashid_cache(nm), NULL_id);
+		}
-	    }
-	    COPY_id ( hashid_cache ( nm ), NULL_id ) ;
-	}
 #endif
-	COPY_id ( member_alt ( mem ), id ) ;
+		COPY_id(member_alt(mem), id);
-    }
+	}
-    return ;
+	return;
+}
 /*
     CLEAR A NAMESPACE MEMBER
     This routine clears all meanings of the member nm of the namespace ns.
 */
-void clear_member
+void
-    PROTO_N ( ( ns, nm ) )
-    PROTO_T ( NAMESPACE ns X HASHID nm )
+clear_member(NAMESPACE ns, HASHID nm)
 {
-    MEMBER mem = search_member ( ns, nm, 0 ) ;
+	MEMBER mem = search_member(ns, nm, 0);
-    if ( !IS_NULL_member ( mem ) ) {
+	if (!IS_NULL_member(mem)) {
-	COPY_id ( member_id ( mem ), NULL_id ) ;
+		COPY_id(member_id(mem), NULL_id);
-	COPY_id ( member_alt ( mem ), NULL_id ) ;
+		COPY_id(member_alt(mem), NULL_id);
-    }
+	}
-    COPY_id ( hashid_cache ( nm ), NULL_id ) ;
+	COPY_id(hashid_cache(nm), NULL_id);
-    return ;
+	return;
 }
 /*
     FIND A MEMBER OF A NAMESPACE
     This routine searches the namespace ns for a member named nm.  This
     is returned if found.  Otherwise if create is true then an empty
     member is created and returned.  Otherwise the null member is returned.
 */
-MEMBER search_member
+MEMBER
-    PROTO_N ( ( ns, nm, create ) )
-    PROTO_T ( NAMESPACE ns X HASHID nm X int create )
+search_member(NAMESPACE ns, HASHID nm, int create)
 {
-    MEMBER mem ;
+	MEMBER mem;
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	/* Null namespace */
+		/* Null namespace */
-	if ( create ) {
+		if (create) {
-	    MAKE_member_small ( NULL_member, mem ) ;
+			MAKE_member_small(NULL_member, mem);
-	} else {
+		} else {
-	    mem = NULL_member ;
+			mem = NULL_member;
-	}
+		}
-    } else if ( IS_nspace_block_etc ( ns ) ) {
+	} else if (IS_nspace_block_etc(ns)) {
-	/* Small namespaces */
+		/* Small namespaces */
-	MEMBER last = DEREF_member ( nspace_last ( ns ) ) ;
+		MEMBER last = DEREF_member(nspace_last(ns));
-	/* Search through members */
+		/* Search through members */
-	mem = last ;
+		mem = last;
-	while ( !IS_NULL_member ( mem ) ) {
+		while (!IS_NULL_member(mem)) {
-	    IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
+			IDENTIFIER mid = DEREF_id(member_id(mem));
-	    if ( !IS_NULL_id ( mid ) ) {
+			if (!IS_NULL_id(mid)) {
-		HASHID mnm = DEREF_hashid ( id_name ( mid ) ) ;
+				HASHID mnm = DEREF_hashid(id_name(mid));
-		if ( EQ_hashid ( nm, mnm ) ) return ( mem ) ;
+				if (EQ_hashid(nm, mnm)) {
+					return (mem);
-	    }
+				}
 #if LANGUAGE_C
+			} else {
-	    /* ... continues */ else {
+			/* ... continues */
-		/* Need to also check tag namespace in C */
+				/* Need to also check tag namespace in C */
-		mid = DEREF_id ( member_alt ( mem ) ) ;
+				mid = DEREF_id(member_alt(mem));
-		if ( !IS_NULL_id ( mid ) ) {
+				if (!IS_NULL_id(mid)) {
-		    HASHID mnm = DEREF_hashid ( id_name ( mid ) ) ;
+					HASHID mnm = DEREF_hashid(id_name(mid));
-		    if ( EQ_hashid ( nm, mnm ) ) return ( mem ) ;
+					if (EQ_hashid(nm, mnm)) {
+						return (mem);
-		}
+					}
-	    }
+				}
 #endif
+			}
-	    mem = DEREF_member ( member_next ( mem ) ) ;
+			mem = DEREF_member(member_next(mem));
-	}
+		}
-	/* Create new member if necessary */
+		/* Create new member if necessary */
-	if ( create ) {
+		if (create) {
-	    MAKE_member_small ( last, mem ) ;
+			MAKE_member_small(last, mem);
-	    COPY_member ( nspace_last ( ns ), mem ) ;
+			COPY_member(nspace_last(ns), mem);
-	}
+		}
-    } else {
+	} else {
-	/* Large namespaces */
+		/* Large namespaces */
-	PTR ( MEMBER ) ptr = DEREF_ptr ( nspace_named_etc_table ( ns ) ) ;
+		PTR(MEMBER) ptr = DEREF_ptr(nspace_named_etc_table(ns));
-	unsigned long sz = DEREF_ulong ( nspace_named_etc_size ( ns ) ) ;
+		unsigned long sz = DEREF_ulong(nspace_named_etc_size(ns));
-	unsigned long h = DEREF_ulong ( hashid_hash ( nm ) ) ;
+		unsigned long h = DEREF_ulong(hashid_hash(nm));
-	SIZE ( MEMBER ) psz = SCALE ( SIZE_member, ( h % sz ) ) ;
+		SIZE(MEMBER) psz = SCALE(SIZE_member,(h % sz));
-	/* Search through members */
+		/* Search through members */
-	ptr = STEP_ptr ( ptr, psz ) ;
+		ptr = STEP_ptr(ptr, psz);
-	mem = DEREF_member ( ptr ) ;
+		mem = DEREF_member(ptr);
-	while ( !IS_NULL_member ( mem ) ) {
+		while (!IS_NULL_member(mem)) {
-	    IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
+			IDENTIFIER mid = DEREF_id(member_id(mem));
-	    if ( !IS_NULL_id ( mid ) ) {
+			if (!IS_NULL_id(mid)) {
-		HASHID mnm = DEREF_hashid ( id_name ( mid ) ) ;
+				HASHID mnm = DEREF_hashid(id_name(mid));
-		if ( EQ_hashid ( nm, mnm ) ) return ( mem ) ;
+				if (EQ_hashid(nm, mnm)) {
+					return (mem);
-	    }
+				}
 #if LANGUAGE_C
+			} else {
-	    /* ... continues */ else {
+			/* ... continues */
-		/* Need to also check tag namespace in C */
+				/* Need to also check tag namespace in C */
-		mid = DEREF_id ( member_alt ( mem ) ) ;
+				mid = DEREF_id(member_alt(mem));
-		if ( !IS_NULL_id ( mid ) ) {
+				if (!IS_NULL_id(mid)) {
-		    HASHID mnm = DEREF_hashid ( id_name ( mid ) ) ;
+					HASHID mnm = DEREF_hashid(id_name(mid));
-		    if ( EQ_hashid ( nm, mnm ) ) return ( mem ) ;
+					if (EQ_hashid(nm, mnm)) {
+						return (mem);
-		}
+					}
-	    }
+				}
 #endif
+			}
-	    mem = DEREF_member ( member_large_tnext ( mem ) ) ;
+			mem = DEREF_member(member_large_tnext(mem));
-	}
+		}
-	/* Create new member if necessary */
+		/* Create new member if necessary */
-	if ( create ) {
+		if (create) {
-	    MEMBER last ;
+			MEMBER last;
-	    mem = DEREF_member ( ptr ) ;
+			mem = DEREF_member(ptr);
-	    MAKE_member_large ( NULL_member, mem, mem ) ;
+			MAKE_member_large(NULL_member, mem, mem);
-	    COPY_member ( ptr, mem ) ;
+			COPY_member(ptr, mem);
-	    last = DEREF_member ( nspace_last ( ns ) ) ;
+			last = DEREF_member(nspace_last(ns));
-	    if ( IS_NULL_member ( last ) ) {
+			if (IS_NULL_member(last)) {
-		COPY_member ( nspace_named_etc_first ( ns ), mem ) ;
+				COPY_member(nspace_named_etc_first(ns), mem);
-	    } else {
+			} else {
-		COPY_member ( member_next ( last ), mem ) ;
+				COPY_member(member_next(last), mem);
-	    }
+			}
-	    COPY_member ( nspace_last ( ns ), mem ) ;
+			COPY_member(nspace_last(ns), mem);
-	}
+		}
-    }
+	}
-    return ( mem ) ;
+	return (mem);
 }
 /*
     UPDATE A NAMESPACE MEMBER
     This routine copies the member mem of the namespace ns to the end of
     the list of all members.  In block namespaces this is to force the
     member to be re-examined in make_decl_stmt.  In class namespaces this
     is to preserve the order of the data members.
 */
-MEMBER update_member
+MEMBER
-    PROTO_N ( ( ns, mem ) )
-    PROTO_T ( NAMESPACE ns X MEMBER mem )
+update_member(NAMESPACE ns, MEMBER mem)
 {
-    IDENTIFIER id = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER id = DEREF_id(member_id(mem));
-    IDENTIFIER alt = DEREF_id ( member_alt ( mem ) ) ;
+	IDENTIFIER alt = DEREF_id(member_alt(mem));
-    COPY_id ( member_id ( mem ), NULL_id ) ;
+	COPY_id(member_id(mem), NULL_id);
-    COPY_id ( member_alt ( mem ), NULL_id ) ;
+	COPY_id(member_alt(mem), NULL_id);
-    if ( IS_member_small ( mem ) ) {
+	if (IS_member_small(mem)) {
-	/* Create new small member */
+		/* Create new small member */
-	MEMBER last = DEREF_member ( nspace_last ( ns ) ) ;
+		MEMBER last = DEREF_member(nspace_last(ns));
-	MAKE_member_small ( last, mem ) ;
+		MAKE_member_small(last, mem);
-	COPY_member ( nspace_last ( ns ), mem ) ;
+		COPY_member(nspace_last(ns), mem);
-    } else {
+	} else {
-	/* Create new large member */
+		/* Create new large member */
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    mem = search_member ( ns, nm, 1 ) ;
+			mem = search_member(ns, nm, 1);
-	} else if ( !IS_NULL_id ( alt ) ) {
+		} else if (!IS_NULL_id(alt)) {
-	    HASHID nm = DEREF_hashid ( id_name ( alt ) ) ;
+			HASHID nm = DEREF_hashid(id_name(alt));
-	    mem = search_member ( ns, nm, 1 ) ;
+			mem = search_member(ns, nm, 1);
-	}
+		}
-    }
+	}
-    COPY_id ( member_id ( mem ), id ) ;
+	COPY_id(member_id(mem), id);
-    COPY_id ( member_alt ( mem ), alt ) ;
+	COPY_id(member_alt(mem), alt);
-    return ( mem ) ;
+	return (mem);
 }
 /*
     FIND A TYPE IDENTIFIER
     This routine checks whether the identifier id is a type name (if bit 0
     of type is true) or a namespace name (if bit 1 of type is true).  In
     C only struct, union and enum tags are allowed.
 */
-static IDENTIFIER select_type_id
+static IDENTIFIER
-    PROTO_N ( ( id, type ) )
-    PROTO_T ( IDENTIFIER id X int type )
+select_type_id(IDENTIFIER id, int type)
+{
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(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:
-		if ( type & 1 ) return ( id ) ;
+			if (type & 1) {
-		break ;
+				return (id);
-	    }
+			}
+			break;
 #if LANGUAGE_CPP
-	    case id_class_alias_tag :
+		case id_class_alias_tag:
-	    case id_enum_alias_tag :
+		case id_enum_alias_tag:
-	    case id_type_alias_tag : {
+		case id_type_alias_tag:
-		if ( type & 1 ) return ( id ) ;
+			if (type & 1) {
-		break ;
+				return (id);
-	    }
+			}
+			break;
-	    case id_nspace_name_tag :
+		case id_nspace_name_tag:
-	    case id_nspace_alias_tag : {
+		case id_nspace_alias_tag:
-		if ( type & 2 ) return ( id ) ;
+			if (type & 2) {
-		break ;
+				return (id);
-	    }
+			}
+			break;
 #endif
+		}
+	}
-    }
-    return ( NULL_id ) ;
+	return (NULL_id);
+}
 /*
     FIND A TYPE MEMBER
     This routine returns the type or namespace name associated with the
     member mem, or the null identifier if this does not exist.  The
     type argument is as above.  In C++ it is necessary to check both
     the id and the alt fields of mem, whereas in C only the alt field
     needs to be examined.
 */
-IDENTIFIER type_member
+IDENTIFIER
-    PROTO_N ( ( mem, type ) )
-    PROTO_T ( MEMBER mem X int type )
+type_member(MEMBER mem, int type)
+{
-    IDENTIFIER id = NULL_id ;
+	IDENTIFIER id = NULL_id;
-    if ( !IS_NULL_member ( mem ) ) {
+	if (!IS_NULL_member(mem)) {
 #if LANGUAGE_CPP
-	id = DEREF_id ( member_id ( mem ) ) ;
+		id = DEREF_id(member_id(mem));
-	id = select_type_id ( id, type ) ;
+		id = select_type_id(id, type);
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    id = DEREF_id ( member_alt ( mem ) ) ;
+			id = DEREF_id(member_alt(mem));
-	    id = select_type_id ( id, type ) ;
+			id = select_type_id(id, type);
-	}
+		}
 #else
-	id = DEREF_id ( member_alt ( mem ) ) ;
+		id = DEREF_id(member_alt(mem));
-	id = select_type_id ( id, type ) ;
+		id = select_type_id(id, type);
 #endif
-    }
+	}
-    return ( id ) ;
+	return (id);
+}
 /*
     IS AN IDENTIFIER IN A LIST?
     This routine checks whether the identifier id is in the list of
     ambiguous meanings given by pid and pids.  Functions are excluded
     because of the complications introduced by using-declarations and
     overloading.  Overload resolution will eliminate duplicate entries
     in this case.
 */
-static int already_found_id
+static int
-    PROTO_N ( ( id, pid, pids ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER pid X LIST ( IDENTIFIER ) pids )
+already_found_id(IDENTIFIER id, IDENTIFIER pid, LIST(IDENTIFIER) pids)
-{
-    if ( IS_id_function_etc ( id ) ) {
-	/* Exclude functions */
-	return ( 0 ) ;
-    }
-    if ( !IS_NULL_id ( pid ) ) {
-	if ( IS_id_ambig ( pid ) ) {
-	    /* Check ambiguous identifiers */
-	    LIST ( IDENTIFIER ) qids = DEREF_list ( id_ambig_ids ( pid ) ) ;
-	    if ( already_found_id ( id, NULL_id, qids ) ) return ( 1 ) ;
-	} else {
-	    /* Check simple identifiers */
-	    if ( !IS_id_function_etc ( pid ) ) {
-		id = DEREF_id ( id_alias ( id ) ) ;
-		pid = DEREF_id ( id_alias ( pid ) ) ;
-		if ( EQ_id ( id, pid ) ) return ( 1 ) ;
-	    }
-	}
-    }
-    if ( !IS_NULL_list ( pids ) ) {
-	/* Check identifier lists */
-	IDENTIFIER qid = DEREF_id ( HEAD_list ( pids ) ) ;
-	pids = TAIL_list ( pids ) ;
-	return ( already_found_id ( id, qid, pids ) ) ;
-    }
-    return ( 0 ) ;
-}
-/*
-    LOOK UP AN IDENTIFIER IN A NAMESPACE
-    This routine looks up the identifier nm in the namespace ns.
-*/
-IDENTIFIER search_id
-    PROTO_N ( ( ns, nm, create, type ) )
-    PROTO_T ( NAMESPACE ns X HASHID nm X int create X int type )
+{
-    IDENTIFIER id ;
-    MEMBER mem = search_member ( ns, nm, create ) ;
-    if ( !IS_NULL_member ( mem ) ) {
+	if (IS_id_function_etc(id)) {
-	if ( type ) {
+		/* Exclude functions */
-	    id = type_member ( mem, type ) ;
-	} else {
+		return (0);
-	    id = DEREF_id ( member_id ( mem ) ) ;
+	}
+	if (!IS_NULL_id(pid)) {
+		if (IS_id_ambig(pid)) {
+			/* Check ambiguous identifiers */
+			LIST(IDENTIFIER) qids = DEREF_list(id_ambig_ids(pid));
+			if (already_found_id(id, NULL_id, qids)) {
+				return (1);
+			}
-    } else {
+		} else {
+			/* Check simple identifiers */
+			if (!IS_id_function_etc(pid)) {
+				id = DEREF_id(id_alias(id));
+				pid = DEREF_id(id_alias(pid));
+				if (EQ_id(id, pid)) {
+					return (1);
+				}
+			}
+		}
+	}
+	if (!IS_NULL_list(pids)) {
+		/* Check identifier lists */
+		IDENTIFIER qid = DEREF_id(HEAD_list(pids));
-	id = NULL_id ;
+		pids = TAIL_list(pids);
+		return (already_found_id(id, qid, pids));
-    }
+	}
-    return ( id ) ;
+	return (0);
+}
+/*
+    LOOK UP AN IDENTIFIER IN A NAMESPACE
+    This routine looks up the identifier nm in the namespace ns.
+*/
+IDENTIFIER
+search_id(NAMESPACE ns, HASHID nm, int create, int type)
+{
+	IDENTIFIER id;
+	MEMBER mem = search_member(ns, nm, create);
+	if (!IS_NULL_member(mem)) {
+		if (type) {
+			id = type_member(mem, type);
+		} else {
+			id = DEREF_id(member_id(mem));
+		}
+	} else {
+		id = NULL_id;
+	}
+	return (id);
+}
 /*
     SEARCH A NAMESPACE FOR AN IDENTIFIER
     This routine searches the namespace ns and used namespaces for an
     identifier named nm, which is returned if found.  Otherwise if create
     is true then a dummy identifier is created and returned.  Otherwise
     the null identifier is returned.  qual is true for qualified look-ups.
     If type is nonzero then only type and namespace names are considered.
     rns gives the original value of ns for use when recursively searching
     used namespaces.
 */
-static IDENTIFIER search_nspace
+static IDENTIFIER
-    PROTO_N ( ( ns, nm, rns, qual, create, type ) )
-    PROTO_T ( NAMESPACE ns X HASHID nm X NAMESPACE rns X int qual X
+search_nspace(NAMESPACE ns, HASHID nm, NAMESPACE rns, int qual, int create,
-	      int create X int type )
+	      int type)
 {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    LIST ( NAMESPACE ) uns ;
+	LIST(NAMESPACE) uns;
-    /* Allow for class namespaces */
+	/* Allow for class namespaces */
-    if ( IS_nspace_ctype ( ns ) ) {
+	if (IS_nspace_ctype(ns)) {
-	id = search_field ( ns, nm, create, type ) ;
+		id = search_field(ns, nm, create, type);
-	return ( id ) ;
+		return (id);
-    }
+	}
-    /* Search main namespace */
+	/* Search main namespace */
-    id = search_id ( ns, nm, create, type ) ;
+	id = search_id(ns, nm, create, type);
-    if ( !IS_NULL_id ( id ) && qual ) {
+	if (!IS_NULL_id(id) && qual) {
-	/* Return found identifier */
+		/* Return found identifier */
-	return ( id ) ;
+		return (id);
-    }
+	}
-    /* Search used namespaces */
+	/* Search used namespaces */
-    uns = DEREF_list ( nspace_use ( ns ) ) ;
+	uns = DEREF_list(nspace_use(ns));
-    if ( !IS_NULL_list ( uns ) ) {
+	if (!IS_NULL_list(uns)) {
-	LIST ( NAMESPACE ) vns = DEREF_list ( nspace_join ( ns ) ) ;
+		LIST(NAMESPACE) vns = DEREF_list(nspace_join(ns));
-	LIST ( NAMESPACE ) uns_orig = uns ;
+		LIST(NAMESPACE) uns_orig = uns;
-	LIST ( NAMESPACE ) vns_orig = vns ;
+		LIST(NAMESPACE) vns_orig = vns;
-	LIST ( IDENTIFIER ) ambig = NULL_list ( IDENTIFIER ) ;
+		LIST(IDENTIFIER) ambig = NULL_list(IDENTIFIER);
-	COPY_list ( nspace_use ( ns ), NULL_list ( NAMESPACE ) ) ;
+		COPY_list(nspace_use(ns), NULL_list(NAMESPACE));
-	COPY_list ( nspace_join ( ns ), NULL_list ( NAMESPACE ) ) ;
+		COPY_list(nspace_join(ns), NULL_list(NAMESPACE));
-	while ( !IS_NULL_list ( uns ) ) {
+		while (!IS_NULL_list(uns)) {
-	    NAMESPACE pns = DEREF_nspace ( HEAD_list ( uns ) ) ;
+			NAMESPACE pns = DEREF_nspace(HEAD_list(uns));
-	    NAMESPACE jns = DEREF_nspace ( HEAD_list ( vns ) ) ;
+			NAMESPACE jns = DEREF_nspace(HEAD_list(vns));
-	    if ( qual || is_subnspace ( rns, jns ) ) {
+			if (qual || is_subnspace(rns, jns)) {
-		/* Look-up identifier in used namespace */
+				/* Look-up identifier in used namespace */
-		IDENTIFIER pid ;
+				IDENTIFIER pid;
-		pid = search_nspace ( pns, nm, rns, qual, 0, type ) ;
+				pid = search_nspace(pns, nm, rns, qual, 0,
+						    type);
-		if ( !IS_NULL_id ( pid ) ) {
+				if (!IS_NULL_id(pid)) {
-		    /* Add found identifier to list */
+					/* Add found identifier to list */
-		    if ( IS_NULL_id ( id ) ) {
+					if (IS_NULL_id(id)) {
-			id = pid ;
+						id = pid;
-		    } else if ( !already_found_id ( pid, id, ambig ) ) {
+					} else if (!already_found_id(pid, id,
+								     ambig)) {
-			CONS_id ( pid, ambig, ambig ) ;
+						CONS_id(pid, ambig, ambig);
-		    }
+					}
-		}
+				}
-	    } else {
+			} else {
-		/* Postpone look-up until join namespace */
+				/* Postpone look-up until join namespace */
-		if ( use_namespace ( pns, jns, jns ) ) {
+				if (use_namespace(pns, jns, jns)) {
-		    CONS_nspace ( jns, join_nspaces, join_nspaces ) ;
+					CONS_nspace(jns, join_nspaces,
+						    join_nspaces);
-		}
+				}
-	    }
+			}
-	    vns = TAIL_list ( vns ) ;
+			vns = TAIL_list(vns);
-	    uns = TAIL_list ( uns ) ;
+			uns = TAIL_list(uns);
-	}
+		}
-	if ( !IS_NULL_list ( ambig ) ) {
+		if (!IS_NULL_list(ambig)) {
-	    /* Ambiguous resolution */
+			/* Ambiguous resolution */
-	    DECL_SPEC ds ;
+			DECL_SPEC ds;
-	    CONS_id ( id, ambig, ambig ) ;
+			CONS_id(id, ambig, ambig);
-	    ds = find_ambig_dspec ( ambig ) ;
+			ds = find_ambig_dspec(ambig);
-	    MAKE_id_ambig ( nm, ds, rns, crt_loc, ambig, 1, id ) ;
+			MAKE_id_ambig(nm, ds, rns, crt_loc, ambig, 1, id);
-	}
+		}
-	COPY_list ( nspace_use ( ns ), uns_orig ) ;
+		COPY_list(nspace_use(ns), uns_orig);
-	COPY_list ( nspace_join ( ns ), vns_orig ) ;
+		COPY_list(nspace_join(ns), vns_orig);
-    }
+	}
-    /* Create dummy identifier if necessary */
+	/* Create dummy identifier if necessary */
-    if ( IS_NULL_id ( id ) && create ) {
+	if (IS_NULL_id(id) && create) {
-	MAKE_id_undef ( nm, dspec_none, ns, crt_loc, id ) ;
+		MAKE_id_undef(nm, dspec_none, ns, crt_loc, id);
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     EXTERNAL NAME LOOK-UP
     This routine searches all the namespaces in the current namespace stack
     which are contained within pns for the identifier pns.  If type is
     nonzero then only type and namespace names are considered.
 */
-IDENTIFIER find_extern_id
+IDENTIFIER
-    PROTO_N ( ( nm, pns, type ) )
-    PROTO_T ( HASHID nm X NAMESPACE pns X int type )
+find_extern_id(HASHID nm, NAMESPACE pns, int type)
 {
-    IDENTIFIER id = NULL_id ;
+	IDENTIFIER id = NULL_id;
-    LIST ( NAMESPACE ) lns = LIST_stack ( namespace_stack ) ;
+	LIST(NAMESPACE) lns = LIST_stack(namespace_stack);
-    while ( !IS_NULL_list ( lns ) ) {
+	while (!IS_NULL_list(lns)) {
-	NAMESPACE ns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+		NAMESPACE ns = DEREF_nspace(HEAD_list(lns));
-	if ( !IS_NULL_nspace ( ns ) ) {
+		if (!IS_NULL_nspace(ns)) {
-	    id = search_nspace ( ns, nm, ns, 0, 0, type ) ;
+			id = search_nspace(ns, nm, ns, 0, 0, type);
-	    if ( !IS_NULL_id ( id ) ) break ;
+			if (!IS_NULL_id(id)) {
+				break;
+			}
-	    if ( EQ_nspace ( ns, pns ) ) break ;
+			if (EQ_nspace(ns, pns)) {
+				break;
+			}
-	}
+		}
-	lns = TAIL_list ( lns ) ;
+		lns = TAIL_list(lns);
-    }
+	}
-    if ( !IS_NULL_list ( join_nspaces ) ) clear_join_nspaces () ;
+	if (!IS_NULL_list(join_nspaces)) {
+		clear_join_nspaces();
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     UNQUALIFIED NAME LOOK-UP
     This routine (aka who the feck is fred?) looks up the name nm in the
     current scope, returning the corresponding identifier.  Note that
     there is always a meaning for nm even if it is the underlying dummy
     identifier.
 */
-IDENTIFIER find_id
+IDENTIFIER
-    PROTO_N ( ( nm ) )
-    PROTO_T ( HASHID nm )
+find_id(HASHID nm)
+{
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    if ( cache_lookup ) {
+	if (cache_lookup) {
-	id = DEREF_id ( hashid_cache ( nm ) ) ;
+		id = DEREF_id(hashid_cache(nm));
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    id = find_extern_id ( nm, NULL_nspace, 0 ) ;
+			id = find_extern_id(nm, NULL_nspace, 0);
-	    if ( IS_NULL_id ( id ) ) {
+			if (IS_NULL_id(id)) {
-		/* Use underlying meaning if not found */
+				/* Use underlying meaning if not found */
-		id = DEREF_id ( hashid_id ( nm ) ) ;
+				id = DEREF_id(hashid_id(nm));
-	    }
+			}
-	    COPY_id ( hashid_cache ( nm ), id ) ;
+			COPY_id(hashid_cache(nm), id);
-	}
+		}
-    } else {
+	} else {
-	id = find_extern_id ( nm, NULL_nspace, 0 ) ;
+		id = find_extern_id(nm, NULL_nspace, 0);
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    /* Use underlying meaning if not found */
+			/* Use underlying meaning if not found */
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
+			id = DEREF_id(hashid_id(nm));
+		}
+	}
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     QUALIFIED NAME LOOK-UP
     This routine (aka who the feck is fred::bloggs?) looks up the name nm
     in the namespace ns.  Only type names are considered when type is
     nonzero.  When ns is the null namespace this reduces to an unqualified
     name look-up.
 */
-IDENTIFIER find_qual_id
+IDENTIFIER
-    PROTO_N ( ( ns, nm, create, type ) )
-    PROTO_T ( NAMESPACE ns X HASHID nm X int create X int type )
+find_qual_id(NAMESPACE ns, HASHID nm, int create, int type)
+{
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    if ( IS_NULL_nspace ( ns ) ) {
+	if (IS_NULL_nspace(ns)) {
-	/* Unqualified name look-up */
+		/* Unqualified name look-up */
-	if ( type == 0 ) {
+		if (type == 0) {
-	    id = find_id ( nm ) ;
+			id = find_id(nm);
+		} else {
+			id = find_type_id(nm, type);
+		}
 	} else {
+		/* Qualified name look-up */
-	    id = find_type_id ( nm, type ) ;
+		id = search_nspace(ns, nm, ns, 1, create, type);
+	}
-    } else {
-	/* Qualified name look-up */
-	id = search_nspace ( ns, nm, ns, 1, create, type ) ;
-    }
-    return ( id ) ;
+	return (id);
 }
 /*
     SIMPLE TYPE NAME LOOK-UP
     This routine looks up the name nm as a type in the current scope,
     returning the corresponding identifier.  If there is no type named
     nm then the null identifier is returned.
 */
-IDENTIFIER find_type_id
+IDENTIFIER
-    PROTO_N ( ( nm, type ) )
-    PROTO_T ( HASHID nm X int type )
+find_type_id(HASHID nm, int type)
 {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    if ( cache_lookup ) {
+	if (cache_lookup) {
-	/* Check whether cached value is a type */
+		/* Check whether cached value is a type */
-	id = DEREF_id ( hashid_cache ( nm ) ) ;
+		id = DEREF_id(hashid_cache(nm));
-	id = select_type_id ( id, type ) ;
+		id = select_type_id(id, type);
-	if ( !IS_NULL_id ( id ) ) return ( id ) ;
+		if (!IS_NULL_id(id)) {
+			return (id);
-    }
+		}
+	}
-    id = find_extern_id ( nm, NULL_nspace, type ) ;
+	id = find_extern_id(nm, NULL_nspace, type);
-    return ( id ) ;
+	return (id);
 }
 /*
     OPERATOR FUNCTION NAME LOOK-UP
     This routine is identical to find_id except that it ignores all class
     namespaces.  This is used when looking up operator functions in C++
     and is the default look-up rule in C.
 */
-IDENTIFIER find_op_id
+IDENTIFIER
-    PROTO_N ( ( nm ) )
-    PROTO_T ( HASHID nm )
+find_op_id(HASHID nm)
 {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    LIST ( NAMESPACE ) lns ;
+	LIST(NAMESPACE) lns;
-    int cache = cache_lookup ;
+	int cache = cache_lookup;
-    if ( cache ) {
+	if (cache) {
-	/* Check cached look-up */
+		/* Check cached look-up */
-	id = DEREF_id ( hashid_cache ( nm ) ) ;
+		id = DEREF_id(hashid_cache(nm));
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+			NAMESPACE ns = DEREF_nspace(id_parent(id));
-	    if ( IS_NULL_nspace ( ns ) || !IS_nspace_ctype ( ns ) ) {
+			if (IS_NULL_nspace(ns) || !IS_nspace_ctype(ns)) {
-		return ( id ) ;
+				return (id);
-	    }
+			}
-	    cache = 0 ;
+			cache = 0;
-	}
+		}
-    }
+	}
-    /* Scan through namespace stack */
+	/* Scan through namespace stack */
-    lns = LIST_stack ( namespace_stack ) ;
+	lns = LIST_stack(namespace_stack);
-    while ( !IS_NULL_list ( lns ) ) {
+	while (!IS_NULL_list(lns)) {
-	NAMESPACE ns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+		NAMESPACE ns = DEREF_nspace(HEAD_list(lns));
-	if ( !IS_NULL_nspace ( ns ) && !IS_nspace_ctype ( ns ) ) {
+		if (!IS_NULL_nspace(ns) && !IS_nspace_ctype(ns)) {
-	    id = search_nspace ( ns, nm, ns, 0, 0, 0 ) ;
+			id = search_nspace(ns, nm, ns, 0, 0, 0);
-	    if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-		if ( !IS_NULL_list ( join_nspaces ) ) clear_join_nspaces () ;
+				if (!IS_NULL_list(join_nspaces)) {
+					clear_join_nspaces();
+				}
+				if (cache) {
-		if ( cache ) COPY_id ( hashid_cache ( nm ), id ) ;
+					COPY_id(hashid_cache(nm), id);
+				}
-		return ( id ) ;
+				return (id);
-	    }
+			}
-	} else {
+		} else {
-	    cache = 0 ;
+			cache = 0;
+		}
+		lns = TAIL_list(lns);
+	}
+	if (!IS_NULL_list(join_nspaces)) {
+		clear_join_nspaces();
+	}
+	id = DEREF_id(hashid_id(nm));
+	if (cache) {
+		COPY_id(hashid_cache(nm), id);
+	}
-	lns = TAIL_list ( lns ) ;
-    }
-    if ( !IS_NULL_list ( join_nspaces ) ) clear_join_nspaces () ;
-    id = DEREF_id ( hashid_id ( nm ) ) ;
-    if ( cache ) COPY_id ( hashid_cache ( nm ), id ) ;
-    return ( id ) ;
+	return (id);
+}
 /*
     FINAL NAME LOOK-UP CHECK
     id will already be a valid identifier for the namespace ns - the couple
     of exceptions - undeclared members and non-simple identifier names
     are handled by this routine.
 */
-IDENTIFIER check_id
+IDENTIFIER
-    PROTO_N ( ( ns, id, templ ) )
-    PROTO_T ( NAMESPACE ns X IDENTIFIER id X int templ )
+check_id(NAMESPACE ns, IDENTIFIER id, int templ)
+{
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	unsigned tag = TAG_id ( id ) ;
+		unsigned tag = TAG_id(id);
-	if ( tag == id_dummy_tag ) {
+		if (tag == id_dummy_tag) {
-	    /* Re-scan dummy identifiers */
+			/* Re-scan dummy identifiers */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-	    id = find_qual_id ( ns, nm, 1, 0 ) ;
+			id = find_qual_id(ns, nm, 1, 0);
-	    tag = TAG_id ( id ) ;
+			tag = TAG_id(id);
+		}
+		if (tag == id_token_tag && crt_id_qualifier != qual_none) {
+			/* Can't qualify token names */
+			report(crt_loc, ERR_token_qual(id));
+		}
+		UNUSED(templ);
+	}
-	if ( tag == id_token_tag && crt_id_qualifier != qual_none ) {
-	    /* Can't qualify token names */
-	    report ( crt_loc, ERR_token_qual ( id ) ) ;
-	}
-	UNUSED ( templ ) ;
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     REMOVE AN ELEMENT OF A SET OF OVERLOADED FUNCTIONS
     This routine removes the function id from the set of overloaded
     functions fid.
 */
-static IDENTIFIER remove_func
+static IDENTIFIER
-    PROTO_N ( ( fid, id ) )
-    PROTO_T ( IDENTIFIER fid X IDENTIFIER id )
+remove_func(IDENTIFIER fid, IDENTIFIER id)
+{
-    if ( !IS_NULL_id ( fid ) ) {
+	if (!IS_NULL_id(fid)) {
-	IDENTIFIER pid = DEREF_id ( id_function_etc_over ( fid ) ) ;
+		IDENTIFIER pid = DEREF_id(id_function_etc_over(fid));
-	if ( EQ_id ( fid, id ) ) {
+		if (EQ_id(fid, id)) {
-	    fid = pid ;
+			fid = pid;
-	    COPY_id ( id_function_etc_over ( id ), NULL_id ) ;
+			COPY_id(id_function_etc_over(id), NULL_id);
-	} else {
+		} else {
-	    pid = remove_func ( pid, id ) ;
+			pid = remove_func(pid, id);
-	    COPY_id ( id_function_etc_over ( fid ), pid ) ;
+			COPY_id(id_function_etc_over(fid), pid);
+		}
+	}
-    }
-    return ( fid ) ;
+	return (fid);
+}
 /*
     REMOVE AN IDENTIFIER FROM A NAMESPACE
     This routine removes the identifier id its parent namespace.
 */
-void remove_id
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+remove_id(IDENTIFIER id)
+{
-    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));
-    MEMBER mem = search_member ( ns, nm, 0 ) ;
+	MEMBER mem = search_member(ns, nm, 0);
-    if ( !IS_NULL_member ( mem ) ) {
+	if (!IS_NULL_member(mem)) {
-	IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER mid = DEREF_id(member_id(mem));
-	IDENTIFIER tid = DEREF_id ( member_alt ( mem ) ) ;
+		IDENTIFIER tid = DEREF_id(member_alt(mem));
-	if ( IS_id_function_etc ( id ) ) {
+		if (IS_id_function_etc(id)) {
-	    mid = remove_func ( mid, id ) ;
+			mid = remove_func(mid, id);
-	} else {
+		} else {
-	    if ( EQ_id ( id, mid ) ) mid = NULL_id ;
+			if (EQ_id(id, mid)) {
+				mid = NULL_id;
+			}
-	    if ( EQ_id ( id, tid ) ) tid = NULL_id ;
+			if (EQ_id(id, tid)) {
+				tid = NULL_id;
+			}
+		}
+		if (IS_NULL_id(mid)) {
+			mid = tid;
+		}
+		COPY_id(member_id(mem), mid);
+		COPY_id(member_alt(mem), tid);
+		COPY_id(hashid_cache(nm), NULL_id);
+		IGNORE check_identifier(id, ns, NULL_exp, ANON_NONE, 1);
+	}
-	if ( IS_NULL_id ( mid ) ) mid = tid ;
-	COPY_id ( member_id ( mem ), mid ) ;
-	COPY_id ( member_alt ( mem ), tid ) ;
-	COPY_id ( hashid_cache ( nm ), NULL_id ) ;
-	IGNORE check_identifier ( id, ns, NULL_exp, ANON_NONE, 1 ) ;
-    }
-    return ;
+	return;
+}
 /*
     DOES AN IDENTIFIER HAVE AN EXTERNAL LINKAGE NAME?
     This routine checks whether the identifier id has an external linkage
     name.  It cannot be a member of a block, an unnamed class or an
     anonymous namespace.
 */
-int has_linkage
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+has_linkage(IDENTIFIER id)
+{
-    while ( !IS_NULL_id ( id ) ) {
+	while (!IS_NULL_id(id)) {
-	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));
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( IS_hashid_anon ( nm ) ) return ( 0 ) ;
+		if (IS_hashid_anon(nm)) {
+			return (0);
+		}
-	if ( !( ds & dspec_extern ) ) return ( 0 ) ;
+		if (!(ds & dspec_extern)) {
+			return (0);
+		}
-	if ( ( ds & dspec_c ) && !anon_c_linkage ) return ( 1 ) ;
+		if ((ds & dspec_c) && !anon_c_linkage) {
+			return (1);
+		}
-	if ( IS_NULL_nspace ( ns ) ) return ( 0 ) ;
+		if (IS_NULL_nspace(ns)) {
+			return (0);
+		}
-	switch ( TAG_nspace ( ns ) ) {
+		switch (TAG_nspace(ns)) {
-	    case nspace_named_tag : break ;
+		case nspace_named_tag:
+			break;
-	    case nspace_ctype_tag : break ;
+		case nspace_ctype_tag:
+			break;
-	    case nspace_global_tag : return ( 1 ) ;
+		case nspace_global_tag:
+			return (1);
+		default:
-	    default : return ( 0 ) ;
+			return (0);
+		}
+		id = DEREF_id(nspace_name(ns));
+	}
-	id = DEREF_id ( nspace_name ( ns ) ) ;
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CHECK HIDING OF LOCAL VARIABLES
     hidden by id.  Note that only the first instance is reported, and that
     the hiding of one declaration by a subsequent incompatible redeclaration
     is excluded.
 */
-void check_hiding
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+check_hiding(IDENTIFIER id)
+{
-    if ( crt_id_qualifier == qual_none ) {
+    if (crt_id_qualifier == qual_none) {
 	/* Check through all look-up namespaces */
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-	LIST ( NAMESPACE ) lns = LIST_stack ( namespace_stack ) ;
+	LIST(NAMESPACE) lns = LIST_stack(namespace_stack);
-	while ( !IS_NULL_list ( lns ) ) {
+	while (!IS_NULL_list(lns)) {
-	    NAMESPACE ns = DEREF_nspace ( HEAD_list ( lns ) ) ;
+	    NAMESPACE ns = DEREF_nspace(HEAD_list(lns));
-	    if ( !IS_NULL_nspace ( ns ) ) {
+	    if (!IS_NULL_nspace(ns)) {
-		IDENTIFIER mid = search_nspace ( ns, nm, ns, 0, 0, 0 ) ;
+		IDENTIFIER mid = search_nspace(ns, nm, ns, 0, 0, 0);
-		if ( !IS_NULL_id ( mid ) && !EQ_id ( mid, id ) ) {
+		if (!IS_NULL_id(mid) && !EQ_id(mid, id)) {
-		    ERROR err = NULL_err ;
+		    ERROR err = NULL_err;
-		    switch ( TAG_id ( mid ) ) {
+		    switch (TAG_id(mid)) {
-			case id_variable_tag :
+			case id_variable_tag:
-			case id_parameter_tag :
+			case id_parameter_tag:
-			case id_function_tag : {
+			case id_function_tag: {
 			    /* Report hiding of these objects */
-			    PTR ( LOCATION ) mloc = id_loc ( mid ) ;
+			    PTR(LOCATION) mloc = id_loc(mid);
-			    err = ERR_basic_scope_hide ( nm, mloc ) ;
+			    err = ERR_basic_scope_hide(nm, mloc);
-			    break ;
+			    break;
+			}
-			case id_stat_member_tag :
+			case id_stat_member_tag:
-			case id_mem_func_tag :
+			case id_mem_func_tag:
-			case id_stat_mem_func_tag :
+			case id_stat_mem_func_tag:
-			case id_member_tag : {
+			case id_member_tag:
 			    /* Report hiding of members */
-			    err = ERR_basic_scope_hide_mem ( nm, mid ) ;
+			    err = ERR_basic_scope_hide_mem(nm, mid);
-			    break ;
+			    break;
-			}
 		    }
-		    if ( !IS_NULL_err ( err ) ) {
+		    if (!IS_NULL_err(err)) {
 			/* Print error */
-			LOCATION loc ;
+			LOCATION loc;
-			DEREF_loc ( id_loc ( id ), loc ) ;
+			DEREF_loc(id_loc(id), loc);
-			report ( crt_loc, err ) ;
+			report(crt_loc, err);
+		    }
-		    break ;
+		    break;
+		}
+	    }
-	    lns = TAIL_list ( lns ) ;
+	    lns = TAIL_list(lns);
+	}
+	if (!IS_NULL_list(join_nspaces)) {
+		clear_join_nspaces();
+	}
-	if ( !IS_NULL_list ( join_nspaces ) ) clear_join_nspaces () ;
+    }
-    return ;
+    return;
+}

Subversion Repositories tendra.SVN

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