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

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997, 1998
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
     This is primarily so that the location of a declaration can be set to
     the location of the declarator rather than the end of the corresponding
     initialiser.
 */
-LOCATION decl_loc = NULL_loc ;
+LOCATION decl_loc = NULL_loc;
-int is_redeclared = 0 ;
+int is_redeclared = 0;
 /*
     DEFAULT LINKAGE FOR INLINE FUNCTIONS AND CONST OBJECTS
     These variables give the default linkages for inline functions and
     const objects and the default cv-qualifiers for external objects.
 */
-DECL_SPEC inline_linkage = dspec_static ;
+DECL_SPEC inline_linkage = dspec_static;
-DECL_SPEC const_linkage = dspec_static ;
+DECL_SPEC const_linkage = dspec_static;
-CV_SPEC cv_extern = cv_none ;
+CV_SPEC cv_extern = cv_none;
 /*
     DUMMY EMPTY DECLARATION SPECIFIER
     The value dspec_empty is used during the processing of declarations
     to mark any declaration specifier which does not contain an explicit
     specifier.  The value dspec_nonempty gives those declaration
     specifiers which constitute an explicit specifier.
 */
 #define dspec_empty		dspec_pure
 #define dspec_nonempty		dspec_keyword
 /*
     COMPLETE A DECLARATION SPECIFIER
     This routine completes the declaration specifier given by the
     specifiers ds, the type t and the cv-qualifier cv.  If these are
     all empty then the result is marked using dspec_empty.  The special
     case 'extern "LANG" typedef' is checked.
 */
-DECL_SPEC complete_dspec
+DECL_SPEC
-    PROTO_N ( ( ds, bt, t, cv ) )
-    PROTO_T ( DECL_SPEC ds X BASE_TYPE bt X TYPE t X CV_SPEC cv )
+complete_dspec(DECL_SPEC ds, BASE_TYPE bt, TYPE t, CV_SPEC cv)
+{
-    DECL_SPEC key = ( ds & dspec_nonempty ) ;
+	DECL_SPEC key = (ds & dspec_nonempty);
-    if ( key || bt || !IS_NULL_type ( t ) || cv ) {
+	if (key || bt || !IS_NULL_type(t) || cv) {
-	/* Have a declaration specifier */
+		/* Have a declaration specifier */
-	if ( ds & dspec_c ) {
+		if (ds & dspec_c) {
-	    /* Have a linkage specification */
+			/* Have a linkage specification */
-	    if ( ds & dspec_typedef ) ds &= ~dspec_extern ;
+			if (ds & dspec_typedef) {
+				ds &= ~dspec_extern;
+			}
-	    ds &= ~dspec_c ;
+			ds &= ~dspec_c;
+		}
+	} else {
+		ds |= dspec_empty;
+	}
-    } else {
-	ds |= dspec_empty ;
-    }
-    return ( ds ) ;
+	return (ds);
+}
 /*
     CHECK INFERRED OBJECT TYPES
     This routine checks the declaration specifiers ds and the type *p for
     inferred types and empty specifier lists.  It is used in object,
     parameter and class member declarations.
 */
-static DECL_SPEC check_inferred_type
+static DECL_SPEC
-    PROTO_N ( ( ds, p, mem ) )
-    PROTO_T ( DECL_SPEC ds X TYPE *p X int mem )
+check_inferred_type(DECL_SPEC ds, TYPE *p, int mem)
 {
-    int infer ;
+	int infer;
-    TYPE t = *p ;
+	TYPE t = *p;
-    int empty = 0 ;
+	int empty = 0;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    /* Report if there are no declaration specifiers */
+	/* Report if there are no declaration specifiers */
-    if ( ds & dspec_empty ) {
+	if (ds & dspec_empty) {
-	if ( mem ) {
+		if (mem) {
-	    err = ERR_class_mem_ds_empty () ;
+			err = ERR_class_mem_ds_empty();
-	} else {
+		} else {
-	    err = ERR_dcl_dcl_ds_empty () ;
+			err = ERR_dcl_dcl_ds_empty();
-	}
+		}
-	ds &= ~dspec_empty ;
+		ds &= ~dspec_empty;
-	empty = 1 ;
+		empty = 1;
-    }
+	}
-    /* Check on inferred types */
+	/* Check on inferred types */
-    infer = is_type_inferred ( t ) ;
+	infer = is_type_inferred(t);
-    if ( infer != INFERRED_NOT ) {
+	if (infer != INFERRED_NOT) {
-	ERROR err2 ;
+		ERROR err2;
-	t = clean_inferred_type ( t ) ;
+		t = clean_inferred_type(t);
-	if ( empty ) {
+		if (empty) {
-	    err2 = ERR_dcl_type_infer ( t ) ;
+			err2 = ERR_dcl_type_infer(t);
-	} else {
+		} else {
-	    err2 = report_inferred_type ( t, infer ) ;
+			err2 = report_inferred_type(t, infer);
-	}
+		}
-	err = concat_error ( err, err2 ) ;
+		err = concat_error(err, err2);
-	*p = t ;
+		*p = t;
-    }
+	}
-    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+	if (!IS_NULL_err(err)) {
+		report(crt_loc, err);
+	}
-    return ( ds ) ;
+	return (ds);
 }
 /*
     CHECK INFERRED FUNCTION TYPES
     This routine checks the declaration specifiers ds and the function
     type t for inferred types and empty specifier lists.  It is used in
     function declarations and definitions (as indicated by def).
 */
-static DECL_SPEC check_func_type
+static DECL_SPEC
-    PROTO_N ( ( ds, t, def, chk, mem ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X int def X int chk X int mem )
+check_func_type(DECL_SPEC ds, TYPE t, int def, int chk, int mem)
 {
-    int empty = 0 ;
+	int empty = 0;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    /* Report if there are no declaration specifiers */
+	/* Report if there are no declaration specifiers */
-    if ( ds & dspec_empty ) {
+	if (ds & dspec_empty) {
-	if ( mem ) {
+		if (mem) {
-	    err = ERR_class_mem_ds_empty () ;
+			err = ERR_class_mem_ds_empty();
-	} else if ( def ) {
+		} else if (def) {
-	    err = ERR_dcl_dcl_ds_func () ;
+			err = ERR_dcl_dcl_ds_func();
-	} else {
+		} else {
-	    err = ERR_dcl_dcl_ds_empty () ;
+			err = ERR_dcl_dcl_ds_empty();
-	}
+		}
-	ds &= ~dspec_empty ;
+		ds &= ~dspec_empty;
-	empty = 1 ;
+		empty = 1;
-    }
+	}
-    /* Check for template types */
+	/* Check for template types */
-    while ( IS_type_templ ( t ) ) {
+	while (IS_type_templ(t)) {
-	ds |= dspec_template ;
+		ds |= dspec_template;
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-    }
+	}
-    /* Check the return type */
+	/* Check the return type */
-    if ( chk ) {
+	if (chk) {
-	TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
+		TYPE r = DEREF_type(type_func_ret(t));
-	int infer = is_type_inferred ( r ) ;
+		int infer = is_type_inferred(r);
-	if ( infer != INFERRED_NOT ) {
+		if (infer != INFERRED_NOT) {
-	    ERROR err2 ;
+			ERROR err2;
-	    r = clean_inferred_type ( r ) ;
+			r = clean_inferred_type(r);
-	    if ( empty ) {
+			if (empty) {
-		err2 = ERR_dcl_type_infer ( r ) ;
+				err2 = ERR_dcl_type_infer(r);
-	    } else {
+			} else {
-		err2 = report_inferred_type ( r, infer ) ;
+				err2 = report_inferred_type(r, infer);
-	    }
+			}
-	    err = concat_error ( err, err2 ) ;
+			err = concat_error(err, err2);
-	    COPY_type ( type_func_ret ( t ), r ) ;
+			COPY_type(type_func_ret(t), r);
+		}
+	}
+	if (!IS_NULL_err(err)) {
+		report(crt_loc, err);
+	}
-    }
-    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-    return ( ds ) ;
+	return (ds);
+}
 /*
     SHIFT A STORAGE CLASS
     This macro is used to shift a storage class specifier into a more
     sensible range.
 */
-#define DSPEC_STORAGE( A )	( ( A ) >> 6 )
+#define DSPEC_STORAGE(A)	((A) >> 6)
 /*
     CHECK STORAGE CLASS SPECIFIERS
     This routine extracts the storage class specifiers from the declaration
     specifiers ds in the context given by loc.  It returns a valid storage
     class specifier.
 */
-static DECL_SPEC check_storage
+static DECL_SPEC
-    PROTO_N ( ( ds, loc, id ) )
-    PROTO_T ( DECL_SPEC ds X int loc X IDENTIFIER id )
+check_storage(DECL_SPEC ds, int loc, IDENTIFIER id)
+{
-    DECL_SPEC st = ( ds & dspec_storage ) ;
+	DECL_SPEC st = (ds & dspec_storage);
-    /* Check on storage class */
+	/* Check on storage class */
-    switch_label : {
+switch_label:
-	switch ( DSPEC_STORAGE ( st ) ) {
+	switch (DSPEC_STORAGE(st)) {
-	    case DSPEC_STORAGE ( dspec_none ) : {
+	case DSPEC_STORAGE(dspec_none): {
 		/* No storage class given */
-		break ;
+		break;
-	    }
+	}
-	    case DSPEC_STORAGE ( dspec_auto ) :
+	case DSPEC_STORAGE(dspec_auto):
-	    case DSPEC_STORAGE ( dspec_register ) : {
+	case DSPEC_STORAGE(dspec_register): {
 		/* Deal with auto and register */
-		switch ( loc ) {
+		switch (loc) {
-		    case CONTEXT_OBJECT : {
+		case CONTEXT_OBJECT: {
 			/* Objects declared in a block are alright */
-			if ( !in_function_defn ) goto bad_auto_lab ;
+			if (!in_function_defn) {
+				goto bad_auto_lab;
+			}
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_FUNCTION : {
+		case CONTEXT_FUNCTION: {
 			/* Functions can't be auto */
-			if ( !in_function_defn ) goto bad_auto_lab ;
+			if (!in_function_defn) {
+				goto bad_auto_lab;
+			}
-			report ( crt_loc, ERR_dcl_stc_auto_func ( st ) ) ;
+			report(crt_loc, ERR_dcl_stc_auto_func(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_PARAMETER :
+		case CONTEXT_PARAMETER:
-		    case CONTEXT_WEAK_PARAM : {
+		case CONTEXT_WEAK_PARAM: {
 			/* Function parameters are alright */
-			if ( st == dspec_auto ) {
+			if (st == dspec_auto) {
-			    /* Can't have auto parameters in C */
+				/* Can't have auto parameters in C */
-			    report ( crt_loc, ERR_dcl_stc_auto_par () ) ;
+				report(crt_loc, ERR_dcl_stc_auto_par());
+			}
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_TEMPL_PARAM : {
+		case CONTEXT_TEMPL_PARAM: {
 			/* Template parameters can't have storage class */
-			report ( crt_loc, ERR_temp_param_dcl_stc ( st ) ) ;
+			report(crt_loc, ERR_temp_param_dcl_stc(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
-		    default :
-		    bad_auto_lab : {
-			/* Anything outside a block can't be auto */
-			report ( crt_loc, ERR_dcl_stc_auto_bad ( st ) ) ;
-			st = dspec_none ;
-			break ;
-		    }
+		}
+		default:
+bad_auto_lab:
+			/* Anything outside a block can't be auto */
+			report(crt_loc, ERR_dcl_stc_auto_bad(st));
+			st = dspec_none;
-		break ;
+			break;
-	    }
+		}
+		break;
+	}
-	    case DSPEC_STORAGE ( dspec_static ) : {
+	case DSPEC_STORAGE(dspec_static): {
 		/* Deal with static */
-		switch ( loc ) {
+		switch (loc) {
-		    case CONTEXT_PARAMETER :
+		case CONTEXT_PARAMETER:
-		    case CONTEXT_WEAK_PARAM : {
+		case CONTEXT_WEAK_PARAM: {
 			/* Function parameters can't be static */
-			report ( crt_loc, ERR_dcl_stc_param ( st ) ) ;
+			report(crt_loc, ERR_dcl_stc_param(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_TEMPL_PARAM : {
+		case CONTEXT_TEMPL_PARAM: {
 			/* Template parameters can't have storage class */
-			report ( crt_loc, ERR_temp_param_dcl_stc ( st ) ) ;
+			report(crt_loc, ERR_temp_param_dcl_stc(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
 		}
-		break ;
+		break;
-	    }
+	}
-	    case DSPEC_STORAGE ( dspec_extern ) : {
+	case DSPEC_STORAGE(dspec_extern): {
 		/* Deal with extern */
-		switch ( loc ) {
+		switch (loc) {
-		    case CONTEXT_OBJECT :
+		case CONTEXT_OBJECT:
-		    case CONTEXT_FUNCTION : {
+		case CONTEXT_FUNCTION: {
 			/* Objects and functions can be extern */
-			if ( !IS_NULL_id ( id ) ) {
+			if (!IS_NULL_id(id)) {
-			    switch ( TAG_id ( id ) ) {
+				switch (TAG_id(id)) {
-				case id_member_tag :
+				case id_member_tag:
-				case id_mem_func_tag :
+				case id_mem_func_tag:
-				case id_stat_member_tag :
+				case id_stat_member_tag:
-				case id_stat_mem_func_tag : {
+				case id_stat_mem_func_tag: {
-				    /* But not class members */
+					/* But not class members */
-				    ERROR err = ERR_dcl_stc_ext_mem () ;
+					ERROR err = ERR_dcl_stc_ext_mem();
-				    report ( crt_loc, err ) ;
+					report(crt_loc, err);
-				    break ;
+					break;
+				}
+				}
-			    }
+			}
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_PARAMETER :
+		case CONTEXT_PARAMETER:
-		    case CONTEXT_WEAK_PARAM : {
+		case CONTEXT_WEAK_PARAM: {
 			/* Function parameters can't be extern */
-			report ( crt_loc, ERR_dcl_stc_param ( st ) ) ;
+			report(crt_loc, ERR_dcl_stc_param(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
-		    case CONTEXT_TEMPL_PARAM : {
+		case CONTEXT_TEMPL_PARAM: {
 			/* Template parameters can't have storage class */
-			report ( crt_loc, ERR_temp_param_dcl_stc ( st ) ) ;
+			report(crt_loc, ERR_temp_param_dcl_stc(st));
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
-		    default : {
+		default:
 			/* Class members can't be extern */
-			report ( crt_loc, ERR_dcl_stc_ext_mem () ) ;
+			report(crt_loc, ERR_dcl_stc_ext_mem());
-			st = dspec_none ;
+			st = dspec_none;
-			break ;
+			break;
-		    }
+		}
-		break ;
+		break;
-	    }
+	}
-	    case DSPEC_STORAGE ( dspec_mutable ) : {
+	case DSPEC_STORAGE(dspec_mutable): {
 		/* Deal with mutable */
-		if ( loc != CONTEXT_MEMBER ) {
+		if (loc != CONTEXT_MEMBER) {
-		    /* Only data members can be mutable */
+			/* Only data members can be mutable */
-		    report ( crt_loc, ERR_dcl_stc_mut_bad () ) ;
+			report(crt_loc, ERR_dcl_stc_mut_bad());
-		    st = dspec_none ;
+			st = dspec_none;
 		}
-		break ;
+		break;
-	    }
+	}
-	    default : {
+	default: {
 		/* More than one storage class - select one */
-		DECL_SPEC nst = dspec_static ;
+		DECL_SPEC nst = dspec_static;
-		while ( !( st & nst ) ) {
+		while (!(st & nst)) {
-		    ASSERT ( nst != dspec_none ) ;
+			ASSERT(nst != dspec_none);
-		    nst <<= 1 ;
+			nst <<= 1;
+		}
-		report ( crt_loc, ERR_dcl_stc_dup ( st, nst ) ) ;
+		report(crt_loc, ERR_dcl_stc_dup(st, nst));
-		st = nst ;
+		st = nst;
-		goto switch_label ;
+		goto switch_label;
-	    }
+	}
+	}
-    }
-    return ( st ) ;
+	return (st);
+}
 /*
     CHECK STORAGE CLASS SPECIFIERS
     This routine extracts the function specifiers (plus friend specifiers)
     from the declaration specifiers ds in the context given by loc (as
     above).  It returns a valid combination of function and friend
     specifiers.
 */
-static DECL_SPEC check_func_spec
+static DECL_SPEC
-    PROTO_N ( ( ds, loc ) )
-    PROTO_T ( DECL_SPEC ds X int loc )
+check_func_spec(DECL_SPEC ds, int loc)
 {
-    DECL_SPEC fn = dspec_none ;
+	DECL_SPEC fn = dspec_none;
-    /* Only functions can be inline */
+	/* Only functions can be inline */
-    if ( ds & dspec_inline ) {
+	if (ds & dspec_inline) {
-	if ( loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER ) {
+		if (loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER) {
-	    fn |= dspec_inline ;
+			fn |= dspec_inline;
-	} else {
+		} else {
-	    report ( crt_loc, ERR_dcl_fct_spec_inline_bad () ) ;
+			report(crt_loc, ERR_dcl_fct_spec_inline_bad());
-	}
+		}
-    }
+	}
-    /* Only function members can be virtual */
+	/* Only function members can be virtual */
-    if ( ds & dspec_virtual ) {
+	if (ds & dspec_virtual) {
-	if ( loc == CONTEXT_FUNC_MEMBER ) {
+		if (loc == CONTEXT_FUNC_MEMBER) {
-	    fn |= dspec_virtual ;
+			fn |= dspec_virtual;
-	} else {
+		} else {
-	    report ( crt_loc, ERR_dcl_fct_spec_virtual () ) ;
+			report(crt_loc, ERR_dcl_fct_spec_virtual());
-	}
+		}
-    }
+	}
-    /* Only function members can be explicit */
+	/* Only function members can be explicit */
-    if ( ds & dspec_explicit ) {
+	if (ds & dspec_explicit) {
-	if ( loc == CONTEXT_FUNC_MEMBER ) {
+		if (loc == CONTEXT_FUNC_MEMBER) {
-	    fn |= dspec_explicit ;
+			fn |= dspec_explicit;
-	} else {
+		} else {
-	    report ( crt_loc, ERR_dcl_fct_spec_explicit () ) ;
+			report(crt_loc, ERR_dcl_fct_spec_explicit());
-	}
+		}
-    }
+	}
-    /* Only functions declared in a class can be friends */
+	/* Only functions declared in a class can be friends */
-    if ( ds & dspec_friend ) {
+	if (ds & dspec_friend) {
-	if ( loc == CONTEXT_FUNCTION && in_class_defn ) {
+		if (loc == CONTEXT_FUNCTION && in_class_defn) {
-	    /* Don't add to specifier list */
+			/* Don't add to specifier list */
-	    /* EMPTY */
+			/* EMPTY */
-	} else if ( in_class_defn ) {
+		} else if (in_class_defn) {
-	    report ( crt_loc, ERR_class_friend_decl () ) ;
+			report(crt_loc, ERR_class_friend_decl());
-	} else {
+		} else {
-	    report ( crt_loc, ERR_dcl_friend_class () ) ;
+			report(crt_loc, ERR_dcl_friend_class());
-	}
+		}
-    }
+	}
-    /* Allow for function discarding */
+	/* Allow for function discarding */
-    if ( loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER ) {
+	if (loc == CONTEXT_FUNCTION || loc == CONTEXT_FUNC_MEMBER) {
-	fn |= dspec_ignore ;
+		fn |= dspec_ignore;
-    }
+	}
-    return ( fn ) ;
+	return (fn);
 }
 /*
     CONSTRUCT A TYPE DECLARATION
     This routine constructs the declaration of a type with declaration
     specifiers ds (which will include typedef), type t and name id in the
     namespace ns.  mem gives the member of ns corresponding to id or the
     null member for class member redeclarations.
 */
-static IDENTIFIER make_type_decl
+static IDENTIFIER
-    PROTO_N ( ( ns, ds, t, mem, id ) )
-    PROTO_T ( NAMESPACE ns X DECL_SPEC ds X TYPE t X
+make_type_decl(NAMESPACE ns, DECL_SPEC ds, TYPE t, MEMBER mem, IDENTIFIER id)
-	      MEMBER mem X IDENTIFIER id )
 {
-    int reported = 0 ;
+	int reported = 0;
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    /* Can't have other declaration specifiers with typedef */
+	/* Can't have other declaration specifiers with typedef */
-    DECL_SPEC st = ( ds & dspec_keyword ) ;
+	DECL_SPEC st = (ds & dspec_keyword);
-    if ( st != dspec_typedef ) {
+	if (st != dspec_typedef) {
-	st &= ~dspec_typedef ;
+		st &= ~dspec_typedef;
-	report ( crt_loc, ERR_dcl_typedef_dspec ( st ) ) ;
+		report(crt_loc, ERR_dcl_typedef_dspec(st));
-    }
+	}
-    /* Check for function cv-qualifiers and exception specifiers */
+	/* Check for function cv-qualifiers and exception specifiers */
-    object_type ( t, id_type_alias_tag ) ;
+	object_type(t, id_type_alias_tag);
-    /* Check for previous declaration */
+	/* Check for previous declaration */
-    if ( IS_NULL_member ( mem ) ) {
+	if (IS_NULL_member(mem)) {
-	mem = search_member ( ns, nm, 1 ) ;
+		mem = search_member(ns, nm, 1);
-	old_id = DEREF_id ( member_id ( mem ) ) ;
+		old_id = DEREF_id(member_id(mem));
-	old_id = redecl_inherit ( old_id, cq, in_class_defn, 2 ) ;
+		old_id = redecl_inherit(old_id, cq, in_class_defn, 2);
-	if ( IS_NULL_id ( old_id ) ) {
+		if (IS_NULL_id(old_id)) {
-	    report ( crt_loc, ERR_lookup_qual_undef ( nm, ns ) ) ;
+			report(crt_loc, ERR_lookup_qual_undef(nm, ns));
-	}
+		}
-    } else {
+	} else {
-	old_id = DEREF_id ( member_id ( mem ) ) ;
+		old_id = DEREF_id(member_id(mem));
-	old_id = redecl_inherit ( old_id, cq, in_class_defn, 2 ) ;
+		old_id = redecl_inherit(old_id, cq, in_class_defn, 2);
-    }
+	}
-    /* Allow for type redeclarations */
+	/* Allow for type redeclarations */
 #if LANGUAGE_CPP
-    id = type_member ( mem, 3 ) ;
+	id = type_member(mem, 3);
-    id = redecl_inherit ( id, cq, in_class_defn, 2 ) ;
+	id = redecl_inherit(id, cq, in_class_defn, 2);
 #else
-    id = old_id ;
+	id = old_id;
 #endif
-    if ( !IS_NULL_id ( id ) && IS_id_class_name_etc ( id ) ) {
+	if (!IS_NULL_id(id) && IS_id_class_name_etc(id)) {
-	/* Already declared as a type name */
+		/* Already declared as a type name */
-	TYPE s ;
+		TYPE s;
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	PTR ( LOCATION ) loc = id_loc ( id ) ;
+		PTR(LOCATION)loc = id_loc(id);
-	unsigned long tokdefs = no_token_defns ;
+		unsigned long tokdefs = no_token_defns;
-	/* Check for reserved identifiers */
+		/* Check for reserved identifiers */
-	DECL_SPEC ods = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ods = DEREF_dspec(id_storage(id));
-	if ( ( ds | ods ) & dspec_reserve ) {
+		if ((ds | ods) & dspec_reserve) {
-	    report ( crt_loc, ERR_basic_odr_decl ( id, loc ) ) ;
+			report(crt_loc, ERR_basic_odr_decl(id, loc));
-	    return ( id ) ;
+			return (id);
-	}
+		}
-	/* Check type compatibility */
+		/* Check type compatibility */
-	s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+		s = DEREF_type(id_class_name_etc_defn(id));
-	s = check_compatible ( s, t, 0, &err, 1 ) ;
+		s = check_compatible(s, t, 0, &err, 1);
-	/* QUERY: or is type equality required? */
+		/* QUERY: or is type equality required? */
+		/* Compatible redefinition */
+		if (IS_NULL_err(err)) {
+			NAMESPACE cns = crt_namespace;
+			if (cq != qual_none) {
+				/* Check qualified definitions */
+				check_decl_nspace(id, ns, 1, cns);
+			}
+			if (in_class_defn && EQ_nspace(ns, cns)) {
+				if (!is_tagged_type(id)) {
+					/* Still not allowed in a class
+					 * definition */
+					report(crt_loc,
+					       ERR_class_mem_redecl(id, loc));
+				}
+			} else if (tokdefs == no_token_defns &&
+				   !in_pragma_dir) {
+				/* Can't redeclare types in C */
+				report(crt_loc, ERR_basic_odr_typedef(id, loc));
+			}
+			if (tag == type_func_tag) {
+				/* Check function types */
+				s = redecl_func_type(id, s, t, 0, 1);
+			}
+			COPY_type(id_class_name_etc_defn(id), s);
+			adjust_access(id, crt_access, 0);
+			return (id);
+		}
+		/* Incompatible redefinition */
+		err = concat_error(err, ERR_basic_link_typedef(id, loc));
+		report(crt_loc, err);
+		reported = 1;
+	}
-	/* Compatible redefinition */
+	/* Declare the type */
-	if ( IS_NULL_err ( err ) ) {
-	    NAMESPACE cns = crt_namespace ;
+	id = make_typedef(ns, nm, t, dspec_none);
-	    if ( cq != qual_none ) {
+	if (is_tagged_type(id)) {
-		/* Check qualified definitions */
+		/* Class-like typedef-names */
-		check_decl_nspace ( id, ns, 1, cns ) ;
+		set_type_member(mem, id);
-	    }
+	} else {
-	    if ( in_class_defn && EQ_nspace ( ns, cns ) ) {
+		/* Object-like typedef-names */
-		if ( !is_tagged_type ( id ) ) {
+		if (!IS_NULL_id(old_id) && !reported) {
-		    /* Still not allowed in a class definition */
+			/* Already declared as an object */
+			PTR(LOCATION)loc = id_loc(old_id);
-		    report ( crt_loc, ERR_class_mem_redecl ( id, loc ) ) ;
+			report(crt_loc, ERR_basic_odr_diff(old_id, loc));
+		}
-	    } else if ( tokdefs == no_token_defns && !in_pragma_dir ) {
-		/* Can't redeclare types in C */
-		report ( crt_loc, ERR_basic_odr_typedef ( id, loc ) ) ;
-	    }
-	    if ( tag == type_func_tag ) {
-		/* Check function types */
-		s = redecl_func_type ( id, s, t, 0, 1 ) ;
-	    }
-	    COPY_type ( id_class_name_etc_defn ( id ), s ) ;
-	    adjust_access ( id, crt_access, 0 ) ;
-	    return ( id ) ;
+		set_member(mem, id);
+	}
-	/* Incompatible redefinition */
+	if (tag == type_func_tag) {
-	err = concat_error ( err, ERR_basic_link_typedef ( id, loc ) ) ;
-	report ( crt_loc, err ) ;
-	reported = 1 ;
-    }
-    /* Declare the type */
+		/* Check function type */
-    id = make_typedef ( ns, nm, t, dspec_none ) ;
+		decl_func_type(id, t, 0);
-    if ( is_tagged_type ( id ) ) {
+	} else if (tag == type_templ_tag) {
-	/* Class-like typedef-names */
-	set_type_member ( mem, id ) ;
+		IGNORE check_templ_params(t, id);
-    } else {
-	/* Object-like typedef-names */
-	if ( !IS_NULL_id ( old_id ) && !reported ) {
-	    /* Already declared as an object */
-	    PTR ( LOCATION ) loc = id_loc ( old_id ) ;
-	    report ( crt_loc, ERR_basic_odr_diff ( old_id, loc ) ) ;
+		report(crt_loc, ERR_temp_decl_bad());
+	}
-	set_member ( mem, id ) ;
-    }
-    if ( tag == type_func_tag ) {
-	/* Check function type */
-	decl_func_type ( id, t, 0 ) ;
-    } else if ( tag == type_templ_tag ) {
-	IGNORE check_templ_params ( t, id ) ;
-	report ( crt_loc, ERR_temp_decl_bad () ) ;
-    }
-    return ( id ) ;
+	return (id);
+}
 /*
     CREATE A SPECIAL TYPE DEFINITION
     This routine creates a typedef of the identifier id to the special
     type t.
 */
-void typedef_special
+void
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
+typedef_special(IDENTIFIER id, TYPE t)
+{
-    int pushed = 0 ;
+	int pushed = 0;
-    NAMESPACE ns = nonblock_namespace ;
+	NAMESPACE ns = nonblock_namespace;
-    if ( !EQ_nspace ( ns, crt_namespace ) ) {
+	if (!EQ_nspace(ns, crt_namespace)) {
-	push_namespace ( ns ) ;
+		push_namespace(ns);
-	pushed = 1 ;
+		pushed = 1;
-    }
+	}
-    decl_loc = preproc_loc ;
+	decl_loc = preproc_loc;
-    if ( in_class_defn ) {
+	if (in_class_defn) {
-	id = make_member_decl ( dspec_typedef, t, id, 0 ) ;
+		id = make_member_decl(dspec_typedef, t, id, 0);
-    } else {
+	} else {
-	id = make_object_decl ( dspec_typedef, t, id, 0 ) ;
+		id = make_object_decl(dspec_typedef, t, id, 0);
-    }
+	}
+	if (do_dump) {
-    if ( do_dump ) dump_declare ( id, &decl_loc, 1 ) ;
+		dump_declare(id, &decl_loc, 1);
+	}
-    if ( pushed ) {
+	if (pushed) {
-	IGNORE pop_namespace () ;
+		IGNORE pop_namespace();
-    }
+	}
-    return ;
+	return;
+}
 /*
     FIND THE LINKAGE OF AN IDENTIFIER
     This routine finds the linkage of the identifier id (including the
     language specifier), returning the default value st if id does not
     represent an object or function.
 */
-static DECL_SPEC find_storage
+static DECL_SPEC
-    PROTO_N ( ( id, st, t ) )
-    PROTO_T ( IDENTIFIER id X DECL_SPEC st X TYPE t )
+find_storage(IDENTIFIER id, DECL_SPEC st, TYPE t)
+{
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_variable_tag :
+		case id_variable_tag:
-	    case id_parameter_tag :
+		case id_parameter_tag:
-	    case id_stat_member_tag :
+		case id_stat_member_tag:
-	    case id_weak_param_tag : {
+		case id_weak_param_tag: {
-		/* Objects */
+			/* Objects */
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		st = ( ds & ( dspec_storage | dspec_language ) ) ;
+			st = (ds & (dspec_storage | dspec_language));
-		break ;
+			break;
-	    }
+		}
-	    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: {
-		/* Functions */
+			/* Functions */
-		DECL_SPEC ds ;
+			DECL_SPEC ds;
 #if LANGUAGE_CPP
-		LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+			LIST(IDENTIFIER)pids = NULL_list(IDENTIFIER);
-		if ( !IS_NULL_type ( t ) ) {
+			if (!IS_NULL_type(t)) {
-		    int eq = 0 ;
+				int eq = 0;
-		    id = resolve_func ( id, t, 0, 0, pids, &eq ) ;
+				id = resolve_func(id, t, 0, 0, pids, &eq);
+				if (IS_NULL_id(id) ||
-		    if ( IS_NULL_id ( id ) || !IS_id_function_etc ( id ) ) {
+				    !IS_id_function_etc(id)) {
-			return ( st ) ;
+					return (st);
-		    }
+				}
-		}
+			}
 #else
-		UNUSED ( t ) ;
+			UNUSED(t);
 #endif
-		ds = DEREF_dspec ( id_storage ( id ) ) ;
+			ds = DEREF_dspec(id_storage(id));
-		st = ( ds & ( dspec_storage | dspec_language ) ) ;
+			st = (ds & (dspec_storage | dspec_language));
-		break ;
+			break;
-	    }
+		}
+		}
+	}
-    }
-    return ( st ) ;
+	return (st);
+}
 /*
     CHECK THE LOCATION OF A DECLARATION
     This routine checks whether the namespace cns is a suitable location
     for redeclaring the object id, which is a member of the namespace ns.
     def is true for a definition.
 */
-void check_decl_nspace
+void
-    PROTO_N ( ( id, ns, def, cns ) )
-    PROTO_T ( IDENTIFIER id X NAMESPACE ns X int def X NAMESPACE cns )
+check_decl_nspace(IDENTIFIER id, NAMESPACE ns, int def, NAMESPACE cns)
+{
-    int func = 0 ;
+	int func = 0;
-    int local_def = really_in_function_defn ;
+	int local_def = really_in_function_defn;
-    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:
-	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: {
-	    /* Can define local types */
+		/* Can define local types */
-	    local_def = 0 ;
+		local_def = 0;
-	    break ;
+		break;
+	}
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag: {
-	    /* Member function */
+		/* Member function */
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( ds & dspec_implicit ) {
+		if (ds & dspec_implicit) {
-		/* Ignore implicit constructors etc */
+			/* Ignore implicit constructors etc */
-		return ;
+			return;
-	    }
+		}
-	    if ( !def && !is_templ_nspace ( ns ) ) {
+		if (!def && !is_templ_nspace(ns)) {
-		/* Can't even redeclare in this case */
+			/* Can't even redeclare in this case */
-		report ( crt_loc, ERR_class_mfct_redecl ( id ) ) ;
+			report(crt_loc, ERR_class_mfct_redecl(id));
-		return ;
+			return;
-	    }
+		}
-	    func = 1 ;
+		func = 1;
-	    break ;
+		break;
+	}
+	case id_undef_tag: {
+		/* Report undeclared members */
+		HASHID nm = DEREF_hashid(id_name(id));
+		report(crt_loc, ERR_lookup_qual_undef(nm, ns));
+		return;
+	}
-	case id_undef_tag : {
-	    /* Report undeclared members */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-	    report ( crt_loc, ERR_lookup_qual_undef ( nm, ns ) ) ;
-	    return ;
+	}
-    }
-    if ( def ) {
+	if (def) {
-	/* Check for enclosing namespace scope */
+		/* Check for enclosing namespace scope */
-	if ( local_def || !is_subnspace ( cns, ns ) ) {
+		if (local_def || !is_subnspace(cns, ns)) {
-	    /* Report badly placed definition */
+			/* Report badly placed definition */
-	    ERROR err ;
+			ERROR err;
-	    if ( IS_nspace_ctype ( ns ) ) {
+			if (IS_nspace_ctype(ns)) {
-		if ( func ) {
+				if (func) {
-		    /* Member functions */
+					/* Member functions */
-		    err = ERR_class_mfct_scope ( id ) ;
+					err = ERR_class_mfct_scope(id);
-		} else {
+				} else {
-		    /* Other class members */
+					/* Other class members */
-		    err = ERR_class_static_data_scope ( id ) ;
+					err = ERR_class_static_data_scope(id);
+				}
+			} else {
+				/* Namespace members */
+				err = ERR_dcl_nspace_memdef_scope(id);
+			}
+			report(crt_loc, err);
+		}
-	    } else {
-		/* Namespace members */
-		err = ERR_dcl_nspace_memdef_scope ( id ) ;
-	    }
-	    report ( crt_loc, err ) ;
+	}
-    }
-    return ;
+	return;
+}
 /*
     CHECK AN OBJECT TYPE
     This routine checks the type t for the object id with declaration
     specifiers ds.
 */
-void check_obj_decl
+void
-    PROTO_N ( ( ds, t, id, tentative ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int tentative )
+check_obj_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int tentative)
 {
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    if ( tag == type_top_tag || tag == type_bottom_tag ) {
+	if (tag == type_top_tag || tag == type_bottom_tag) {
-	/* Always report void declarations */
+		/* Always report void declarations */
-	report ( crt_loc, ERR_basic_fund_void_decl ( id, t ) ) ;
+		report(crt_loc, ERR_basic_fund_void_decl(id, t));
-    } else if ( tag == type_templ_tag ) {
+	} else if (tag == type_templ_tag) {
-	/* Shouldn't have template type */
+		/* Shouldn't have template type */
-	report ( crt_loc, ERR_temp_decl_bad () ) ;
+		report(crt_loc, ERR_temp_decl_bad());
-    } else if ( ds & dspec_defn ) {
+	} else if (ds & dspec_defn) {
-	/* Only check otherwise if this is a definition */
+		/* Only check otherwise if this is a definition */
-	if ( tag == type_array_tag ) {
+		if (tag == type_array_tag) {
-	    /* Arrays may be completed by the initialiser */
+			/* Arrays may be completed by the initialiser */
-	    /* EMPTY */
+			/* EMPTY */
-	} else if ( tag == type_ref_tag ) {
+		} else if (tag == type_ref_tag) {
-	    /* References don't need checking */
+			/* References don't need checking */
-	    /* EMPTY */
+			/* EMPTY */
-	} else {
+		} else {
-	    ERROR err ;
+			ERROR err;
-	    if ( !tentative ) {
+			if (!tentative) {
-		err = check_complete ( t ) ;
+				err = check_complete(t);
-		if ( !IS_NULL_err ( err ) ) {
+				if (!IS_NULL_err(err)) {
-		    /* Other definitions should have complete type */
+					/* Other definitions should have
+					 * complete type */
+					ERROR err2 =
-		    ERROR err2 = ERR_basic_types_def_incompl ( id ) ;
+					    ERR_basic_types_def_incompl(id);
-		    err = concat_error ( err, err2 ) ;
+					err = concat_error(err, err2);
-		    report ( crt_loc, err ) ;
+					report(crt_loc, err);
-		}
+				}
-	    }
+			}
-	    err = check_abstract ( t ) ;
+			err = check_abstract(t);
-	    if ( !IS_NULL_err ( err ) ) {
+			if (!IS_NULL_err(err)) {
-		/* Objects can't have abstract type */
+				/* Objects can't have abstract type */
-		ERROR err2 = ERR_class_abstract_decl ( id ) ;
+				ERROR err2 = ERR_class_abstract_decl(id);
-		err = concat_error ( err, err2 ) ;
+				err = concat_error(err, err2);
-		report ( crt_loc, err ) ;
+				report(crt_loc, err);
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     DECLARE AN OBJECT
     This routine constructs the declaration of an object with declaration
     specifiers ds, type t and name id.
 */
-IDENTIFIER make_object_decl
+IDENTIFIER
-    PROTO_N ( ( ds, t, id, def ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int def )
+make_object_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int def)
+{
-    ERROR err ;
+	ERROR err;
-    MEMBER mem ;
+	MEMBER mem;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    int redef = 0 ;
+	int redef = 0;
-    int simple_id = 1 ;
+	int simple_id = 1;
-    int tentative = 0 ;
+	int tentative = 0;
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    IDENTIFIER alt_id ;
+	IDENTIFIER alt_id;
-    DECL_SPEC st, df, rs ;
+	DECL_SPEC st, df, rs;
-    IDENTIFIER prev_id = NULL_id ;
+	IDENTIFIER prev_id = NULL_id;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    unsigned itag = id_variable_tag ;
+	unsigned itag = id_variable_tag;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    /* Check for template specialisations */
+	/* Check for template specialisations */
-    bound_specialise = 0 ;
+	bound_specialise = 0;
-    if ( is_templ_decl ( id, NULL_type ) || is_templ_spec ( t ) ) {
+	if (is_templ_decl(id, NULL_type) || is_templ_spec(t)) {
-	t = bind_specialise ( &id, t, ds, 0, 1, def ) ;
+		t = bind_specialise(&id, t, ds, 0, 1, def);
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    /* Invalid specialisation */
+			/* Invalid specialisation */
-	    crt_id_qualifier = qual_none ;
+			crt_id_qualifier = qual_none;
-	    crt_templ_qualifier = 0 ;
+			crt_templ_qualifier = 0;
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
+			id = DEREF_id(hashid_id(nm));
-	    while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-	    }
+			}
-	    id = make_object_decl ( ds, t, id, def ) ;
+			id = make_object_decl(ds, t, id, def);
-	    return ( id ) ;
+			return (id);
-	}
+		}
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
+		ns = DEREF_nspace(id_parent(id));
-	check_decl_nspace ( id, ns, 0, crt_namespace ) ;
+		check_decl_nspace(id, ns, 0, crt_namespace);
-	old_id = id ;
+		old_id = id;
-	mem = NULL_member ;
+		mem = NULL_member;
-	simple_id = 0 ;
+		simple_id = 0;
+	} else {
+		/* Check on identifier name */
+		QUALIFIER cq = crt_id_qualifier;
+		err = check_id_name(id, CONTEXT_OBJECT);
+		if (!IS_NULL_err(err)) {
+			report(crt_loc, err);
+		}
+		/* Check for qualified identifiers */
+		if (cq == qual_none) {
+			/* Declaration of simple identifier */
+			ns = crt_namespace;
+			mem = search_member(ns, nm, 1);
+			old_id = DEREF_id(member_id(mem));
+			alt_id = DEREF_id(member_alt(mem));
+			if (!IS_NULL_id(old_id)) {
+				if (in_function_defn && (ds & dspec_extern)) {
+					/* Redeclaration of block external */
+					prev_id = find_previous(t, id);
+					if (EQ_id(prev_id, old_id)) {
+						old_id = NULL_id;
+					}
-    } else {
+				} else {
+					old_id = redecl_inherit(old_id, cq, 0,
+);
+				}
+				redef = 1;
+			} else if (!IS_NULL_id(alt_id)) {
+				redef = 1;
+			}
+		} else {
+			/* Redeclaration of class or namespace member */
+			ns = DEREF_nspace(id_parent(id));
+			check_decl_nspace(id, ns, 0, crt_namespace);
+			if (IS_id_undef(id)) {
+				if (IS_nspace_ctype(ns)) {
+					itag = id_stat_member_tag;
+				}
+				mem = search_member(ns, nm, 1);
+				old_id = NULL_id;
+			} else {
+				mem = NULL_member;
+				old_id = redecl_inherit(id, cq, 0, 2);
+				t = bind_specialise(&old_id, t, ds, 0, 0, def);
+				if (!IS_NULL_id(old_id)) {
+					id = old_id;
+					itag = TAG_id(id);
+					ns = DEREF_nspace(id_parent(id));
+				}
+			}
+			simple_id = 0;
+		}
+	}
-	/* Check on identifier name */
+	/* Deal with inferred types */
+	ds = check_inferred_type(ds, &t, 0);
+	/* Check on storage class specifiers */
+	st = check_storage(ds, CONTEXT_OBJECT, old_id);
+	/* Deal with type definitions */
+	if (ds & dspec_typedef) {
+		id = make_type_decl(ns, ds, t, mem, id);
+		return (id);
+	}
-	QUALIFIER cq = crt_id_qualifier ;
+	/* Check on function specifiers */
-	err = check_id_name ( id, CONTEXT_OBJECT ) ;
+	IGNORE check_func_spec(ds, CONTEXT_OBJECT);
+	/* Find the object linkage and whether it is a definition */
+	if (st == dspec_extern) {
+		/* Explicit extern indicates a declaration (probably) */
+		df = dspec_none;
+		if (in_function_defn && simple_id) {
+			if (IS_NULL_id(prev_id)) {
+				prev_id = find_previous(t, id);
+			}
+			st = find_storage(prev_id, st, NULL_type);
+		} else {
+			prev_id = old_id;
+			st = find_storage(old_id, st, t);
+		}
+	} else {
-	if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+		if (tag == type_templ_tag && bound_specialise) {
+			/* A template specialisation is a declaration
+			 * (probably) */
+			df = dspec_none;
+		} else {
+			/* Everything else is a definition */
+			df = dspec_defn;
+		}
+		if (in_function_defn) {
+			/* Objects declared in a block have no linkage */
+			if (IS_NULL_member(mem)) {
+				/* Use old linkage if explicitly qualified */
+				st = find_storage(old_id, dspec_none, t);
+			} else if (st == dspec_static) {
+				st = dspec_none;
+			} else if (st == dspec_register) {
+				st = (dspec_auto | dspec_register);
+				used_register = 1;
+			} else {
+				st = dspec_auto;
+			}
+		} else if (st == dspec_static) {
+			/* Check static declarations */
+			if (!def) {
+				tentative = LANGUAGE_C;
+			}
+		} else if (st == dspec_none) {
+			/* Objects declared const have internal linkage */
+			CV_SPEC qual = find_cv_qual(t);
+			if (qual & cv_const) {
+				st = const_linkage;
+				if (st & dspec_static) {
+					st = find_storage(old_id, st, t);
+				}
+			} else {
+				st = dspec_extern;
+			}
+			/* find_storage is not applied for objects */
+			if (!def) {
+				tentative = LANGUAGE_C;
+			}
+		}
+	}
-	/* Check for qualified identifiers */
+	/* Create the declaration */
+	t = lvalue_type(t);
+	rs = (ds & dspec_other);
+	ds = (st | df | rs);
-	if ( cq == qual_none ) {
+	if (!IS_NULL_id(old_id)) {
+		/* Check redeclarations */
+		old_id = redecl_id(ds, t, old_id, 0, 0);
+		if (IS_NULL_id(old_id) && IS_NULL_member(mem)) {
-	    /* Declaration of simple identifier */
+			/* Bad redeclaration of class or namespace member */
-	    ns = crt_namespace ;
+			nm = lookup_anon();
-	    mem = search_member ( ns, nm, 1 ) ;
+			mem = search_member(ns, nm, 1);
-	    old_id = DEREF_id ( member_id ( mem ) ) ;
+			itag = id_stat_member_tag;
+		}
+	}
-	    alt_id = DEREF_id ( member_alt ( mem ) ) ;
+	object_type(t, itag);
-	    if ( !IS_NULL_id ( old_id ) ) {
+	if (IS_NULL_id(old_id)) {
+		/* Construct the declaration */
+		ds = adjust_linkage(ds, 0);
+		MAKE_id_variable_etc(itag, nm, ds, ns, decl_loc, t, id);
-		if ( in_function_defn && ( ds & dspec_extern ) ) {
+		if (in_function_defn) {
+			if (ds & dspec_linkage) {
-		    /* Redeclaration of block external */
+				/* Block function declarations */
-		    prev_id = find_previous ( t, id ) ;
+				id = unify_previous(id, t, prev_id, 0);
-		    if ( EQ_id ( prev_id, old_id ) ) old_id = NULL_id ;
+			} else if (redef && (ds & dspec_auto)) {
+				/* Redeclarations of local variables */
+				mem = update_member(ns, mem);
+			}
 		} else {
-		    old_id = redecl_inherit ( old_id, cq, 0, 2 ) ;
-		}
-		redef = 1 ;
-	    } else if ( !IS_NULL_id ( alt_id ) ) {
-		redef = 1 ;
-	    }
-	} else {
-	    /* Redeclaration of class or namespace member */
-	    ns = DEREF_nspace ( id_parent ( id ) ) ;
-	    check_decl_nspace ( id, ns, 0, crt_namespace ) ;
-	    if ( IS_id_undef ( id ) ) {
-		if ( IS_nspace_ctype ( ns ) ) itag = id_stat_member_tag ;
-		mem = search_member ( ns, nm, 1 ) ;
-		old_id = NULL_id ;
-	    } else {
-		mem = NULL_member ;
-		old_id = redecl_inherit ( id, cq, 0, 2 ) ;
+			id = unify_subsequent(id, t, 0);
-		t = bind_specialise ( &old_id, t, ds, 0, 0, def ) ;
-		if ( !IS_NULL_id ( old_id ) ) {
-		    id = old_id ;
-		    itag = TAG_id ( id ) ;
-		    ns = DEREF_nspace ( id_parent ( id ) ) ;
+		}
-	    }
-	    simple_id = 0 ;
-	}
-    }
-    /* Deal with inferred types */
-    ds = check_inferred_type ( ds, &t, 0 ) ;
-    /* Check on storage class specifiers */
-    st = check_storage ( ds, CONTEXT_OBJECT, old_id ) ;
-    /* Deal with type definitions */
-    if ( ds & dspec_typedef ) {
-	id = make_type_decl ( ns, ds, t, mem, id ) ;
-	return ( id ) ;
+		set_member(mem, id);
-    }
-    /* Check on function specifiers */
-    IGNORE check_func_spec ( ds, CONTEXT_OBJECT ) ;
-    /* Find the object linkage and whether it is a definition */
-    if ( st == dspec_extern ) {
-	/* Explicit extern indicates a declaration (probably) */
-	df = dspec_none ;
-	if ( in_function_defn && simple_id ) {
+		if (itag == id_variable_tag && option(OPT_decl_hide)) {
-	    if ( IS_NULL_id ( prev_id ) ) {
-		prev_id = find_previous ( t, id ) ;
-	    }
-	    st = find_storage ( prev_id, st, NULL_type ) ;
-	} else {
-	    prev_id = old_id ;
+			check_hiding(id);
-	    st = find_storage ( old_id, st, t ) ;
-	}
+		}
-    } else {
-	if ( tag == type_templ_tag && bound_specialise ) {
-	    /* A template specialisation is a declaration (probably) */
-	    df = dspec_none ;
+		is_redeclared = 0;
 	} else {
-	    /* Everything else is a definition */
+		/* Redeclare an existing object */
-	    df = dspec_defn ;
+		id = old_id;
-	}
-	if ( in_function_defn ) {
-	    /* Objects declared in a block have no linkage */
-	    if ( IS_NULL_member ( mem ) ) {
+		if (IS_id_member(id)) {
-		/* Use old linkage if explicitly qualified */
-		st = find_storage ( old_id, dspec_none, t ) ;
+			t = DEREF_type(id_member_type(id));
-	    } else if ( st == dspec_static ) {
-		st = dspec_none ;
-	    } else if ( st == dspec_register ) {
-		st = ( dspec_auto | dspec_register ) ;
-		used_register = 1 ;
-	    } else {
+		} else {
-		st = dspec_auto ;
-	    }
-	} else if ( st == dspec_static ) {
-	    /* Check static declarations */
-	    if ( !def ) tentative = LANGUAGE_C ;
-	} else if ( st == dspec_none ) {
-	    /* Objects declared const have internal linkage */
-	    CV_SPEC qual = find_cv_qual ( t ) ;
-	    if ( qual & cv_const ) {
-		st = const_linkage ;
-		if ( st & dspec_static ) {
-		    st = find_storage ( old_id, st, t ) ;
+			t = DEREF_type(id_variable_etc_type(id));
+		}
-	    } else {
-		st = dspec_extern ;
-	    }
-	    /* find_storage is not applied for objects */
-	    if ( !def ) tentative = LANGUAGE_C ;
-	}
-    }
-    /* Create the declaration */
-    t = lvalue_type ( t ) ;
-    rs = ( ds & dspec_other ) ;
+		ds = DEREF_dspec(id_storage(id));
-    ds = ( st | df | rs ) ;
-    if ( !IS_NULL_id ( old_id ) ) {
-	/* Check redeclarations */
+		is_redeclared = 1;
-	old_id = redecl_id ( ds, t, old_id, 0, 0 ) ;
-	if ( IS_NULL_id ( old_id ) && IS_NULL_member ( mem ) ) {
-	    /* Bad redeclaration of class or namespace member */
-	    nm = lookup_anon () ;
-	    mem = search_member ( ns, nm, 1 ) ;
-	    itag = id_stat_member_tag ;
-	}
-    }
-    object_type ( t, itag ) ;
-    if ( IS_NULL_id ( old_id ) ) {
-	/* Construct the declaration */
-	ds = adjust_linkage ( ds, 0 ) ;
-	MAKE_id_variable_etc ( itag, nm, ds, ns, decl_loc, t, id ) ;
-	if ( in_function_defn ) {
-	    if ( ds & dspec_linkage ) {
-		/* Block function declarations */
-		id = unify_previous ( id, t, prev_id, 0 ) ;
-	    } else if ( redef && ( ds & dspec_auto ) ) {
-		/* Redeclarations of local variables */
-		mem = update_member ( ns, mem ) ;
-	    }
-	} else {
-	    id = unify_subsequent ( id, t, 0 ) ;
+	}
-	set_member ( mem, id ) ;
+#if LANGUAGE_CPP
-	if ( itag == id_variable_tag && option ( OPT_decl_hide ) ) {
+	if (ds & dspec_c) {
-	    check_hiding ( id ) ;
+		c_linkage(id, 0);
+	}
-	is_redeclared = 0 ;
-    } else {
-	/* Redeclare an existing object */
-	id = old_id ;
-	if ( IS_id_member ( id ) ) {
-	    t = DEREF_type ( id_member_type ( id ) ) ;
-	} else {
-	    t = DEREF_type ( id_variable_etc_type ( id ) ) ;
-	}
-	ds = DEREF_dspec ( id_storage ( id ) ) ;
-	is_redeclared = 1 ;
-    }
-#if LANGUAGE_CPP
-    if ( ds & dspec_c ) c_linkage ( id, 0 ) ;
 #endif
-    check_obj_decl ( ds, t, id, tentative ) ;
+	check_obj_decl(ds, t, id, tentative);
-    return ( id ) ;
+	return (id);
+}
 /*
     DECLARE A FUNCTION
     This routine constructs a function declaration for a function with
     declaration specifiers ds, type t and name id.  The argument def is
     true to distinguish function definitions from function declarations.
+	}
-	set_member ( mem, id ) ;
+#endif
-	decl_func_type ( id, t, def ) ;
-	/* Check for conversion functions */
+	/* Allow for discarded functions */
-	if ( it == hashid_conv_tag && itag != id_mem_func_tag ) {
+	if (!(rs & dspec_ignore) && option(OPT_discard_func)) {
-	    report ( crt_loc, ERR_class_conv_fct_mem () ) ;
+		ds &= ~dspec_ignore;
-	}
-	if ( itag == id_function_tag && option ( OPT_decl_hide ) ) {
-	    check_hiding ( id ) ;
+		COPY_dspec(id_storage(id), ds);
+	}
-	is_redeclared = 0 ;
-    } else {
-	/* Redeclare the function */
-	id = old_id ;
-	is_redeclared = 1 ;
-    }
-    ds = DEREF_dspec ( id_storage ( id ) ) ;
 #if LANGUAGE_CPP
+	if (allocator) {
-    if ( ds & dspec_c ) c_linkage ( id, def ) ;
+		recheck_allocator(id, allocator);
+	}
 #endif
-    /* Allow for discarded functions */
-    if ( !( rs & dspec_ignore ) && option ( OPT_discard_func ) ) {
-	ds &= ~dspec_ignore ;
-	COPY_dspec ( id_storage ( id ), ds ) ;
-    }
-#if LANGUAGE_CPP
-    if ( allocator ) recheck_allocator ( id, allocator ) ;
-#endif
-    if ( main_func ) recheck_main ( id ) ;
-    return ( id ) ;
+	if (main_func) {
-}
-/*
-    CHECK A PARAMETER DECLARATION
-    This routine checks the type of the parameter id declared with type t.
-*/
-void check_par_decl
+		recheck_main(id);
-    PROTO_N ( ( t, id, loc ) )
-    PROTO_T ( TYPE t X IDENTIFIER id X int loc )
-{
-    unsigned tag = TAG_type ( t ) ;
-    if ( tag == type_compound_tag ) {
-	/* Parameters can't have abstract type */
-	ERROR err = check_abstract ( t ) ;
-	if ( !IS_NULL_err ( err ) ) {
-	    err = concat_error ( err, ERR_class_abstract_par () ) ;
-	    report ( crt_loc, err ) ;
+	}
-    } else if ( tag == type_templ_tag ) {
-	/* Shouldn't have template type */
-	report ( crt_loc, ERR_temp_decl_bad () ) ;
-    }
-    if ( loc == CONTEXT_WEAK_PARAM ) {
-	/* Check for 'void' and other types */
-	ERROR err = check_param_type ( id, t ) ;
-	if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-    }
-    return ;
+	return (id);
+}
 /*
+    CHECK A PARAMETER DECLARATION
+    This routine checks the type of the parameter id declared with type t.
+*/
+void
+check_par_decl(TYPE t, IDENTIFIER id, int loc)
+{
+	unsigned tag = TAG_type(t);
+	if (tag == type_compound_tag) {
+		/* Parameters can't have abstract type */
+		ERROR err = check_abstract(t);
+		if (!IS_NULL_err(err)) {
+			err = concat_error(err, ERR_class_abstract_par());
+			report(crt_loc, err);
+		}
+	} else if (tag == type_templ_tag) {
+		/* Shouldn't have template type */
+		report(crt_loc, ERR_temp_decl_bad());
+	}
+	if (loc == CONTEXT_WEAK_PARAM) {
+		/* Check for 'void' and other types */
+		ERROR err = check_param_type(id, t);
+		if (!IS_NULL_err(err)) {
+			report(crt_loc, err);
+		}
+	}
+	return;
+}
+/*
     DECLARE A FUNCTION PARAMETER
     This routine constructs the declaration of a function parameter or
     non-type template parameter (as indicated by loc) with declaration
     specifiers ds, type t and name id.  Note that t is not checked - this
     is only a declaration, and t may still legitimately be void, however
     function and array parameters are adjusted to pointer parameters at
     this stage.
 */
-IDENTIFIER make_param_decl
+IDENTIFIER
-    PROTO_N ( ( ds, t, id, loc ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int loc )
+make_param_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int loc)
 {
-    ERROR err ;
+	ERROR err;
-    DECL_SPEC st, rs ;
+	DECL_SPEC st, rs;
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    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 old_id = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER old_id = DEREF_id(member_id(mem));
-    /* Check on identifier name */
+	/* Check on identifier name */
-    err = check_id_name ( id, loc ) ;
+	err = check_id_name(id, loc);
-    if ( !IS_NULL_err ( err ) ) report ( decl_loc, err ) ;
+	if (!IS_NULL_err(err)) {
+		report(decl_loc, err);
+	}
-    /* Deal with inferred types */
+	/* Deal with inferred types */
-    ds = check_inferred_type ( ds, &t, 0 ) ;
+	ds = check_inferred_type(ds, &t, 0);
-    func_type_defn ( 1 ) ;
+	func_type_defn(1);
+	/* Check on storage class specifiers */
+	st = check_storage(ds, loc, old_id);
+	if (st == dspec_register) {
+		st = (dspec_auto | dspec_register);
+		used_register = 1;
+	} else {
+		st = dspec_auto;
+	}
-    /* Check on storage class specifiers */
+	/* Deal with type definitions */
-    st = check_storage ( ds, loc, old_id ) ;
-    if ( st == dspec_register ) {
+	if (ds & dspec_typedef) {
-	st = ( dspec_auto | dspec_register ) ;
+		/* Can't have typedef in function parameters */
-	used_register = 1 ;
-    } else {
-	st = dspec_auto ;
+		report(decl_loc, ERR_dcl_typedef_par());
-    }
+	}
-    /* Deal with type definitions */
-    if ( ds & dspec_typedef ) {
-	/* Can't have typedef in function parameters */
+	/* Check on function specifiers */
-	report ( decl_loc, ERR_dcl_typedef_par () ) ;
+	IGNORE check_func_spec(ds, loc);
-    }
-    /* Check on function specifiers */
-    IGNORE check_func_spec ( ds, loc ) ;
-    /* Create the parameter declaration */
+	/* Create the parameter declaration */
-    t = make_param_type ( t, loc ) ;
+	t = make_param_type(t, loc);
-    rs = ( ds & dspec_other ) ;
+	rs = (ds & dspec_other);
-    ds = ( st | rs | dspec_defn ) ;
+	ds = (st | rs | dspec_defn);
-    if ( !IS_NULL_id ( old_id ) ) {
+	if (!IS_NULL_id(old_id)) {
-	/* Check for redeclarations */
+		/* Check for redeclarations */
-	if ( loc == CONTEXT_TEMPL_PARAM ) {
+		if (loc == CONTEXT_TEMPL_PARAM) {
-	    report ( decl_loc, ERR_temp_param_dup ( nm ) ) ;
+			report(decl_loc, ERR_temp_param_dup(nm));
-	    nm = lookup_anon () ;
+			nm = lookup_anon();
-	    mem = search_member ( ns, nm, 1 ) ;
+			mem = search_member(ns, nm, 1);
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
+			id = DEREF_id(hashid_id(nm));
-	} else {
+		} else {
-	    if ( loc == CONTEXT_WEAK_PARAM ) {
+			if (loc == CONTEXT_WEAK_PARAM) {
-		if ( IS_id_weak_param ( old_id ) ) {
+				if (IS_id_weak_param(old_id)) {
-		    /* Check for order of declaration */
+					/* Check for order of declaration */
+					MEMBER mem1 =
-		    MEMBER mem1 = DEREF_member ( nspace_last ( ns ) ) ;
+					    DEREF_member(nspace_last(ns));
-		    while ( !EQ_member ( mem1, mem ) ) {
+					while (!EQ_member(mem1, mem)) {
+						IDENTIFIER mid =
-			IDENTIFIER mid = DEREF_id ( member_id ( mem1 ) ) ;
+						    DEREF_id(member_id(mem1));
+						if (!IS_NULL_id(mid) &&
-			if ( !IS_NULL_id ( mid ) && IS_id_parameter ( mid ) ) {
+						    IS_id_parameter(mid)) {
-			    report ( decl_loc, ERR_dcl_fct_par_order () ) ;
+							report(decl_loc, ERR_dcl_fct_par_order());
-			    break ;
+							break;
+						}
+						mem1 = DEREF_member(member_next(mem1));
+					}
+					old_id = NULL_id;
+				} else if (!IS_id_parameter(old_id)) {
+					report(decl_loc, ERR_dcl_fct_par_undecl(nm));
+				}
+			}
+			if (!IS_NULL_id(old_id)) {
+				if (IS_id_parameter(old_id)) {
+					/* Make up new name for parameter */
+					nm = lookup_anon();
+					mem = search_member(ns, nm, 1);
+				}
+				IGNORE redecl_id(ds, t, old_id, 0, 0);
+			}
-			mem1 = DEREF_member ( member_next ( mem1 ) ) ;
-		    }
-		    old_id = NULL_id ;
-		} else if ( !IS_id_parameter ( old_id ) ) {
-		    report ( decl_loc, ERR_dcl_fct_par_undecl ( nm ) ) ;
-		}
-	    }
-	    if ( !IS_NULL_id ( old_id ) ) {
-		if ( IS_id_parameter ( old_id ) ) {
-		    /* Make up new name for parameter */
-		    nm = lookup_anon () ;
-		    mem = search_member ( ns, nm, 1 ) ;
+		}
-		IGNORE redecl_id ( ds, t, old_id, 0, 0 ) ;
-	    }
-	}
-    } else {
+	} else {
-	if ( loc == CONTEXT_WEAK_PARAM ) {
+		if (loc == CONTEXT_WEAK_PARAM) {
-	    report ( decl_loc, ERR_dcl_fct_par_undecl ( nm ) ) ;
+			report(decl_loc, ERR_dcl_fct_par_undecl(nm));
+		}
+	}
-    }
-    ds = adjust_linkage ( ds, 0 ) ;
+	ds = adjust_linkage(ds, 0);
-    if ( loc == CONTEXT_TEMPL_PARAM ) {
+	if (loc == CONTEXT_TEMPL_PARAM) {
-	IDENTIFIER pid ;
+		IDENTIFIER pid;
-	object_type ( t, id_token_tag ) ;
+		object_type(t, id_token_tag);
-	id = make_exp_param ( t, id ) ;
+		id = make_exp_param(t, id);
-	pid = DEREF_id ( id_token_alt ( id ) ) ;
+		pid = DEREF_id(id_token_alt(id));
-	set_member ( mem, pid ) ;
+		set_member(mem, pid);
-    } else {
+	} else {
-	t = lvalue_type ( t ) ;
+		t = lvalue_type(t);
-	object_type ( t, id_parameter_tag ) ;
+		object_type(t, id_parameter_tag);
-	MAKE_id_parameter ( nm, ds, ns, decl_loc, t, id ) ;
+		MAKE_id_parameter(nm, ds, ns, decl_loc, t, id);
-	set_member ( mem, id ) ;
+		set_member(mem, id);
-    }
+	}
-    check_par_decl ( t, id, loc ) ;
+	check_par_decl(t, id, loc);
-    is_redeclared = 0 ;
+	is_redeclared = 0;
-    return ( id ) ;
+	return (id);
 }
 /*
     DECLARE A NON-PROTOTYPE FUNCTION PARAMETER
     This routine is used to declare a non-prototype function parameter.
 */
-IDENTIFIER weak_param_decl
+IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+weak_param_decl(IDENTIFIER id)
+{
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    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 old_id = DEREF_id ( member_id ( mem ) ) ;
+	IDENTIFIER old_id = DEREF_id(member_id(mem));
-    if ( !IS_NULL_id ( old_id ) ) {
+	if (!IS_NULL_id(old_id)) {
-	nm = lookup_anon () ;
+		nm = lookup_anon();
-	mem = search_member ( ns, nm, 1 ) ;
+		mem = search_member(ns, nm, 1);
-	IGNORE redecl_id ( dspec_none, NULL_type, old_id, 0, 0 ) ;
+		IGNORE redecl_id(dspec_none, NULL_type, old_id, 0, 0);
-    }
+	}
-    MAKE_id_weak_param ( nm, dspec_none, ns, decl_loc, id ) ;
+	MAKE_id_weak_param(nm, dspec_none, ns, decl_loc, id);
-    set_member ( mem, id ) ;
+	set_member(mem, id);
-    is_redeclared = 0 ;
+	is_redeclared = 0;
-    return ( id ) ;
+	return (id);
+}
 /*
     CHECK A MEMBER DECLARATION
     This routine checks the declaration of the class member id with type
     t and declaration specifiers ds.
 */
-void check_mem_decl
+void
-    PROTO_N ( ( ds, t, id ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id )
+check_mem_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id)
 {
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    if ( ds & dspec_mutable ) {
+	if (ds & dspec_mutable) {
-	/* Can't apply mutable to a const member */
+		/* Can't apply mutable to a const member */
-	CV_SPEC qual = find_cv_qual ( t ) ;
+		CV_SPEC qual = find_cv_qual(t);
-	if ( qual & cv_const ) {
+		if (qual & cv_const) {
-	    report ( crt_loc, ERR_dcl_stc_mut_const ( id ) ) ;
+			report(crt_loc, ERR_dcl_stc_mut_const(id));
-	    if ( IS_id_member ( id ) ) {
+			if (IS_id_member(id)) {
-		qual &= ~cv_const ;
+				qual &= ~cv_const;
-		t = qualify_type ( t, qual, 0 ) ;
+				t = qualify_type(t, qual, 0);
-		COPY_type ( id_member_type ( id ), t ) ;
+				COPY_type(id_member_type(id), t);
-	    }
+			}
-	}
+		}
-    }
+	}
-    if ( tag == type_top_tag || tag == type_bottom_tag ) {
+	if (tag == type_top_tag || tag == type_bottom_tag) {
-	/* Always report void members */
+		/* Always report void members */
-	report ( crt_loc, ERR_basic_fund_void_mem ( id, t ) ) ;
+		report(crt_loc, ERR_basic_fund_void_mem(id, t));
-    } else if ( tag == type_templ_tag ) {
+	} else if (tag == type_templ_tag) {
-	/* Shouldn't have template type */
+		/* Shouldn't have template type */
-	report ( crt_loc, ERR_temp_decl_bad () ) ;
+		report(crt_loc, ERR_temp_decl_bad());
-    } else if ( ds & dspec_defn ) {
+	} else if (ds & dspec_defn) {
-	/* Only check otherwise for defined (non-static) members */
+		/* Only check otherwise for defined (non-static) members */
-	if ( tag == type_ref_tag ) {
+		if (tag == type_ref_tag) {
-	    /* References don't need checking */
+			/* References don't need checking */
-	    /* EMPTY */
+			/* EMPTY */
-	} else {
+		} else {
-	    /* Other members should have complete type */
+			/* Other members should have complete type */
-	    ERROR err = check_complete ( t ) ;
+			ERROR err = check_complete(t);
-	    if ( !IS_NULL_err ( err ) ) {
+			if (!IS_NULL_err(err)) {
-		ERROR err2 = ERR_class_mem_incompl_mem ( id ) ;
+				ERROR err2 = ERR_class_mem_incompl_mem(id);
-		err = concat_error ( err, err2 ) ;
+				err = concat_error(err, err2);
-		report ( crt_loc, err ) ;
+				report(crt_loc, err);
-	    } else {
+			} else {
-		/* Members can't have abstract type */
+				/* Members can't have abstract type */
-		err = check_abstract ( t ) ;
+				err = check_abstract(t);
-		if ( !IS_NULL_err ( err ) ) {
+				if (!IS_NULL_err(err)) {
-		    ERROR err2 = ERR_class_abstract_mem ( id ) ;
+					ERROR err2 = ERR_class_abstract_mem(id);
-		    err = concat_error ( err, err2 ) ;
+					err = concat_error(err, err2);
-		    report ( crt_loc, err ) ;
+					report(crt_loc, err);
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     DECLARE A CLASS MEMBER
     This routine constructs the declaration of a class member with
     declaration specifiers ds, type t and name id.  Note that the access
     declarations (i.e. just a qualified-id and a semicolon) can only be
     spotted at this stage.  The argument sm is true if this is the first
     declarator in a list and the next token is a semicolon.
+	}
-	MAKE_member_large ( NULL_member, NULL_member, mem ) ;
-	COPY_id ( member_id ( mem ), id ) ;
-	COPY_member ( nspace_last ( ns ), mem ) ;
-	COPY_member ( member_next ( mem_old ), mem ) ;
-    }
-    set_member ( mem, id ) ;
+	set_member(mem, id);
-    check_mem_decl ( ds, t, id ) ;
+	check_mem_decl(ds, t, id);
-    is_redeclared = 0 ;
+	is_redeclared = 0;
-    /* Adjust class information */
+	/* Adjust class information */
-    if ( st == dspec_static ) {
+	if (st == dspec_static) {
-	if ( really_in_function_defn ) {
+		if (really_in_function_defn) {
-	    /* Can't have static members in local classes */
+			/* Can't have static members in local classes */
-	    report ( crt_loc, ERR_class_local_static ( id ) ) ;
+			report(crt_loc, ERR_class_local_static(id));
+		}
+		ci |= cinfo_static;
+	} else {
+		/* Check member types */
+		if (crt_access != dspec_public) {
+			ci |= cinfo_private;
+		}
+		ci = check_member_type(ct, ci, t, 0);
+		ci &= ~cinfo_empty;
+	}
-	ci |= cinfo_static ;
-    } else {
-	/* Check member types */
-	if ( crt_access != dspec_public ) ci |= cinfo_private ;
-	ci = check_member_type ( ct, ci, t, 0 ) ;
-	ci &= ~cinfo_empty ;
-    }
-    COPY_cinfo ( ctype_info ( ct ), ci ) ;
+	COPY_cinfo(ctype_info(ct), ci);
-    return ( id ) ;
+	return (id);
+}
 /*
     MAINTAIN SPECIAL MEMBER FUNCTIONS FOR A CLASS
     This routine updates the special member function information for
     the class ct using the function id.  tag gives the identifier name tag.
 */
-void special_func_mem
+void
-    PROTO_N ( ( ct, id, tag, prev ) )
-    PROTO_T ( CLASS_TYPE ct X IDENTIFIER id X unsigned tag X IDENTIFIER prev )
+special_func_mem(CLASS_TYPE ct, IDENTIFIER id, unsigned tag, IDENTIFIER prev)
+{
-    switch ( tag ) {
+	switch (tag) {
-	case hashid_constr_tag : {
+	case hashid_constr_tag: {
-	    /* Set constructor */
+		/* Set constructor */
-	    COPY_id ( ctype_constr ( ct ), id ) ;
+		COPY_id(ctype_constr(ct), id);
-	    break ;
+		break;
+	}
-	case hashid_destr_tag : {
+	case hashid_destr_tag: {
-	    /* Set destructor */
+		/* Set destructor */
-	    COPY_id ( ctype_destr ( ct ), id ) ;
+		COPY_id(ctype_destr(ct), id);
-	    break ;
+		break;
+	}
-	case hashid_conv_tag : {
+	case hashid_conv_tag: {
-	    /* Maintain list of conversion functions */
+		/* Maintain list of conversion functions */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		HASHID nm = DEREF_hashid(id_name(id));
-	    LIST ( IDENTIFIER ) conv = DEREF_list ( ctype_conv ( ct ) ) ;
+		LIST(IDENTIFIER)conv = DEREF_list(ctype_conv(ct));
-	    LIST ( IDENTIFIER ) p = conv ;
+		LIST(IDENTIFIER)p = conv;
-	    while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-		IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
+			IDENTIFIER pid = DEREF_id(HEAD_list(p));
-		HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
+			HASHID pnm = DEREF_hashid(id_name(pid));
-		if ( EQ_hashid ( nm, pnm ) ) {
+			if (EQ_hashid(nm, pnm)) {
-		    /* Already member of list */
+				/* Already member of list */
-		    IDENTIFIER over ;
+				IDENTIFIER over;
-		    over = DEREF_id ( id_function_etc_over ( id ) ) ;
+				over = DEREF_id(id_function_etc_over(id));
-		    if ( !EQ_id ( pid, over ) && !EQ_id ( pid, prev ) ) {
+				if (!EQ_id(pid, over) && !EQ_id(pid, prev)) {
-			/* Template function has produced duplicate */
+					/* Template function has produced
+					 * duplicate */
-			PTR ( LOCATION ) ploc = id_loc ( pid ) ;
+					PTR(LOCATION)ploc = id_loc(pid);
+					report(crt_loc,
-			report ( crt_loc, ERR_class_mem_redecl ( id, ploc ) ) ;
+					       ERR_class_mem_redecl(id, ploc));
-		    }
+				}
-		    COPY_id ( HEAD_list ( p ), id ) ;
+				COPY_id(HEAD_list(p), id);
-		    return ;
+				return;
+			}
+			p = TAIL_list(p);
+		}
-		p = TAIL_list ( p ) ;
-	    }
-	    CONS_id ( id, conv, conv ) ;
+		CONS_id(id, conv, conv);
-	    COPY_list ( ctype_conv ( ct ), conv ) ;
+		COPY_list(ctype_conv(ct), conv);
-	    break ;
+		break;
+	}
+	}
-    }
-    return ;
+	return;
+}
 /*
     DECLARE A CLASS FUNCTION MEMBER
     declarations.
 */
 #if LANGUAGE_CPP
-IDENTIFIER make_func_mem_decl
+IDENTIFIER
-    PROTO_N ( ( ds, t, id, def ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int def )
+make_func_mem_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int def)
+{
-    ERROR err ;
+	ERROR err;
-    MEMBER mem ;
+	MEMBER mem;
-    int ok = 1 ;
+	int ok = 1;
-    int chk = 1 ;
+	int chk = 1;
-    unsigned it ;
+	unsigned it;
-    unsigned itag ;
+	unsigned itag;
-    int allocator = 0 ;
+	int allocator = 0;
-    IDENTIFIER old_id ;
+	IDENTIFIER old_id;
-    LIST ( VIRTUAL ) vt ;
+	LIST(VIRTUAL)vt;
-    DECL_SPEC st, df, fn, rs ;
+	DECL_SPEC st, df, fn, rs;
-    IDENTIFIER over_id = NULL_id ;
+	IDENTIFIER over_id = NULL_id;
-    IDENTIFIER hide_id = NULL_id ;
+	IDENTIFIER hide_id = NULL_id;
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
-    CLASS_TYPE ct = crt_class ;
+	CLASS_TYPE ct = crt_class;
-    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+	CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-    /* Check for template specialisations */
-    if ( is_templ_decl ( id, t ) || is_templ_spec ( t ) ) {
-	st = ( dspec_extern | ( ds & dspec_inline ) ) ;
-	IGNORE bind_specialise ( &id, t, st, 0, 1, def ) ;
-	if ( !IS_NULL_id ( id ) ) {
-	    report ( crt_loc, ERR_temp_spec_member ( id ) ) ;
-	}
-	return ( id ) ;
-    }
-    /* Find previous declaration */
-    mem = search_member ( ns, nm, 1 ) ;
-    old_id = DEREF_id ( member_id ( mem ) ) ;
-    if ( !IS_NULL_id ( old_id ) ) {
-	old_id = redecl_inherit ( old_id, cq, 1, 1 ) ;
-    }
+	/* Check for template specialisations */
+	if (is_templ_decl(id, t) || is_templ_spec(t)) {
+		st = (dspec_extern | (ds & dspec_inline));
+		IGNORE bind_specialise(&id, t, st, 0, 1, def);
+		if (!IS_NULL_id(id)) {
+			report(crt_loc, ERR_temp_spec_member(id));
+		}
+		return (id);
+	}
+	/* Find previous declaration */
+	mem = search_member(ns, nm, 1);
+	old_id = DEREF_id(member_id(mem));
+	if (!IS_NULL_id(old_id)) {
+		old_id = redecl_inherit(old_id, cq, 1, 1);
+	}
-    /* Check on member qualifications */
+	/* Check on member qualifications */
-    if ( cq != qual_none ) {
+	if (cq != qual_none) {
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
+		ns = DEREF_nspace(id_parent(id));
-	if ( EQ_nspace ( ns, crt_namespace ) ) {
+		if (EQ_nspace(ns, crt_namespace)) {
-	    /* Qualifier indicates the current class */
+			/* Qualifier indicates the current class */
-	    report ( crt_loc, ERR_dcl_meaning_mem ( cq, id ) ) ;
+			report(crt_loc, ERR_dcl_meaning_mem(cq, id));
-	    crt_id_qualifier = qual_none ;
+			crt_id_qualifier = qual_none;
-	} else {
+		} else {
-	    /* Qualifier indicates some other namespace */
+			/* Qualifier indicates some other namespace */
-	    id = make_func_decl ( ds, t, id, def ) ;
+			id = make_func_decl(ds, t, id, def);
-	    return ( id ) ;
+			return (id);
+		}
+	}
+	/* Check on identifier name */
+	err = check_id_name(id, CONTEXT_FUNC_MEMBER);
+	if (!IS_NULL_err(err)) {
+		report(crt_loc, err);
+		ok = 0;
+	}
+	/* Allow for special functions */
+	it = TAG_hashid(nm);
+	switch (it) {
+	case hashid_constr_tag: {
+		t = check_constr(t, id, ns);
+		ds &= ~dspec_empty;
+		ds |= dspec_main;
+		break;
+	}
+	case hashid_destr_tag: {
+		t = check_destr(t, id, ns);
+		ds &= ~dspec_empty;
+		ds |= dspec_main;
+		break;
 	}
+	case hashid_op_tag: {
+		t = check_operator(t, id, 1, &allocator);
+		if (!allocator) {
+			ds |= dspec_ignore;
-    }
+		}
+		break;
+	}
+	case hashid_conv_tag: {
+		t = check_conv(t, id);
+		ds &= ~dspec_empty;
+		chk = 0;
+		break;
+	}
+	}
+	/* Deal with inferred types */
+	ds = check_func_type(ds, t, def, chk, 1);
-    /* Check on identifier name */
+	/* Handle function definitions */
-    err = check_id_name ( id, CONTEXT_FUNC_MEMBER ) ;
-    if ( !IS_NULL_err ( err ) ) {
-	report ( crt_loc, err ) ;
-	ok = 0 ;
+	if (def) {
-    }
-    /* Allow for special functions */
+		/* Functions defined in a class are inline */
-    it = TAG_hashid ( nm ) ;
-    switch ( it ) {
-	case hashid_constr_tag : {
-	    t = check_constr ( t, id, ns ) ;
-	    ds &= ~dspec_empty ;
+		df = dspec_defn;
-	    ds |= dspec_main ;
+		ds |= dspec_inline;
-	    break ;
+	} else {
-	}
-	case hashid_destr_tag : {
-	    t = check_destr ( t, id, ns ) ;
-	    ds &= ~dspec_empty ;
-	    ds |= dspec_main ;
+		df = dspec_none;
-	    break ;
+	}
-	case hashid_op_tag : {
-	    t = check_operator ( t, id, 1, &allocator ) ;
-	    if ( !allocator ) ds |= dspec_ignore ;
-	    break ;
-	}
-	case hashid_conv_tag : {
-	    t = check_conv ( t, id ) ;
-	    ds &= ~dspec_empty ;
-	    chk = 0 ;
-	    break ;
-	}
-    }
-    /* Deal with inferred types */
-    ds = check_func_type ( ds, t, def, chk, 1 ) ;
-    /* Handle function definitions */
+	/* Check on storage class specifiers */
-    if ( def ) {
-	/* Functions defined in a class are inline */
+	st = check_storage(ds, CONTEXT_FUNC_MEMBER, old_id);
-	df = dspec_defn ;
-	ds |= dspec_inline ;
-    } else {
-	df = dspec_none ;
-    }
+	/* Deal with type definitions */
+	if (ds & dspec_typedef) {
+		/* Can only apply typedef to declarations, not definitions */
+		if (!def) {
+			if (ok) {
-    /* Check on storage class specifiers */
+				/* Recheck identifier name */
-    st = check_storage ( ds, CONTEXT_FUNC_MEMBER, old_id ) ;
+				err = check_id_name(id, CONTEXT_MEMBER);
+				if (!IS_NULL_err(err)) {
+					report(crt_loc, err);
+				}
+			}
+			id = make_type_decl(ns, ds, t, mem, id);
+			return (id);
+		}
+		report(crt_loc, ERR_dcl_typedef_func());
+	}
-    /* Deal with type definitions */
-    if ( ds & dspec_typedef ) {
-	/* Can only apply typedef to declarations, not definitions */
-	if ( !def ) {
-	    if ( ok ) {
-		/* Recheck identifier name */
-		err = check_id_name ( id, CONTEXT_MEMBER ) ;
-		if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-	    }
-	    id = make_type_decl ( ns, ds, t, mem, id ) ;
-	    return ( id ) ;
-	}
-	report ( crt_loc, ERR_dcl_typedef_func () ) ;
-    }
-    /* Check special functions */
+	/* Check special functions */
-    if ( allocator ) {
+	if (allocator) {
-	/* Allocator functions are implicitly static */
-	if ( st != dspec_static ) {
-	    st = dspec_static ;
-	    allocator |= 0x4 ;
-	}
-    } else if ( st == dspec_static ) {
-	switch ( it ) {
-	    case hashid_constr_tag : {
-		/* Constructors can't be static */
-		report ( crt_loc, ERR_class_ctor_static () ) ;
-		st = dspec_none ;
-		break ;
-	    }
-	    case hashid_destr_tag : {
-		/* Destructors can't be static */
-		report ( crt_loc, ERR_class_dtor_static () ) ;
-		st = dspec_none ;
-		break ;
-	    }
-	    case hashid_op_tag : {
-		/* Overloaded operators can't be static */
-		report ( crt_loc, ERR_over_oper_static () ) ;
-		st = dspec_none ;
-		break ;
-	    }
-	    case hashid_conv_tag : {
-		/* Conversion functions can't be static */
-		report ( crt_loc, ERR_class_conv_fct_mem () ) ;
-		st = dspec_none ;
-		break ;
-	    }
-	}
-    }
-    /* Check on function specifiers */
-    fn = check_func_spec ( ds, CONTEXT_FUNC_MEMBER ) ;
-    vt = overrides_virtual ( ct, nm, t, &hide_id ) ;
-    if ( !IS_NULL_list ( vt ) ) {
-	/* Check for overriding of virtual functions */
-	if ( !( fn & dspec_virtual ) ) {
-	    if ( !( ds & dspec_implicit ) ) {
-		err = ERR_class_virtual_override ( nm ) ;
-		if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-	    }
-	    fn |= dspec_virtual ;
-	}
-    } else if ( !IS_NULL_id ( hide_id ) ) {
-	err = ERR_class_virtual_hide ( nm, hide_id ) ;
-	if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-    }
-    if ( fn & dspec_virtual ) {
-	if ( st == dspec_static ) {
-	    /* Static members can't be virtual */
-	    err = ERR_class_static_mfct_virt () ;
-	    if ( allocator & 0x4 ) {
 		/* Allocator functions are implicitly static */
 /*
     DECLARE A FRIEND FUNCTION
     This routine is used to handle the declaration of a friend function
     within a class.  The parameters are identical to those in the previous
     routine.
 */
 #if LANGUAGE_CPP
-IDENTIFIER make_friend_decl
-    PROTO_N ( ( ds, t, id, def, chum ) )
-    PROTO_T ( DECL_SPEC ds X TYPE t X IDENTIFIER id X int def X int chum )
-{
-    ERROR err ;
-    MEMBER mem ;
-    int chk = 1 ;
-    unsigned it ;
-    int allocator = 0 ;
-    int main_func = 0 ;
-    IDENTIFIER old_id ;
-    NAMESPACE ns, ens ;
-    DECL_SPEC st, df, fn, rs ;
-    IDENTIFIER over_id = NULL_id ;
-    unsigned itag = id_function_tag ;
-    QUALIFIER cq = crt_id_qualifier ;
-    int td = crt_templ_qualifier ;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-    /* Check for template specialisations */
-    if ( in_template_decl && cq == qual_none && td == 0 && chum ) {
-	TYPE s = injected_type ( t, 1 ) ;
-	if ( !EQ_type ( s, t ) ) {
-	    /* Friend declaration is implicitly a template */
-	    int eq = 0 ;
-	    IDENTIFIER tid = make_friend_decl ( ds, s, id, 0, 0 ) ;
-	    if ( do_dump ) dump_declare ( tid, &decl_loc, 0 ) ;
-	    id = deduce_func ( tid, t, &eq ) ;
-	    if ( IS_NULL_id ( id ) ) return ( tid ) ;
-	    crt_templ_qualifier = 1 ;
-	}
-    }
-    if ( is_templ_decl ( id, t ) || is_templ_spec ( t ) ) {
-	t = bind_specialise ( &id, t, ds, 0, 1, def ) ;
-	if ( IS_NULL_id ( id ) ) {
-	    /* Invalid specialisation */
-	    crt_id_qualifier = qual_none ;
-	    crt_templ_qualifier = 0 ;
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
-	    while ( IS_type_templ ( t ) ) {
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
-	    }
-	    id = make_friend_decl ( ds, t, id, def, chum ) ;
-	    return ( id ) ;
-	}
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
-	ens = ns ;
-	mem = NULL_member ;
-	old_id = id ;
-	if ( def ) {
-	    /* Check enclosing namespace scope */
-	    check_decl_nspace ( id, ns, def, nonclass_namespace ) ;
-	}
-    } else {
-	/* Deal with typedef immediately */
-	if ( ( ds & dspec_typedef ) && !def ) {
-	    id = make_func_mem_decl ( ds, t, id, def ) ;
-	    return ( id ) ;
-	}
+IDENTIFIER
+make_friend_decl(DECL_SPEC ds, TYPE t, IDENTIFIER id, int def, int chum)
+{
+	ERROR err;
+	MEMBER mem;
+	int chk = 1;
+	unsigned it;
+	int allocator = 0;
+	int main_func = 0;
+	IDENTIFIER old_id;
+	NAMESPACE ns, ens;
+	DECL_SPEC st, df, fn, rs;
-	/* Check on identifier name */
+	IDENTIFIER over_id = NULL_id;
-	err = check_id_name ( id, CONTEXT_FUNCTION ) ;
+	unsigned itag = id_function_tag;
-	if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+	QUALIFIER cq = crt_id_qualifier;
+	int td = crt_templ_qualifier;
+	HASHID nm = DEREF_hashid(id_name(id));
-	/* Check on member qualification */
+	/* Check for template specialisations */
-	if ( cq == qual_none ) {
-	    /* Declaration of simple identifier */
-	    ns = nonclass_namespace ;
-	    ens = nonblock_namespace ;
-	    mem = search_member ( ns, nm, 1 ) ;
-	    old_id = DEREF_id ( member_id ( mem ) ) ;
-	    if ( !IS_NULL_id ( old_id ) ) {
-		old_id = redecl_inherit ( old_id, cq, 0, 1 ) ;
-	    }
-	    if ( in_template_decl && is_templ_nspace ( crt_namespace ) ) {
+	if (in_template_decl && cq == qual_none && td == 0 && chum) {
-		/* Friend of template class */
-		NAMESPACE tns = templ_namespace ;
+		TYPE s = injected_type(t, 1);
-		mem = search_member ( tns, nm, 1 ) ;
+		if (!EQ_type(s, t)) {
-	    }
-	} else {
-	    /* Redeclaration of class or namespace member */
+			/* Friend declaration is implicitly a template */
-	    ns = DEREF_nspace ( id_parent ( id ) ) ;
-	    ens = ns ;
+			int eq = 0;
-	    /* QUERY: Any other restrictions? */
+			IDENTIFIER tid = make_friend_decl(ds, s, id, 0, 0);
-	    if ( IS_id_undef ( id ) ) {
+			if (do_dump) {
-		report ( crt_loc, ERR_lookup_qual_undef ( nm, ns ) ) ;
-		if ( IS_nspace_ctype ( ns ) ) itag = id_mem_func_tag ;
-		mem = search_member ( ns, nm, 1 ) ;
+				dump_declare(tid, &decl_loc, 0);
-		old_id = NULL_id ;
-	    } else {
+			}
-		mem = NULL_member ;
-		old_id = redecl_inherit ( id, cq, 0, 1 ) ;
+			id = deduce_func(tid, t, &eq);
-		t = bind_specialise ( &old_id, t, ds, 0, 0, def ) ;
-		if ( !IS_NULL_id ( old_id ) ) {
+			if (IS_NULL_id(id)) {
-		    id = old_id ;
+				return (tid);
-		    itag = TAG_id ( id ) ;
-		    ns = DEREF_nspace ( id_parent ( id ) ) ;
-		    ens = ns ;
+			}
-		    if ( def ) {
+			crt_templ_qualifier = 1;
-			/* Check enclosing namespace scope */
-			check_decl_nspace ( id, ns, def, nonclass_namespace ) ;
-		    }
 		}
-	    }
+	}
 /*
     CHECK ON AN ANONYMOUS UNION
     An anonymous union cannot have private or protected members or member
     functions (in addition, no union can have static data members).  This
     ct is anonymous.
 */
 #if LANGUAGE_CPP
-static void check_anon_union
+static void
-    PROTO_N ( ( ct ) )
-    PROTO_T ( CLASS_TYPE ct )
+check_anon_union(CLASS_TYPE ct)
+{
-    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+	CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-    if ( ci & cinfo_private ) {
+	if (ci & cinfo_private) {
-	report ( crt_loc, ERR_class_union_anon_private () ) ;
+		report(crt_loc, ERR_class_union_anon_private());
-    }
+	}
-    if ( ci & cinfo_function ) {
+	if (ci & cinfo_function) {
-	report ( crt_loc, ERR_class_union_anon_func () ) ;
+		report(crt_loc, ERR_class_union_anon_func());
-    }
+	}
-    return ;
+	return;
+}
 #endif
     specifiers t (which may be an elaborate pre-type).  Whether this is
     legal depends on the value of the flag have_type_specifier described
     in predict.c, which indicates whether t contained a type declaration
     or definition.  Note that anonymous unions come under this heading
     (I hate anonymous unions).
+	}
-	case TYPE_DECL_ANON : {
-	    report ( crt_loc, ERR_dcl_dcl_anon () ) ;
-	    break ;
+	}
-	case TYPE_DECL_OVER_ELAB : {
-	    report ( crt_loc, ERR_dcl_type_elab_qual ( key ) ) ;
-	    break ;
-	}
-    }
-    return ( tid ) ;
+	return (tid);
+}
 /*
     CHECK AN EMPTY MEMBER DECLARATION
     This routine handles a class member declaration with no declarators,
     comprising the declaration specifiers ds, the template type qualifiers
     q and the type specifiers t.  This is similar to empty_object_decl,
     except that provision needs to be made for friend declarations of the
     form 'friend class C'.
 /*
     CHECK AN EMPTY DECLARATION
     This routine checks the empty declaration declared with the declaration
     specifiers ds, the template type qualifiers q, the pre-type bt and t
     and the cv-qualifiers cv (not all of which will be empty).  The tok
     parameter is used to pass in the number of the last lexical token read,
     this is used for a backwards compatibility hack involving types such
     as wchar_t which used to be defined by typedefs, but are now keywords.
     mem is true for member declarations.
 */
-IDENTIFIER empty_decl
+IDENTIFIER
-    PROTO_N ( ( ds, q, bt, t, cv, tok, mem ) )
-    PROTO_T ( DECL_SPEC ds X TYPE q X BASE_TYPE bt X TYPE t X
+empty_decl(DECL_SPEC ds, TYPE q, BASE_TYPE bt, TYPE t, CV_SPEC cv, int tok,
-	      CV_SPEC cv X int tok X int mem )
+	   int mem)
 {
-    /* Check for empty declarations */
+	/* Check for empty declarations */
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    int have_specifier = 1 ;
+	int have_specifier = 1;
-    decl_loc = crt_loc ;
+	decl_loc = crt_loc;
-    if ( ds == dspec_none && bt == btype_none && cv == cv_none ) {
+	if (ds == dspec_none && bt == btype_none && cv == cv_none) {
-	if ( IS_NULL_type ( q ) ) {
+		if (IS_NULL_type(q)) {
-	    if ( IS_NULL_type ( t ) ) {
+			if (IS_NULL_type(t)) {
-		/* Only semicolon in declaration */
+				/* Only semicolon in declaration */
-		if ( mem ) {
+				if (mem) {
-		    if ( tok != lex_func_Hop ) {
+					if (tok != lex_func_Hop) {
-			/* Allowed after function definition */
+						/* Allowed after function
+						 * definition */
-			report ( crt_loc, ERR_class_mem_semicolon () ) ;
+						report(crt_loc, ERR_class_mem_semicolon());
-		    }
+					}
-		} else {
+				} else {
+					report(crt_loc,
-		    report ( crt_loc, ERR_dcl_dcl_semicolon () ) ;
+					       ERR_dcl_dcl_semicolon());
-		}
+				}
-		return ( NULL_id ) ;
+				return (NULL_id);
-	    }
+			}
-	    if ( have_type_declaration == TYPE_DECL_NONE ) {
+			if (have_type_declaration == TYPE_DECL_NONE) {
-		/* No type specifier in declaration */
+				/* No type specifier in declaration */
-		have_specifier = 0 ;
+				have_specifier = 0;
-	    }
+			}
-	}
+		}
-    }
+	}
-    /* Check for definitions of built-in types */
+	/* Check for definitions of built-in types */
-    if ( ( ds & dspec_typedef ) && !mem ) {
+	if ((ds & dspec_typedef) && !mem) {
-	BASE_TYPE bs = key_type ( tok ) ;
+		BASE_TYPE bs = key_type(tok);
-	if ( bs ) {
+		if (bs) {
-	    /* Type is now a keyword */
+			/* Type is now a keyword */
-	    HASHID nm = KEYWORD ( tok ) ;
+			HASHID nm = KEYWORD(tok);
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
+			id = DEREF_id(hashid_id(nm));
-	    bt &= ~bs ;
+			bt &= ~bs;
-	    t = complete_pre_type ( bt, t, cv, 0 ) ;
+			t = complete_pre_type(bt, t, cv, 0);
-	    report ( crt_loc, ERR_lex_key_word ( tok ) ) ;
+			report(crt_loc, ERR_lex_key_word(tok));
-	    crt_id_qualifier = qual_none ;
+			crt_id_qualifier = qual_none;
-	    crt_templ_qualifier = 0 ;
+			crt_templ_qualifier = 0;
-	    id = make_object_decl ( ds, t, id, 0 ) ;
+			id = make_object_decl(ds, t, id, 0);
-	    return ( id ) ;
+			return (id);
-	}
+		}
-    }
+	}
-    /* Check for type access declarations */
+	/* Check for type access declarations */
-    if ( !have_specifier && mem ) {
+	if (!have_specifier && mem) {
-	if ( !IS_NULL_type ( t ) && IS_type_pre ( t ) ) {
+		if (!IS_NULL_type(t) && IS_type_pre(t)) {
-	    BASE_TYPE key = DEREF_btype ( type_pre_rep ( t ) ) ;
+			BASE_TYPE key = DEREF_btype(type_pre_rep(t));
-	    if ( key == btype_alias ) {
+			if (key == btype_alias) {
-		IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
+				IDENTIFIER tid = DEREF_id(type_name(t));
-		QUALIFIER qual = DEREF_qual ( type_pre_nqual ( t ) ) ;
+				QUALIFIER qual = DEREF_qual(type_pre_nqual(t));
-		if ( qual && !IS_NULL_id ( tid ) ) {
+				if (qual && !IS_NULL_id(tid)) {
-		    id = access_decl ( tid ) ;
+					id = access_decl(tid);
-		    return ( id ) ;
+					return (id);
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    /* Perform the declaration */
+	/* Perform the declaration */
-    t = empty_complete_pre_type ( bt, t, cv, 0 ) ;
+	t = empty_complete_pre_type(bt, t, cv, 0);
-    if ( mem ) {
+	if (mem) {
-	report ( crt_loc, ERR_class_mem_declarator () ) ;
+		report(crt_loc, ERR_class_mem_declarator());
-	id = empty_member_decl ( ds, q, t ) ;
+		id = empty_member_decl(ds, q, t);
-    } else {
+	} else {
-	id = empty_object_decl ( ds, q, t ) ;
+		id = empty_object_decl(ds, q, t);
-    }
+	}
-    if ( in_weak_param ) {
+	if (in_weak_param) {
-	/* Shouldn't happen in parameter declaration lists */
+		/* Shouldn't happen in parameter declaration lists */
-	report ( crt_loc, ERR_dcl_fct_par_none () ) ;
+		report(crt_loc, ERR_dcl_fct_par_none());
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     UPDATE EXTERNAL DECLARATION INFORMATION
     This routine is called after each external declaration.  d gives
     the number of objects declared and e gives the associated expression
     for an asm definition.  Note that this is the point of instantiation
     for any pending templates.
 */
-void external_declaration
+void
-    PROTO_N ( ( e, d ) )
-    PROTO_T ( EXP e X int d )
+external_declaration(EXP e, int d)
+{
-    if ( crt_file_type == 0 ) {
+	if (crt_file_type == 0) {
-	no_declarations += ( unsigned long ) d ;
+		no_declarations += (unsigned long)d;
-    }
-    if ( !IS_NULL_exp ( e ) ) {
-	/* Compile any asm definitions */
-	compile_asm ( e ) ;
-    }
-    if ( !in_preproc_dir ) {
-	if ( crt_access_list.pending ) {
-	    /* Clear any outstanding access checks */
-	    IGNORE report_access ( NULL_id ) ;
+	}
+	if (!IS_NULL_exp(e)) {
+		/* Compile any asm definitions */
+		compile_asm(e);
+	}
+	if (!in_preproc_dir) {
+		if (crt_access_list.pending) {
+			/* Clear any outstanding access checks */
+			IGNORE report_access(NULL_id);
+		}
-	if ( !IS_NULL_list ( pending_templates ) ) {
+		if (!IS_NULL_list(pending_templates)) {
-	    /* Instantiate any pending templates */
+			/* Instantiate any pending templates */
-	    clear_templates ( 0 ) ;
+			clear_templates(0);
+		}
+	}
-    }
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

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