WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/template.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.
 */
 #include "syntax.h"
 #include "template.h"
 #include "tokdef.h"
 #include "token.h"
 #include "ustring.h"
 /*
     TEMPLATE ARGUMENT HACK FLAG
     This flag can be set to true to indicate that the template argument
     hack, namely mapping '>>' to '> >' at the end of a set of template
     arguments, should be applied.
 */
-static int apply_rshift_hack = 0 ;
+static int apply_rshift_hack = 0;
 /*
     SKIP TEMPLATE ARGUMENTS OR PARAMETERS
     This routine skips a set of template arguments or parameters.  It
     returns the sequence of preprocessing tokens enclosed between the
     initial '<' and the matching closing '>'.
 */
-static PPTOKEN *skip_template
+static PPTOKEN *
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+skip_template(IDENTIFIER id)
+{
-    PPTOKEN *q ;
+	PPTOKEN *q;
-    LOCATION loc ;
+	LOCATION loc;
-    int templ = 0 ;
+	int templ = 0;
-    int angles = 1 ;
+	int angles = 1;
-    int brackets = 0 ;
+	int brackets = 0;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    PPTOKEN *p = crt_token ;
+	PPTOKEN *p = crt_token;
-    loc = crt_loc ;
+	loc = crt_loc;
-    do {
+	do {
-	switch ( t ) {
+		switch (t) {
-	    case lex_less : {
+		case lex_less:
-		/* Open angle brackets */
+			/* Open angle brackets */
-		if ( !brackets && templ ) angles++ ;
+			if (!brackets && templ) {
+				angles++;
+			}
-		templ = 0 ;
+			templ = 0;
-		break ;
+			break;
-	    }
-	    case lex_greater : {
+		case lex_greater:
-		/* Close angle brackets */
+			/* Close angle brackets */
-		if ( !brackets ) angles-- ;
+			if (!brackets) {
+				angles--;
+			}
-		templ = 0 ;
+			templ = 0;
-		break ;
+			break;
-	    }
-	    case lex_rshift : {
+		case lex_rshift:
-		/* Map '>>' to '> >' */
+			/* Map '>>' to '> >' */
-		if ( !brackets && apply_rshift_hack ) {
+			if (!brackets && apply_rshift_hack) {
-		    PPTOKEN *r = new_pptok () ;
+				PPTOKEN *r = new_pptok();
-		    r->tok = lex_greater ;
+				r->tok = lex_greater;
-		    r->next = crt_token->next ;
+				r->next = crt_token->next;
-		    crt_token->tok = lex_greater ;
+				crt_token->tok = lex_greater;
-		    crt_token->next = r ;
+				crt_token->next = r;
-		    angles-- ;
+				angles--;
-		    report ( crt_loc, ERR_temp_names_hack () ) ;
+				report(crt_loc, ERR_temp_names_hack());
-		}
+			}
-		templ = 0 ;
+			templ = 0;
-		break ;
+			break;
-	    }
-	    case lex_open_Hround :
+		case lex_open_Hround:
-	    case lex_open_Hbrace_H1 :
+		case lex_open_Hbrace_H1:
-	    case lex_open_Hbrace_H2 :
+		case lex_open_Hbrace_H2:
-	    case lex_open_Hsquare_H1 :
+		case lex_open_Hsquare_H1:
-	    case lex_open_Hsquare_H2 : {
+		case lex_open_Hsquare_H2:
-		/* Open brackets */
+			/* Open brackets */
-		brackets++ ;
+			brackets++;
-		templ = 0 ;
+			templ = 0;
-		break ;
+			break;
-	    }
-	    case lex_close_Hround :
+		case lex_close_Hround:
-	    case lex_close_Hbrace_H1 :
+		case lex_close_Hbrace_H1:
-	    case lex_close_Hbrace_H2 :
+		case lex_close_Hbrace_H2:
-	    case lex_close_Hsquare_H1 :
+		case lex_close_Hsquare_H1:
-	    case lex_close_Hsquare_H2 : {
+		case lex_close_Hsquare_H2:
-		/* Close brackets */
+			/* Close brackets */
-		if ( brackets ) brackets-- ;
+			if (brackets) {
+				brackets--;
+			}
-		templ = 0 ;
+			templ = 0;
-		break ;
+			break;
-	    }
-	    case lex_identifier :
+		case lex_identifier:
-	    case lex_template :
+		case lex_template:
-	    case lex_const_Hcast :
+		case lex_const_Hcast:
-	    case lex_static_Hcast :
+		case lex_static_Hcast:
-	    case lex_dynamic_Hcast :
+		case lex_dynamic_Hcast:
-	    case lex_reinterpret_Hcast : {
+		case lex_reinterpret_Hcast:
-		/* These may be followed by '<' */
+			/* These may be followed by '<' */
-		/* NOT YET IMPLEMENTED - but are they? */
+			/* NOT YET IMPLEMENTED - but are they? */
-		templ = 1 ;
+			templ = 1;
-		break ;
+			break;
-	    }
-	    case lex_eof : {
+		case lex_eof:
-		/* End of file */
+			/* End of file */
-		if ( IS_NULL_id ( id ) ) {
+			if (IS_NULL_id(id)) {
-		    report ( loc, ERR_temp_param_eof () ) ;
+				report(loc, ERR_temp_param_eof());
-		} else {
+			} else {
-		    report ( loc, ERR_temp_names_eof ( id ) ) ;
+				report(loc, ERR_temp_names_eof(id));
+			}
+			angles = 0;
+			break;
+		default:
+			/* Other tokens */
+			templ = 0;
+			break;
+		}
-		angles = 0 ;
-		break ;
-	    }
-	    default : {
-		/* Other tokens */
-		templ = 0 ;
-		break ;
-	    }
-	}
-	q = crt_token ;
+		q = crt_token;
-	t = expand_preproc ( EXPAND_AHEAD ) ;
+		t = expand_preproc(EXPAND_AHEAD);
-    } while ( angles ) ;
+	} while (angles);
-    q->tok = lex_close_Htemplate ;
+	q->tok = lex_close_Htemplate;
-    snip_tokens ( p, q ) ;
+	snip_tokens(p, q);
-    return ( p ) ;
+	return (p);
+}
 /*
     SKIP A SET OF TEMPLATE ARGUMENTS
     otherwise.  After skipping the current token is either still the
     template name or the token following the template arguments, depending
     on the value of started.
 */
-PPTOKEN *skip_template_args
+PPTOKEN *
-    PROTO_N ( ( id, started ) )
-    PROTO_T ( IDENTIFIER id X int started )
+skip_template_args(IDENTIFIER id, int started)
+{
-    PPTOKEN *q ;
+	PPTOKEN *q;
-    PPTOKEN *p = crt_token ;
+	PPTOKEN *p = crt_token;
-    int t = crt_lex_token ;
+	int t = crt_lex_token;
-    if ( started ) {
+	if (started) {
-	/* Patch in dummy preprocessing token */
+		/* Patch in dummy preprocessing token */
-	q = patch_tokens ( 1 ) ;
+		q = patch_tokens(1);
-	q->tok = t ;
+		q->tok = t;
-	t = lex_ignore_token ;
+		t = lex_ignore_token;
-	p->tok = t ;
+		p->tok = t;
-    }
+	}
-    IGNORE expand_preproc ( EXPAND_AHEAD ) ;
+	IGNORE expand_preproc(EXPAND_AHEAD);
-    crt_lex_token = lex_open_Htemplate ;
+	crt_lex_token = lex_open_Htemplate;
-    crt_token->tok = lex_open_Htemplate ;
+	crt_token->tok = lex_open_Htemplate;
-    q = skip_template ( id ) ;
+	q = skip_template(id);
-    crt_lex_token = t ;
+	crt_lex_token = t;
-    crt_token = p ;
+	crt_token = p;
-    if ( started ) {
+	if (started) {
-	/* Advance to following token */
+		/* Advance to following token */
-	ADVANCE_LEXER ;
-    }
-    return ( q ) ;
-}
-/*
-    PARSE A SET OF TEMPLATE ARGUMENTS
-    This routine parses the template arguments p.  Note that unlike token
-    arguments the template argument sorts are deduced by look-ahead rather
-    than from the template sort.
-*/
-static LIST ( TOKEN ) parse_template_args
-    PROTO_N ( ( p ) )
-    PROTO_T ( PPTOKEN *p )
-{
-    int t ;
-    PARSE_STATE st ;
-    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
-    if ( p == NULL ) return ( args ) ;
-    /* Initialise parser */
-    save_state ( &st, 1 ) ;
-    init_parser ( p ) ;
-    ADVANCE_LEXER ;
-    t = crt_lex_token ;
-    if ( t == lex_open_Htemplate ) {
-	/* Step over open bracket */
-	ADVANCE_LEXER ;
-	t = crt_lex_token ;
-    }
-    /* Scan through arguments */
-    if ( t != lex_close_Htemplate ) {
-	for ( ; ; ) {
-	    TOKEN arg ;
-	    if ( predict_typeid ( 2 ) ) {
-		TYPE r = NULL_type ;
-		have_type_specifier = 0 ;
-		if ( predict_typename () ) {
-		    /* Template argument */
-		    IDENTIFIER rid = NULL_id ;
-		    parse_id ( &rid ) ;
-		    MAKE_tok_class ( r, rid, arg ) ;
-		} else {
-		    /* Type argument */
-		    parse_type ( &r ) ;
-		    MAKE_tok_type ( btype_lang, r, arg ) ;
-		}
-	    } else {
-		/* Expression argument */
-		EXP e = NULL_exp ;
-		TYPE r = NULL_type ;
-		parse_exp ( &e ) ;
-		if ( !IS_NULL_exp ( e ) ) {
-		    r = DEREF_type ( exp_type ( e ) ) ;
-		}
-		MAKE_tok_exp ( r, 1, e, arg ) ;
-	    }
-	    if ( have_syntax_error ) break ;
-	    CONS_tok ( arg, args, args ) ;
-	    t = crt_lex_token ;
-	    if ( t == lex_close_Htemplate ) {
-		break ;
-	    } else if ( t == lex_comma ) {
-		ADVANCE_LEXER ;
+		ADVANCE_LEXER;
-	    } else {
-		t = lex_close_Htemplate ;
-		report ( crt_loc, ERR_lex_expect ( t ) ) ;
-		break ;
-	    }
+	}
-    }
-    /* Restore state */
-    restore_state ( &st ) ;
-    p = restore_parser () ;
-    free_tok_list ( p ) ;
-    /* Return result */
-    args = REVERSE_list ( args ) ;
-    return ( args ) ;
+	return (q);
+}
 /*
-    CHECK A TEMPLATE PARAMETER TYPE
+    PARSE A SET OF TEMPLATE ARGUMENTS
-    This routine checks the type t of the template parameter id.
+    This routine parses the template arguments p.  Note that unlike token
+    arguments the template argument sorts are deduced by look-ahead rather
+    than from the template sort.
 */
-static void templ_param_type
+static LIST(TOKEN)
-    PROTO_N ( ( id, t ) )
+parse_template_args(PPTOKEN *p)
-    PROTO_T ( IDENTIFIER id X TYPE t )
+{
-    switch ( TAG_type ( t ) ) {
-	case type_floating_tag :
+	int t;
-	case type_top_tag :
+	PARSE_STATE st;
-	case type_bottom_tag : {
+	LIST(TOKEN) args = NULL_list(TOKEN);
-	    /* Illegal parameter types */
+	if (p == NULL) {
-	    report ( crt_loc, ERR_temp_param_type ( id, t ) ) ;
-	    break ;
+		return (args);
+	}
+	/* Initialise parser */
+	save_state(&st, 1);
+	init_parser(p);
+	ADVANCE_LEXER;
+	t = crt_lex_token;
+	if (t == lex_open_Htemplate) {
+		/* Step over open bracket */
+		ADVANCE_LEXER;
+		t = crt_lex_token;
+	}
+	/* Scan through arguments */
+	if (t != lex_close_Htemplate) {
+		for (;;) {
+			TOKEN arg;
+			if (predict_typeid(2)) {
+				TYPE r = NULL_type;
+				have_type_specifier = 0;
+				if (predict_typename()) {
+					/* Template argument */
+					IDENTIFIER rid = NULL_id;
+					parse_id(&rid);
+					MAKE_tok_class(r, rid, arg);
+				} else {
+					/* Type argument */
+					parse_type(&r);
+					MAKE_tok_type(btype_lang, r, arg);
+				}
+			} else {
+				/* Expression argument */
+				EXP e = NULL_exp;
+				TYPE r = NULL_type;
+				parse_exp(&e);
+				if (!IS_NULL_exp(e)) {
+					r = DEREF_type(exp_type(e));
-    }
+				}
+				MAKE_tok_exp(r, 1, e, arg);
+			}
+			if (have_syntax_error) {
+				break;
+			}
+			CONS_tok(arg, args, args);
+			t = crt_lex_token;
+			if (t == lex_close_Htemplate) {
+				break;
+			} else if (t == lex_comma) {
+				ADVANCE_LEXER;
+			} else {
+				t = lex_close_Htemplate;
+				report(crt_loc, ERR_lex_expect(t));
+				break;
+			}
+		}
+	}
+	/* Restore state */
+	restore_state(&st);
+	p = restore_parser();
+	free_tok_list(p);
+	/* Return result */
+	args = REVERSE_list(args);
-    return ;
+	return (args);
+}
 /*
+    CHECK A TEMPLATE PARAMETER TYPE
+    This routine checks the type t of the template parameter id.
+*/
+static void
+templ_param_type(IDENTIFIER id, TYPE t)
+{
+	switch (TAG_type(t)) {
+	case type_floating_tag:
+	case type_top_tag:
+	case type_bottom_tag:
+		/* Illegal parameter types */
+		report(crt_loc, ERR_temp_param_type(id, t));
+		break;
+	}
+	return;
+}
+/*
     DEFINE A TEMPLATE PARAMETER
     This routine defines the template parameter id to be arg.
 */
-static int define_templ_param
+static int
-    PROTO_N ( ( id, arg, tid, def ) )
-    PROTO_T ( IDENTIFIER id X TOKEN arg X IDENTIFIER tid X int def )
+define_templ_param(IDENTIFIER id, TOKEN arg, IDENTIFIER tid, int def)
+{
-    int ok = 1 ;
+    int ok = 1;
-    TOKEN sort = DEREF_tok ( id_token_sort ( id ) ) ;
+    TOKEN sort = DEREF_tok(id_token_sort(id));
-    unsigned tag = TAG_tok ( sort ) ;
+    unsigned tag = TAG_tok(sort);
-    if ( tag == tok_type_tag ) {
+    if (tag == tok_type_tag) {
 	/* Type parameter */
-	TYPE t ;
+	TYPE t;
-	if ( IS_tok_type ( arg ) ) {
+	if (IS_tok_type(arg)) {
-	    t = DEREF_type ( tok_type_value ( arg ) ) ;
+	    t = DEREF_type(tok_type_value(arg));
-	    if ( def ) t = expand_type ( t, 2 ) ;
-	    if ( !is_global_type ( t ) ) {
+	    if (def) {
-		/* Type must have external linkage */
-		ERROR err = ERR_temp_arg_local ( t ) ;
-		err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
-		report ( crt_loc, err ) ;
+		    t = expand_type(t, 2);
+	    }
+	    if (!is_global_type(t)) {
+		/* Type must have external linkage */
+		ERROR err = ERR_temp_arg_local(t);
+		err = concat_error(ERR_temp_arg_init(id, tid), err);
+		report(crt_loc, err);
+	    }
-	    COPY_type ( tok_type_value ( arg ), t ) ;
+	    COPY_type(tok_type_value(arg), t);
 	} else {
 	    /* Non-type argument supplied */
-	    t = type_error ;
+	    t = type_error;
-	    report ( crt_loc, ERR_temp_arg_type ( id, tid ) ) ;
+	    report(crt_loc, ERR_temp_arg_type(id, tid));
-	    ok = 0 ;
+	    ok = 0;
+	}
-	COPY_type ( tok_type_value ( sort ), t ) ;
+	COPY_type(tok_type_value(sort), t);
-    } else if ( tag == tok_exp_tag ) {
+    } else if (tag == tok_exp_tag) {
 	/* Expression parameter */
-	EXP e ;
+	EXP e;
-	if ( IS_tok_exp ( arg ) ) {
+	if (IS_tok_exp(arg)) {
-	    int over = 0 ;
+	    int over = 0;
-	    ERROR err = NULL_err ;
+	    ERROR err = NULL_err;
-	    TYPE s1 = DEREF_type ( tok_exp_type ( sort ) ) ;
+	    TYPE s1 = DEREF_type(tok_exp_type(sort));
-	    TYPE s2 = expand_type ( s1, 2 ) ;
+	    TYPE s2 = expand_type(s1, 2);
+	    if (!EQ_type(s1, s2)) {
-	    if ( !EQ_type ( s1, s2 ) ) templ_param_type ( id, s2 ) ;
+		    templ_param_type(id, s2);
+	    }
-	    e = DEREF_exp ( tok_exp_value ( arg ) ) ;
+	    e = DEREF_exp(tok_exp_value(arg));
-	    if ( def ) {
+	    if (def) {
 		/* Perform conversion if necessary */
-		unsigned etag = TAG_exp ( e ) ;
+		unsigned etag = TAG_exp(e);
-		e = convert_reference ( e, REF_ASSIGN ) ;
+		e = convert_reference(e, REF_ASSIGN);
-		e = expand_exp ( e, 2, 0 ) ;
+		e = expand_exp(e, 2, 0);
-		if ( IS_exp_address_mem ( e ) ) {
+		if (IS_exp_address_mem(e)) {
 		    /* Check for overloaded pointer to members */
-		    EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
+		    EXP a = DEREF_exp(exp_address_mem_arg(e));
-		    if ( IS_exp_member ( a ) ) {
+		    if (IS_exp_member(a)) {
-			IDENTIFIER mid = DEREF_id ( exp_member_id ( a ) ) ;
+			IDENTIFIER mid = DEREF_id(exp_member_id(a));
-			if ( IS_id_function_etc ( mid ) ) {
+			if (IS_id_function_etc(mid)) {
-			    mid = DEREF_id ( id_function_etc_over ( mid ) ) ;
+			    mid = DEREF_id(id_function_etc_over(mid));
-			    if ( !IS_NULL_id ( mid ) ) over = 1 ;
+			    if (!IS_NULL_id(mid)) {
-			}
+				    over = 1;
-		    }
+			    }
-		}
+			}
-		if ( IS_type_array ( s2 ) ) {
-		    if ( etag == exp_paren_tag ) e = make_paren_exp ( e ) ;
-		    e = init_array ( s2, cv_none, e, 1, &err ) ;
-		} else {
+		    }
-		    e = init_assign ( s2, cv_none, e, &err ) ;
 		}
-		if ( !IS_NULL_err ( err ) ) err = init_error ( err, 0 ) ;
-	    }
-	    if ( is_const_exp ( e, 1 ) ) {
-		switch ( TAG_type ( s2 ) ) {
+		if (IS_type_array(s2)) {
-		    case type_integer_tag :
-		    case type_floating_tag :
-		    case type_top_tag :
-		    case type_bottom_tag :
-		    case type_enumerate_tag :
-		    case type_token_tag :
+		    if (etag == exp_paren_tag) {
-		    case type_error_tag : {
+			    e = make_paren_exp(e);
-			/* Constants of these types are alright */
-			break ;
+		    }
+		    e = init_array(s2, cv_none, e, 1, &err);
+		} else {
+		    e = init_assign(s2, cv_none, e, &err);
+		}
+		if (!IS_NULL_err(err)) {
+			err = init_error(err, 0);
+		}
+	    }
+	    if (is_const_exp(e, 1)) {
+		switch (TAG_type(s2)) {
+		    case type_integer_tag:
+		    case type_floating_tag:
+		    case type_top_tag:
+		    case type_bottom_tag:
+		    case type_enumerate_tag:
+		    case type_token_tag:
+		    case type_error_tag:
+			/* Constants of these types are alright */
+			break;
-		    default : {
+		    default: {
 			/* Check linkage in other cases */
-			EXP pa = NULL_exp ;
+			EXP pa = NULL_exp;
-			DECL_SPEC ln = find_exp_linkage ( e, &pa, 0 ) ;
+			DECL_SPEC ln = find_exp_linkage(e, &pa, 0);
-			if ( ln & dspec_extern ) {
+			if (ln & dspec_extern) {
 			    /* External linkage */
 			    /* EMPTY */
-			} else if ( ln & dspec_static ) {
+			} else if (ln & dspec_static) {
 			    /* Internal linkage */
-			    ERROR err2 = ERR_temp_arg_internal () ;
+			    ERROR err2 = ERR_temp_arg_internal();
-			    err = concat_error ( err, err2 ) ;
+			    err = concat_error(err, err2);
 			} else {
 			    /* No linkage */
-			    ERROR err2 = ERR_temp_arg_bad () ;
+			    ERROR err2 = ERR_temp_arg_bad();
-			    err = concat_error ( err, err2 ) ;
+			    err = concat_error(err, err2);
+			}
-			if ( over ) {
+			if (over) {
 			    /* Overloaded pointer to member */
-			    ERROR err2 = ERR_temp_arg_over () ;
+			    ERROR err2 = ERR_temp_arg_over();
-			    err = concat_error ( err, err2 ) ;
+			    err = concat_error(err, err2);
+			}
-			break ;
+			break;
+		    }
+		}
 	    } else {
-		err = concat_error ( err, ERR_temp_arg_const () ) ;
+		err = concat_error(err, ERR_temp_arg_const());
-	    }
-	    if ( !IS_NULL_err ( err ) ) {
-		err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
-		report ( crt_loc, err ) ;
+	    }
+	    if (!IS_NULL_err(err)) {
+		err = concat_error(ERR_temp_arg_init(id, tid), err);
+		report(crt_loc, err);
+	    }
-	    COPY_type ( tok_exp_type ( arg ), s2 ) ;
+	    COPY_type(tok_exp_type(arg), s2);
-	    COPY_exp ( tok_exp_value ( arg ), e ) ;
+	    COPY_exp(tok_exp_value(arg), e);
 	} else {
 	    /* Non-expression argument supplied */
-	    e = make_error_exp ( 0 ) ;
+	    e = make_error_exp(0);
-	    report ( crt_loc, ERR_temp_arg_exp ( id, tid ) ) ;
+	    report(crt_loc, ERR_temp_arg_exp(id, tid));
-	    ok = 0 ;
+	    ok = 0;
 	}
-	COPY_exp ( tok_exp_value ( sort ), e ) ;
+	COPY_exp(tok_exp_value(sort), e);
     } else {
 	/* Template class parameter */
-	IDENTIFIER sid ;
+	IDENTIFIER sid;
-	if ( IS_tok_class ( arg ) ) {
+	if (IS_tok_class(arg)) {
-	    sid = DEREF_id ( tok_class_value ( arg ) ) ;
+	    sid = DEREF_id(tok_class_value(arg));
-	    if ( !IS_NULL_id ( sid ) && IS_id_class_name_etc ( sid ) ) {
+	    if (!IS_NULL_id(sid) && IS_id_class_name_etc(sid)) {
-		TYPE s = DEREF_type ( id_class_name_etc_defn ( sid ) ) ;
+		TYPE s = DEREF_type(id_class_name_etc_defn(sid));
-		if ( !is_global_type ( s ) ) {
+		if (!is_global_type(s)) {
 		    /* Type must have external linkage */
-		    ERROR err = ERR_temp_arg_local ( s ) ;
+		    ERROR err = ERR_temp_arg_local(s);
-		    err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
+		    err = concat_error(ERR_temp_arg_init(id, tid), err);
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
+		}
+	    }
-	    init_template_param ( id, sid ) ;
+	    init_template_param(id, sid);
 	} else {
 	    /* Non-template argument supplied */
-	    HASHID nm = KEYWORD ( lex_zzzz ) ;
+	    HASHID nm = KEYWORD(lex_zzzz);
-	    sid = DEREF_id ( hashid_id ( nm ) ) ;
+	    sid = DEREF_id(hashid_id(nm));
-	    report ( crt_loc, ERR_temp_arg_templ ( id, tid ) ) ;
+	    report(crt_loc, ERR_temp_arg_templ(id, tid));
-	    ok = 0 ;
+	    ok = 0;
+	}
-	COPY_id ( tok_class_value ( sort ), sid ) ;
+	COPY_id(tok_class_value(sort), sid);
+    }
-    return ( ok ) ;
+    return (ok);
+}
 /*
     DEFAULT TEMPLATE ARGUMENTS FLAG
     This flag may be set to false to suppress template default arguments.
 */
-int allow_templ_dargs = 1 ;
+int allow_templ_dargs = 1;
 /*
     CHECK A SET OF TEMPLATE ARGUMENTS
     This routine checks the set of template arguments args for the template
     tid of sort tok.  Note that if tid is a function then there may be
     less arguments than parameters, in this case in_template_decl is set
     to indicate that certain template parameters remain unbound.
 */
-static LIST ( TOKEN ) check_templ_args
+static LIST(TOKEN)
-    PROTO_N ( ( tok, args, tid ) )
-    PROTO_T ( TOKEN tok X LIST ( TOKEN ) args X IDENTIFIER tid )
+check_templ_args(TOKEN tok, LIST(TOKEN) args, IDENTIFIER tid)
 {
-    int s ;
+	int s;
-    int reported = 0 ;
+	int reported = 0;
-    LIST ( TOKEN ) a = args ;
+	LIST(TOKEN) a = args;
-    LIST ( TOKEN ) b = NULL_list ( TOKEN ) ;
+	LIST(TOKEN) b = NULL_list(TOKEN);
-    LIST ( TOKEN ) d = DEREF_list ( tok_templ_dargs ( tok ) ) ;
+	LIST(TOKEN) d = DEREF_list(tok_templ_dargs(tok));
-    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
+	LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(tok));
-    LIST ( IDENTIFIER ) qids = pids ;
+	LIST(IDENTIFIER) qids = pids;
-    if ( in_template_decl && depends_on_args ( args, pids, 0, 1 ) ) {
+	if (in_template_decl && depends_on_args(args, pids, 0, 1)) {
-	/* Be extra careful in this case */
+		/* Be extra careful in this case */
-	tok = expand_sort ( tok, 1, 1 ) ;
+		tok = expand_sort(tok, 1, 1);
-	args = check_templ_args ( tok, args, tid ) ;
+		args = check_templ_args(tok, args, tid);
-	return ( args ) ;
+		return (args);
-    }
+	}
-    s = save_token_args ( qids, NULL_list ( TOKEN ) ) ;
+	s = save_token_args(qids, NULL_list(TOKEN));
-    if ( !allow_templ_dargs ) d = NULL_list ( TOKEN ) ;
+	if (!allow_templ_dargs)d = NULL_list(TOKEN);
-    while ( !IS_NULL_list ( pids ) ) {
+	while (!IS_NULL_list(pids)) {
-	TOKEN arg = NULL_tok ;
+		TOKEN arg = NULL_tok;
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	if ( !IS_NULL_list ( a ) ) {
+		if (!IS_NULL_list(a)) {
-	    /* Use argument from list */
+			/* Use argument from list */
-	    arg = DEREF_tok ( HEAD_list ( a ) ) ;
+			arg = DEREF_tok(HEAD_list(a));
-	} else if ( !IS_NULL_list ( d ) ) {
+		} else if (!IS_NULL_list(d)) {
-	    /* Use default argument */
+			/* Use default argument */
-	    arg = DEREF_tok ( HEAD_list ( d ) ) ;
+			arg = DEREF_tok(HEAD_list(d));
-	    if ( !IS_NULL_tok ( arg ) ) {
+			if (!IS_NULL_tok(arg)) {
-		/* Add copy to list of arguments */
+				/* Add copy to list of arguments */
-		arg = expand_sort ( arg, -1, 1 ) ;
+				arg = expand_sort(arg, -1, 1);
-		CONS_tok ( arg, b, b ) ;
+				CONS_tok(arg, b, b);
-	    }
+			}
-	}
+		}
-	if ( IS_NULL_tok ( arg ) ) {
+		if (IS_NULL_tok(arg)) {
-	    /* Not enough arguments */
+			/* Not enough arguments */
-	    if ( !reported ) {
+			if (!reported) {
-		if ( IS_id_function_etc ( tid ) ) {
+				if (IS_id_function_etc(tid)) {
-		    /* Allow for argument deduction */
+					/* Allow for argument deduction */
-		    a = NULL_list ( TOKEN ) ;
+					a = NULL_list(TOKEN);
-		    in_template_decl++ ;
+					in_template_decl++;
-		    break ;
+					break;
-		}
+				}
-		report ( crt_loc, ERR_temp_arg_less ( tid ) ) ;
+				report(crt_loc, ERR_temp_arg_less(tid));
-		reported = 1 ;
+				reported = 1;
-	    }
+			}
-	    arg = DEREF_tok ( id_token_sort ( pid ) ) ;
+			arg = DEREF_tok(id_token_sort(pid));
-	    IGNORE is_bound_tok ( arg, 1 ) ;
+			IGNORE is_bound_tok(arg, 1);
-	    arg = expand_sort ( arg, 2, 1 ) ;
+			arg = expand_sort(arg, 2, 1);
-	    CONS_tok ( arg, b, b ) ;
+			CONS_tok(arg, b, b);
-	}
+		}
-	IGNORE define_templ_param ( pid, arg, tid, 1 ) ;
+		IGNORE define_templ_param(pid, arg, tid, 1);
-	if ( !IS_NULL_list ( d ) ) d = TAIL_list ( d ) ;
+		if (!IS_NULL_list(d)) {
+			d = TAIL_list(d);
+		}
-	if ( !IS_NULL_list ( a ) ) a = TAIL_list ( a ) ;
+		if (!IS_NULL_list(a)) {
+			a = TAIL_list(a);
+		}
-	pids = TAIL_list ( pids ) ;
+		pids = TAIL_list(pids);
-    }
+	}
-    if ( !IS_NULL_list ( a ) ) {
+	if (!IS_NULL_list(a)) {
-	/* Too many arguments */
+		/* Too many arguments */
-	report ( crt_loc, ERR_temp_arg_more ( tid ) ) ;
+		report(crt_loc, ERR_temp_arg_more(tid));
-    }
+	}
-    if ( !IS_NULL_list ( b ) ) {
+	if (!IS_NULL_list(b)) {
-	/* Add default arguments to list */
+		/* Add default arguments to list */
-	b = REVERSE_list ( b ) ;
+		b = REVERSE_list(b);
-	args = APPEND_list ( args, b ) ;
+		args = APPEND_list(args, b);
-    }
+	}
-    restore_token_args ( qids, s ) ;
+	restore_token_args(qids, s);
-    return ( args ) ;
+	return (args);
 }
 /*
     CHECK A SET OF DEDUCED TEMPLATE ARGUMENTS
     This routine checks the deduced template arguments args for the
     template tid with parameters pids.
 */
-void check_deduced_args
+void
-    PROTO_N ( ( tid, pids, args ) )
-    PROTO_T ( IDENTIFIER tid X LIST ( IDENTIFIER ) pids X LIST ( TOKEN ) args )
+check_deduced_args(IDENTIFIER tid, LIST(IDENTIFIER) pids, LIST(TOKEN) args)
+{
-    while ( !IS_NULL_list ( pids ) && !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(pids) && !IS_NULL_list(args)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
+		TOKEN arg = DEREF_tok(HEAD_list(args));
-	IGNORE define_templ_param ( pid, arg, tid, 0 ) ;
+		IGNORE define_templ_param(pid, arg, tid, 0);
-	args = TAIL_list ( args ) ;
+		args = TAIL_list(args);
-	pids = TAIL_list ( pids ) ;
+		pids = TAIL_list(pids);
-    }
+	}
-    return ;
+	return;
+}
 /*
     DOES A SET OF TEMPLATE ARGUMENTS MATCH A SORT?
     This routine checks whether the template arguments args form a match
     for an initial segment of the template sort tok.
 */
-static int match_template_args
+static int
-    PROTO_N ( ( tok, args ) )
-    PROTO_T ( TOKEN tok X LIST ( TOKEN ) args )
+match_template_args(TOKEN tok, LIST(TOKEN) args)
+{
-    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
+	LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(tok));
-    while ( !IS_NULL_list ( pids ) && !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(pids) && !IS_NULL_list(args)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	TOKEN sort = DEREF_tok ( id_token_sort ( pid ) ) ;
+		TOKEN sort = DEREF_tok(id_token_sort(pid));
-	TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
+		TOKEN arg = DEREF_tok(HEAD_list(args));
-	if ( TAG_tok ( arg ) != TAG_tok ( sort ) ) {
+		if (TAG_tok(arg)!= TAG_tok(sort)) {
-	    /* Argument sorts do not match */
+			/* Argument sorts do not match */
-	    return ( 0 ) ;
+			return (0);
+		}
+		args = TAIL_list(args);
+		pids = TAIL_list(pids);
+	}
+	if (!IS_NULL_list(args)) {
+		/* Too many arguments */
+		return (0);
+	}
-	args = TAIL_list ( args ) ;
-	pids = TAIL_list ( pids ) ;
-    }
-    if ( !IS_NULL_list ( args ) ) {
-	/* Too many arguments */
-	return ( 0 ) ;
+	return (1);
-    }
-    return ( 1 ) ;
 }
 /*
     APPLY A FUNCTION TEMPLATE
     This routine applies the function template id to the arguments args.
     Because id may comprise several overloaded template functions it is
     necessary to check each to determine whether the template parameter
     sorts match the argument sorts.  If more than one match is found the
     result is an overloaded function.
 */
-static IDENTIFIER apply_func_templ
+static IDENTIFIER
+apply_func_templ(IDENTIFIER id, LIST(TOKEN) args, int def)
+{
+	int force = 0;
+	IDENTIFIER tid = NULL_id;
+	do {
+		/* Build up result */
+		IDENTIFIER fid = id;
+		while (!IS_NULL_id(fid)) {
+			TYPE t = DEREF_type(id_function_etc_type(fid));
+			if (IS_type_templ(t)) {
+				TOKEN sort = DEREF_tok(type_templ_sort(t));
+				if (force || match_template_args(sort, args)) {
+					/* Argument sorts match */
+					IDENTIFIER sid = tid;
+					int td = in_template_decl;
+					args =
+					    check_templ_args(sort, args, fid);
-    PROTO_N ( ( id, args, def ) )
+					tid = instance_func(fid, args, 0, def);
+					COPY_id(id_function_etc_over(tid), sid);
+					in_template_decl = td;
+				}
+			}
+			fid = DEREF_id(id_function_etc_over(fid));
+		}
+		if (force) {
+			/* Should have bound arguments by now */
+			if (IS_NULL_id(tid)) {
+				tid = id;
+			}
+		} else {
+			/* Try again allowing for mismatches */
+			force = 1;
+		}
+	} while (IS_NULL_id(tid));
+	return (tid);
+}
+/*
+    APPLY A TYPEDEF TEMPLATE
+    This routine applies the typedef template id to the arguments args.
+*/
+static TYPE
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def )
+apply_typedef_templ(IDENTIFIER id, LIST(TOKEN) args)
+{
-    int force = 0 ;
+	TYPE t = DEREF_type(id_class_name_etc_defn(id));
-    IDENTIFIER tid = NULL_id ;
+	if (IS_type_templ(t)) {
-    do {
+		int td = in_template_decl;
-	/* Build up result */
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
-	IDENTIFIER fid = id ;
+		LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(sort));
-	while ( !IS_NULL_id ( fid ) ) {
+		args = check_templ_args(sort, args, id);
-	    TYPE t = DEREF_type ( id_function_etc_type ( fid ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-	    if ( IS_type_templ ( t ) ) {
+		if (is_templ_type(t)) {
+			/* Template template parameter */
-		TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+			IDENTIFIER tid = DEREF_id(type_token_tok(t));
-		if ( force || match_template_args ( sort, args ) ) {
+			MAKE_type_token(cv_none, tid, args, t);
+		} else {
-		    /* Argument sorts match */
+			/* Expand type definition */
-		    IDENTIFIER sid = tid ;
+			int d = save_token_args(pids, args);
-		    int td = in_template_decl ;
+			TYPE s = expand_type(t, 1);
-		    args = check_templ_args ( sort, args, fid ) ;
+			if (EQ_type(s, t)) {
-		    tid = instance_func ( fid, args, 0, def ) ;
+				s = copy_typedef(id, t, cv_none);
+			}
-		    COPY_id ( id_function_etc_over ( tid ), sid ) ;
+			restore_token_args(pids, d);
-		    in_template_decl = td ;
+			t = s;
+		}
-	    }
-	    fid = DEREF_id ( id_function_etc_over ( fid ) ) ;
-	}
-	if ( force ) {
-	    /* Should have bound arguments by now */
-	    if ( IS_NULL_id ( tid ) ) tid = id ;
-	} else {
-	    /* Try again allowing for mismatches */
-	    force = 1 ;
-	}
-    } while ( IS_NULL_id ( tid ) ) ;
-    return ( tid ) ;
-}
-/*
-    APPLY A TYPEDEF TEMPLATE
-    This routine applies the typedef template id to the arguments args.
-*/
-static TYPE apply_typedef_templ
-    PROTO_N ( ( id, args ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args )
-{
-    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
-    if ( IS_type_templ ( t ) ) {
-	int td = in_template_decl ;
+		in_template_decl = td;
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
-	LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-	args = check_templ_args ( sort, args, id ) ;
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
-	if ( is_templ_type ( t ) ) {
-	    /* Template template parameter */
-	    IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
-	    MAKE_type_token ( cv_none, tid, args, t ) ;
 	} else {
-	    /* Expand type definition */
-	    int d = save_token_args ( pids, args ) ;
-	    TYPE s = expand_type ( t, 1 ) ;
+		report(crt_loc, ERR_temp_names_not(id));
-	    if ( EQ_type ( s, t ) ) s = copy_typedef ( id, t, cv_none ) ;
+		t = copy_typedef(id, t, cv_none);
-	    restore_token_args ( pids, d ) ;
-	    t = s ;
+	}
-	in_template_decl = td ;
-    } else {
-	report ( crt_loc, ERR_temp_names_not ( id ) ) ;
-	t = copy_typedef ( id, t, cv_none ) ;
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     APPLY A CLASS TEMPLATE
     This routine applies the class template id to the arguments args.
 */
-static IDENTIFIER apply_type_templ
+static IDENTIFIER
-    PROTO_N ( ( id, args, def ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def )
+apply_type_templ(IDENTIFIER id, LIST(TOKEN) args, int def)
 {
-    if ( IS_id_class_name ( id ) ) {
+	if (IS_id_class_name(id)) {
-	/* Class template */
+		/* Class template */
-	TYPE t ;
+		TYPE t;
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( ds & dspec_implicit ) {
+		if (ds & dspec_implicit) {
-	    /* Allow for nested calls */
+			/* Allow for nested calls */
-	    IDENTIFIER tid = find_template ( id, 0 ) ;
+			IDENTIFIER tid = find_template(id, 0);
-	    if ( !IS_NULL_id ( tid ) ) id = tid ;
+			if (!IS_NULL_id(tid)) {
+				id = tid;
+			}
-	}
+		}
-	t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+		t = DEREF_type(id_class_name_etc_defn(id));
-	if ( IS_type_templ ( t ) ) {
+		if (IS_type_templ(t)) {
-	    int td = in_template_decl ;
+			int td = in_template_decl;
-	    TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+			TOKEN sort = DEREF_tok(type_templ_sort(t));
-	    args = check_templ_args ( sort, args, id ) ;
+			args = check_templ_args(sort, args, id);
-	    id = instance_type ( id, args, 0, def ) ;
+			id = instance_type(id, args, 0, def);
-	    in_template_decl = td ;
+			in_template_decl = td;
-	} else {
+		} else {
-	    report ( crt_loc, ERR_temp_names_not ( id ) ) ;
+			report(crt_loc, ERR_temp_names_not(id));
-	}
+		}
-    } else {
+	} else {
-	/* Type alias template */
+		/* Type alias template */
-	TYPE t = apply_typedef_templ ( id, args ) ;
+		TYPE t = apply_typedef_templ(id, args);
-	if ( IS_type_compound ( t ) ) {
+		if (IS_type_compound(t)) {
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	    complete_class ( ct, def ) ;
+			complete_class(ct, def);
-	    id = DEREF_id ( ctype_name ( ct ) ) ;
+			id = DEREF_id(ctype_name(ct));
-	} else {
+		} else {
-	    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_loc = crt_loc ;
+			decl_loc = crt_loc;
-	    id = make_typedef ( ns, nm, t, dspec_none ) ;
+			id = make_typedef(ns, nm, t, dspec_none);
-	}
+		}
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     APPLY A TEMPLATE TO A SET OF ARGUMENTS
     This routine applies the template id to the arguments args.
 */
-IDENTIFIER apply_template
+IDENTIFIER
-    PROTO_N ( ( id, args, def, force ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def X int force )
+apply_template(IDENTIFIER id, LIST(TOKEN) args, int def, int force)
 {
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ds & dspec_template ) {
+	if (ds & dspec_template) {
-	if ( IS_id_function_etc ( id ) ) {
+		if (IS_id_function_etc(id)) {
-	    id = apply_func_templ ( id, args, def ) ;
+			id = apply_func_templ(id, args, def);
+		} else {
+			id = apply_type_templ(id, args, def);
+		}
 	} else {
+		TYPE form;
-	    id = apply_type_templ ( id, args, def ) ;
+		MAKE_type_token(cv_none, id, args, form);
+		if (force || is_templ_depend(form)) {
+			/* Dummy template identifier */
+			HASHID nm = DEREF_hashid(id_name(id));
+			NAMESPACE ns = DEREF_nspace(id_parent(id));
+			MAKE_id_undef(nm, dspec_none, ns, crt_loc, id);
+			COPY_type(id_undef_form(id), form);
+		} else {
+			report(crt_loc, ERR_temp_names_not(id));
+		}
+	}
-    } else {
-	TYPE form ;
-	MAKE_type_token ( cv_none, id, args, form ) ;
-	if ( force || is_templ_depend ( form ) ) {
-	    /* Dummy template identifier */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-	    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
-	    MAKE_id_undef ( nm, dspec_none, ns, crt_loc, id ) ;
-	    COPY_type ( id_undef_form ( id ), form ) ;
-	} else {
-	    report ( crt_loc, ERR_temp_names_not ( id ) ) ;
-	}
-    }
-    return ( id ) ;
+	return (id);
 }
 /*
     PARSE A SET OF NON-TYPE TEMPLATE ARGUMENTS
     This routine parses the template arguments p for the non-class template
     id.  This includes both template functions and dummy template identifiers
     such as in 'ptr->template id < ... >'.
 */
-IDENTIFIER parse_id_template
+IDENTIFIER
-    PROTO_N ( ( id, p, def ) )
-    PROTO_T ( IDENTIFIER id X PPTOKEN *p X int def )
+parse_id_template(IDENTIFIER id, PPTOKEN *p, int def)
 {
-    LIST ( TOKEN ) args = parse_template_args ( p ) ;
+	LIST(TOKEN) args = parse_template_args(p);
-    id = apply_template ( id, args, def, 1 ) ;
+	id = apply_template(id, args, def, 1);
-    return ( id ) ;
+	return (id);
 }
 /*
     PARSE A SET OF TYPE TEMPLATE ARGUMENTS
     This routine parses the template arguments p for the class template
     id.  def is passed to instance_type.
 */
-IDENTIFIER parse_type_template
+IDENTIFIER
-    PROTO_N ( ( id, p, def ) )
-    PROTO_T ( IDENTIFIER id X PPTOKEN *p X int def )
+parse_type_template(IDENTIFIER id, PPTOKEN *p, int def)
+{
-    LIST ( TOKEN ) args = parse_template_args ( p ) ;
+	LIST(TOKEN) args = parse_template_args(p);
-    id = apply_type_templ ( id, args, def ) ;
+	id = apply_type_templ(id, args, def);
-    return ( id ) ;
+	return (id);
+}
 /*
     PARSE A SET OF TYPEDEF TEMPLATE ARGUMENTS
     This routine parses the template arguments p for the typedef
     template id.
 */
-TYPE parse_typedef_templ
+TYPE
-    PROTO_N ( ( id, p ) )
-    PROTO_T ( IDENTIFIER id X PPTOKEN *p )
+parse_typedef_templ(IDENTIFIER id, PPTOKEN *p)
 {
-    LIST ( TOKEN ) args = parse_template_args ( p ) ;
+	LIST(TOKEN) args = parse_template_args(p);
-    TYPE t = apply_typedef_templ ( id, args ) ;
+	TYPE t = apply_typedef_templ(id, args);
-    return ( t ) ;
+	return (t);
 }
 /*
     DEDUCE A TEMPLATE TYPE
     This routine deduces the arguments for the template type id called
     without arguments.  Within a template class definition the template
     name gives the the template applied to the current arguments.
     Otherwise template declarations and definitions (for which used is
     false) are allowed but other instances are not.
 */
-TYPE deduce_type_template
+TYPE
-    PROTO_N ( ( id, used ) )
-    PROTO_T ( IDENTIFIER id X int used )
+deduce_type_template(IDENTIFIER id, int used)
 {
-    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+	TYPE t = DEREF_type(id_class_name_etc_defn(id));
-    if ( used ) {
+	if (used) {
-	TYPE s = t ;
+		TYPE s = t;
-	while ( IS_type_templ ( s ) ) {
+		while (IS_type_templ(s)) {
-	    s = DEREF_type ( type_templ_defn ( s ) ) ;
+			s = DEREF_type(type_templ_defn(s));
-	}
+		}
-	if ( IS_type_compound ( s ) ) {
+		if (IS_type_compound(s)) {
-	    CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(type_compound_defn(s));
-	    if ( defining_class ( cs ) ) {
+			if (defining_class(cs)) {
-		/* In class definition */
+				/* In class definition */
-		return ( s ) ;
+				return (s);
-	    }
+			}
-	}
+		}
-	report ( crt_loc, ERR_temp_local_not ( t ) ) ;
+		report(crt_loc, ERR_temp_local_not(t));
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     CURRENT TEMPLATE NAMESPACE
     This variable is used within a template declaration to hold the
     namespace in which the template parameters are declared.
 */
-NAMESPACE templ_namespace = NULL_nspace ;
+NAMESPACE templ_namespace = NULL_nspace;
 /*
     LIST OF ALL TEMPLATE PARAMETERS
     These lists are dummy values representing the lists of all template
     parameters and all template or token parameters.
 */
-LIST ( IDENTIFIER ) any_templ_param = NULL_list ( IDENTIFIER ) ;
+LIST(IDENTIFIER) any_templ_param = NULL_list(IDENTIFIER);
-LIST ( IDENTIFIER ) any_token_param = NULL_list ( IDENTIFIER ) ;
+LIST(IDENTIFIER) any_token_param = NULL_list(IDENTIFIER);
 /*
     PARSE A SET OF TEMPLATE PARAMETERS
     This routine parses a set of template parameters.  It is entered after
     the initial 'template' has been read.  ex is true if this was preceded
     by 'export'.
 */
-TOKEN template_params
+TOKEN
-    PROTO_N ( ( ex ) )
-    PROTO_T ( int ex )
+template_params(int ex)
 {
-    int t ;
+	int t;
-    TOKEN tok ;
+	TOKEN tok;
-    PPTOKEN *p ;
+	PPTOKEN *p;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    LOCATION loc ;
+	LOCATION loc;
-    PARSE_STATE s ;
+	PARSE_STATE s;
-    int have_darg = 0 ;
+	int have_darg = 0;
-    unsigned long npars = 0 ;
+	unsigned long npars = 0;
-    DECL_SPEC use = dspec_none ;
+	DECL_SPEC use = dspec_none;
-    LIST ( TOKEN ) dargs = NULL_list ( TOKEN ) ;
+	LIST(TOKEN) dargs = NULL_list(TOKEN);
-    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+	LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);
-    /* Can't have template declarations inside blocks */
+	/* Can't have template declarations inside blocks */
-    if ( in_function_defn ) {
+	if (in_function_defn) {
-	report ( crt_loc, ERR_temp_decl_scope () ) ;
+		report(crt_loc, ERR_temp_decl_scope());
-    } else if ( in_class_defn && really_in_function_defn ) {
+	} else if (in_class_defn && really_in_function_defn) {
-	report ( crt_loc, ERR_temp_mem_local () ) ;
+		report(crt_loc, ERR_temp_mem_local());
-    }
+	}
-    /* Mark exported templates */
+	/* Mark exported templates */
-    if ( ex || option ( OPT_templ_export ) ) use |= dspec_extern ;
+	if (ex || option(OPT_templ_export))use |= dspec_extern;
-    /* Check for initial '<' */
+	/* Check for initial '<' */
-    if ( crt_lex_token != lex_less ) {
+	if (crt_lex_token != lex_less) {
-	/* Explicit instantiation */
+		/* Explicit instantiation */
-	MAKE_tok_templ ( use, NULL_nspace, tok ) ;
+		MAKE_tok_templ(use, NULL_nspace, tok);
-	return ( tok ) ;
+		return (tok);
-    }
+	}
-    /* Start template parameter namespace */
+	/* Start template parameter namespace */
-    ns = make_namespace ( NULL_id, nspace_templ_tag, 0 ) ;
+	ns = make_namespace(NULL_id, nspace_templ_tag, 0);
-    push_namespace ( ns ) ;
+	push_namespace(ns);
-    in_template_decl++ ;
+	in_template_decl++;
-    record_location++ ;
+	record_location++;
-    /* Prepare to parse template parameters */
+	/* Prepare to parse template parameters */
-    ADVANCE_LEXER ;
+	ADVANCE_LEXER;
-    loc = crt_loc ;
+	loc = crt_loc;
-    p = skip_template ( NULL_id ) ;
+	p = skip_template(NULL_id);
-    save_state ( &s, 1 ) ;
+	save_state(&s, 1);
-    crt_loc = loc ;
+	crt_loc = loc;
-    init_parser ( p ) ;
+	init_parser(p);
-    ADVANCE_LEXER ;
+	ADVANCE_LEXER;
-    t = crt_lex_token ;
+	t = crt_lex_token;
-    /* Parse template parameters */
+	/* Parse template parameters */
-    if ( t != lex_close_Htemplate ) {
+	if (t != lex_close_Htemplate) {
-	for ( ; ; ) {
+		for (;;) {
-	    /* Declare parameter */
+			/* Declare parameter */
-	    IDENTIFIER pid = NULL_id ;
+			IDENTIFIER pid = NULL_id;
-	    decl_loc = crt_loc ;
+			decl_loc = crt_loc;
-	    if ( predict_template () ) {
+			if (predict_template()) {
-		/* Type parameter */
+				/* Type parameter */
-		parse_type_param ( &pid ) ;
+				parse_type_param(&pid);
-	    } else {
-		/* Expression parameter */
-		if ( crt_lex_token == lex_typename ) {
-		    /* Replace 'typename' by 'class' */
-		    crt_lex_token = lex_class ;
-		}
-		parse_param ( NULL_type, CONTEXT_TEMPL_PARAM, &pid ) ;
-	    }
-	    /* Add parameter to list */
-	    if ( !IS_NULL_id ( pid ) ) {
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
-		ds |= dspec_template ;
-		COPY_dspec ( id_storage ( pid ), ds ) ;
-		if ( do_dump ) dump_token_param ( pid ) ;
-		tok = DEREF_tok ( id_token_sort ( pid ) ) ;
-		switch ( TAG_tok ( tok ) ) {
-		    case tok_exp_tag : {
-			/* Expression parameter */
-			int c ;
-			EXP e ;
-			TYPE r ;
-			DECONS_tok_exp ( r, c, e, tok ) ;
-			templ_param_type ( pid, r ) ;
-			if ( IS_NULL_exp ( e ) ) {
-			    if ( have_darg ) have_darg = 2 ;
-			    tok = NULL_tok ;
-			} else {
-			    COPY_exp ( tok_exp_value ( tok ), NULL_exp ) ;
-			    MAKE_tok_exp ( r, c, e, tok ) ;
-			    have_darg = 1 ;
-			}
-			break ;
-		    }
-		    case tok_type_tag : {
-			/* Type parameter */
-			TYPE r = DEREF_type ( tok_type_value ( tok ) ) ;
-			if ( IS_NULL_type ( r ) ) {
-			    if ( have_darg ) have_darg = 2 ;
-			    tok = NULL_tok ;
-			} else {
-			    COPY_type ( tok_type_value ( tok ), NULL_type ) ;
-			    MAKE_tok_type ( btype_lang, r, tok ) ;
-			    have_darg = 1 ;
-			}
-			break ;
-		    }
-		    case tok_class_tag : {
-			/* Template class parameter */
-			TYPE r = DEREF_type ( tok_class_type ( tok ) ) ;
-			IDENTIFIER cid = DEREF_id ( tok_class_value ( tok ) ) ;
-			if ( IS_NULL_id ( cid ) ) {
-			    if ( have_darg ) have_darg = 2 ;
-			    tok = NULL_tok ;
 			} else {
+				/* Expression parameter */
+				if (crt_lex_token == lex_typename) {
+					/* Replace 'typename' by 'class' */
+					crt_lex_token = lex_class;
+				}
+				parse_param(NULL_type, CONTEXT_TEMPL_PARAM,
+					    &pid);
+			}
+			/* Add parameter to list */
+			if (!IS_NULL_id(pid)) {
+				DECL_SPEC ds = DEREF_dspec(id_storage(pid));
+				ds |= dspec_template;
+				COPY_dspec(id_storage(pid), ds);
+				if (do_dump) {
+					dump_token_param(pid);
+				}
+				tok = DEREF_tok(id_token_sort(pid));
+				switch (TAG_tok(tok)) {
+				case tok_exp_tag: {
+					/* Expression parameter */
+					int c;
+					EXP e;
+					TYPE r;
+					DECONS_tok_exp(r, c, e, tok);
+					templ_param_type(pid, r);
+					if (IS_NULL_exp(e)) {
+						if (have_darg) {
+							have_darg = 2;
+						}
+						tok = NULL_tok;
+					} else {
+						COPY_exp(tok_exp_value(tok),
+							 NULL_exp);
+						MAKE_tok_exp(r, c, e, tok);
+						have_darg = 1;
+					}
+					break;
+				}
+				case tok_type_tag: {
+					/* Type parameter */
+					TYPE r = DEREF_type(tok_type_value(tok));
+					if (IS_NULL_type(r)) {
+						if (have_darg) {
+							have_darg = 2;
+						}
+						tok = NULL_tok;
+					} else {
+						COPY_type(tok_type_value(tok),
+							  NULL_type);
+						MAKE_tok_type(btype_lang, r,
+							      tok);
+						have_darg = 1;
+					}
+					break;
+				}
+				case tok_class_tag: {
+					/* Template class parameter */
+					TYPE r =
+					    DEREF_type(tok_class_type(tok));
+					IDENTIFIER cid =
+					    DEREF_id(tok_class_value(tok));
+					if (IS_NULL_id(cid)) {
+						if (have_darg) {
+							have_darg = 2;
+						}
+						tok = NULL_tok;
+					} else {
-			    COPY_id ( tok_class_value ( tok ), NULL_id ) ;
+						COPY_id(tok_class_value(tok),
+							NULL_id);
-			    MAKE_tok_class ( r, cid, tok ) ;
+						MAKE_tok_class(r, cid, tok);
-			    have_darg = 1 ;
+						have_darg = 1;
+					}
+					break;
+				}
+				default:
+					/* Shouldn't occur */
+					tok = NULL_tok;
+					break;
+				}
+				if (have_darg == 2) {
+					/* Missing default argument */
+					report(crt_loc,
+					       ERR_temp_param_default(pid));
+				}
+				CONS_tok(tok, dargs, dargs);
+				CONS_id(pid, pids, pids);
+				npars++;
+			}
+			/* Check for next parameter */
+			t = crt_lex_token;
+			if (t == lex_close_Htemplate) {
+				/* End of parameter list */
+				break;
+			} else if (t == lex_comma) {
+				/* Move on to next parameter */
+				ADVANCE_LEXER;
+			} else {
+				/* Syntax error */
+				if (!have_syntax_error) {
+					ERROR err = ERR_lex_parse(crt_token);
+					report(crt_loc, err);
+				}
+				break;
+			}
-			break ;
-		    }
-		    default : {
-			/* Shouldn't occur */
-			tok = NULL_tok ;
-			break ;
-		    }
-		}
-		if ( have_darg == 2 ) {
-		    /* Missing default argument */
-		    report ( crt_loc, ERR_temp_param_default ( pid ) ) ;
-		}
-		CONS_tok ( tok, dargs, dargs ) ;
-		CONS_id ( pid, pids, pids ) ;
-		npars++ ;
-	    }
-	    /* Check for next parameter */
-	    t = crt_lex_token ;
-	    if ( t == lex_close_Htemplate ) {
-		/* End of parameter list */
-		break ;
-	    } else if ( t == lex_comma ) {
-		/* Move on to next parameter */
-		ADVANCE_LEXER ;
-	    } else {
-		/* Syntax error */
-		if ( !have_syntax_error ) {
-		    ERROR err = ERR_lex_parse ( crt_token ) ;
-		    report ( crt_loc, err ) ;
+		}
-		break ;
-	    }
+	}
-    }
-    /* Restore parser */
+	/* Restore parser */
-    restore_state ( &s ) ;
+	restore_state(&s);
-    p = restore_parser () ;
+	p = restore_parser();
-    free_tok_list ( p ) ;
+	free_tok_list(p);
-    /* Construct the result */
+	/* Construct the result */
-    MAKE_tok_templ ( use, crt_namespace, tok ) ;
+	MAKE_tok_templ(use, crt_namespace, tok);
-    if ( IS_NULL_list ( pids ) ) {
+	if (IS_NULL_list(pids)) {
-	/* Explicit specialisation */
+		/* Explicit specialisation */
-	IGNORE pop_namespace () ;
+		IGNORE pop_namespace();
-	in_template_decl-- ;
+		in_template_decl--;
-	record_location-- ;
+		record_location--;
-    } else {
+	} else {
-	IGNORE check_value ( OPT_VAL_template_pars, npars ) ;
+		IGNORE check_value(OPT_VAL_template_pars, npars);
-	pids = REVERSE_list ( pids ) ;
+		pids = REVERSE_list(pids);
-	dargs = REVERSE_list ( dargs ) ;
+		dargs = REVERSE_list(dargs);
-	COPY_list ( tok_templ_pids ( tok ), pids ) ;
+		COPY_list(tok_templ_pids(tok), pids);
-	COPY_list ( tok_templ_dargs ( tok ), dargs ) ;
+		COPY_list(tok_templ_dargs(tok), dargs);
-	set_proc_token ( pids ) ;
+		set_proc_token(pids);
-	templ_namespace = ns ;
+		templ_namespace = ns;
-    }
+	}
-    return ( tok ) ;
+	return (tok);
+}
 /*
     CREATE A TEMPLATE TYPE QUALIFIER
     This routine creates a template type qualifier from the template
     parameters tok and the type t.  It also terminates the template
     parameter namespace while leaving its names in scope.
 */
-TYPE make_template_type
+TYPE
-    PROTO_N ( ( tok, t ) )
-    PROTO_T ( TOKEN tok X TYPE t )
+make_template_type(TOKEN tok, TYPE t)
+{
-    TYPE s ;
+	TYPE s;
-    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
+	LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(tok));
-    if ( !IS_NULL_list ( pids ) ) {
+	if (!IS_NULL_list(pids)) {
-	/* Remove template parameters */
+		/* Remove template parameters */
-	IGNORE restore_namespace () ;
+		IGNORE restore_namespace();
-    }
+	}
-    MAKE_type_templ ( cv_none, tok, NULL_type, 0, s ) ;
+	MAKE_type_templ(cv_none, tok, NULL_type, 0, s);
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	unsigned tag = TAG_type ( t ) ;
+		unsigned tag = TAG_type(t);
-	NAMESPACE ns = DEREF_nspace ( tok_templ_pars ( tok ) ) ;
+		NAMESPACE ns = DEREF_nspace(tok_templ_pars(tok));
-	if ( IS_NULL_nspace ( ns ) ) {
+		if (IS_NULL_nspace(ns)) {
-	    /* Can't have 'template template < ... >' */
+			/* Can't have 'template template < ... >' */
-	    report ( crt_loc, ERR_temp_explicit_templ () ) ;
+			report(crt_loc, ERR_temp_explicit_templ());
-	    s = NULL_type ;
+			s = NULL_type;
-	} else {
+		} else {
-	    if ( tag == type_templ_tag ) {
+			if (tag == type_templ_tag) {
-		tok = DEREF_tok ( type_templ_sort ( t ) ) ;
+				tok = DEREF_tok(type_templ_sort(t));
-		ns = DEREF_nspace ( tok_templ_pars ( tok ) ) ;
+				ns = DEREF_nspace(tok_templ_pars(tok));
-		if ( IS_NULL_nspace ( ns ) ) {
+				if (IS_NULL_nspace(ns)) {
-		    /* Can't have 'template < ... > template' */
+					/* Can't have 'template < ... >
+					 * template' */
+					report(crt_loc,
-		    report ( crt_loc, ERR_temp_explicit_templ () ) ;
+					       ERR_temp_explicit_templ());
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+					t = DEREF_type(type_templ_defn(t));
-		    tag = TAG_type ( t ) ;
+					tag = TAG_type(t);
+				}
+			}
+		}
-	    }
-	}
-	if ( tag == type_func_tag ) {
+		if (tag == type_func_tag) {
-	    /* Ignore linkage specifiers */
+			/* Ignore linkage specifiers */
-	    CV_SPEC cv = DEREF_cv ( type_func_mqual ( t ) ) ;
+			CV_SPEC cv = DEREF_cv(type_func_mqual(t));
-	    cv &= ~cv_language ;
+			cv &= ~cv_language;
-	    cv |= cv_cpp ;
+			cv |= cv_cpp;
-	    COPY_cv ( type_func_mqual ( t ), cv ) ;
+			COPY_cv(type_func_mqual(t), cv);
+		}
+		s = inject_pre_type(t, s, 0);
+	}
-	s = inject_pre_type ( t, s, 0 ) ;
-    }
-    return ( s ) ;
+	return (s);
+}
 /*
     END A TEMPLATE DECLARATION
     This routine ends a template declaration.  It removes the names from
     the template parameter namespace from scope.
 */
-void end_template
+void
-    PROTO_N ( ( tok ) )
-    PROTO_T ( TOKEN tok )
+end_template(TOKEN tok)
 {
-    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
+	LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(tok));
-    if ( !IS_NULL_list ( pids ) ) {
+	if (!IS_NULL_list(pids)) {
-	remove_namespace () ;
+		remove_namespace();
-	templ_namespace = NULL_nspace ;
+		templ_namespace = NULL_nspace;
-	in_template_decl-- ;
+		in_template_decl--;
-	record_location-- ;
+		record_location--;
-	if ( in_template_decl ) {
+		if (in_template_decl) {
-	    /* Find enclosing template namespace */
+			/* Find enclosing template namespace */
-	    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_nspace_templ ( ns ) ) {
+				if (IS_nspace_templ(ns)) {
-		    templ_namespace = ns ;
+					templ_namespace = ns;
-		    break ;
+					break;
-		}
+				}
-		lns = TAIL_list ( lns ) ;
+				lns = TAIL_list(lns);
-	    }
+			}
-	}
+		}
-    }
+	}
-    if ( !in_template_decl ) clear_templates ( 1 ) ;
+	if (!in_template_decl) {
+		clear_templates(1);
+	}
-    return ;
+	return;
 }
 /*
     CHECK A TEMPLATE DECLARATOR
     This routine is called whenever the template type t is used to qualify
     a class definition or a function declarator.
 */
-void template_decl
+void
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+template_decl(TYPE t)
 {
-    while ( !IS_NULL_type ( t ) && IS_type_templ ( t ) ) {
+	while (!IS_NULL_type(t) && IS_type_templ(t)) {
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
-	DECL_SPEC ds = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
+		DECL_SPEC ds = DEREF_dspec(tok_templ_usage(sort));
-	if ( ds & dspec_used ) {
+		if (ds & dspec_used) {
-	    /* Already used */
+			/* Already used */
-	    report ( crt_loc, ERR_temp_decl_one () ) ;
+			report(crt_loc, ERR_temp_decl_one());
-	}
+		}
-	ds |= dspec_used ;
+		ds |= dspec_used;
-	COPY_dspec ( tok_templ_usage ( sort ), ds ) ;
+		COPY_dspec(tok_templ_usage(sort), ds);
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-    }
+	}
-    return ;
+	return;
 }
 /*
     EXPORT A SET OF TEMPLATE INSTANCES
     This routine exports the instances associated with the template type t.
     It returns the non-template component of t.
 */
-static TYPE export_instances
+static TYPE
-    PROTO_N ( ( t, def ) )
-    PROTO_T ( TYPE t X int def )
+export_instances(TYPE t, int def)
+{
-    while ( IS_type_templ ( t ) ) {
+	while (IS_type_templ(t)) {
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
-	INSTANCE apps = DEREF_inst ( tok_templ_apps ( sort ) ) ;
+		INSTANCE apps = DEREF_inst(tok_templ_apps(sort));
-	while ( !IS_NULL_inst ( apps ) ) {
+		while (!IS_NULL_inst(apps)) {
-	    DECL_SPEC acc = DEREF_dspec ( inst_templ_access ( apps ) ) ;
+			DECL_SPEC acc = DEREF_dspec(inst_templ_access(apps));
-	    if ( !( acc & ( dspec_alias | dspec_main ) ) ) {
+			if (!(acc & (dspec_alias | dspec_main))) {
-		IDENTIFIER id = DEREF_id ( inst_templ_id ( apps ) ) ;
+				IDENTIFIER id = DEREF_id(inst_templ_id(apps));
-		export_template ( id, def ) ;
+				export_template(id, def);
-	    }
+			}
-	    acc |= dspec_typedef ;
+			acc |= dspec_typedef;
-	    COPY_dspec ( inst_templ_access ( apps ), acc ) ;
+			COPY_dspec(inst_templ_access(apps), acc);
-	    apps = DEREF_inst ( inst_next ( apps ) ) ;
+			apps = DEREF_inst(inst_next(apps));
+		}
+		t = DEREF_type(type_templ_defn(t));
+	}
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     EXPORT A TEMPLATE IDENTIFIER
     This routine marks the template identifier id as having been exported.
     def is 2 for the first explicit declaration of a template, 1 for a
     redeclaration and 0 otherwise.
 */
-void export_template
-    PROTO_N ( ( id, def ) )
-    PROTO_T ( IDENTIFIER id X int def )
+void export_template(IDENTIFIER id, int def)
 {
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ds & ( dspec_inherit | dspec_implicit ) ) return ;
+	if (ds & (dspec_inherit | dspec_implicit)) {
+		return;
+	}
-    if ( ds & ( dspec_inline | dspec_static ) ) return ;
+	if (ds & (dspec_inline | dspec_static)) {
+		return;
+	}
-    if ( def == 0 && ( ds & dspec_typedef ) ) {
+	if (def == 0 && (ds & dspec_typedef)) {
-	/* Already exported */
+		/* Already exported */
-	return ;
+		return;
-    }
+	}
-    ds |= dspec_typedef ;
+	ds |= dspec_typedef;
-    COPY_dspec ( id_storage ( id ), ds ) ;
+	COPY_dspec(id_storage(id), ds);
-    if ( def == 2 && !has_linkage ( id ) ) {
+	if (def == 2 && !has_linkage(id)) {
-	/* Can't export anonymous identifiers */
+		/* Can't export anonymous identifiers */
-	report ( crt_loc, ERR_temp_decl_export ( id ) ) ;
+		report(crt_loc, ERR_temp_decl_export(id));
-    }
+	}
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_class_name_tag :
+	case id_class_name_tag:
-	case id_class_alias_tag : {
+	case id_class_alias_tag: {
-	    /* Template classes */
+		/* Template classes */
-	    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+		TYPE t = DEREF_type(id_class_name_etc_defn(id));
-	    t = export_instances ( t, def ) ;
+		t = export_instances(t, def);
-	    if ( IS_type_compound ( t ) ) {
+		if (IS_type_compound(t)) {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-		IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+			IDENTIFIER cid = DEREF_id(ctype_name(ct));
-		if ( EQ_id ( id, cid ) ) {
+			if (EQ_id(id, cid)) {
-		    NAMESPACE ns = DEREF_nspace ( ctype_member ( ct ) ) ;
+				NAMESPACE ns = DEREF_nspace(ctype_member(ct));
+				MEMBER mem =
-		    MEMBER mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
+				    DEREF_member(nspace_ctype_first(ns));
-		    while ( !IS_NULL_member ( mem ) ) {
+				while (!IS_NULL_member(mem)) {
-			/* Scan through class members */
+					/* Scan through class members */
+					IDENTIFIER pid =
-			IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
+					    DEREF_id(member_id(mem));
+					IDENTIFIER qid =
-			IDENTIFIER qid = DEREF_id ( member_alt ( mem ) ) ;
+					    DEREF_id(member_alt(mem));
-			if ( !IS_NULL_id ( pid ) ) {
+					if (!IS_NULL_id(pid)) {
-			    export_template ( pid, def ) ;
+						export_template(pid, def);
-			}
+					}
+					if (!IS_NULL_id(qid) &&
-			if ( !IS_NULL_id ( qid ) && !EQ_id ( qid, pid ) ) {
+					    !EQ_id(qid, pid)) {
-			    export_template ( qid, def ) ;
+						export_template(qid, def);
-			}
+					}
-			mem = DEREF_member ( member_next ( mem ) ) ;
+					mem = DEREF_member(member_next(mem));
-		    }
+				}
-		}
+			}
-	    }
+		}
-	    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: {
-	    /* Template functions */
+		/* Template functions */
-	    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
+		TYPE t = DEREF_type(id_function_etc_type(id));
-	    IGNORE export_instances ( t, def ) ;
+		IGNORE export_instances(t, def);
-	    update_tag ( id, 0 ) ;
+		update_tag(id, 0);
-	    break ;
+		break;
 	}
-	case id_stat_member_tag : {
+	case id_stat_member_tag:
-	    /* Static data members */
+		/* Static data members */
-	    update_tag ( id, 0 ) ;
+		update_tag(id, 0);
-	    break ;
+		break;
 	}
-    }
-    return ;
+	return;
 }
 /*
     HAS A TEMPLATE BEEN EXPORTED?
     This routine checks whether the template instance id has been exported.
 */
-int is_exported
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_exported(IDENTIFIER id)
+{
-    TYPE form ;
+	TYPE form;
-    int def = 0 ;
+	int def = 0;
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ds & dspec_typedef ) return ( 1 ) ;
-    form = find_form ( id, &def ) ;
-    if ( !IS_NULL_type ( form ) && IS_type_instance ( form ) ) {
-	IDENTIFIER tid = DEREF_id ( type_instance_id ( form ) ) ;
-	ds = DEREF_dspec ( id_storage ( tid ) ) ;
-	if ( ds & dspec_typedef ) {
+	if (ds & dspec_typedef) {
-	    export_template ( id, 0 ) ;
-	    return ( 1 ) ;
+		return (1);
+	}
+	form = find_form(id, &def);
+	if (!IS_NULL_type(form) && IS_type_instance(form)) {
+		IDENTIFIER tid = DEREF_id(type_instance_id(form));
+		ds = DEREF_dspec(id_storage(tid));
+		if (ds & dspec_typedef) {
+			export_template(id, 0);
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CREATE A SET OF PRIMARY TEMPLATE ARGUMENTS
     This routine creates a list of primary template arguments corresponding
     to the template parameters pids.
 */
-LIST ( TOKEN ) make_primary_args
+LIST(TOKEN)
-    PROTO_N ( ( pids ) )
-    PROTO_T ( LIST ( IDENTIFIER ) pids )
+make_primary_args(LIST(IDENTIFIER) pids)
+{
-    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
+	LIST(TOKEN) args = NULL_list(TOKEN);
-    while ( !IS_NULL_list ( pids ) ) {
+	while (!IS_NULL_list(pids)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-	TOKEN arg = apply_token ( pid, NULL_list ( TOKEN ) ) ;
+		TOKEN arg = apply_token(pid, NULL_list(TOKEN));
-	CONS_tok ( arg, args, args ) ;
+		CONS_tok(arg, args, args);
-	pids = TAIL_list ( pids ) ;
+		pids = TAIL_list(pids);
-    }
+	}
-    return ( REVERSE_list ( args ) ) ;
+	return (REVERSE_list(args));
+}
 /*
     CHECK A SET OF PRIMARY TEMPLATE PARAMETERS
     This routine checks the template parameters given by the type t for
     the declaration of the primary template class or function id.  It
     returns the non-template component of t.
 */
+TYPE
+check_templ_params(TYPE t, IDENTIFIER id)
+{
+	int depth = 0;
+	unsigned tag = TAG_type(t);
+	while (tag == type_templ_tag) {
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
+		NAMESPACE ns = DEREF_nspace(tok_templ_pars(sort));
+		DECL_SPEC use = DEREF_dspec(tok_templ_usage(sort));
+		LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(sort));
+		TYPE s = DEREF_type(type_templ_defn(t));
+		tag = TAG_type(s);
+		if (IS_NULL_list(pids)) {
+			/* No template parameters */
+			if (IS_NULL_nspace(ns)) {
+				/* Explicit instantiation */
+				report(decl_loc, ERR_temp_explicit_bad(id));
+			} else {
+				/* Specialisation */
+				report(decl_loc, ERR_temp_param_none(id));
+				COPY_id(nspace_name(ns), id);
+			}
+		} else {
+			/* Create primary specialisation */
+			TYPE form;
+			TYPE prim;
+			INSTANCE apps;
+			DECL_SPEC ds = (dspec_template | dspec_extern |
+					dspec_main);
+			LIST(TOKEN) args = make_primary_args(pids);
+			MAKE_type_token(cv_none, id, args, form);
+			MAKE_type_templ(cv_none, sort, form, 1, prim);
+			apps = DEREF_inst(tok_templ_apps(sort));
+			MAKE_inst_templ(prim, apps, id, ds, all_instances,
+					apps);
+			COPY_inst(type_token_app(form), apps);
+			COPY_inst(tok_templ_apps(sort), apps);
+			all_instances = apps;
+			if (tag == type_compound_tag) {
+				CLASS_TYPE cs =
+				    DEREF_ctype(type_compound_defn(s));
+				COPY_type(ctype_form(cs), form);
+			} else if (tag == type_func_tag) {
+				/* Can't have default arguments with function */
-TYPE check_templ_params
+				if (check_templ_dargs(t)) {
+					report(decl_loc, ERR_temp_param_func());
+				}
+			}
+			COPY_id(nspace_name(ns), id);
+		}
+		if (use & dspec_extern) {
-    PROTO_N ( ( t, id ) )
+			export_template(id, 2);
+		}
+		depth++;
+		t = s;
+	}
+	if (depth > 1) {
+		/* More than one level of templates */
+		report(decl_loc, ERR_temp_decl_bad());
+	}
+	return (t);
+}
+/*
-    PROTO_T ( TYPE t X IDENTIFIER id )
+    CHECK FOR TEMPLATE DEFAULT ARGUMENTS
+    This routine returns true if the template type t has default arguments.
+*/
+int
+check_templ_dargs(TYPE t)
+{
-    int depth = 0 ;
-    unsigned tag = TAG_type ( t ) ;
-    while ( tag == type_templ_tag ) {
+	if (IS_type_templ(t)) {
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
-	NAMESPACE ns = DEREF_nspace ( tok_templ_pars ( sort ) ) ;
-	DECL_SPEC use = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
-	LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
+		LIST(TOKEN) dargs = DEREF_list(tok_templ_dargs(sort));
-	TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-	tag = TAG_type ( s ) ;
-	if ( IS_NULL_list ( pids ) ) {
+		while (!IS_NULL_list(dargs)) {
-	    /* No template parameters */
+			TOKEN darg = DEREF_tok(HEAD_list(dargs));
-	    if ( IS_NULL_nspace ( ns ) ) {
+			if (!IS_NULL_tok(darg)) {
-		/* Explicit instantiation */
-		report ( decl_loc, ERR_temp_explicit_bad ( id ) ) ;
-	    } else {
+				return (1);
-		/* Specialisation */
-		report ( decl_loc, ERR_temp_param_none ( id ) ) ;
-		COPY_id ( nspace_name ( ns ), id ) ;
-	    }
+			}
-	} else {
-	    /* Create primary specialisation */
-	    TYPE form ;
-	    TYPE prim ;
-	    INSTANCE apps ;
-	    DECL_SPEC ds = ( dspec_template | dspec_extern | dspec_main ) ;
-	    LIST ( TOKEN ) args = make_primary_args ( pids ) ;
-	    MAKE_type_token ( cv_none, id, args, form ) ;
-	    MAKE_type_templ ( cv_none, sort, form, 1, prim ) ;
-	    apps = DEREF_inst ( tok_templ_apps ( sort ) ) ;
-	    MAKE_inst_templ ( prim, apps, id, ds, all_instances, apps ) ;
-	    COPY_inst ( type_token_app ( form ), apps ) ;
-	    COPY_inst ( tok_templ_apps ( sort ), apps ) ;
-	    all_instances = apps ;
+			dargs = TAIL_list(dargs);
-	    if ( tag == type_compound_tag ) {
-		CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
-		COPY_type ( ctype_form ( cs ), form ) ;
-	    } else if ( tag == type_func_tag ) {
-		/* Can't have default arguments with function */
-		if ( check_templ_dargs ( t ) ) {
-		    report ( decl_loc, ERR_temp_param_func () ) ;
+		}
-	    }
-	    COPY_id ( nspace_name ( ns ), id ) ;
+	}
-	if ( use & dspec_extern ) export_template ( id, 2 ) ;
-	depth++ ;
-	t = s ;
-    }
-    if ( depth > 1 ) {
-	/* More than one level of templates */
-	report ( decl_loc, ERR_temp_decl_bad () ) ;
-    }
-    return ( t ) ;
-}
-/*
-    CHECK FOR TEMPLATE DEFAULT ARGUMENTS
-    This routine returns true if the template type t has default arguments.
-*/
-int check_templ_dargs
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
-{
-    if ( IS_type_templ ( t ) ) {
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
-	LIST ( TOKEN ) dargs = DEREF_list ( tok_templ_dargs ( sort ) ) ;
-	while ( !IS_NULL_list ( dargs ) ) {
-	    TOKEN darg = DEREF_tok ( HEAD_list ( dargs ) ) ;
-	    if ( !IS_NULL_tok ( darg ) ) return ( 1 ) ;
-	    dargs = TAIL_list ( dargs ) ;
-	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     FIND AN UNDERLYING TEMPLATE
     This routine checks whether the identifier id results from the
     application of a template.  If so it returns the underlying template.
 */
-IDENTIFIER find_template
+IDENTIFIER
-    PROTO_N ( ( id, force ) )
-    PROTO_T ( IDENTIFIER id X int force )
+find_template(IDENTIFIER id, int force)
+{
-    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: {
-		/* Template classes */
+			/* Template classes */
-		CLASS_TYPE ct ;
+			CLASS_TYPE ct;
-		int templ = 0 ;
+			int templ = 0;
-		TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
+			TYPE t = DEREF_type(id_class_name_defn(id));
-		while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-		    templ = 1 ;
+				templ = 1;
-		}
+			}
-		ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			ct = DEREF_ctype(type_compound_defn(t));
-		t = DEREF_type ( ctype_form ( ct ) ) ;
+			t = DEREF_type(ctype_form(ct));
-		if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
+			if (!IS_NULL_type(t) && IS_type_token(t)) {
-		    IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
+				IDENTIFIER tid = DEREF_id(type_token_tok(t));
-		    if ( !IS_id_token ( tid ) ) return ( tid ) ;
+				if (!IS_id_token(tid)) {
-		}
-		if ( templ && force ) {
-		    /* Primary template class */
-		    return ( id ) ;
+					return (tid);
-		}
+				}
-		break ;
-	    }
-	    case id_function_tag :
-	    case id_mem_func_tag :
-	    case id_stat_mem_func_tag : {
-		/* Template functions */
-		TYPE t = DEREF_type ( id_function_etc_form ( id ) ) ;
-		if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
-		    IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
-		    if ( !IS_id_token ( tid ) ) return ( tid ) ;
-		}
+			}
-		if ( force ) {
+			if (templ && force) {
-		    t = DEREF_type ( id_function_etc_type ( id ) ) ;
-		    if ( IS_type_templ ( t ) ) {
-			/* Primary template function */
+				/* Primary template class */
-			return ( id ) ;
+				return (id);
-		    }
+			}
+			break;
+		}
-		break ;
+		case id_function_tag:
-	    }
-	    case id_ambig_tag : {
+		case id_mem_func_tag:
-		/* Ambiguous identifiers */
+		case id_stat_mem_func_tag: {
-		LIST ( IDENTIFIER ) pids ;
+			/* Template functions */
-		pids = DEREF_list ( id_ambig_ids ( id ) ) ;
+			TYPE t = DEREF_type(id_function_etc_form(id));
-		if ( !IS_NULL_list ( pids ) ) {
+			if (!IS_NULL_type(t) && IS_type_token(t)) {
-		    IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+				IDENTIFIER tid = DEREF_id(type_token_tok(t));
-		    IDENTIFIER tid = find_template ( pid, force ) ;
-		    if ( !IS_NULL_id ( tid ) ) {
+				if (!IS_id_token(tid)) {
-			pids = TAIL_list ( pids ) ;
+					return (tid);
-			while ( !IS_NULL_list ( pids ) ) {
-			    IDENTIFIER sid ;
+				}
-			    pid = DEREF_id ( HEAD_list ( pids ) ) ;
-			    sid = find_template ( pid, force ) ;
-			    if ( !EQ_id ( sid, tid ) ) return ( NULL_id ) ;
-			    pids = TAIL_list ( pids ) ;
+			}
+			if (force) {
+				t = DEREF_type(id_function_etc_type(id));
+				if (IS_type_templ(t)) {
+					/* Primary template function */
+					return (id);
+				}
+			}
+			break;
+		}
+		case id_ambig_tag: {
+			/* Ambiguous identifiers */
+			LIST(IDENTIFIER) pids;
+			pids = DEREF_list(id_ambig_ids(id));
+			if (!IS_NULL_list(pids)) {
+				IDENTIFIER pid = DEREF_id(HEAD_list(pids));
+				IDENTIFIER tid = find_template(pid, force);
+				if (!IS_NULL_id(tid)) {
+					pids = TAIL_list(pids);
+					while (!IS_NULL_list(pids)) {
+						IDENTIFIER sid;
+						pid = DEREF_id(HEAD_list(pids));
+						sid = find_template(pid, force);
+						if (!EQ_id(sid, tid)) {
+							return (NULL_id);
+						}
+						pids = TAIL_list(pids);
+					}
-			return ( tid ) ;
+					return (tid);
-		    }
+				}
+			}
+			break;
+		}
+		}
-		break ;
-	    }
+	}
-    }
-    return ( NULL_id ) ;
+	return (NULL_id);
 }
 /*
     REDECLARE A TEMPLATE PARAMETER
     This routine checks the template parameter id for redeclarations.
 */
-static IDENTIFIER redecl_templ_param
+static IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+redecl_templ_param(IDENTIFIER id)
-{
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-    MEMBER mem = search_member ( crt_namespace, nm, 1 ) ;
-    IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
-    if ( !IS_NULL_id ( pid ) ) {
-	/* Parameter already defined */
-	report ( crt_loc, ERR_temp_param_dup ( nm ) ) ;
-	nm = lookup_anon () ;
-	id = DEREF_id ( hashid_id ( nm ) ) ;
-    }
-    return ( id ) ;
-}
-/*
-    DECLARE A TEMPLATE TYPE PARAMETER
-    This routine declares a template type parameter named id.
-*/
-IDENTIFIER make_type_param
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+{
+	HASHID nm = DEREF_hashid(id_name(id));
+	MEMBER mem = search_member(crt_namespace, nm, 1);
+	IDENTIFIER pid = DEREF_id(member_id(mem));
-    TOKEN tok ;
+	if (!IS_NULL_id(pid)) {
+		/* Parameter already defined */
-    MAKE_tok_type ( btype_template, NULL_type, tok ) ;
+		report(crt_loc, ERR_temp_param_dup(nm));
-    id = redecl_templ_param ( id ) ;
+		nm = lookup_anon();
-    id = make_token_decl ( tok, 0, id, NULL_id ) ;
+		id = DEREF_id(hashid_id(nm));
+	}
-    return ( id ) ;
+	return (id);
+}
+/*
+    DECLARE A TEMPLATE TYPE PARAMETER
+    This routine declares a template type parameter named id.
+*/
+IDENTIFIER
+make_type_param(IDENTIFIER id)
+{
+	TOKEN tok;
+	MAKE_tok_type(btype_template, NULL_type, tok);
+	id = redecl_templ_param(id);
+	id = make_token_decl(tok, 0, id, NULL_id);
+	return (id);
+}
 /*
     SET A DEFAULT TEMPLATE TYPE ARGUMENT
     This routine sets the default value for the template type parameter id
     to be t.
 */
-void init_type_param
+void
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
+init_type_param(IDENTIFIER id, TYPE t)
+{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
+	COPY_dspec(id_storage(id), (ds & ~dspec_pure));
-    IGNORE define_type_token ( id, t, 0 ) ;
+	IGNORE define_type_token(id, t, 0);
-    COPY_dspec ( id_storage ( id ), ds ) ;
+	COPY_dspec(id_storage(id), ds);
-    return ;
+	return;
+}
 /*
     DECLARE A TEMPLATE EXPRESSION PARAMETER
     This routine declares a template expression parameter named id of
     type t.
 */
-IDENTIFIER make_exp_param
+IDENTIFIER
+make_exp_param(TYPE t, IDENTIFIER id)
+{
+	TOKEN tok;
+	t = rvalue_type(t);
+	MAKE_tok_exp(t, 1, NULL_exp, tok);
+	id = make_token_decl(tok, 0, id, NULL_id);
+	return (id);
+}
+/*
+    SET A DEFAULT TEMPLATE EXPRESSION ARGUMENT
+    This routine sets the default value for the template expression
-    PROTO_N ( ( t, id ) )
+    parameter id to be e.
+*/
+void
-    PROTO_T ( TYPE t X IDENTIFIER id )
+init_exp_param(IDENTIFIER id, EXP e)
+{
-    TOKEN tok ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    t = rvalue_type ( t ) ;
+	COPY_dspec(id_storage(id), (ds & ~dspec_pure));
-    MAKE_tok_exp ( t, 1, NULL_exp, tok ) ;
+	IGNORE define_exp_token(id, e, 1);
-    id = make_token_decl ( tok, 0, id, NULL_id ) ;
+	COPY_dspec(id_storage(id), ds);
-    return ( id ) ;
+	return;
+}
 /*
-    SET A DEFAULT TEMPLATE EXPRESSION ARGUMENT
-    This routine sets the default value for the template expression
-    parameter id to be e.
-*/
-void init_exp_param
-    PROTO_N ( ( id, e ) )
-    PROTO_T ( IDENTIFIER id X EXP e )
-{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-    COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
-    IGNORE define_exp_token ( id, e, 1 ) ;
-    COPY_dspec ( id_storage ( id ), ds ) ;
-    return ;
-}
-/*
     DECLARE A TEMPLATE TEMPLATE PARAMETER
     This routine declares a template template parameter named id of type t.
 */
-IDENTIFIER make_template_param
+IDENTIFIER
-    PROTO_N ( ( t, id ) )
-    PROTO_T ( TYPE t X IDENTIFIER id )
+make_template_param(TYPE t, IDENTIFIER id)
+{
-    TOKEN tok ;
+	TOKEN tok;
-    MAKE_tok_class ( t, NULL_id, tok ) ;
+	MAKE_tok_class(t, NULL_id, tok);
-    id = redecl_templ_param ( id ) ;
+	id = redecl_templ_param(id);
-    id = make_token_decl ( tok, 0, id, NULL_id ) ;
+	id = make_token_decl(tok, 0, id, NULL_id);
-    return ( id ) ;
+	return (id);
+}
 /*
     SET A TEMPLATE TEMPLATE ARGUMENT
     This routine sets the value for the template template parameter id to
     be tid.  This is used both to set a default argument value and to
     define a template template parameter.
 */
-void init_template_param
+void
-    PROTO_N ( ( id, tid ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER tid )
+init_template_param(IDENTIFIER id, IDENTIFIER tid)
 {
-    if ( !IS_NULL_id ( tid ) ) {
+	if (!IS_NULL_id(tid)) {
-	if ( IS_id_class_name_etc ( tid ) ) {
+		if (IS_id_class_name_etc(tid)) {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
+			COPY_dspec(id_storage(id), (ds & ~dspec_pure));
-	    IGNORE define_templ_token ( id, tid ) ;
+			IGNORE define_templ_token(id, tid);
-	    COPY_dspec ( id_storage ( id ), ds ) ;
+			COPY_dspec(id_storage(id), ds);
-	} else {
+		} else {
-	    report ( crt_loc, ERR_temp_arg_templ_not ( id, tid ) ) ;
+			report(crt_loc, ERR_temp_arg_templ_not(id, tid));
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     LIST OF DUMMY TYPE PARAMETERS
     This list is used to store all the dummy type parameters created by
     make_dummy_type to avoid duplicates.
 */
-static LIST ( IDENTIFIER ) dummy_types = NULL_list ( IDENTIFIER ) ;
+static LIST(IDENTIFIER) dummy_types = NULL_list(IDENTIFIER);
 /*
     CREATE A DUMMY TYPE PARAMETER
     This routine creates a dummy type parameter named id in the namespace
     ns.  bt gives the token type kind.
 */
+static TYPE
+make_dummy_type(NAMESPACE ns, IDENTIFIER id, BASE_TYPE bt, LIST(TOKEN) args)
+{
+	TYPE t;
+	HASHID nm = DEREF_hashid(id_name(id));
+	LIST(IDENTIFIER) p = dummy_types;
+	while (!IS_NULL_list(p)) {
+		IDENTIFIER pid = DEREF_id(HEAD_list(p));
+		HASHID pnm = DEREF_hashid(id_name(pid));
+		NAMESPACE pns = DEREF_nspace(id_parent(pid));
+		if (EQ_hashid(nm, pnm) && EQ_nspace(ns, pns)) {
+			TOKEN tok = DEREF_tok(id_token_sort(pid));
+			BASE_TYPE pt = DEREF_btype(tok_type_kind(tok));
+			if (bt == pt) {
+				id = pid;
+				break;
+			}
+		}
+		p = TAIL_list(p);
+	}
+	if (IS_NULL_list(p)) {
+		/* Create new parameter */
+		TOKEN tok;
+		DECL_SPEC ds = (dspec_template | dspec_token | dspec_auto |
+				dspec_pure | dspec_implicit);
+		MAKE_tok_type(bt, NULL_type, tok);
+		MAKE_id_token(nm, ds, ns, crt_loc, tok, NULL_id, id);
+		COPY_id(id_token_alt(id), id);
+		CONS_id(id, dummy_types, dummy_types);
+	}
+	MAKE_type_token(cv_none, id, args, t);
+	return (t);
+}
+/*
+    DOES A TYPE REPRESENT A TEMPLATE SPECIALISATION?
-static TYPE make_dummy_type
+    This routine checks whether the type t represents an explicit template
-    PROTO_N ( ( ns, id, bt, args ) )
+    specialisation or instantiation.
-    PROTO_T ( NAMESPACE ns X IDENTIFIER id X BASE_TYPE bt X
+*/
+int
-	      LIST ( TOKEN ) args )
+is_templ_spec(TYPE t)
+{
-    TYPE t ;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	while (!IS_NULL_type(t) && IS_type_templ(t)) {
-    LIST ( IDENTIFIER ) p = dummy_types ;
+		LIST(IDENTIFIER) pids;
-    while ( !IS_NULL_list ( p ) ) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
-	HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
-	NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
-	if ( EQ_hashid ( nm, pnm ) && EQ_nspace ( ns, pns ) ) {
-	    TOKEN tok = DEREF_tok ( id_token_sort ( pid ) ) ;
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
-	    BASE_TYPE pt = DEREF_btype ( tok_type_kind ( tok ) ) ;
+		pids = DEREF_list(tok_templ_pids(sort));
-	    if ( bt == pt ) {
+		if (IS_NULL_list(pids)) {
-		id = pid ;
-		break ;
+			return (1);
-	    }
+		}
+		t = DEREF_type(type_templ_defn(t));
+	}
-	p = TAIL_list ( p ) ;
-    }
-    if ( IS_NULL_list ( p ) ) {
-	/* Create new parameter */
-	TOKEN tok ;
-	DECL_SPEC ds = ( dspec_template | dspec_token | dspec_auto |
-			 dspec_pure | dspec_implicit ) ;
-	MAKE_tok_type ( bt, NULL_type, tok ) ;
-	MAKE_id_token ( nm, ds, ns, crt_loc, tok, NULL_id, id ) ;
-	COPY_id ( id_token_alt ( id ), id ) ;
-	CONS_id ( id, dummy_types, dummy_types ) ;
-    }
-    MAKE_type_token ( cv_none, id, args, t ) ;
-    return ( t ) ;
-}
-/*
-    DOES A TYPE REPRESENT A TEMPLATE SPECIALISATION?
-    This routine checks whether the type t represents an explicit template
-    specialisation or instantiation.
-*/
-int is_templ_spec
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
-{
-    while ( !IS_NULL_type ( t ) && IS_type_templ ( t ) ) {
-	LIST ( IDENTIFIER ) pids ;
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
-	pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-	if ( IS_NULL_list ( pids ) ) return ( 1 ) ;
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     IS A TYPE A TEMPLATE PARAMETER?
     This routine checks whether the type t represents a template parameter
     and a template declaration is currently being processed.
 */
-int is_templ_type
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+is_templ_type(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
+	if (!IS_NULL_type(t) && IS_type_token(t)) {
-	IDENTIFIER id = DEREF_id ( type_token_tok ( t ) ) ;
+		IDENTIFIER id = DEREF_id(type_token_tok(t));
+		if (is_templ_param(id)) {
-	if ( is_templ_param ( id ) ) return ( in_template_decl ) ;
+			return (in_template_decl);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES A TYPE DEPEND ON A TEMPLATE TYPE PARAMETER?
     This routine checks whether the type t is dependent on any template
     parameter.
 */
-int is_templ_depend
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+is_templ_depend(TYPE t)
 {
-    if ( in_template_decl ) {
+	if (in_template_decl) {
-	/* Only need to check in a template declaration */
+		/* Only need to check in a template declaration */
-	return ( depends_on ( t, any_templ_param ) ) ;
+		return (depends_on(t, any_templ_param));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     IS AN IDENTIFIER A TEMPLATE TYPE PARAMETER?
     This routine checks whether the token identifier id represents a
     template type parameter.
 */
-int is_templ_param
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_templ_param(IDENTIFIER id)
+{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( ( ds & dspec_template ) && ( ds & dspec_auto ) ) return ( 1 ) ;
+	if ((ds & dspec_template) && (ds & dspec_auto)) {
+		return (1);
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     IS AN IDENTIFIER AN ALIAS FOR A TEMPLATE TYPE PARAMETER?
     This routine checks whether the identifier id is the internal name
     for a template type parameter.
 */
-int is_templ_alias
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_templ_alias(IDENTIFIER id)
+{
-    unsigned tag = TAG_id ( id ) ;
+	unsigned tag = TAG_id(id);
-    if ( tag == id_type_alias_tag ) {
+	if (tag == id_type_alias_tag) {
-	TYPE t = DEREF_type ( id_type_alias_defn ( id ) ) ;
+		TYPE t = DEREF_type(id_type_alias_defn(id));
-	if ( IS_type_token ( t ) ) {
+		if (IS_type_token(t)) {
-	    id = DEREF_id ( type_token_tok ( t ) ) ;
+			id = DEREF_id(type_token_tok(t));
-	    tag = TAG_id ( id ) ;
+			tag = TAG_id(id);
+		}
+	} else if (tag == id_token_tag) {
+		id = DEREF_id(id_token_alt(id));
+		tag = TAG_id(id);
+	}
+	if (tag == id_token_tag && is_templ_param(id)) {
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		if (!(ds & dspec_implicit)) {
+			return (1);
+		}
+	}
-    } else if ( tag == id_token_tag ) {
-	id = DEREF_id ( id_token_alt ( id ) ) ;
-	tag = TAG_id ( id ) ;
-    }
-    if ( tag == id_token_tag && is_templ_param ( id ) ) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	if ( !( ds & dspec_implicit ) ) return ( 1 ) ;
-    }
-    return ( 0 ) ;
+	return (0);
 }
 /*
     IS AN IDENTIFIER A TEMPLATE DECLARATOR?
     This routine checks whether the declarator id represents a template
     instance.  If id is a function declaration then t gives the function
     type.
 */
-int is_templ_decl
+int
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
+is_templ_decl(IDENTIFIER id, TYPE t)
 {
-    if ( crt_templ_qualifier ) {
+	if (crt_templ_qualifier) {
-	/* Declaration is a template-id */
+		/* Declaration is a template-id */
-	IDENTIFIER tid = find_template ( id, 0 ) ;
+		IDENTIFIER tid = find_template(id, 0);
-	if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
+		if (!IS_NULL_id(tid)) {
+			return (1);
-    }
+		}
+	}
-    if ( !IS_NULL_type ( t ) && crt_id_qualifier != qual_none ) {
+	if (!IS_NULL_type(t) && crt_id_qualifier != qual_none) {
-	/* Function declarator is a qualified-id */
+		/* Function declarator is a qualified-id */
-	int eq = 0 ;
+		int eq = 0;
-	LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+		LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);
-	IDENTIFIER pid = resolve_func ( id, t, 1, 1, pids, &eq ) ;
+		IDENTIFIER pid = resolve_func(id, t, 1, 1, pids, &eq);
-	if ( !IS_NULL_id ( pid ) ) {
+		if (!IS_NULL_id(pid)) {
-	    IDENTIFIER tid = find_template ( pid, 0 ) ;
+			IDENTIFIER tid = find_template(pid, 0);
-	    if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
+			if (!IS_NULL_id(tid)) {
+				return (1);
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     IS A NAMESPACE A TEMPLATE CLASS?
     This routine checks whether the namespace ns represents a template
     class or a nested class of a template class or a block of a template
     function.
 */
-int is_templ_nspace
+int
-    PROTO_N ( ( ns ) )
-    PROTO_T ( NAMESPACE ns )
+is_templ_nspace(NAMESPACE ns)
 {
-    while ( !IS_NULL_nspace ( ns ) ) {
+	while (!IS_NULL_nspace(ns)) {
-	IDENTIFIER tid ;
+		IDENTIFIER tid;
-	IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
+		IDENTIFIER id = DEREF_id(nspace_name(ns));
-	if ( IS_NULL_id ( id ) ) break ;
+		if (IS_NULL_id(id)) {
+			break;
+		}
-	tid = find_template ( id, 1 ) ;
+		tid = find_template(id, 1);
-	if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
+		if (!IS_NULL_id(tid)) {
+			return (1);
+		}
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
+		ns = DEREF_nspace(id_parent(id));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     CHECK A TYPENAME
     This routine checks whether 'typename ns::id' can be used to declare
     a type.  If so this type is returned, otherwise the null type is
     returned.  Any following template arguments are dealt with in this
     routine.
 */
-TYPE check_typename
+TYPE
-    PROTO_N ( ( ns, id, key ) )
-    PROTO_T ( NAMESPACE ns X IDENTIFIER id X BASE_TYPE key )
+check_typename(NAMESPACE ns, IDENTIFIER id, BASE_TYPE key)
 {
-    TYPE s = NULL_type ;
+	TYPE s = NULL_type;
-    if ( in_template_decl ) {
+	if (in_template_decl) {
-	if ( !IS_NULL_nspace ( ns ) && IS_nspace_ctype ( ns ) ) {
+		if (!IS_NULL_nspace(ns) && IS_nspace_ctype(ns)) {
-	    IDENTIFIER tid = DEREF_id ( nspace_name ( ns ) ) ;
+			IDENTIFIER tid = DEREF_id(nspace_name(ns));
-	    TYPE t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
+			TYPE t = DEREF_type(id_class_name_etc_defn(tid));
-	    while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		/* Step over any template qualifiers */
+				/* Step over any template qualifiers */
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-	    }
+			}
-	    if ( is_templ_depend ( t ) ) {
+			if (is_templ_depend(t)) {
-		/* Qualifier depends on a template parameter */
+				/* Qualifier depends on a template parameter */
-		int templ = 0 ;
+				int templ = 0;
-		LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
+				LIST(TOKEN) args = NULL_list(TOKEN);
-		if ( crt_lex_token == lex_less ) {
+				if (crt_lex_token == lex_less) {
-		    /* Step over template arguments */
+					/* Step over template arguments */
+					PPTOKEN *p =
-		    PPTOKEN *p = skip_template_args ( NULL_id, 1 ) ;
+					    skip_template_args(NULL_id, 1);
-		    args = parse_template_args ( p ) ;
+					args = parse_template_args(p);
-		    templ = 1 ;
+					templ = 1;
-		}
+				}
-		if ( IS_id_class_name_etc ( id ) ) {
+				if (IS_id_class_name_etc(id)) {
-		    if ( templ ) {
+					if (templ) {
-			/* Apply template arguments */
+						/* Apply template arguments */
-			id = apply_template ( id, args, 0, 0 ) ;
+						id = apply_template(id, args,
+, 0);
-		    }
+					}
-		    s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+					s = DEREF_type(id_class_name_etc_defn(id));
-		    if ( IS_type_templ ( s ) ) {
+					if (IS_type_templ(s)) {
-			s = deduce_type_template ( id, 1 ) ;
+						s = deduce_type_template(id, 1);
-		    }
+					}
-		    s = copy_typedef ( id, s, cv_none ) ;
+					s = copy_typedef(id, s, cv_none);
-		    COPY_id ( type_name ( s ), id ) ;
+					COPY_id(type_name(s), id);
-		    use_id ( id, 0 ) ;
+					use_id(id, 0);
-		} else {
+				} else {
-		    BASE_TYPE bt = ( btype_template | btype_typename ) ;
+					BASE_TYPE bt = (btype_template |
+							btype_typename);
+					if (templ) {
-		    if ( templ ) bt |= btype_args ;
+						bt |= btype_args;
+					}
-		    s = make_dummy_type ( ns, id, bt, args ) ;
+					s = make_dummy_type(ns, id, bt, args);
-		    if ( key != btype_none ) {
+					if (key != btype_none) {
-			/* Result should be a class */
+						/* Result should be a class */
-			id = DEREF_id ( type_token_tok ( s ) ) ;
+						id = DEREF_id(type_token_tok(s));
-			args = NULL_list ( TOKEN ) ;
+						args = NULL_list(TOKEN);
-			s = make_dummy_class ( id, args, key ) ;
+						s = make_dummy_class(id, args,
+								     key);
-		    }
+					}
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ( s ) ;
+	return (s);
+}
 /*
     DECLARE A TYPENAME
     This routine handles a type declared using typename.  ns gives the
     name qualifiers used in the declaration and id gives the actual member
     name.  Any following template arguments are dealt with in this
     routine.
 */
-TYPE make_typename
+TYPE
-    PROTO_N ( ( ns, id ) )
-    PROTO_T ( NAMESPACE ns X IDENTIFIER id )
+make_typename(NAMESPACE ns, IDENTIFIER id)
 {
-    TYPE s = check_typename ( ns, id, btype_none ) ;
+	TYPE s = check_typename(ns, id, btype_none);
-    if ( IS_NULL_type ( s ) ) {
+	if (IS_NULL_type(s)) {
-	int templ = 0 ;
+		int templ = 0;
-	LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
+		LIST(TOKEN) args = NULL_list(TOKEN);
-	report ( crt_loc, ERR_temp_res_qual () ) ;
+		report(crt_loc, ERR_temp_res_qual());
-	if ( crt_lex_token == lex_less ) {
+		if (crt_lex_token == lex_less) {
-	    /* Step over template arguments */
+			/* Step over template arguments */
-	    PPTOKEN *p = skip_template_args ( NULL_id, 1 ) ;
+			PPTOKEN *p = skip_template_args(NULL_id, 1);
-	    args = parse_template_args ( p ) ;
+			args = parse_template_args(p);
-	    templ = 1 ;
+			templ = 1;
-	}
+		}
-	if ( IS_id_class_name_etc ( id ) ) {
+		if (IS_id_class_name_etc(id)) {
-	    /* Name denotes a type - return that */
+			/* Name denotes a type - return that */
-	    if ( templ ) {
+			if (templ) {
-		/* Apply template arguments */
+				/* Apply template arguments */
-		id = apply_template ( id, args, 0, 0 ) ;
+				id = apply_template(id, args, 0, 0);
-	    }
+			}
-	    s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+			s = DEREF_type(id_class_name_etc_defn(id));
-	    if ( IS_type_templ ( s ) ) {
+			if (IS_type_templ(s)) {
-		s = deduce_type_template ( id, 1 ) ;
+				s = deduce_type_template(id, 1);
-	    }
+			}
-	    s = copy_typedef ( id, s, cv_none ) ;
+			s = copy_typedef(id, s, cv_none);
-	    COPY_id ( type_name ( s ), id ) ;
+			COPY_id(type_name(s), id);
-	    use_id ( id, 0 ) ;
+			use_id(id, 0);
-	} else {
+		} else {
-	    /* Return the error type */
+			/* Return the error type */
-	    s = type_error ;
+			s = type_error;
-	}
+		}
-    }
+	}
-    return ( s ) ;
+	return (s);
 }
 /*
     LIST OF BAD TYPENAMES
     Without some action, an illegal typename can be reported many times.
     A list of all bad typename look-ups is maintained so that the error is
     only reported once.
 */
-static LIST ( IDENTIFIER ) non_typenames = NULL_list ( IDENTIFIER ) ;
+static LIST(IDENTIFIER) non_typenames = NULL_list(IDENTIFIER);
 /*
     FIND THE TYPE GIVEN BY A TYPENAME
     This routine expands the type name id.  If no expansion is possible
     then the null type is returned.  type indicates whether the look-up
     should be for a type name or an object name (the latter is used when
     searching for a type previously declared using typename).
 */
-TYPE find_typename
+TYPE
-    PROTO_N ( ( id, args, bt, type ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X BASE_TYPE bt X int type )
+find_typename(IDENTIFIER id, LIST(TOKEN) args, BASE_TYPE bt, int type)
+{
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+	NAMESPACE ns = DEREF_nspace(id_parent(id));
-    NAMESPACE cns = rescan_nspace ( ns ) ;
+	NAMESPACE cns = rescan_nspace(ns);
-    if ( !EQ_nspace ( cns, ns ) ) {
+	if (!EQ_nspace(cns, ns)) {
-	/* Rescan type name */
+		/* Rescan type name */
-	LIST ( IDENTIFIER ) p ;
+		LIST(IDENTIFIER) p;
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		HASHID nm = DEREF_hashid(id_name(id));
-	IDENTIFIER tid = search_field ( cns, nm, 0, type ) ;
+		IDENTIFIER tid = search_field(cns, nm, 0, type);
-	if ( !IS_NULL_id ( tid ) && IS_id_class_name_etc ( tid ) ) {
+		if (!IS_NULL_id(tid) && IS_id_class_name_etc(tid)) {
-	    /* Type name */
+			/* Type name */
-	    if ( bt & btype_args ) {
+			if (bt & btype_args) {
-		/* Apply template arguments */
+				/* Apply template arguments */
-		tid = apply_template ( tid, args, 0, 0 ) ;
+				tid = apply_template(tid, args, 0, 0);
-	    }
+			}
-	    t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
+			t = DEREF_type(id_class_name_etc_defn(tid));
-	    if ( IS_type_templ ( t ) ) {
+			if (IS_type_templ(t)) {
-		t = deduce_type_template ( tid, 1 ) ;
+				t = deduce_type_template(tid, 1);
-	    }
+			}
-	    t = copy_typedef ( tid, t, cv_none ) ;
+			t = copy_typedef(tid, t, cv_none);
-	    COPY_id ( type_name ( t ), tid ) ;
+			COPY_id(type_name(t), tid);
-	    use_id ( tid, 0 ) ;
+			use_id(tid, 0);
-	    return ( t ) ;
+			return (t);
-	}
+		}
-	/* Check for template parameters */
+		/* Check for template parameters */
-	if ( in_template_decl ) {
+		if (in_template_decl) {
-	    if ( !IS_NULL_nspace ( cns ) && IS_nspace_ctype ( cns ) ) {
+			if (!IS_NULL_nspace(cns) && IS_nspace_ctype(cns)) {
-		tid = DEREF_id ( nspace_name ( cns ) ) ;
+				tid = DEREF_id(nspace_name(cns));
-		t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
+				t = DEREF_type(id_class_name_etc_defn(tid));
-		while ( IS_type_templ ( t ) ) {
+				while (IS_type_templ(t)) {
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+					t = DEREF_type(type_templ_defn(t));
+				}
+				if (is_templ_depend(t)) {
+					t = make_dummy_type(cns, id, bt, args);
+					return (t);
+				}
+			}
+		}
+		/* Report error */
+		p = non_typenames;
+		t = type_error;
+		while (!IS_NULL_list(p)) {
+			IDENTIFIER pid = DEREF_id(HEAD_list(p));
+			HASHID pnm = DEREF_hashid(id_name(pid));
+			NAMESPACE pns = DEREF_nspace(id_parent(pid));
+			if (EQ_hashid(pnm, nm) && EQ_nspace(pns, cns)) {
+				/* Already reported */
+				break;
+			}
+		}
+		if (IS_NULL_list(p)) {
+			/* Report undefined type */
+			MAKE_id_type_alias(nm, dspec_none, cns, crt_loc, t,
+					   tid);
+			CONS_id(tid, non_typenames, non_typenames);
+			report(crt_loc, ERR_temp_res_type(cns, nm));
+		}
-		if ( is_templ_depend ( t ) ) {
-		    t = make_dummy_type ( cns, id, bt, args ) ;
-		    return ( t ) ;
-		}
-	    }
-	}
-	/* Report error */
-	p = non_typenames ;
-	t = type_error ;
-	while ( !IS_NULL_list ( p ) ) {
-	    IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
-	    HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
-	    NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
-	    if ( EQ_hashid ( pnm, nm ) && EQ_nspace ( pns, cns ) ) {
-		/* Already reported */
-		break ;
-	    }
-	}
-	if ( IS_NULL_list ( p ) ) {
-	    /* Report undefined type */
-	    MAKE_id_type_alias ( nm, dspec_none, cns, crt_loc, t, tid ) ;
-	    CONS_id ( tid, non_typenames, non_typenames ) ;
-	    report ( crt_loc, ERR_temp_res_type ( cns, nm ) ) ;
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     IDENTIFY TWO LISTS OF TEMPLATE PARAMETERS
     This routine identifies the list of template parameters ps with those
     in pt, returning true if this is possible.
 */
-int eq_templ_params
+int
-    PROTO_N ( ( ps, pt ) )
-    PROTO_T ( LIST ( IDENTIFIER ) ps X LIST ( IDENTIFIER ) pt )
+eq_templ_params(LIST(IDENTIFIER) ps, LIST(IDENTIFIER) pt)
+{
-    int ok = 1 ;
+	int ok = 1;
-    while ( !IS_NULL_list ( ps ) && !IS_NULL_list ( pt ) ) {
+	while (!IS_NULL_list(ps) && !IS_NULL_list(pt)) {
-	IDENTIFIER is = DEREF_id ( HEAD_list ( ps ) ) ;
+		IDENTIFIER is = DEREF_id(HEAD_list(ps));
-	IDENTIFIER it = DEREF_id ( HEAD_list ( pt ) ) ;
+		IDENTIFIER it = DEREF_id(HEAD_list(pt));
-	if ( !EQ_id ( is, it ) ) {
+		if (!EQ_id(is, it)) {
-	    TOKEN ns, nt ;
+			TOKEN ns, nt;
-	    unsigned vs, vt ;
+			unsigned vs, vt;
-	    if ( IS_NULL_id ( is ) ) return ( 0 ) ;
+			if (IS_NULL_id(is)) {
+				return (0);
+			}
-	    if ( IS_NULL_id ( it ) ) return ( 0 ) ;
+			if (IS_NULL_id(it)) {
+				return (0);
+			}
-	    ns = DEREF_tok ( id_token_sort ( is ) ) ;
+			ns = DEREF_tok(id_token_sort(is));
-	    nt = DEREF_tok ( id_token_sort ( it ) ) ;
+			nt = DEREF_tok(id_token_sort(it));
-	    vs = TAG_tok ( ns ) ;
+			vs = TAG_tok(ns);
-	    vt = TAG_tok ( nt ) ;
+			vt = TAG_tok(nt);
-	    if ( vs != vt ) {
+			if (vs != vt) {
-		/* Parameter sorts should be equal */
+				/* Parameter sorts should be equal */
-		ok = 0 ;
+				ok = 0;
-		break ;
+				break;
-	    }
+			}
-	    if ( vs == tok_exp_tag ) {
+			if (vs == tok_exp_tag) {
-		/* Check expression parameter types */
+				/* Check expression parameter types */
-		TYPE rs = DEREF_type ( tok_exp_type ( ns ) ) ;
+				TYPE rs = DEREF_type(tok_exp_type(ns));
-		TYPE rt = DEREF_type ( tok_exp_type ( nt ) ) ;
+				TYPE rt = DEREF_type(tok_exp_type(nt));
-		rs = expand_type ( rs, 2 ) ;
+				rs = expand_type(rs, 2);
-		if ( eq_type ( rs, rt ) != 1 ) {
+				if (eq_type(rs, rt)!= 1) {
+					ok = 0;
+					break;
+				}
+			}
+			if (vs == tok_class_tag) {
+				/* Check template class parameter types */
+				TYPE rs = DEREF_type(tok_class_type(ns));
+				TYPE rt = DEREF_type(tok_class_type(nt));
+				rs = expand_type(rs, 2);
+				if (eq_template(rs, rt, 0, 1, 0) != 3) {
-		    ok = 0 ;
+					ok = 0;
-		    break ;
+					break;
+				}
+			}
+			it = DEREF_id(id_alias(it));
+			COPY_id(id_alias(is), it);
+		}
-	    }
-	    if ( vs == tok_class_tag ) {
+		pt = TAIL_list(pt);
-		/* Check template class parameter types */
-		TYPE rs = DEREF_type ( tok_class_type ( ns ) ) ;
-		TYPE rt = DEREF_type ( tok_class_type ( nt ) ) ;
-		rs = expand_type ( rs, 2 ) ;
+		ps = TAIL_list(ps);
-		if ( eq_template ( rs, rt, 0, 1, 0 ) != 3 ) {
-		    ok = 0 ;
-		    break ;
-		}
+	}
-	    }
-	    it = DEREF_id ( id_alias ( it ) ) ;
+	if (!EQ_list(ps, pt)) {
-	    COPY_id ( id_alias ( is ), it ) ;
+		ok = 0;
+	}
-	pt = TAIL_list ( pt ) ;
-	ps = TAIL_list ( ps ) ;
-    }
-    if ( !EQ_list ( ps, pt ) ) ok = 0 ;
-    return ( ok ) ;
+	return (ok);
+}
 /*
     RESTORE A LIST OF TEMPLATE PARAMETERS
     This routine clears the aliases set up by eq_templ_param from the
     list of template parameters ps.
 */
-void restore_templ_params
+void
-    PROTO_N ( ( ps ) )
-    PROTO_T ( LIST ( IDENTIFIER ) ps )
+restore_templ_params(LIST(IDENTIFIER)ps)
+{
-    while ( !IS_NULL_list ( ps ) ) {
+	while (!IS_NULL_list(ps)) {
-	IDENTIFIER is = DEREF_id ( HEAD_list ( ps ) ) ;
+		IDENTIFIER is = DEREF_id(HEAD_list(ps));
-	COPY_id ( id_alias ( is ), is ) ;
+		COPY_id(id_alias(is), is);
-	ps = TAIL_list ( ps ) ;
+		ps = TAIL_list(ps);
-    }
+	}
-    return ;
+	return;
 }
 /*
     CHECK FOR TEMPLATE TYPE EQUALITY
     This routine checks whether the template types s and t are equal
     under a simple renaming of template parameters.  If def is false
     only the template parameters (and not the underlying type) are checked.
     mq and rf are as in eq_func_type, as is the return value.
 */
-int eq_template
+int
-    PROTO_N ( ( s, t, def, mq, rf ) )
-    PROTO_T ( TYPE s X TYPE t X int def X int mq X int rf )
+eq_template(TYPE s, TYPE t, int def, int mq, int rf)
 {
-    TOKEN as = DEREF_tok ( type_templ_sort ( s ) ) ;
+	TOKEN as = DEREF_tok(type_templ_sort(s));
-    TOKEN at = DEREF_tok ( type_templ_sort ( t ) ) ;
+	TOKEN at = DEREF_tok(type_templ_sort(t));
-    LIST ( IDENTIFIER ) ps = DEREF_list ( tok_templ_pids ( as ) ) ;
+	LIST(IDENTIFIER) ps = DEREF_list(tok_templ_pids(as));
-    LIST ( IDENTIFIER ) pt = DEREF_list ( tok_templ_pids ( at ) ) ;
+	LIST(IDENTIFIER) pt = DEREF_list(tok_templ_pids(at));
-    int eq = eq_templ_params ( ps, pt ) ;
+	int eq = eq_templ_params(ps, pt);
-    if ( eq && def ) {
+	if (eq && def) {
-	/* Check for equality of definitions */
+		/* Check for equality of definitions */
-	int ft = force_template ;
+		int ft = force_template;
-	TYPE ds = DEREF_type ( type_templ_defn ( s ) ) ;
+		TYPE ds = DEREF_type(type_templ_defn(s));
-	TYPE dt = DEREF_type ( type_templ_defn ( t ) ) ;
+		TYPE dt = DEREF_type(type_templ_defn(t));
-	force_template = 0 ;
+		force_template = 0;
-	eq = eq_func_type ( ds, dt, mq, rf ) ;
+		eq = eq_func_type(ds, dt, mq, rf);
-	force_template = ft ;
+		force_template = ft;
-    }
+	}
-    restore_templ_params ( ps ) ;
+	restore_templ_params(ps);
-    return ( eq ) ;
+	return (eq);
 }
 /*
     RENAME TEMPLATE PARAMETERS IN A TYPE
     This routine renames the parameters in the given template sort,
     returning the template type formed by applying this renaming to t.
 */
-static TYPE rename_templ_params
+static TYPE
-    PROTO_N ( ( sort, t, rec ) )
-    PROTO_T ( TOKEN sort X TYPE t X int rec )
+rename_templ_params(TOKEN sort, TYPE t, int rec)
-{
-    if ( rec ) {
-	int d ;
-	LIST ( TOKEN ) args ;
-	LIST ( IDENTIFIER ) pids ;
-	LIST ( IDENTIFIER ) qids ;
-	pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-	sort = expand_sort ( sort, 1, 1 ) ;
-	qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-	args = make_primary_args ( qids ) ;
-	d = save_token_args ( pids, args ) ;
-	t = expand_type ( t, 1 ) ;
-	restore_token_args ( pids, d ) ;
-    }
-    MAKE_type_templ ( cv_none, sort, t, 1, t ) ;
-    return ( t ) ;
-}
-/*
-    CHECK FOR TEMPLATE TYPE SPECIALISATION
-    This routine checks whether the type t is a specialisation of the
-    template type s.  Type qualifiers are ignored if qu is false.
-*/
-int deduce_template
-    PROTO_N ( ( s, t, qu ) )
-    PROTO_T ( TYPE s X TYPE t X int qu )
+{
+	if (rec) {
-    int eq ;
+		int d;
-    TYPE r = DEREF_type ( type_templ_defn ( s ) ) ;
-    TOKEN sort = DEREF_tok ( type_templ_sort ( s ) ) ;
+		LIST(TOKEN) args;
-    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
+		LIST(IDENTIFIER) pids;
-    if ( in_template_decl && depends_on ( t, pids ) ) {
-	/* Rename parameters if necessary */
+		LIST(IDENTIFIER) qids;
-	CV_SPEC cv = DEREF_cv ( type_qual ( s ) ) ;
+		pids = DEREF_list(tok_templ_pids(sort));
-	s = rename_templ_params ( sort, r, 1 ) ;
+		sort = expand_sort(sort, 1, 1);
-	COPY_cv ( type_qual ( s ), cv ) ;
-	eq = deduce_template ( s, t, qu ) ;
+		qids = DEREF_list(tok_templ_pids(sort));
-    } else {
-	/* Perform argument deduction */
+		args = make_primary_args(qids);
-	int d ;
-	force_template++ ;
-	d = save_token_args ( pids, NULL_list ( TOKEN ) ) ;
+		d = save_token_args(pids, args);
-	eq = eq_type_qual ( r, t, qu ) ;
-	if ( eq == 3 ) eq = 0 ;
+		t = expand_type(t, 1);
-	restore_token_args ( pids, d ) ;
+		restore_token_args(pids, d);
-	force_template-- ;
-    }
+	}
+	MAKE_type_templ(cv_none, sort, t, 1, t);
-    return ( eq ) ;
+	return (t);
+}
 /*
+    CHECK FOR TEMPLATE TYPE SPECIALISATION
+    This routine checks whether the type t is a specialisation of the
+    template type s.  Type qualifiers are ignored if qu is false.
+*/
+int
+deduce_template(TYPE s, TYPE t, int qu)
+{
+	int eq;
+	TYPE r = DEREF_type(type_templ_defn(s));
+	TOKEN sort = DEREF_tok(type_templ_sort(s));
+	LIST(IDENTIFIER) pids = DEREF_list(tok_templ_pids(sort));
+	if (in_template_decl && depends_on(t, pids)) {
+		/* Rename parameters if necessary */
+		CV_SPEC cv = DEREF_cv(type_qual(s));
+		s = rename_templ_params(sort, r, 1);
+		COPY_cv(type_qual(s), cv);
+		eq = deduce_template(s, t, qu);
+	} else {
+		/* Perform argument deduction */
+		int d;
+		force_template++;
+		d = save_token_args(pids, NULL_list(TOKEN));
+		eq = eq_type_qual(r, t, qu);
+		if (eq == 3) {
+			eq = 0;
+		}
+		restore_token_args(pids, d);
+		force_template--;
+	}
+	return (eq);
+}
+/*
     REDECLARE A TEMPLATE TYPE
     This routine checks the redeclaration of the template id of type ps to
     have type pt.  The primary purpose of this is to check for default
     arguments in the redeclaration.  The non-template components are
     returned via ps and pt.
 */
-void redecl_template
+void
-    PROTO_N ( ( ps, pt, id ) )
-    PROTO_T ( TYPE *ps X TYPE *pt X IDENTIFIER id )
+redecl_template(TYPE *ps, TYPE *pt, IDENTIFIER id)
 {
-    TYPE s = *ps ;
+	TYPE s = *ps;
-    TYPE t = *pt ;
+	TYPE t = *pt;
-    while ( IS_type_templ ( s ) ) {
+	while (IS_type_templ(s)) {
-	s = DEREF_type ( type_templ_defn ( s ) ) ;
+		s = DEREF_type(type_templ_defn(s));
-    }
-    while ( IS_type_templ ( t ) ) {
-	TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
-	DECL_SPEC use = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
-	if ( use & dspec_extern ) export_template ( id, 1 ) ;
-	if ( check_templ_dargs ( t ) ) {
-	    /* Can't have default arguments in redeclaration */
-	    report ( decl_loc, ERR_temp_param_redecl () ) ;
+	}
+	while (IS_type_templ(t)) {
+		TOKEN sort = DEREF_tok(type_templ_sort(t));
+		DECL_SPEC use = DEREF_dspec(tok_templ_usage(sort));
+		if (use & dspec_extern) {
+			export_template(id, 1);
+		}
+		if (check_templ_dargs(t)) {
+			/* Can't have default arguments in redeclaration */
+			report(decl_loc, ERR_temp_param_redecl());
+		}
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
+		t = DEREF_type(type_templ_defn(t));
-    }
+	}
-    *pt = t ;
+	*pt = t;
-    *ps = s ;
+	*ps = s;
-    return ;
+	return;
+}
 /*
     RESET THE PRIMARY FORM OF A TEMPLATE
     This routine changes the primary representation of a template from
     s to t.  This is done when, for example, the latter is a definition
     while the former is only a declaration.
 */
-void reset_primary_templ
+void
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( TYPE s X TYPE t )
+reset_primary_templ(TYPE s, TYPE t)
 {
-    unsigned ns = TAG_type ( s ) ;
+	unsigned ns = TAG_type(s);
-    unsigned nt = TAG_type ( t ) ;
+	unsigned nt = TAG_type(t);
-    while ( ns == type_templ_tag && nt == type_templ_tag ) {
+	while (ns == type_templ_tag && nt == type_templ_tag) {
-	TOKEN as = DEREF_tok ( type_templ_sort ( s ) ) ;
+		TOKEN as = DEREF_tok(type_templ_sort(s));
-	TOKEN at = DEREF_tok ( type_templ_sort ( t ) ) ;
+		TOKEN at = DEREF_tok(type_templ_sort(t));
-	LIST ( IDENTIFIER ) ps = DEREF_list ( tok_templ_pids ( as ) ) ;
+		LIST(IDENTIFIER) ps = DEREF_list(tok_templ_pids(as));
-	LIST ( IDENTIFIER ) pt = DEREF_list ( tok_templ_pids ( at ) ) ;
+		LIST(IDENTIFIER) pt = DEREF_list(tok_templ_pids(at));
-	INSTANCE apps = DEREF_inst ( tok_templ_apps ( as ) ) ;
+		INSTANCE apps = DEREF_inst(tok_templ_apps(as));
-	INSTANCE app = apps ;
+		INSTANCE app = apps;
-	LIST ( TOKEN ) dargs = DEREF_list ( tok_templ_dargs ( as ) ) ;
+		LIST(TOKEN) dargs = DEREF_list(tok_templ_dargs(as));
-	while ( !IS_NULL_inst ( app ) ) {
+		while (!IS_NULL_inst(app)) {
-	    DECL_SPEC ds = DEREF_dspec ( inst_templ_access ( app ) ) ;
+			DECL_SPEC ds = DEREF_dspec(inst_templ_access(app));
-	    if ( ds & dspec_main ) {
+			if (ds & dspec_main) {
-		/* Replace primary template instance */
+				/* Replace primary template instance */
-		TYPE form = DEREF_type ( inst_form ( app ) ) ;
+				TYPE form = DEREF_type(inst_form(app));
-		LIST ( TOKEN ) args = make_primary_args ( pt ) ;
+				LIST(TOKEN) args = make_primary_args(pt);
-		COPY_tok ( type_templ_sort ( form ), at ) ;
+				COPY_tok(type_templ_sort(form), at);
-		form = DEREF_type ( type_templ_defn ( form ) ) ;
+				form = DEREF_type(type_templ_defn(form));
-		COPY_list ( type_token_args ( form ), args ) ;
+				COPY_list(type_token_args(form), args);
-	    }
+			}
-	    app = DEREF_inst ( inst_next ( app ) ) ;
+			app = DEREF_inst(inst_next(app));
-	}
+		}
-	if ( check_templ_dargs ( s ) ) {
+		if (check_templ_dargs(s)) {
-	    /* Expand default arguments */
+			/* Expand default arguments */
-	    LIST ( TOKEN ) args = make_primary_args ( pt ) ;
+			LIST(TOKEN) args = make_primary_args(pt);
-	    int d = save_token_args ( ps, args ) ;
+			int d = save_token_args(ps, args);
-	    dargs = expand_args ( dargs, 1, 1 ) ;
+			dargs = expand_args(dargs, 1, 1);
-	    restore_token_args ( ps, d ) ;
+			restore_token_args(ps, d);
+		}
+		COPY_list(tok_templ_dargs(at), dargs);
+		COPY_inst(tok_templ_apps(at), apps);
+		s = DEREF_type(type_templ_defn(s));
+		t = DEREF_type(type_templ_defn(t));
+		ns = TAG_type(s);
+		nt = TAG_type(t);
+	}
-	COPY_list ( tok_templ_dargs ( at ), dargs ) ;
-	COPY_inst ( tok_templ_apps ( at ), apps ) ;
-	s = DEREF_type ( type_templ_defn ( s ) ) ;
-	t = DEREF_type ( type_templ_defn ( t ) ) ;
-	ns = TAG_type ( s ) ;
-	nt = TAG_type ( t ) ;
-    }
-    return ;
+	return;
+}
 /*
     IS AN IDENTIFIER A TEMPLATE PARAMETER?
     This routine checks whether the token identifier id is one of the
     template or token parameters given by pids.
 */
-int depends_on_param
+int
-    PROTO_N ( ( id, pids ) )
-    PROTO_T ( IDENTIFIER id X LIST ( IDENTIFIER ) pids )
+depends_on_param(IDENTIFIER id, LIST(IDENTIFIER) pids)
 {
-    if ( IS_id_token ( id ) ) {
+	if (IS_id_token(id)) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( !( ds & dspec_ignore ) ) {
+		if (!(ds & dspec_ignore)) {
-	    if ( EQ_list ( pids, any_templ_param ) ) {
+			if (EQ_list(pids, any_templ_param)) {
-		/* Short-cut for list of all template parameters */
+				/* Short-cut for list of all template
+				 * parameters */
-		if ( ( ds & dspec_template ) && ( ds & dspec_auto ) ) {
+				if ((ds & dspec_template) &&
+				    (ds & dspec_auto)) {
-		    return ( 1 ) ;
+					return (1);
-		}
+				}
-		return ( 0 ) ;
+				return (0);
-	    }
+			}
-	    if ( EQ_list ( pids, any_token_param ) ) {
+			if (EQ_list(pids, any_token_param)) {
-		/* Short-cut for list of all token parameters */
+				/* Short-cut for list of all token parameters */
-		if ( ds & dspec_auto ) return ( 1 ) ;
+				if (ds & dspec_auto) {
+					return (1);
+				}
-		return ( 0 ) ;
+				return (0);
-	    }
+			}
-	    while ( !IS_NULL_list ( pids ) ) {
+			while (!IS_NULL_list(pids)) {
-		IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+				IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-		if ( EQ_id ( pid, id ) ) return ( 1 ) ;
+				if (EQ_id(pid, id)) {
+					return (1);
+				}
-		pids = TAIL_list ( pids ) ;
+				pids = TAIL_list(pids);
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES AN IDENTIFIER DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the identifier id is one of the template
     parameters pids or is a template function with an argument depending
     on pids.  If use is true then any other identifiers found are marked
     as used.
 */
-static int depends_on_id
+static int
-    PROTO_N ( ( id, pids, use ) )
-    PROTO_T ( IDENTIFIER id X LIST ( IDENTIFIER ) pids X int use )
+depends_on_id(IDENTIFIER id, LIST(IDENTIFIER) pids, int use)
 {
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	NAMESPACE ns ;
+		NAMESPACE ns;
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_class_name_tag : {
+		case id_class_name_tag: {
-		/* Check for template classes */
+			/* Check for template classes */
-		TYPE form ;
+			TYPE form;
-		CLASS_TYPE ct ;
+			CLASS_TYPE ct;
-		TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
+			TYPE t = DEREF_type(id_class_name_defn(id));
-		while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-		}
+			}
-		ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			ct = DEREF_ctype(type_compound_defn(t));
-		form = DEREF_type ( ctype_form ( ct ) ) ;
+			form = DEREF_type(ctype_form(ct));
-		if ( !IS_NULL_type ( form ) ) {
+			if (!IS_NULL_type(form)) {
-		    if ( depends_on ( form, pids ) ) return ( 1 ) ;
+				if (depends_on(form, pids)) {
+					return (1);
+				}
-		}
+			}
-		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: {
-		/* Check for template functions */
+			/* Check for template functions */
-		TYPE form = DEREF_type ( id_function_etc_form ( id ) ) ;
+			TYPE form = DEREF_type(id_function_etc_form(id));
-		if ( !IS_NULL_type ( form ) ) {
+			if (!IS_NULL_type(form)) {
-		    /* Check function form */
+				/* Check function form */
-		    if ( depends_on ( form, pids ) ) return ( 1 ) ;
+				if (depends_on(form, pids)) {
+					return (1);
+				}
+			}
+			if (use) {
+				reuse_id(id, 0);
+			}
+			break;
+		}
+		case id_token_tag: {
+			/* Check for template parameters */
+			if (depends_on_param(id, pids)) {
+				return (1);
+			}
+			break;
+		}
+		case id_ambig_tag: {
+			/* Check ambiguous identifiers */
+			LIST(IDENTIFIER) qids;
+			qids = DEREF_list(id_ambig_ids(id));
+			while (!IS_NULL_list(qids)) {
+				IDENTIFIER qid = DEREF_id(HEAD_list(qids));
+				if (depends_on_id(qid, pids, use)) {
+					return (1);
+				}
+				qids = TAIL_list(qids);
+			}
+			break;
+		}
+		case id_stat_member_tag: {
+			/* Mark static data members */
+			if (use) {
+				reuse_id(id, 0);
+			}
+			break;
+		}
+		}
-		if ( use ) reuse_id ( id, 0 ) ;
+		ns = DEREF_nspace(id_parent(id));
-		break ;
-	    }
-	    case id_token_tag : {
+		if (!IS_NULL_nspace(ns)) {
-		/* Check for template parameters */
+			/* Check enclosing namespace */
-		if ( depends_on_param ( id, pids ) ) return ( 1 ) ;
-		break ;
-	    }
-	    case id_ambig_tag : {
-		/* Check ambiguous identifiers */
-		LIST ( IDENTIFIER ) qids ;
-		qids = DEREF_list ( id_ambig_ids ( id ) ) ;
-		while ( !IS_NULL_list ( qids ) ) {
-		    IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
+			IDENTIFIER cid = DEREF_id(nspace_name(ns));
-		    if ( depends_on_id ( qid, pids, use ) ) return ( 1 ) ;
+			return (depends_on_id(cid, pids, 0));
-		    qids = TAIL_list ( qids ) ;
+		}
-		break ;
-	    }
-	    case id_stat_member_tag : {
-		/* Mark static data members */
-		if ( use ) reuse_id ( id, 0 ) ;
-		break ;
-	    }
-	}
-	ns = DEREF_nspace ( id_parent ( id ) ) ;
-	if ( !IS_NULL_nspace ( ns ) ) {
-	    /* Check enclosing namespace */
-	    IDENTIFIER cid = DEREF_id ( nspace_name ( ns ) ) ;
-	    return ( depends_on_id ( cid, pids, 0 ) ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES A LIST OF TOKEN ARGUMENTS DEPEND ON A TEMPLATE PARAMETER?
     algorithm is modified to check whether any token argument depends
     on a later template parameter (e.g. does the first element of args
     depend on the second, third, etc. element of pids).
 */
-int depends_on_args
+int
-    PROTO_N ( ( args, pids, use, next ) )
-    PROTO_T ( LIST ( TOKEN ) args X LIST ( IDENTIFIER ) pids X
+depends_on_args(LIST(TOKEN) args, LIST(IDENTIFIER) pids, int use, int next)
-	      int use X int next )
+{
-    while ( !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(args)) {
-	TOKEN tok = DEREF_tok ( HEAD_list ( args ) ) ;
+		TOKEN tok = DEREF_tok(HEAD_list(args));
-	if ( next ) {
+		if (next) {
-	    /* Move on to next parameter */
+			/* Move on to next parameter */
-	    if ( IS_NULL_list ( pids ) ) break ;
+			if (IS_NULL_list(pids)) {
-	    pids = TAIL_list ( pids ) ;
-	}
-	if ( !IS_NULL_tok ( tok ) ) {
-	    switch ( TAG_tok ( tok ) ) {
-		case tok_exp_tag : {
-		    EXP e = DEREF_exp ( tok_exp_value ( tok ) ) ;
-		    if ( depends_on_exp ( e, pids, use ) ) return ( 1 ) ;
-		    break ;
+				break;
-		}
+			}
-		case tok_stmt_tag : {
+			pids = TAIL_list(pids);
-		    EXP e = DEREF_exp ( tok_stmt_value ( tok ) ) ;
-		    if ( depends_on_exp ( e, pids, use ) ) return ( 1 ) ;
-		    break ;
+		}
+		if (!IS_NULL_tok(tok)) {
+			switch (TAG_tok(tok)) {
+			case tok_exp_tag: {
+				EXP e = DEREF_exp(tok_exp_value(tok));
+				if (depends_on_exp(e, pids, use)) {
+					return (1);
+				}
+				break;
+			}
+			case tok_stmt_tag: {
+				EXP e = DEREF_exp(tok_stmt_value(tok));
+				if (depends_on_exp(e, pids, use)) {
+					return (1);
+				}
+				break;
+			}
-		case tok_nat_tag :
+			case tok_nat_tag:
-		case tok_snat_tag : {
+			case tok_snat_tag: {
-		    NAT n = DEREF_nat ( tok_nat_etc_value ( tok ) ) ;
+				NAT n = DEREF_nat(tok_nat_etc_value(tok));
-		    if ( depends_on_nat ( n, pids, use ) ) return ( 1 ) ;
+				if (depends_on_nat(n, pids, use)) {
+					return (1);
+				}
+				break;
+			}
+			case tok_type_tag: {
+				TYPE t = DEREF_type(tok_type_value(tok));
+				if (depends_on(t, pids)) {
+					return (1);
+				}
+				break;
+			}
+			case tok_member_tag: {
+				OFFSET off = DEREF_off(tok_member_value(tok));
+				if (depends_on_off(off, pids, use)) {
+					return (1);
+				}
+				break;
+			}
+			case tok_class_tag:
+				/* NOT YET IMPLEMENTED */
-		    break ;
+				break;
+			}
+		}
+		args = TAIL_list(args);
+	}
+	return (0);
+}
+/*
+    DOES AN INTEGRAL CONSTANT DEPEND ON A TEMPLATE PARAMETER?
+    This routine checks whether the integral constant n depends on one
+    of the template parameters pids.
+*/
+int
+depends_on_nat(NAT n, LIST(IDENTIFIER) pids, int use)
+{
+	if (!IS_NULL_nat(n)) {
+		switch (TAG_nat(n)) {
+		case nat_calc_tag: {
+			EXP e = DEREF_exp(nat_calc_value(n));
+			return (depends_on_exp(e, pids, use));
+		}
+		case nat_token_tag: {
+			IDENTIFIER tid = DEREF_id(nat_token_tok(n));
+			LIST(TOKEN) args = DEREF_list(nat_token_args(n));
+			if (depends_on_param(tid, pids)) {
+				return (2);
+			}
+			if (depends_on_args(args, pids, use, 0)) {
+				return (1);
+			}
+			break;
+		}
-		case tok_type_tag : {
-		    TYPE t = DEREF_type ( tok_type_value ( tok ) ) ;
-		    if ( depends_on ( t, pids ) ) return ( 1 ) ;
-		    break ;
-		}
-		case tok_member_tag : {
-		    OFFSET off = DEREF_off ( tok_member_value ( tok ) ) ;
-		    if ( depends_on_off ( off, pids, use ) ) return ( 1 ) ;
-		    break ;
-		}
-		case tok_class_tag : {
-		    /* NOT YET IMPLEMENTED */
-		    break ;
+		}
-	    }
+	}
-	args = TAIL_list ( args ) ;
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
-    DOES AN INTEGRAL CONSTANT DEPEND ON A TEMPLATE PARAMETER?
-    This routine checks whether the integral constant n depends on one
-    of the template parameters pids.
-*/
-int depends_on_nat
-    PROTO_N ( ( n, pids, use ) )
-    PROTO_T ( NAT n X LIST ( IDENTIFIER ) pids X int use )
-{
-    if ( !IS_NULL_nat ( n ) ) {
-	switch ( TAG_nat ( n ) ) {
-	    case nat_calc_tag : {
-		EXP e = DEREF_exp ( nat_calc_value ( n ) ) ;
-		return ( depends_on_exp ( e, pids, use ) ) ;
-	    }
-	    case nat_token_tag : {
-		IDENTIFIER tid = DEREF_id ( nat_token_tok ( n ) ) ;
-		LIST ( TOKEN ) args = DEREF_list ( nat_token_args ( n ) ) ;
-		if ( depends_on_param ( tid, pids ) ) return ( 2 ) ;
-		if ( depends_on_args ( args, pids, use, 0 ) ) return ( 1 ) ;
-		break ;
-	    }
-	}
-    }
-    return ( 0 ) ;
-}
-/*
     DOES A LIST OF EXPRESSIONS DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the list of expressions p depends on one
     of the template parameters pids.
 */
-static int depends_on_exp_list
+static int
-    PROTO_N ( ( p, pids, use ) )
-    PROTO_T ( LIST ( EXP ) p X LIST ( IDENTIFIER ) pids X int use )
+depends_on_exp_list(LIST(EXP) p, LIST(IDENTIFIER) pids, int use)
 {
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP a = DEREF_exp(HEAD_list(p));
-	if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
+		if (depends_on_exp(a, pids, use)) {
+			return (1);
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     DOES AN EXPRESSION DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the expression e depends on one of the
     template parameters pids.  If e is actually a template parameter
     then 2 is returned.
 /*
     DOES AN OFFSET DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the offset off depends on one of the
     template parameters pids.
 */
-int depends_on_off
+int
-    PROTO_N ( ( off, pids, use ) )
-    PROTO_T ( OFFSET off X LIST ( IDENTIFIER ) pids X int use )
+depends_on_off(OFFSET off, LIST(IDENTIFIER) pids, int use)
+{
-    if ( !IS_NULL_off ( off ) ) {
+	if (!IS_NULL_off(off)) {
-	ASSERT ( ORDER_off == 13 ) ;
+		ASSERT(ORDER_off == 13);
-	switch ( TAG_off ( off ) ) {
+		switch (TAG_off(off)) {
-	    case off_zero_tag : {
+		case off_zero_tag: {
-		TYPE t = DEREF_type ( off_zero_type ( off ) ) ;
+			TYPE t = DEREF_type(off_zero_type(off));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+			if (depends_on(t, pids)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_type_tag : {
+		case off_type_tag: {
-		TYPE t = DEREF_type ( off_type_type ( off ) ) ;
+			TYPE t = DEREF_type(off_type_type(off));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+			if (depends_on(t, pids)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_array_tag : {
+		case off_array_tag: {
-		TYPE t = DEREF_type ( off_array_type ( off ) ) ;
+			TYPE t = DEREF_type(off_array_type(off));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+			if (depends_on(t, pids)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_extra_tag : {
+		case off_extra_tag: {
-		TYPE t = DEREF_type ( off_extra_type ( off ) ) ;
+			TYPE t = DEREF_type(off_extra_type(off));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+			if (depends_on(t, pids)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
 #if 0
-	    case off_base_tag : {
+		case off_base_tag: {
-		GRAPH graph = DEREF_graph ( off_base_graph ( off ) ) ;
+			GRAPH graph = DEREF_graph(off_base_graph(off));
-		break ;
+			break;
-	    }
+		}
-	    case off_deriv_tag : {
+		case off_deriv_tag: {
-		GRAPH graph = DEREF_graph ( off_deriv_graph ( off ) ) ;
+			GRAPH graph = DEREF_graph(off_deriv_graph(off));
-		OFFSET direct = DEREF_off ( off_deriv_direct ( off ) ) ;
+			OFFSET direct = DEREF_off(off_deriv_direct(off));
-		OFFSET indirect = DEREF_off ( off_deriv_indirect ( off ) ) ;
+			OFFSET indirect = DEREF_off(off_deriv_indirect(off));
-		break ;
+			break;
-	    }
+		}
-	    case off_member_tag : {
+		case off_member_tag: {
-		IDENTIFIER id = DEREF_id ( off_member_id ( off ) ) ;
+			IDENTIFIER id = DEREF_id(off_member_id(off));
-		break ;
+			break;
-	    }
+		}
 #endif
-	    case off_ptr_mem_tag : {
+		case off_ptr_mem_tag: {
-		EXP a = DEREF_exp ( off_ptr_mem_arg ( off ) ) ;
+			EXP a = DEREF_exp(off_ptr_mem_arg(off));
-		if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
+			if (depends_on_exp(a, pids, use)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_negate_tag : {
+		case off_negate_tag: {
-		OFFSET a = DEREF_off ( off_negate_arg ( off ) ) ;
+			OFFSET a = DEREF_off(off_negate_arg(off));
-		if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
+			if (depends_on_off(a, pids, use)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_plus_tag : {
+		case off_plus_tag: {
-		OFFSET a = DEREF_off ( off_plus_arg1 ( off ) ) ;
+			OFFSET a = DEREF_off(off_plus_arg1(off));
-		OFFSET b = DEREF_off ( off_plus_arg2 ( off ) ) ;
+			OFFSET b = DEREF_off(off_plus_arg2(off));
-		if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
+			if (depends_on_off(a, pids, use)) {
+				return (1);
+			}
-		if ( depends_on_off ( b, pids, use ) ) return ( 1 ) ;
+			if (depends_on_off(b, pids, use)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_mult_tag : {
+		case off_mult_tag: {
-		OFFSET a = DEREF_off ( off_mult_arg1 ( off ) ) ;
+			OFFSET a = DEREF_off(off_mult_arg1(off));
-		EXP b = DEREF_exp ( off_mult_arg2 ( off ) ) ;
+			EXP b = DEREF_exp(off_mult_arg2(off));
-		if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
+			if (depends_on_off(a, pids, use)) {
+				return (1);
+			}
-		if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
+			if (depends_on_exp(b, pids, use)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_ptr_diff_tag : {
+		case off_ptr_diff_tag: {
-		EXP a = DEREF_exp ( off_ptr_diff_ptr1 ( off ) ) ;
+			EXP a = DEREF_exp(off_ptr_diff_ptr1(off));
-		EXP b = DEREF_exp ( off_ptr_diff_ptr2 ( off ) ) ;
+			EXP b = DEREF_exp(off_ptr_diff_ptr2(off));
-		if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
+			if (depends_on_exp(a, pids, use)) {
+				return (1);
+			}
-		if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
+			if (depends_on_exp(b, pids, use)) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case off_token_tag : {
+		case off_token_tag: {
-		IDENTIFIER tid = DEREF_id ( off_token_tok ( off ) ) ;
+			IDENTIFIER tid = DEREF_id(off_token_tok(off));
-		LIST ( TOKEN ) args = DEREF_list ( off_token_args ( off ) ) ;
+			LIST(TOKEN) args = DEREF_list(off_token_args(off));
-		if ( depends_on_param ( tid, pids ) ) return ( 2 ) ;
+			if (depends_on_param(tid, pids)) {
+				return (2);
+			}
-		if ( depends_on_args ( args, pids, use, 0 ) ) return ( 1 ) ;
+			if (depends_on_args(args, pids, use, 0)) {
+				return (1);
+			}
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES A TYPE DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the type t depends on one of the template
     parameters pids.
 */
-int depends_on
+int
-    PROTO_N ( ( t, pids ) )
-    PROTO_T ( TYPE t X LIST ( IDENTIFIER ) pids )
+depends_on(TYPE t, LIST(IDENTIFIER) pids)
 {
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	ASSERT ( ORDER_type == 18 ) ;
+		ASSERT(ORDER_type == 18);
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_ptr_tag :
+		case type_ptr_tag:
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_etc_sub(t));
-		return ( depends_on ( s, pids ) ) ;
+			return (depends_on(s, pids));
-	    }
+		}
-	    case type_ptr_mem_tag : {
+		case type_ptr_mem_tag: {
-		TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_mem_sub(t));
-		CLASS_TYPE cr = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+			CLASS_TYPE cr = DEREF_ctype(type_ptr_mem_of(t));
-		TYPE r = DEREF_type ( ctype_form ( cr ) ) ;
+			TYPE r = DEREF_type(ctype_form(cr));
-		if ( depends_on ( s, pids ) ) return ( 1 ) ;
+			if (depends_on(s, pids)) {
+				return (1);
+			}
-		return ( depends_on ( r, pids ) ) ;
+			return (depends_on(r, pids));
-	    }
+		}
-	    case type_func_tag : {
+		case type_func_tag: {
-		TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
+			TYPE r = DEREF_type(type_func_ret(t));
-		LIST ( TYPE ) p = DEREF_list ( type_func_mtypes ( t ) ) ;
+			LIST(TYPE) p = DEREF_list(type_func_mtypes(t));
-		if ( depends_on ( r, pids ) ) return ( 1 ) ;
+			if (depends_on(r, pids)) {
+				return (1);
+			}
-		while ( !IS_NULL_list ( p ) ) {
+			while (!IS_NULL_list(p)) {
-		    TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+				TYPE s = DEREF_type(HEAD_list(p));
-		    if ( depends_on ( s, pids ) ) return ( 1 ) ;
+				if (depends_on(s, pids)) {
+					return (1);
+				}
-		    p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case type_array_tag : {
+		case type_array_tag: {
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_array_sub(t));
-		NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+			NAT n = DEREF_nat(type_array_size(t));
-		if ( depends_on ( s, pids ) ) return ( 1 ) ;
+			if (depends_on(s, pids)) {
+				return (1);
+			}
-		return ( depends_on_nat ( n, pids, 0 ) ) ;
+			return (depends_on_nat(n, pids, 0));
-	    }
+		}
-	    case type_bitfield_tag : {
+		case type_bitfield_tag: {
-		INT_TYPE it = DEREF_itype ( type_bitfield_defn ( t ) ) ;
+			INT_TYPE it = DEREF_itype(type_bitfield_defn(t));
-		TYPE s = DEREF_type ( itype_bitfield_sub ( it ) ) ;
+			TYPE s = DEREF_type(itype_bitfield_sub(it));
-		NAT n = DEREF_nat ( itype_bitfield_size ( it ) ) ;
+			NAT n = DEREF_nat(itype_bitfield_size(it));
-		if ( depends_on ( s, pids ) ) return ( 1 ) ;
+			if (depends_on(s, pids)) {
+				return (1);
+			}
-		return ( depends_on_nat ( n, pids, 0 ) ) ;
+			return (depends_on_nat(n, pids, 0));
-	    }
+		}
-	    case type_compound_tag : {
+		case type_compound_tag: {
-		CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(type_compound_defn(t));
-		IDENTIFIER cid = DEREF_id ( ctype_name ( cs ) ) ;
+			IDENTIFIER cid = DEREF_id(ctype_name(cs));
-		return ( depends_on_id ( cid, pids, 0 ) ) ;
+			return (depends_on_id(cid, pids, 0));
-	    }
+		}
-	    case type_enumerate_tag : {
+		case type_enumerate_tag: {
-		ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+			ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
-		IDENTIFIER eid = DEREF_id ( etype_name ( et ) ) ;
+			IDENTIFIER eid = DEREF_id(etype_name(et));
-		return ( depends_on_id ( eid, pids, 0 ) ) ;
+			return (depends_on_id(eid, pids, 0));
-	    }
+		}
-	    case type_token_tag : {
+		case type_token_tag: {
-		IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
+			IDENTIFIER tid = DEREF_id(type_token_tok(t));
-		LIST ( TOKEN ) args = DEREF_list ( type_token_args ( t ) ) ;
+			LIST(TOKEN) args = DEREF_list(type_token_args(t));
-		if ( depends_on_param ( tid, pids ) ) return ( 1 ) ;
+			if (depends_on_param(tid, pids)) {
+				return (1);
+			}
-		if ( depends_on_args ( args, pids, 0, 0 ) ) return ( 1 ) ;
+			if (depends_on_args(args, pids, 0, 0)) {
+				return (1);
+			}
-		if ( IS_id_token ( tid ) ) {
+			if (IS_id_token(tid)) {
-		    TOKEN sort = DEREF_tok ( id_token_sort ( tid ) ) ;
+				TOKEN sort = DEREF_tok(id_token_sort(tid));
-		    if ( IS_tok_type ( sort ) ) {
+				if (IS_tok_type(sort)) {
-			BASE_TYPE bt ;
+					BASE_TYPE bt;
-			bt = DEREF_btype ( tok_type_kind ( sort ) ) ;
+					bt = DEREF_btype(tok_type_kind(sort));
-			if ( bt & btype_typename ) {
+					if (bt & btype_typename) {
-			    /* Allow for typename */
+						/* Allow for typename */
-			    return ( depends_on_id ( tid, pids, 0 ) ) ;
+						return (depends_on_id(tid, pids,
+));
+					}
+				}
+			}
+			break;
+		}
+		case type_templ_tag: {
+			int dep;
+			LIST(IDENTIFIER) qids;
+			TYPE s = DEREF_type(type_templ_defn(t));
+			TOKEN sort = DEREF_tok(type_templ_sort(t));
+			qids = DEREF_list(tok_templ_pids(sort));
+			while (!IS_NULL_list(qids)) {
+				/* Suppress template parameters */
+				IDENTIFIER qid = DEREF_id(HEAD_list(qids));
+				DECL_SPEC ds = DEREF_dspec(id_storage(qid));
+				ds |= dspec_ignore;
+				COPY_dspec(id_storage(qid), ds);
+				qids = TAIL_list(qids);
+			}
+			dep = depends_on(s, pids);
+			qids = DEREF_list(tok_templ_pids(sort));
+			while (!IS_NULL_list(qids)) {
+				/* Restore template parameters */
+				IDENTIFIER qid = DEREF_id(HEAD_list(qids));
+				DECL_SPEC ds = DEREF_dspec(id_storage(qid));
+				ds &= ~dspec_ignore;
+				COPY_dspec(id_storage(qid), ds);
+				qids = TAIL_list(qids);
+			}
-		    }
-		}
-		break ;
-	    }
-	    case type_templ_tag : {
-		int dep ;
+			return (dep);
-		LIST ( IDENTIFIER ) qids ;
-		TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-		TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
-		qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-		while ( !IS_NULL_list ( qids ) ) {
-		    /* Suppress template parameters */
-		    IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( qid ) ) ;
-		    ds |= dspec_ignore ;
-		    COPY_dspec ( id_storage ( qid ), ds ) ;
-		    qids = TAIL_list ( qids ) ;
+		}
-		dep = depends_on ( s, pids ) ;
-		qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-		while ( !IS_NULL_list ( qids ) ) {
-		    /* Restore template parameters */
-		    IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( qid ) ) ;
-		    ds &= ~dspec_ignore ;
-		    COPY_dspec ( id_storage ( qid ), ds ) ;
-		    qids = TAIL_list ( qids ) ;
+		}
-		return ( dep ) ;
-	    }
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES A FUNCTION CALL DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the function call 'id ( args )' depends
     on a template parameter.
 */
-int dependent_call
+int
-    PROTO_N ( ( id, args ) )
-    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args )
+dependent_call(IDENTIFIER id, LIST(EXP) args)
+{
-    if ( in_template_decl ) {
+	if (in_template_decl) {
-	/* Only check in a template declaration */
+		/* Only check in a template declaration */
-	LIST ( IDENTIFIER ) pids = any_templ_param ;
+		LIST(IDENTIFIER) pids = any_templ_param;
-	if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
+		if (depends_on_id(id, pids, 0)) {
+			return (1);
+		}
-	if ( IS_id_function_etc ( id ) ) {
+		if (IS_id_function_etc(id)) {
-	    while ( !IS_NULL_id ( id ) ) {
+			while (!IS_NULL_id(id)) {
-		TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
+				TYPE t = DEREF_type(id_function_etc_type(id));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+				if (depends_on(t, pids)) {
+					return (1);
+				}
-		id = DEREF_id ( id_function_etc_over ( id ) ) ;
+				id = DEREF_id(id_function_etc_over(id));
-	    }
+			}
-	}
+		}
-	while ( !IS_NULL_list ( args ) ) {
+		while (!IS_NULL_list(args)) {
-	    EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+			EXP a = DEREF_exp(HEAD_list(args));
-	    if ( !IS_NULL_exp ( a ) ) {
+			if (!IS_NULL_exp(a)) {
-		/* Check argument type */
+				/* Check argument type */
-		TYPE t = DEREF_type ( exp_type ( a ) ) ;
+				TYPE t = DEREF_type(exp_type(a));
-		if ( depends_on ( t, pids ) ) return ( 1 ) ;
+				if (depends_on(t, pids)) {
+					return (1);
-	    }
+				}
+			}
-	    args = TAIL_list ( args ) ;
+			args = TAIL_list(args);
+		}
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     DOES A FUNCTION CAST DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the resolution of the overloaded function
     id to the type t depends on a template parameter.
 */
-int dependent_cast
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
-{
-    if ( in_template_decl ) {
-	/* Only check in a template declaration */
-	LIST ( IDENTIFIER ) pids = any_templ_param ;
-	if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
-	if ( depends_on ( t, pids ) ) return ( 1 ) ;
-    }
-    return ( 0 ) ;
-}
-/*
-    DOES A CONVERSION DEPEND ON A TEMPLATE PARAMETER?
-    This routine checks whether the conversion 't ( args )' depends
-    on a template parameter.
-*/
+int
-int dependent_conv
-    PROTO_N ( ( t, args ) )
-    PROTO_T ( TYPE t X LIST ( EXP ) args )
+dependent_cast(IDENTIFIER id, TYPE t)
+{
-    if ( in_template_decl ) {
+	if (in_template_decl) {
-	/* Only check in a template declaration */
+		/* Only check in a template declaration */
-	LIST ( IDENTIFIER ) pids = any_templ_param ;
+		LIST(IDENTIFIER) pids = any_templ_param;
-	if ( depends_on ( t, pids ) ) return ( 1 ) ;
+		if (depends_on_id(id, pids, 0)) {
-	while ( !IS_NULL_list ( args ) ) {
+			return (1);
-	    EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
+		}
-	    if ( !IS_NULL_exp ( a ) ) {
+		if (depends_on(t, pids)) {
-		/* Check argument type */
+			return (1);
-		TYPE s = DEREF_type ( exp_type ( a ) ) ;
-		if ( depends_on ( s, pids ) ) return ( 1 ) ;
-	    }
+		}
-	    args = TAIL_list ( args ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
+    DOES A CONVERSION DEPEND ON A TEMPLATE PARAMETER?
+    This routine checks whether the conversion 't ( args )' depends
+    on a template parameter.
+*/
+int
+dependent_conv(TYPE t, LIST(EXP) args)
+{
+	if (in_template_decl) {
+		/* Only check in a template declaration */
+		LIST(IDENTIFIER) pids = any_templ_param;
+		if (depends_on(t, pids)) {
+			return (1);
+		}
+		while (!IS_NULL_list(args)) {
+			EXP a = DEREF_exp(HEAD_list(args));
+			if (!IS_NULL_exp(a)) {
+				/* Check argument type */
+				TYPE s = DEREF_type(exp_type(a));
+				if (depends_on(s, pids)) {
+					return (1);
+				}
+			}
+			args = TAIL_list(args);
+		}
+	}
+	return (0);
+}
+/*
     DOES AN IDENTIFIER DEPEND ON A TEMPLATE PARAMETER?
     This routine checks whether the identifier id depends on a template
     parameter.
 */
-int dependent_id
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+dependent_id(IDENTIFIER id)
+{
-    if ( in_template_decl ) {
+	if (in_template_decl) {
-	/* Only check in a template declaration */
+		/* Only check in a template declaration */
-	LIST ( IDENTIFIER ) pids = any_templ_param ;
+		LIST(IDENTIFIER) pids = any_templ_param;
-	if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
+		if (depends_on_id(id, pids, 0)) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     MARK THE IDENTIFIERS IN AN EXPRESSION AS USED
     This routine marks all the identifiers in the expression e as having
     been used.  This routine is combined with the depends_on functions
     only because they happen to give a convenient tree-walking skeleton.
 */
-void mark_used
+void
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+mark_used(EXP e)
 {
-    if ( !suppress_usage ) {
+	if (!suppress_usage) {
-	IGNORE depends_on_exp ( e, NULL_list ( IDENTIFIER ), 1 ) ;
+		IGNORE depends_on_exp(e, NULL_list(IDENTIFIER), 1);
-    }
+	}
-    return ;
+	return;
 }
 /*
     FIND AN INJECTED TYPE
     This routine modifies the type t which is injected from a template
     into an enclosing scope (for example, a friend of a template class)
     by qualifying it by copies of any unbound template qualifiers.
 */
-TYPE injected_type
+TYPE
-    PROTO_N ( ( t, rec ) )
-    PROTO_T ( TYPE t X int rec )
+injected_type(TYPE t, int rec)
+{
-    IDENTIFIER pid = NULL_id ;
+	IDENTIFIER pid = 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));
-	IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
+		IDENTIFIER id = DEREF_id(nspace_name(ns));
-	if ( !IS_NULL_id ( id ) ) {
+		if (!IS_NULL_id(id)) {
-	    if ( !EQ_id ( id, pid ) ) {
+			if (!EQ_id(id, pid)) {
-		TYPE s = NULL_type ;
+				TYPE s = NULL_type;
-		switch ( TAG_id ( id ) ) {
+				switch (TAG_id(id)) {
-		    case id_class_name_tag :
+				case id_class_name_tag:
-		    case id_class_alias_tag : {
+				case id_class_alias_tag:
-			s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+					s = DEREF_type(id_class_name_etc_defn(id));
-			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:
-			s = DEREF_type ( id_function_etc_type ( id ) ) ;
+					s = DEREF_type(id_function_etc_type(id));
-			break ;
+					break;
+				}
+				if (!IS_NULL_type(s) && IS_type_templ(s)) {
+					LIST(IDENTIFIER)pids;
+					TOKEN sort =
+					    DEREF_tok(type_templ_sort(s));
+					pids = DEREF_list(tok_templ_pids(sort));
+					if (depends_on(t, pids)) {
+						t = rename_templ_params(sort, t,
+									rec);
-		    }
+					}
+				}
+				pid = id;
+			}
+		}
-		if ( !IS_NULL_type ( s ) && IS_type_templ ( s ) ) {
-		    LIST ( IDENTIFIER ) pids ;
-		    TOKEN sort = DEREF_tok ( type_templ_sort ( s ) ) ;
-		    pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
-		    if ( depends_on ( t, pids ) ) {
-			t = rename_templ_params ( sort, t, rec ) ;
-		    }
-		}
-		pid = id ;
+		lns = TAIL_list(lns);
-	    }
+	}
-	lns = TAIL_list ( lns ) ;
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     DUMMY TEMPLATE PARAMETER TYPE
     This variable gives a dummy template parameter type which allows the
     propagation of types dependent in some non-obvious fashion on some
     template parameter.
 */
-TYPE type_templ_param ;
+TYPE type_templ_param;
 /*
     INITIALISE TEMPLATE ROUTINES
     This routine initialises the template routines.  In particular it
     initialises the dummy template parameter type.
 */
-void init_templates
+void
-    PROTO_Z ()
+init_templates(void)
+{
-    string s = ustrlit ( "<type>" ) ;
+	string s = ustrlit("<type>");
-    unsigned long h = hash ( s ) ;
+	unsigned long h = hash(s);
-    HASHID nm = lookup_name ( s, h, 0, lex_identifier ) ;
+	HASHID nm = lookup_name(s, h, 0, lex_identifier);
-    IDENTIFIER id = DEREF_id ( hashid_id ( nm ) ) ;
+	IDENTIFIER id = DEREF_id(hashid_id(nm));
-    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
+	LIST(TOKEN) args = NULL_list(TOKEN);
-    TYPE t = make_dummy_type ( crt_namespace, id, btype_template, args ) ;
+	TYPE t = make_dummy_type(crt_namespace, id, btype_template, args);
-    type_templ_param = t ;
+	type_templ_param = t;
-    CONS_id ( NULL_id, NULL_list ( IDENTIFIER ), any_templ_param ) ;
+	CONS_id(NULL_id, NULL_list(IDENTIFIER), any_templ_param);
-    CONS_id ( NULL_id, NULL_list ( IDENTIFIER ), any_token_param ) ;
+	CONS_id(NULL_id, NULL_list(IDENTIFIER), any_token_param);
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

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