WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/overload.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "xalloc.h"
 /*
     CANDIDATE LIST
     This variable gives the main candidate list used in overload resolution.
 */
-CANDIDATE_LIST candidates = { NULL, 0, 0, NULL, 0 } ;
+CANDIDATE_LIST candidates = { NULL, 0, 0, NULL, 0 };
 /*
     ADD A CANDIDATE TO A LIST
     This routine adds the candidate given by id, bid and kind to the
     candidate list p.
 */
-static void add_candidate
+static void
-    PROTO_N ( ( p, id, bid, kind ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X IDENTIFIER bid X int kind )
+add_candidate(CANDIDATE_LIST *p, IDENTIFIER id, IDENTIFIER bid, int kind)
 {
-    CANDIDATE *q = p->elem ;
+	CANDIDATE *q = p->elem;
-    unsigned n = p->size ;
+	unsigned n = p->size;
-    unsigned m = p->max_size ;
+	unsigned m = p->max_size;
-    if ( n >= m ) {
+	if (n >= m) {
-	/* Increase size if necessary */
+		/* Increase size if necessary */
-	m += 200 ;
+		m += 200;
-	q = xrealloc_nof ( q, CANDIDATE, m ) ;
+		q = xrealloc_nof(q, CANDIDATE, m);
-	p->elem = q ;
+		p->elem = q;
-	p->max_size = m ;
+		p->max_size = m;
-    }
+	}
-    q [n].func = id ;
+	q[n].func = id;
-    q [n].base = bid ;
+	q[n].base = bid;
-    q [n].kind = kind ;
+	q[n].kind = kind;
-    q [n].rank = RANK_NONE ;
+	q[n].rank = RANK_NONE;
-    q [n].convs = NULL ;
+	q[n].convs = NULL;
-    q [n].cond = NULL_exp ;
+	q[n].cond = NULL_exp;
-    p->size = n + 1 ;
+	p->size = n + 1;
-    return ;
+	return;
+}
 /*
     ADD AN IDENTIFIER TO A CANDIDATE LIST
     This routine adds the overloaded function identifier id to the candidate
     list given by p.  The kind argument is stored in the kind field of each
     candidate.  The table of candidate functions may need extending.  Note
     that the candidates are added in the reverse order in which they were
     declared.
 */
-void add_candidates
+void
-    PROTO_N ( ( p, id, over, kind ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X int over X int kind )
+add_candidates(CANDIDATE_LIST *p, IDENTIFIER id, int over, int kind)
 {
-    unsigned tag = TAG_id ( id ) ;
+	unsigned tag = TAG_id(id);
-    switch ( tag ) {
+	switch (tag) {
-	case id_function_tag :
+	case id_function_tag:
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag:
-	    /* Functions */
+		/* Functions */
-	    while ( !IS_NULL_id ( id ) ) {
+		while (!IS_NULL_id(id)) {
-		IDENTIFIER bid = DEREF_id ( id_alias ( id ) ) ;
+			IDENTIFIER bid = DEREF_id(id_alias(id));
-		add_candidate ( p, id, bid, kind ) ;
+			add_candidate(p, id, bid, kind);
-		if ( !over ) break ;
+			if (!over) {
+				break;
+			}
-		id = DEREF_id ( id_function_etc_over ( id ) ) ;
+			id = DEREF_id(id_function_etc_over(id));
-	    }
+		}
-	    break ;
+		break;
-	}
-	case id_builtin_tag : {
+	case id_builtin_tag:
-	    /* Built-in operators */
+		/* Built-in operators */
-	    add_candidate ( p, id, id, kind ) ;
+		add_candidate(p, id, id, kind);
-	    break ;
+		break;
-	}
-	case id_ambig_tag : {
+	case id_ambig_tag: {
-	    /* Ambiguous functions */
+		/* Ambiguous functions */
-	    LIST ( IDENTIFIER ) r = DEREF_list ( id_ambig_ids ( id ) ) ;
+		LIST(IDENTIFIER) r = DEREF_list(id_ambig_ids(id));
+		if (over) {
-	    if ( over ) over = DEREF_int ( id_ambig_over ( id ) ) ;
+			over = DEREF_int(id_ambig_over(id));
+		}
-	    while ( !IS_NULL_list ( r ) ) {
+		while (!IS_NULL_list(r)) {
-		IDENTIFIER rid = DEREF_id ( HEAD_list ( r ) ) ;
+			IDENTIFIER rid = DEREF_id(HEAD_list(r));
-		add_candidates ( p, rid, over, kind ) ;
+			add_candidates(p, rid, over, kind);
-		r = TAIL_list ( r ) ;
+			r = TAIL_list(r);
-	    }
+		}
-	    break ;
+		break;
+	}
-    }
+	}
-    return ;
+	return;
+}
 /*
     LOOK UP A FUNCTION IN AN ARGUMENT NAMESPACE
     This routine looks up the function id in the namespace containing the
     type name cid.  Any functions found are added to the candidate list p.
 */
+static IDENTIFIER
+koenig_id(CANDIDATE_LIST *p, IDENTIFIER id, IDENTIFIER cid, int kind)
+{
+	if (!IS_NULL_id(cid)) {
+		NAMESPACE cns = DEREF_nspace(id_parent(cid));
+		if (!IS_NULL_nspace(cns)) {
+			switch (TAG_nspace(cns)) {
+			case nspace_named_tag:
+			case nspace_unnamed_tag:
+			case nspace_global_tag: {
+				/* Look up identifier in parent class */
+				HASHID nm = DEREF_hashid(id_name(id));
+				MEMBER mem = search_member(cns, nm, 0);
+				if (!IS_NULL_member(mem)) {
+					IDENTIFIER fid =
+					    DEREF_id(member_id(mem));
+					if (!IS_NULL_id(fid) &&
+					    !EQ_id(fid, id)) {
+						add_candidates(p, fid, 1, kind);
+						id = fid;
+					}
+				}
+				break;
+			}
+			case nspace_ctype_tag: {
+				/* Allow for nested classes */
+				IDENTIFIER pid = DEREF_id(nspace_name(cns));
+				id = koenig_id(p, id, pid, kind);
+				break;
+			}
+			}
+		}
+	}
+	return (id);
+}
+/*
+    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A CLASS
+    This routine performs argument dependent name look-up for the function
+    id and the argument class type ct.
+*/
-static IDENTIFIER koenig_id
+static IDENTIFIER
+koenig_class(CANDIDATE_LIST *p, IDENTIFIER id, CLASS_TYPE ct, int kind)
+{
+	TYPE form = DEREF_type(ctype_form(ct));
+	if (IS_NULL_type(form)) {
+		IDENTIFIER cid = DEREF_id(ctype_name(ct));
+		GRAPH gr = DEREF_graph(ctype_base(ct));
+		LIST(GRAPH) br = DEREF_list(graph_tails(gr));
-    PROTO_N ( ( p, id, cid, kind ) )
+		id = koenig_id(p, id, cid, kind);
+		while (!IS_NULL_list(br)) {
+			GRAPH gs = DEREF_graph(HEAD_list(br));
+			CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
+			id = koenig_class(p, id, cs, kind);
+			br = TAIL_list(br);
+		}
+	} else {
+		id = koenig_candidates(p, id, form, kind);
+	}
+	return (id);
+}
+/*
+    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A TOKEN ARGUMENT
+    This routine performs argument dependent name look-up for the function
+    id and the token argument tok.
+*/
+static IDENTIFIER
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X IDENTIFIER cid X int kind )
+koenig_token(CANDIDATE_LIST *p, IDENTIFIER id, TOKEN tok, int kind)
+{
+	if (!IS_NULL_tok(tok)) {
+		ASSERT(ORDER_tok == 10);
+		switch (TAG_tok(tok)) {
+		case tok_type_tag: {
+			TYPE t = DEREF_type(tok_type_value(tok));
+			id = koenig_candidates(p, id, t, kind);
+			break;
+		}
+		case tok_class_tag: {
+			IDENTIFIER tid = DEREF_id(tok_class_value(tok));
+			id = koenig_id(p, id, tid, kind);
+			break;
+		}
+		}
+	}
+	return (id);
+}
+/*
+    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP
+    This routine performs argument dependent name look-up for the function
+    id and the argument type t, adding any candidates found to the list p.
+*/
+IDENTIFIER
+koenig_candidates(CANDIDATE_LIST *p, IDENTIFIER id, TYPE t, int kind)
+{
-    if ( !IS_NULL_id ( cid ) ) {
+	if (!IS_NULL_type(t)) {
+		ASSERT(ORDER_type == 18);
+		switch (TAG_type(t)) {
+		case type_ptr_tag:
+		case type_ref_tag: {
-	NAMESPACE cns = DEREF_nspace ( id_parent ( cid ) ) ;
+			TYPE s = DEREF_type(type_ptr_etc_sub(t));
+			id = koenig_candidates(p, id, s, kind);
+			break;
+		}
+		case type_ptr_mem_tag: {
+			CLASS_TYPE cs = DEREF_ctype(type_ptr_mem_of(t));
+			TYPE s = DEREF_type(type_ptr_mem_sub(t));
+			id = koenig_class(p, id, cs, kind);
+			id = koenig_candidates(p, id, s, kind);
+			break;
+		}
+		case type_func_tag: {
+			TYPE r = DEREF_type(type_func_ret(t));
+			LIST(TYPE) q = DEREF_list(type_func_ptypes(t));
+			id = koenig_candidates(p, id, r, kind);
-	if ( !IS_NULL_nspace ( cns ) ) {
+			while (!IS_NULL_list(q)) {
-	    switch ( TAG_nspace ( cns ) ) {
+				TYPE s = DEREF_type(HEAD_list(q));
+				id = koenig_candidates(p, id, s, kind);
+				q = TAIL_list(q);
+			}
+			break;
+		}
-		case nspace_named_tag :
+		case type_array_tag: {
+			TYPE s = DEREF_type(type_array_sub(t));
+			id = koenig_candidates(p, id, s, kind);
+			break;
+		}
-		case nspace_unnamed_tag :
+		case type_compound_tag: {
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			id = koenig_class(p, id, ct, kind);
+			break;
+		}
-		case nspace_global_tag : {
+		case type_enumerate_tag: {
-		    /* Look up identifier in parent class */
+			ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
-		    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			IDENTIFIER eid = DEREF_id(etype_name(et));
+			id = koenig_id(p, id, eid, kind);
+			break;
+		}
+		case type_token_tag: {
-		    MEMBER mem = search_member ( cns, nm, 0 ) ;
+			IDENTIFIER tid = DEREF_id(type_token_tok(t));
+			LIST(TOKEN) args = DEREF_list(type_token_args(t));
-		    if ( !IS_NULL_member ( mem ) ) {
+			if (IS_id_token(tid)) {
-			IDENTIFIER fid = DEREF_id ( member_id ( mem ) ) ;
+				tid = DEREF_id(id_token_alt(tid));
+			}
-			if ( !IS_NULL_id ( fid ) && !EQ_id ( fid, id ) ) {
+			id = koenig_id(p, id, tid, kind);
+			while (!IS_NULL_list(args)) {
+				TOKEN arg = DEREF_tok(HEAD_list(args));
-			    add_candidates ( p, fid, 1, kind ) ;
+				id = koenig_token(p, id, arg, kind);
-			    id = fid ;
+				args = TAIL_list(args);
+			}
+			break;
-		    }
+		}
+		case type_templ_tag: {
+			TYPE s = DEREF_type(type_templ_defn(t));
+			id = koenig_candidates(p, id, s, kind);
-		    break ;
+			break;
+		}
-		case nspace_ctype_tag : {
-		    /* Allow for nested classes */
-		    IDENTIFIER pid = DEREF_id ( nspace_name ( cns ) ) ;
-		    id = koenig_id ( p, id, pid, kind ) ;
-		    break ;
+		}
-	    }
+	}
-    }
-    return ( id ) ;
+	return (id);
-}
-/*
-    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A CLASS
-    This routine performs argument dependent name look-up for the function
-    id and the argument class type ct.
-*/
-static IDENTIFIER koenig_class
-    PROTO_N ( ( p, id, ct, kind ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X CLASS_TYPE ct X int kind )
-{
-    TYPE form = DEREF_type ( ctype_form ( ct ) ) ;
-    if ( IS_NULL_type ( form ) ) {
-	IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
-	GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
-	LIST ( GRAPH ) br = DEREF_list ( graph_tails ( gr ) ) ;
-	id = koenig_id ( p, id, cid, kind ) ;
-	while ( !IS_NULL_list ( br ) ) {
-	    GRAPH gs = DEREF_graph ( HEAD_list ( br ) ) ;
-	    CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
-	    id = koenig_class ( p, id, cs, kind ) ;
-	    br = TAIL_list ( br ) ;
-	}
-    } else {
-	id = koenig_candidates ( p, id, form, kind ) ;
-    }
-    return ( id ) ;
+}
 /*
-    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A TOKEN ARGUMENT
-    This routine performs argument dependent name look-up for the function
-    id and the token argument tok.
-*/
-static IDENTIFIER koenig_token
-    PROTO_N ( ( p, id, tok, kind ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X TOKEN tok X int kind )
-{
-    if ( !IS_NULL_tok ( tok ) ) {
-	ASSERT ( ORDER_tok == 10 ) ;
-	switch ( TAG_tok ( tok ) ) {
-	    case tok_type_tag : {
-		TYPE t = DEREF_type ( tok_type_value ( tok ) ) ;
-		id = koenig_candidates ( p, id, t, kind ) ;
-		break ;
-	    }
-	    case tok_class_tag : {
-		IDENTIFIER tid = DEREF_id ( tok_class_value ( tok ) ) ;
-		id = koenig_id ( p, id, tid, kind ) ;
-		break ;
-	    }
-	}
-    }
-    return ( id ) ;
-}
-/*
-    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP
-    This routine performs argument dependent name look-up for the function
-    id and the argument type t, adding any candidates found to the list p.
-*/
-IDENTIFIER koenig_candidates
-    PROTO_N ( ( p, id, t, kind ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X TYPE t X int kind )
-{
-    if ( !IS_NULL_type ( t ) ) {
-	ASSERT ( ORDER_type == 18 ) ;
-	switch ( TAG_type ( t ) ) {
-	    case type_ptr_tag :
-	    case type_ref_tag : {
-		TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
-		id = koenig_candidates ( p, id, s, kind ) ;
-		break ;
-	    }
-	    case type_ptr_mem_tag : {
-		CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
-		TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
-		id = koenig_class ( p, id, cs, kind ) ;
-		id = koenig_candidates ( p, id, s, kind ) ;
-		break ;
-	    }
-	    case type_func_tag : {
-		TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
-		LIST ( TYPE ) q = DEREF_list ( type_func_ptypes ( t ) ) ;
-		id = koenig_candidates ( p, id, r, kind ) ;
-		while ( !IS_NULL_list ( q ) ) {
-		    TYPE s = DEREF_type ( HEAD_list ( q ) ) ;
-		    id = koenig_candidates ( p, id, s, kind ) ;
-		    q = TAIL_list ( q ) ;
-		}
-		break ;
-	    }
-	    case type_array_tag : {
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-		id = koenig_candidates ( p, id, s, kind ) ;
-		break ;
-	    }
-	    case type_compound_tag : {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		id = koenig_class ( p, id, ct, kind ) ;
-		break ;
-	    }
-	    case type_enumerate_tag : {
-		ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
-		IDENTIFIER eid = DEREF_id ( etype_name ( et ) ) ;
-		id = koenig_id ( p, id, eid, kind ) ;
-		break ;
-	    }
-	    case type_token_tag : {
-		IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
-		LIST ( TOKEN ) args = DEREF_list ( type_token_args ( t ) ) ;
-		if ( IS_id_token ( tid ) ) {
-		    tid = DEREF_id ( id_token_alt ( tid ) ) ;
-		}
-		id = koenig_id ( p, id, tid, kind ) ;
-		while ( !IS_NULL_list ( args ) ) {
-		    TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
-		    id = koenig_token ( p, id, arg, kind ) ;
-		    args = TAIL_list ( args ) ;
-		}
-		break ;
-	    }
-	    case type_templ_tag : {
-		TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-		id = koenig_candidates ( p, id, s, kind ) ;
-		break ;
-	    }
-	}
-    }
-    return ( id ) ;
-}
-/*
     FREE A LIST OF CANDIDATES
     This routine frees the elements of the candidate list p.
 */
-void free_candidates
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( CANDIDATE_LIST *p )
+free_candidates(CANDIDATE_LIST *p)
+{
-    xfree_nof ( p->elem ) ;
+	xfree_nof(p->elem);
-    xfree_nof ( p->convs ) ;
+	xfree_nof(p->convs);
-    p->elem = NULL ;
+	p->elem = NULL;
-    p->size = 0 ;
+	p->size = 0;
-    p->max_size = 0 ;
+	p->max_size = 0;
-    p->convs = NULL ;
+	p->convs = NULL;
-    p->nconvs = 0 ;
+	p->nconvs = 0;
-    return ;
+	return;
+}
 /*
     SWAP PARAMETER TYPE FIELDS FOR A FUNCTION
     Overload resolution is based on the mtypes field of the function type.
     This routine can be used to force resolution on the ptypes field by
     swapping the two fields for the overloaded function identifier id.
     Note that after overload resolution the fields should be swapped back.
 */
-void swap_ptypes
+void
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+swap_ptypes(IDENTIFIER id)
 {
-    LIST ( TYPE ) ptypes ;
+	LIST(TYPE) ptypes;
-    LIST ( TYPE ) mtypes ;
+	LIST(TYPE) mtypes;
-    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+	TYPE fn = DEREF_type(id_function_etc_type(id));
-    while ( IS_type_templ ( fn ) ) {
+	while (IS_type_templ(fn)) {
-	/* Allow for template functions */
+		/* Allow for template functions */
-	fn = DEREF_type ( type_templ_defn ( fn ) ) ;
+		fn = DEREF_type(type_templ_defn(fn));
-    }
+	}
-    ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
+	ptypes = DEREF_list(type_func_ptypes(fn));
-    mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
+	mtypes = DEREF_list(type_func_mtypes(fn));
-    if ( !EQ_list ( ptypes, mtypes ) ) {
+	if (!EQ_list(ptypes, mtypes)) {
-	COPY_list ( type_func_ptypes ( fn ), mtypes ) ;
+		COPY_list(type_func_ptypes(fn), mtypes);
-	COPY_list ( type_func_mtypes ( fn ), ptypes ) ;
+		COPY_list(type_func_mtypes(fn), ptypes);
-    }
+	}
-    return ;
+	return;
 }
 /*
     SWAP PARAMETER TYPE FIELDS FOR CANDIDATES FUNCTIONS
     This routine swaps the parameter type fields for all the constructor
     candidates in p, starting with the nth entry.
 */
-void swap_candidates
+void
-    PROTO_N ( ( p, n ) )
-    PROTO_T ( CANDIDATE_LIST *p X unsigned n )
+swap_candidates(CANDIDATE_LIST *p, unsigned n)
 {
-    unsigned i, m = p->size ;
+	unsigned i, m = p->size;
-    for ( i = n ; i < m ; i++ ) {
+	for (i = n; i < m; i++) {
-	CANDIDATE *r = p->elem + i ;
+		CANDIDATE *r = p->elem + i;
-	if ( r->kind == KIND_CONSTR ) {
+		if (r->kind == KIND_CONSTR) {
-	    swap_ptypes ( r->base ) ;
+			swap_ptypes(r->base);
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     LIST CANDIDATES FOR ERROR REPORTING
     This routine appends messages listing all the candidates from the list
     p of rank at least rank to the end of the error message err.  No action
     is taken if err is the null error.
 */
-ERROR list_candidates
+ERROR
-    PROTO_N ( ( err, p, rank ) )
-    PROTO_T ( ERROR err X CANDIDATE_LIST *p X unsigned rank )
+list_candidates(ERROR err, CANDIDATE_LIST *p, unsigned rank)
 {
-    if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	ERROR err2 = ERR_over_match_viable_list () ;
+		ERROR err2 = ERR_over_match_viable_list();
-	if ( !IS_NULL_err ( err2 ) ) {
+		if (!IS_NULL_err(err2)) {
-	    unsigned m = 0 ;
+			unsigned m = 0;
-	    CANDIDATE *q = p->elem ;
+			CANDIDATE *q = p->elem;
-	    unsigned n = p->size ;
+			unsigned n = p->size;
-	    err = concat_error ( err, err2 ) ;
+			err = concat_error(err, err2);
-	    while ( n ) {
+			while (n) {
-		CANDIDATE *r = q + ( --n ) ;
+				CANDIDATE *r = q + (--n);
-		if ( r->rank >= rank ) {
+				if (r->rank >= rank) {
-		    /* List viable candidates */
+					/* List viable candidates */
-		    IDENTIFIER bid = r->base ;
+					IDENTIFIER bid = r->base;
+					DECL_SPEC ds =
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( bid ) ) ;
+					    DEREF_dspec(id_storage(bid));
-		    if ( !( ds & dspec_register ) ) {
+					if (!(ds & dspec_register)) {
-			IDENTIFIER id = r->func ;
+						IDENTIFIER id = r->func;
-			if ( IS_id_builtin ( id ) ) {
+						if (IS_id_builtin(id)) {
-			    /* Dump dummy built-in operators */
+							/* Dump dummy built-in
+							 * operators */
+							if (do_dump) {
-			    if ( do_dump ) dump_builtin ( id ) ;
+								dump_builtin(id);
+							}
+						}
+						m++;
+						err2 = ERR_fail_list_item(m, id, id_loc(id));
+						err = concat_error(err, err2);
+						ds |= dspec_register;
+						COPY_dspec(id_storage(bid), ds);
+					}
+				}
+			}
-			m++ ;
-			err2 = ERR_fail_list_item ( m, id, id_loc ( id ) ) ;
-			err = concat_error ( err, err2 ) ;
-			ds |= dspec_register ;
-			COPY_dspec ( id_storage ( bid ), ds ) ;
-		    }
-		}
-	    }
-	    if ( m ) {
+			if (m) {
-		n = p->size ;
+				n = p->size;
-		while ( n ) {
+				while (n) {
-		    /* Clear marks */
+					/* Clear marks */
-		    CANDIDATE *r = q + ( --n ) ;
+					CANDIDATE *r = q + (--n);
-		    IDENTIFIER bid = r->base ;
+					IDENTIFIER bid = r->base;
+					DECL_SPEC ds =
-		    DECL_SPEC ds = DEREF_dspec ( id_storage ( bid ) ) ;
+					    DEREF_dspec(id_storage(bid));
-		    if ( ds & dspec_register ) {
+					if (ds & dspec_register) {
-			ds &= ~dspec_register ;
+						ds &= ~dspec_register;
-			COPY_dspec ( id_storage ( bid ), ds ) ;
+						COPY_dspec(id_storage(bid), ds);
-		    }
+					}
+				}
+			}
+			err = concat_error(err, ERR_fail_list_end(m));
+		}
-	    }
-	    err = concat_error ( err, ERR_fail_list_end ( m ) ) ;
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     OVERLOAD MATCHING INFORMATION
     resolution.  If match_no_args is nonzero it gives the number of
     candidates which take the right number of arguments, otherwise if it
     is zero it indicates that either there are no such functions or there
     is only one candidate.  Similarly match_no_viable gives the number of
     viable candidates (counting viable templates twice).
 */
-unsigned match_no_args = 0 ;
+unsigned match_no_args = 0;
-unsigned match_no_viable = 0 ;
+unsigned match_no_viable = 0;
-static unsigned viable_templates = 0 ;
+static unsigned viable_templates = 0;
-int resolved_kind = KIND_FUNC ;
+int resolved_kind = KIND_FUNC;
 /*
     IS A CANDIDATE FUNCTION PLAUSIBLE?
     A candidate function is plausible for a list of arguments if it accepts
     that number of arguments.  This routine tests whether the candidate r
     is plausible.  It returns the absolute difference between the number
     of arguments and the number of parameters (i.e. zero for a plausible
     candidate).
 */
-static unsigned plausible_candidate
+static unsigned
-    PROTO_N ( ( r, nargs ) )
-    PROTO_T ( CANDIDATE *r X unsigned nargs )
+plausible_candidate(CANDIDATE *r, unsigned nargs)
+{
-    IDENTIFIER id = r->base ;
+	IDENTIFIER id = r->base;
-    if ( IS_id_builtin ( id ) ) {
+	if (IS_id_builtin(id)) {
-	/* Built-in candidates */
+		/* Built-in candidates */
-	LIST ( TYPE ) mtypes = DEREF_list ( id_builtin_ptypes ( id ) ) ;
+		LIST(TYPE) mtypes = DEREF_list(id_builtin_ptypes(id));
-	unsigned npars = LENGTH_list ( mtypes ) ;
+		unsigned npars = LENGTH_list(mtypes);
-	if ( nargs == npars ) {
+		if (nargs == npars) {
-	    /* Equal numbers of arguments and parameters */
+			/* Equal numbers of arguments and parameters */
-	    return ( 0 ) ;
+			return (0);
-	} else if ( nargs > npars ) {
+		} else if (nargs > npars) {
-	    /* More arguments than parameters */
+			/* More arguments than parameters */
-	    return ( nargs - npars ) ;
+			return (nargs - npars);
-	} else {
+		} else {
-	    /* Less arguments than parameters */
+			/* Less arguments than parameters */
-	    return ( npars - nargs ) ;
+			return (npars - nargs);
-	}
-    } else {
-	/* Function candidates */
-	unsigned npars ;
-	LIST ( TYPE ) mtypes ;
-	TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
-	while ( IS_type_templ ( fn ) ) {
-	    /* Allow for template functions */
-	    fn = DEREF_type ( type_templ_defn ( fn ) ) ;
-	}
+		}
-	mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
-	npars = LENGTH_list ( mtypes ) ;
-	if ( nargs == npars ) {
-	    /* Equal numbers of arguments and parameters */
-	    return ( 0 ) ;
-	} else if ( nargs > npars ) {
-	    /* More arguments than parameters */
-	    int ell = DEREF_int ( type_func_ellipsis ( fn ) ) ;
-	    if ( ell ) {
-		/* Match with ellipsis */
-		return ( 0 ) ;
-	    }
-	    return ( nargs - npars ) ;
 	} else {
+		/* Function candidates */
+		unsigned npars;
+		LIST(TYPE) mtypes;
+		TYPE fn = DEREF_type(id_function_etc_type(id));
+		while (IS_type_templ(fn)) {
+			/* Allow for template functions */
+			fn = DEREF_type(type_templ_defn(fn));
+		}
+		mtypes = DEREF_list(type_func_mtypes(fn));
+		npars = LENGTH_list(mtypes);
+		if (nargs == npars) {
+			/* Equal numbers of arguments and parameters */
+			return (0);
+		} else if (nargs > npars) {
+			/* More arguments than parameters */
+			int ell = DEREF_int(type_func_ellipsis(fn));
+			if (ell) {
+				/* Match with ellipsis */
+				return (0);
+			}
+			return (nargs - npars);
+		} else {
-	    /* Less arguments than parameters */
+			/* Less arguments than parameters */
-	    unsigned margs = min_no_args ( fn ) ;
+			unsigned margs = min_no_args(fn);
-	    if ( nargs >= margs ) {
+			if (nargs >= margs) {
-		/* Match with default arguments */
+				/* Match with default arguments */
-		return ( 0 ) ;
+				return (0);
-	    }
+			}
-	    return ( margs - nargs ) ;
+			return (margs - nargs);
+		}
+	}
-    }
-    /* NOTREACHED */
+	/* NOTREACHED */
+}
 /*
     INHERITANCE MATCHING FLAG
     This flag may be set to true to make the match for the implicit
     this parameter for an inherited function as good as a match for
     a non-inherited function from the point of view of function
     overloading.
 */
-int match_this = 0 ;
+int match_this = 0;
 /*
     IS A PLAUSIBLE CANDIDATE FUNCTION VIABLE?
     A plausible candidate function is viable for a list of arguments if
     there is an implicit conversion sequence for each argument to the
     corresponding parameter type.  This routine tests whether the plausible
     candidate r is viable, building up the corresponding list of conversions.
     It returns the number of arguments for which a sequence exists, plus
     one.
 /*
     COMPARE TWO FUNCTIONS
     This routine compares the candidate functions rid and sid to determine
     which is better under the template specialisation rules.  It returns
 if rid is better than sid, 2 if sid is better than rid, and 0 otherwise.
 */
-static int compare_funcs
+static int
-    PROTO_N ( ( rid, sid ) )
-    PROTO_T ( IDENTIFIER rid X IDENTIFIER sid )
+compare_funcs(IDENTIFIER rid, IDENTIFIER sid)
+{
-    int res = 0 ;
+	int res = 0;
-    if ( EQ_id ( rid, sid ) ) {
+	if (EQ_id(rid, sid)) {
-	/* Select first if equal */
+		/* Select first if equal */
-	res = 1 ;
+		res = 1;
-    } else {
-	if ( IS_NULL_id ( rid ) ) {
-	    res = 2 ;
-	} else if ( IS_NULL_id ( sid ) ) {
-	    res = 1 ;
 	} else {
-	    rid = find_template ( rid, 0 ) ;
-	    sid = find_template ( sid, 0 ) ;
-	    if ( !IS_NULL_id ( rid ) ) {
+		if (IS_NULL_id(rid)) {
-		if ( !IS_NULL_id ( sid ) ) {
+			res = 2;
-		    /* Both template functions */
+		} else if (IS_NULL_id(sid)) {
-		    res = compare_specs ( rid, sid ) ;
+			res = 1;
 		} else {
+			rid = find_template(rid, 0);
+			sid = find_template(sid, 0);
+			if (!IS_NULL_id(rid)) {
+				if (!IS_NULL_id(sid)) {
+					/* Both template functions */
+					res = compare_specs(rid, sid);
+				} else {
-		    /* rid is a template function */
+					/* rid is a template function */
-		    res = 2 ;
+					res = 2;
-		}
+				}
-	    } else if ( !IS_NULL_id ( sid ) ) {
+			} else if (!IS_NULL_id(sid)) {
-		/* sid is a template function */
+				/* sid is a template function */
-		res = 1 ;
+				res = 1;
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ( res ) ;
+	return (res);
 }
 /*
     COMPARE TWO CANDIDATE FUNCTIONS
     This routine compares the candidate functions r and s for the argument
     list args and return type ret.  It returns 1 if r is better than s, 2 if
     s is better than r, and some other value otherwise.  Better in this
     sense means at least as good for all arguments, plus strictly better
     in at least one argument or the return type.
 */
-static int compare_candidates
+static int
-    PROTO_N ( ( r, s, args, ret ) )
-    PROTO_T ( CANDIDATE *r X CANDIDATE *s X LIST ( EXP ) args X TYPE ret )
+compare_candidates(CANDIDATE *r, CANDIDATE *s, LIST(EXP) args, TYPE ret)
 {
-    int res = 0 ;
+	int res = 0;
-    CONVERSION *cr = r->convs ;
+	CONVERSION *cr = r->convs;
-    CONVERSION *cs = s->convs ;
+	CONVERSION *cs = s->convs;
-    /* Compare each argument in turn */
+	/* Compare each argument in turn */
-    while ( !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(args)) {
-	int cmp = compare_seq ( cr, cs ) ;
+		int cmp = compare_seq(cr, cs);
-	if ( cmp == 1 ) {
+		if (cmp == 1) {
-	    /* r better in this argument */
+			/* r better in this argument */
-	    if ( res == 2 ) return ( 0 ) ;
+			if (res == 2) {
+				return (0);
+			}
-	    res = 1 ;
+			res = 1;
-	} else if ( cmp == 2 ) {
+		} else if (cmp == 2) {
-	    /* s better in this argument */
+			/* s better in this argument */
-	    if ( res == 1 ) return ( 0 ) ;
+			if (res == 1) {
+				return (0);
+			}
-	    res = 2 ;
+			res = 2;
-	}
+		}
-	cr++ ;
+		cr++;
-	cs++ ;
+		cs++;
-	args = TAIL_list ( args ) ;
+		args = TAIL_list(args);
-    }
+	}
-    /* Tie breakers */
+	/* Tie breakers */
-    if ( res == 0 ) {
+	if (res == 0) {
-	res = compare_funcs ( r->base, s->base ) ;
+		res = compare_funcs(r->base, s->base);
-	if ( res == 0 && !IS_NULL_type ( ret ) ) {
+		if (res == 0 && !IS_NULL_type(ret)) {
-	    /* Resolve on return type */
+			/* Resolve on return type */
-	    res = compare_seq ( cr, cs ) ;
+			res = compare_seq(cr, cs);
-	}
+		}
-    }
+	}
-    return ( res ) ;
+	return (res);
 }
 /*
     OVERLOADED FUNCTION RESOLUTION
     This routine selects the best match from the list of overloaded function
     given by p based on the argument list args and the return type ret (which
     may be the null type).  The list of candidate functions will not be empty.
     If replay is true then the conversion sequences have already been
     calculated and only the final tournament to select the best viable
     candidate is necessary.
+		}
-	    }
+	}
-    } else {
-	/* No clear tournament winner */
-	if ( best->rank >= RANK_VIABLE ) best->rank = RANK_VIABLE ;
-    }
-    return ( best ) ;
+	return (best);
+}
 /*
     FIND A LIST OF POSSIBLE TYPE VALUES
     target dependent type t or its promotion.  In the latter case prom
     is set to true.  If neither t or its promotion is target dependent
     then the empty list is returned.
 */
-static LIST ( TYPE ) possible_types
+static LIST(TYPE)
-    PROTO_N ( ( t, prom ) )
-    PROTO_T ( TYPE t X int *prom )
+possible_types(TYPE t, int *prom)
+{
-    LIST ( TYPE ) r = NULL_list ( TYPE ) ;
+	LIST(TYPE) r = NULL_list(TYPE);
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    /* Integral type */
+		/* Integral type */
-	    INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	    r = DEREF_list ( itype_cases ( it ) ) ;
+		r = DEREF_list(itype_cases(it));
-	    if ( LENGTH_list ( r ) == 1 ) {
+		if (LENGTH_list(r) == 1) {
-		/* Type is not target dependent */
+			/* Type is not target dependent */
-		t = DEREF_type ( itype_prom ( it ) ) ;
+			t = DEREF_type(itype_prom(it));
-		it = DEREF_itype ( type_integer_rep ( t ) ) ;
+			it = DEREF_itype(type_integer_rep(t));
-		r = DEREF_list ( itype_cases ( it ) ) ;
+			r = DEREF_list(itype_cases(it));
-		if ( LENGTH_list ( r ) == 1 ) {
+			if (LENGTH_list(r) == 1) {
-		    /* Promoted type is not target dependent */
+				/* Promoted type is not target dependent */
-		    r = NULL_list ( TYPE ) ;
+				r = NULL_list(TYPE);
-		} else {
+			} else {
-		    *prom = 1 ;
+				*prom = 1;
+			}
+		}
+		break;
-	    }
+	}
+	case type_bitfield_tag:
+	case type_enumerate_tag:
+		/* Enumeration and bitfield types */
+		t = promote_type(t);
+		r = possible_types(t, prom);
+		*prom = 1;
-	    break ;
+		break;
+	}
-	case type_bitfield_tag :
-	case type_enumerate_tag : {
-	    /* Enumeration and bitfield types */
-	    t = promote_type ( t ) ;
-	    r = possible_types ( t, prom ) ;
-	    *prom = 1 ;
-	    break ;
-	}
-    }
-    return ( r ) ;
+	return (r);
+}
 /*
     CHECK FOR TARGET DEPENDENT OVERLOADED FUNCTION RESOLUTIONS
     This routine is called when an ambiguous overload resolution is
     detected to determine which of the viable candidates to proceed with.
     The parameters are as in resolve_overload.
 */
-CANDIDATE *resolve_ambiguous
+CANDIDATE *
-    PROTO_N ( ( p, args, ret, depth ) )
-    PROTO_T ( CANDIDATE_LIST *p X LIST ( EXP ) args X TYPE ret X int depth )
+resolve_ambiguous(CANDIDATE_LIST *p, LIST(EXP) args, TYPE ret, int depth)
+{
-    CANDIDATE *q = p->elem ;
+    CANDIDATE *q = p->elem;
-    CANDIDATE *best = q ;
+    CANDIDATE *best = q;
-    unsigned i, n = p->size ;
+    unsigned i, n = p->size;
-    unsigned overall_rank = RANK_VIABLE ;
+    unsigned overall_rank = RANK_VIABLE;
     /* Check for arguments of error type */
-    if ( depth == 0 ) {
+    if (depth == 0) {
-	LIST ( EXP ) a = args ;
+	LIST(EXP) a = args;
-	while ( !IS_NULL_list ( a ) ) {
+	while (!IS_NULL_list(a)) {
-	    EXP e = DEREF_exp ( HEAD_list ( a ) ) ;
+	    EXP e = DEREF_exp(HEAD_list(a));
-	    if ( !IS_NULL_exp ( e ) ) {
+	    if (!IS_NULL_exp(e)) {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
+		TYPE t = DEREF_type(exp_type(e));
-		if ( IS_type_error ( t ) ) {
+		if (IS_type_error(t)) {
 		    /* Error types are ignored */
-		    overall_rank = RANK_BEST ;
+		    overall_rank = RANK_BEST;
-		    break ;
+		    break;
+		}
+	    }
-	    a = TAIL_list ( a ) ;
+	    a = TAIL_list(a);
+	}
+    }
     /* Check for target dependent resolutions */
-    if ( overall_rank != RANK_BEST ) {
+    if (overall_rank != RANK_BEST) {
-	unsigned na = 0 ;
+	unsigned na = 0;
-	LIST ( EXP ) a = args ;
+	LIST(EXP) a = args;
-	EXP saved [100] ;
+	EXP saved[100];
-	EXP *save = saved ;
+	EXP *save = saved;
+	if (n >= 100) {
-	if ( n >= 100 ) save = xmalloc_nof ( EXP, n ) ;
+		save = xmalloc_nof(EXP, n);
+	}
-	for ( i = 0 ; i < n ; i++ ) save [i] = NULL_exp ;
+	for (i = 0; i < n; i++)save[i] = NULL_exp;
-	while ( !IS_NULL_list ( a ) ) {
+	while (!IS_NULL_list(a)) {
-	    EXP e = DEREF_exp ( HEAD_list ( a ) ) ;
+	    EXP e = DEREF_exp(HEAD_list(a));
-	    if ( !IS_NULL_exp ( e ) ) {
+	    if (!IS_NULL_exp(e)) {
-		int prom = 0 ;
+		int prom = 0;
-		int have_match = 0 ;
+		int have_match = 0;
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
+		TYPE t = DEREF_type(exp_type(e));
-		LIST ( TYPE ) pt = possible_types ( t, &prom ) ;
+		LIST(TYPE) pt = possible_types(t, &prom);
-		if ( !IS_NULL_list ( pt ) ) {
+		if (!IS_NULL_list(pt)) {
-		    CANDIDATE *r ;
+		    CANDIDATE *r;
-		    LIST ( TYPE ) ps = pt ;
+		    LIST(TYPE) ps = pt;
-		    unsigned new_rank = RANK_TARGET ;
+		    unsigned new_rank = RANK_TARGET;
-		    if ( prom ) {
+		    if (prom) {
 			/* Only use promoted types if no exact match */
-			for ( i = 0 ; i < n ; i++ ) {
+			for (i = 0; i < n; i++) {
-			    r = q + i ;
+			    r = q + i;
-			    if ( r->rank >= RANK_VIABLE ) {
+			    if (r->rank >= RANK_VIABLE) {
-				if ( r->convs [ na ].rank == CONV_EXACT ) {
+				if (r->convs[na].rank == CONV_EXACT) {
-				    ps = NULL_list ( TYPE ) ;
+				    ps = NULL_list(TYPE);
-				    new_rank = overall_rank ;
+				    new_rank = overall_rank;
-				    break ;
+				    break;
+				}
+			    }
+			}
+		    }
-		    overall_rank = new_rank ;
+		    overall_rank = new_rank;
-		    while ( !IS_NULL_list ( ps ) ) {
+		    while (!IS_NULL_list(ps)) {
-			TYPE u = t ;
+			TYPE u = t;
-			TYPE s = DEREF_type ( HEAD_list ( ps ) ) ;
+			TYPE s = DEREF_type(HEAD_list(ps));
-			COPY_type ( exp_type ( e ), s ) ;
+			COPY_type(exp_type(e), s);
-			for ( i = 0 ; i < n ; i++ ) {
+			for (i = 0; i < n; i++) {
-			    r = q + i ;
+			    r = q + i;
-			    if ( r->rank >= RANK_VIABLE ) {
+			    if (r->rank >= RANK_VIABLE) {
 				/* Recalculate conversions */
-				r->convs [ na ].rank = CONV_NONE ;
+				r->convs[na].rank = CONV_NONE;
-				IGNORE viable_candidate ( r, args, ret ) ;
+				IGNORE viable_candidate(r, args, ret);
-				r->rank = RANK_VIABLE ;
+				r->rank = RANK_VIABLE;
+			    }
+			}
-			r = resolve_overload ( p, args, ret, 1 ) ;
+			r = resolve_overload(p, args, ret, 1);
-			if ( r->rank == RANK_VIABLE ) {
+			if (r->rank == RANK_VIABLE) {
 			    /* Check further arguments */
-			    for ( i = 0 ; i < n ; i++ ) {
+			    for (i = 0; i < n; i++) {
 				/* Save conditions */
-				save [i] = q [i].cond ;
+				save[i] = q[i].cond;
-				q [i].cond = NULL_exp ;
+				q[i].cond = NULL_exp;
+			    }
-			    r = resolve_ambiguous ( p, args, ret, 1 ) ;
+			    r = resolve_ambiguous(p, args, ret, 1);
-			    for ( i = 0 ; i < n ; i++ ) {
+			    for (i = 0; i < n; i++) {
 				/* Restore conditions */
-				EXP c = q [i].cond ;
+				EXP c = q[i].cond;
-				q [i].cond = save [i] ;
+				q[i].cond = save[i];
-				save [i] = c ;
+				save[i] = c;
+			    }
+			}
-			COPY_type ( exp_type ( e ), t ) ;
+			COPY_type(exp_type(e), t);
-			if ( r->rank >= RANK_TARGET ) {
+			if (r->rank >= RANK_TARGET) {
 			    /* Create condition for resolution */
+			    if (prom) {
-			    if ( prom ) u = promote_type ( u ) ;
+				    u = promote_type(u);
+			    }
-			    for ( i = 0 ; i < n ; i++ ) {
+			    for (i = 0; i < n; i++) {
-				r = q + i ;
+				r = q + i;
-				if ( r->rank >= RANK_TARGET ) {
+				if (r->rank >= RANK_TARGET) {
-				    EXP c1, c2 ;
+				    EXP c1, c2;
-				    TYPE ti = type_sint ;
+				    TYPE ti = type_sint;
-				    TYPE tb = type_bool ;
+				    TYPE tb = type_bool;
-				    NTEST nt = ntest_eq ;
+				    NTEST nt = ntest_eq;
-				    MAKE_exp_rtti_no ( ti, u, c1 ) ;
+				    MAKE_exp_rtti_no(ti, u, c1);
-				    MAKE_exp_rtti_no ( ti, s, c2 ) ;
+				    MAKE_exp_rtti_no(ti, s, c2);
-				    MAKE_exp_compare ( tb, nt, c1, c2, c1 ) ;
+				    MAKE_exp_compare(tb, nt, c1, c2, c1);
-				    c2 = save [i] ;
+				    c2 = save[i];
-				    if ( !IS_NULL_exp ( c2 ) ) {
+				    if (!IS_NULL_exp(c2)) {
-					MAKE_exp_log_and ( tb, c1, c2, c1 ) ;
+					MAKE_exp_log_and(tb, c1, c2, c1);
-				    }
-				    c2 = r->cond ;
-				    if ( !IS_NULL_exp ( c2 ) ) {
-					MAKE_exp_log_or ( tb, c1, c2, c1 ) ;
+				    }
+				    c2 = r->cond;
+				    if (!IS_NULL_exp(c2)) {
+					MAKE_exp_log_or(tb, c1, c2, c1);
+				    }
-				    r->cond = c1 ;
+				    r->cond = c1;
-				    have_match = 1 ;
+				    have_match = 1;
+				}
-				save [i] = NULL_exp ;
+				save[i] = NULL_exp;
+			    }
-			} else if ( option ( OPT_overload_strict ) ) {
+			} else if (option(OPT_overload_strict)) {
 			    /* Don't have match in all cases */
-			    have_match = 0 ;
+			    have_match = 0;
-			    break ;
+			    break;
+			}
-			ps = TAIL_list ( ps ) ;
+			ps = TAIL_list(ps);
 		    }
-		    if ( !have_match ) {
+		    if (!have_match) {
-			overall_rank = RANK_VIABLE ;
+			overall_rank = RANK_VIABLE;
-			break ;
+			break;
+		    }
+		}
+	    }
-	    a = TAIL_list ( a ) ;
+	    a = TAIL_list(a);
-	    na++ ;
+	    na++;
+	}
+	if (save != saved) {
+		xfree_nof(save);
+	}
-	if ( save != saved ) xfree_nof ( save ) ;
+    }
     /* Select last viable candidate */
-    for ( i = 0 ; i < n ; i++ ) {
+    for (i = 0; i < n; i++) {
-	CANDIDATE *r = q + i ;
+	CANDIDATE *r = q + i;
-	if ( r->rank >= RANK_VIABLE ) {
+	if (r->rank >= RANK_VIABLE) {
-	    if ( overall_rank == RANK_TARGET ) {
+	    if (overall_rank == RANK_TARGET) {
-		if ( IS_NULL_exp ( r->cond ) ) {
+		if (IS_NULL_exp(r->cond)) {
-		    if ( depth == 0 ) r->rank = RANK_ARGS ;
+		    if (depth == 0)r->rank = RANK_ARGS;
 		} else {
-		    r->rank = overall_rank ;
+		    r->rank = overall_rank;
-		    best = r ;
+		    best = r;
 		}
 	    } else {
-		r->rank = overall_rank ;
+		r->rank = overall_rank;
-		best = r ;
+		best = r;
+	    }
+	}
+    }
-    return ( best ) ;
+    return (best);
 }
 /*
     LIST OF ALL AMBIGUOUS OVERLOADED FUNCTIONS
     This list is used to hold all the dummy tokenised functions constructed
     to represent target dependent overload resolutions.  The functions are
     determined by the list of candidates, the list of argument types and
     the qualifier used.
 */
 typedef struct ambig_func_tag {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    LIST ( IDENTIFIER ) funcs ;
+	LIST(IDENTIFIER) funcs;
-    LIST ( TYPE ) types ;
+	LIST(TYPE) types;
-    QUALIFIER qual ;
+	QUALIFIER qual;
-    struct ambig_func_tag *next ;
+	struct ambig_func_tag *next;
-} AMBIG_FUNCTION ;
+} AMBIG_FUNCTION;
-static AMBIG_FUNCTION *all_ambig_funcs = NULL ;
+static AMBIG_FUNCTION *all_ambig_funcs = NULL;
 /*
     FIND A PREVIOUS AMBIGUOUS OVERLOADED FUNCTION
     This routine searches the list of all ambiguous overloaded functions
     for one which candidate functions p, argument types q and qualifier
     qual.
 */
-static IDENTIFIER previous_ambig_func
+static IDENTIFIER
-    PROTO_N ( ( p, q, qual ) )
-    PROTO_T ( LIST ( IDENTIFIER ) p X LIST ( TYPE ) q X QUALIFIER qual )
+previous_ambig_func(LIST(IDENTIFIER) p, LIST(TYPE) q, QUALIFIER qual)
 {
-    AMBIG_FUNCTION *f = all_ambig_funcs ;
+	AMBIG_FUNCTION *f = all_ambig_funcs;
-    if ( f ) {
+	if (f) {
-	unsigned np = LENGTH_list ( p ) ;
+		unsigned np = LENGTH_list(p);
-	unsigned nq = LENGTH_list ( q ) ;
+		unsigned nq = LENGTH_list(q);
-	while ( f != NULL ) {
+		while (f != NULL) {
-	    if ( f->qual == qual ) {
+			if (f->qual == qual) {
-		int ok = 1 ;
+				int ok = 1;
-		LIST ( IDENTIFIER ) pf = f->funcs ;
+				LIST(IDENTIFIER) pf = f->funcs;
-		LIST ( TYPE ) qf = f->types ;
+				LIST(TYPE) qf = f->types;
-		if ( LENGTH_list ( pf ) == np ) {
+				if (LENGTH_list(pf) == np) {
-		    LIST ( IDENTIFIER ) pg = p ;
+					LIST(IDENTIFIER) pg = p;
-		    while ( !IS_NULL_list ( pg ) ) {
+					while (!IS_NULL_list(pg)) {
+						IDENTIFIER nf =
-			IDENTIFIER nf = DEREF_id ( HEAD_list ( pf ) ) ;
+						    DEREF_id(HEAD_list(pf));
+						IDENTIFIER ng =
-			IDENTIFIER ng = DEREF_id ( HEAD_list ( pg ) ) ;
+						    DEREF_id(HEAD_list(pg));
-			if ( !EQ_id ( nf, ng ) ) {
+						if (!EQ_id(nf, ng)) {
-			    ok = 0 ;
+							ok = 0;
-			    break ;
+							break;
-			}
+						}
-			pf = TAIL_list ( pf ) ;
+						pf = TAIL_list(pf);
-			pg = TAIL_list ( pg ) ;
+						pg = TAIL_list(pg);
-		    }
+					}
-		}
+				}
-		if ( ok && LENGTH_list ( qf ) == nq ) {
+				if (ok && LENGTH_list(qf) == nq) {
-		    LIST ( TYPE ) qg = q ;
+					LIST(TYPE) qg = q;
-		    while ( !IS_NULL_list ( qg ) ) {
+					while (!IS_NULL_list(qg)) {
+						TYPE tf =
-			TYPE tf = DEREF_type ( HEAD_list ( qf ) ) ;
+						    DEREF_type(HEAD_list(qf));
+						TYPE tg =
-			TYPE tg = DEREF_type ( HEAD_list ( qg ) ) ;
+						    DEREF_type(HEAD_list(qg));
-			if ( !eq_type ( tf, tg ) ) {
+						if (!eq_type(tf, tg)) {
-			    ok = 0 ;
+							ok = 0;
-			    break ;
+							break;
+						}
+						qf = TAIL_list(qf);
+						qg = TAIL_list(qg);
+					}
+				}
+				if (ok) {
+					return (f->id);
+				}
+			}
-			qf = TAIL_list ( qf ) ;
+			f = f->next;
-			qg = TAIL_list ( qg ) ;
-		    }
+		}
-		if ( ok ) return ( f->id ) ;
-	    }
-	    f = f->next ;
+	}
-    }
-    return ( NULL_id ) ;
+	return (NULL_id);
+}
 /*
     CONSTRUCT AN AMBIGUOUS OVERLOADED FUNCTION
     This routine constructs a dummy tokenised function to represent the
     target dependent overload resolution given by the candidates p for
     the function call 'id ( args )' detected by the previous call to
     resolve_ambiguous.  Any errors arising are added to err.
 */
-IDENTIFIER make_ambig_func
+IDENTIFIER
-    PROTO_N ( ( p, id, args, qual, err ) )
-    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X LIST ( EXP ) args X
+make_ambig_func(CANDIDATE_LIST *p, IDENTIFIER id, LIST(EXP) args,
-	      QUALIFIER qual X ERROR *err )
+		QUALIFIER qual, ERROR *err)
 {
-    EXP res ;
+	EXP res;
-    TYPE fn ;
+	TYPE fn;
-    TOKEN tok ;
+	TOKEN tok;
-    TYPE form ;
+	TYPE form;
-    MEMBER mem ;
+	MEMBER mem;
-    DECL_SPEC ds ;
+	DECL_SPEC ds;
-    IDENTIFIER tid ;
+	IDENTIFIER tid;
-    LIST ( TYPE ) mt ;
+	LIST(TYPE) mt;
-    AMBIG_FUNCTION *all ;
+	AMBIG_FUNCTION *all;
-    TYPE ret = NULL_type ;
+	TYPE ret = NULL_type;
-    TYPE et = type_error ;
+	TYPE et = type_error;
-    CANDIDATE *q = p->elem ;
+	CANDIDATE *q = p->elem;
-    unsigned i, n = p->size ;
+	unsigned i, n = p->size;
-    NAMESPACE ns = crt_namespace ;
+	NAMESPACE ns = crt_namespace;
-    QUALIFIER cq = crt_id_qualifier ;
+	QUALIFIER cq = crt_id_qualifier;
-    int tq = crt_templ_qualifier ;
+	int tq = crt_templ_qualifier;
-    int td = have_type_declaration ;
+	int td = have_type_declaration;
-    unsigned tag = id_function_tag ;
+	unsigned tag = id_function_tag;
-    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+	HASHID nm = DEREF_hashid(id_name(id));
+	/* List of viable candidates */
+	LIST(EXP) conds = NULL_list(EXP);
+	LIST(TYPE) types = NULL_list(TYPE);
+	LIST(IDENTIFIER) funcs = NULL_list(IDENTIFIER);
+	/* Check function return types */
+	for (i = 0; i < n; i++) {
+		CANDIDATE *r = q + i;
+		if (r->rank >= RANK_VIABLE) {
+			int suspect = 0;
+			TYPE ta = NULL_type;
+			IDENTIFIER fid = r->base;
+			switch (TAG_id(fid)) {
+			case id_builtin_tag: {
+				ta = DEREF_type(id_builtin_ret(fid));
+				break;
+			}
+			case id_function_tag: {
+				TYPE fa = DEREF_type(id_function_type(fid));
+				if (IS_type_func(fa)) {
+					ta = DEREF_type(type_func_ret(fa));
+				}
+				break;
+			}
+			case id_mem_func_tag: {
+				TYPE fa = DEREF_type(id_mem_func_type(fid));
+				if (IS_type_func(fa)) {
+					HASHID fnm = DEREF_hashid(id_name(fid));
+					mt = DEREF_list(type_func_mtypes(fa));
+					et = DEREF_type(HEAD_list(mt));
+					if (IS_hashid_constr(fnm)) {
+						ta = DEREF_type(hashid_constr_type(fnm));
+					} else {
+						ta = DEREF_type(type_func_ret(fa));
+						tag = id_mem_func_tag;
+					}
+				}
+				break;
+			}
+			case id_stat_mem_func_tag: {
+				TYPE fa =
+				    DEREF_type(id_stat_mem_func_type(fid));
+				if (IS_type_func(fa)) {
+					mt = DEREF_list(type_func_mtypes(fa));
+					et = DEREF_type(HEAD_list(mt));
+					ta = DEREF_type(type_func_ret(fa));
+					if (tag != id_mem_func_tag) {
+						tag = id_stat_mem_func_tag;
+					}
+				}
+				break;
+			}
+			}
+			ret = common_type(ret, ta, &suspect);
+			if (suspect) {
+				ret = NULL_type;
+			}
+			CONS_exp(r->cond, conds, conds);
+			CONS_id(fid, funcs, funcs);
+		}
+	}
+	if (IS_NULL_type(ret)) {
+		/* Couldn't bring return types to common type */
+		ERROR err2 = ERR_over_match_best_common();
+		add_error(err, err2);
+		ret = type_error;
+	}
+	if (err != KILL_err) {
+		*err = list_candidates(*err, p, RANK_VIABLE);
+	}
+	/* Create list of argument types */
+	while (!IS_NULL_list(args)) {
+		TYPE t;
+		EXP e = DEREF_exp(HEAD_list(args));
+		if (IS_NULL_exp(e)) {
+			t = et;
+			et = type_error;
+		} else {
+			t = DEREF_type(exp_type(e));
+			if (IS_type_bitfield(t)) {
+				t = promote_type(t);
+			} else {
+				CV_SPEC cv = DEREF_cv(type_qual(t));
+				if (cv & cv_lvalue) {
+					MAKE_type_ref(cv_none, t, t);
+				}
+			}
+		}
+		CONS_type(t, types, types);
+		args = TAIL_list(args);
+	}
+	types = REVERSE_list(types);
+	/* Check for previous instance */
+	tid = previous_ambig_func(funcs, types, qual);
+	if (!IS_NULL_id(tid)) {
+		DESTROY_list(funcs, SIZE_id);
+		DESTROY_list(types, SIZE_type);
+		free_exp_list(conds, 1);
+		return (tid);
+	}
+	/* Create new instance */
+	all = xmalloc_one(AMBIG_FUNCTION);
+	all->id = NULL_id;
+	all->funcs = funcs;
+	all->types = types;
+	all->qual = qual;
+	all->next = all_ambig_funcs;
+	all_ambig_funcs = all;
+	/* Scan through argument types */
+	crt_id_qualifier = qual_none;
+	crt_templ_qualifier = 0;
+	have_type_declaration = TYPE_DECL_NONE;
+	decl_loc = crt_loc;
+	begin_param(id);
+	mt = types;
+	while (!IS_NULL_list(mt)) {
+		HASHID pnm = lookup_anon();
+		IDENTIFIER pid = DEREF_id(hashid_id(pnm));
+		TYPE t = DEREF_type(HEAD_list(mt));
+		pid = make_param_decl(dspec_none, t, pid, CONTEXT_PARAMETER);
+		init_param(pid, NULL_exp);
+		mt = TAIL_list(mt);
+	}
+	fn = make_func_type(ret, FUNC_NONE, cv_none, empty_type_set);
+	if (tag != id_function_tag) {
+		mt = DEREF_list(type_func_ptypes(fn));
+		mt = TAIL_list(mt);
+		COPY_list(type_func_ptypes(fn), mt);
+	}
+	end_param();
+	/* Create a function identifier */
+	ds = (dspec_static | dspec_token | dspec_reserve);
+	MAKE_id_function_etc(tag, nm, ds, ns, crt_loc, fn, NULL_id, id);
-    /* List of viable candidates */
+	/* Create token identifier */
+	ns = token_namespace;
+	nm = lookup_anon();
-    LIST ( EXP ) conds = NULL_list ( EXP ) ;
+	mem = search_member(ns, nm, 1);
+	MAKE_tok_func(fn, tok);
-    LIST ( TYPE ) types = NULL_list ( TYPE ) ;
+	MAKE_id_token(nm, ds, ns, crt_loc, tok, id, tid);
-    LIST ( IDENTIFIER ) funcs = NULL_list ( IDENTIFIER ) ;
+	MAKE_type_token(cv_none, tid, NULL_list(TOKEN), form);
+	COPY_type(id_function_etc_form(id), form);
+	set_member(mem, tid);
+	tok = func_proc_token(tok);
-    /* Check function return types */
+	/* Define token */
+	res = install_error(&crt_loc, ERR_over_match_best_install());
-    for ( i = 0 ; i < n ; i++ ) {
+	while (!IS_NULL_list(funcs)) {
+		EXP c, f;
-	CANDIDATE *r = q + i ;
+		LIST(EXP) fargs = NULL_list(EXP);
+		LIST(IDENTIFIER) pids = DEREF_list(tok_proc_bids(tok));
+		IDENTIFIER fid = DEREF_id(HEAD_list(funcs));
+		DESTROY_CONS_exp(destroy, c, conds, conds);
+		while (!IS_NULL_list(pids)) {
-	if ( r->rank >= RANK_VIABLE ) {
+			/* Build up argument list */
+			TYPE t;
-	    int suspect = 0 ;
+			int prom = 0;
-	    TYPE ta = NULL_type ;
+			LIST(TYPE) pt;
-	    IDENTIFIER fid = r->base ;
+			IDENTIFIER pid = DEREF_id(HEAD_list(pids));
+			EXP e = apply_exp_token(pid, NULL_list(TOKEN), 0);
+			e = convert_reference(e, REF_NORMAL);
-	    switch ( TAG_id ( fid ) ) {
+			t = DEREF_type(exp_type(e));
+			pt = possible_types(t, &prom);
-		case id_builtin_tag : {
+			if (!IS_NULL_list(pt)) {
-		    ta = DEREF_type ( id_builtin_ret ( fid ) ) ;
+				/* Mark target dependent arguments */
+				MAKE_exp_paren(t, e, e);
+			}
+			CONS_exp(e, fargs, fargs);
-		    break ;
+			pids = TAIL_list(pids);
+		}
-		case id_function_tag : {
+		fargs = REVERSE_list(fargs);
-		    TYPE fa = DEREF_type ( id_function_type ( fid ) ) ;
-		    if ( IS_type_func ( fa ) ) {
+		if (IS_id_builtin(fid)) {
-			ta = DEREF_type ( type_func_ret ( fa ) ) ;
+			f = apply_builtin(fid, fargs);
-		    }
+		} else {
-		    break ;
-		}
-		case id_mem_func_tag : {
-		    TYPE fa = DEREF_type ( id_mem_func_type ( fid ) ) ;
-		    if ( IS_type_func ( fa ) ) {
-			HASHID fnm = DEREF_hashid ( id_name ( fid ) ) ;
+			HASHID fnm = DEREF_hashid(id_name(fid));
-			mt = DEREF_list ( type_func_mtypes ( fa ) ) ;
+			use_func_id(fid, 1, 0);
-			et = DEREF_type ( HEAD_list ( mt ) ) ;
-			if ( IS_hashid_constr ( fnm ) ) {
+			if (IS_hashid_constr(fnm)) {
-			    ta = DEREF_type ( hashid_constr_type ( fnm ) ) ;
+				f = apply_constr(fid, fargs);
 			} else {
-			    ta = DEREF_type ( type_func_ret ( fa ) ) ;
+				f = apply_func_id(fid, qual, NULL_graph, fargs);
-			    tag = id_mem_func_tag ;
+			}
-		    }
-		    break ;
+		}
-		case id_stat_mem_func_tag : {
+		if (!IS_type_top_etc(ret)) {
-		    TYPE fa = DEREF_type ( id_stat_mem_func_type ( fid ) ) ;
-		    if ( IS_type_func ( fa ) ) {
+			/* Convert to common return type */
-			mt = DEREF_list ( type_func_mtypes ( fa ) ) ;
+			ERROR err2 = NULL_err;
-			et = DEREF_type ( HEAD_list ( mt ) ) ;
+			f = convert_reference(f, REF_ASSIGN);
-			ta = DEREF_type ( type_func_ret ( fa ) ) ;
+			f = cast_exp(ret, f, &err2, CAST_IMPLICIT);
-			if ( tag != id_mem_func_tag ) {
+			if (!IS_NULL_err(err2)) {
-			    tag = id_stat_mem_func_tag ;
+				report(crt_loc, err2);
+			}
-		    }
-		    break ;
+		}
-	    }
+		if (IS_NULL_exp(res)) {
-	    ret = common_type ( ret, ta, &suspect ) ;
+			free_exp(c, 1);
-	    if ( suspect ) ret = NULL_type ;
+			res = f;
+		} else {
-	    CONS_exp ( r->cond, conds, conds ) ;
+			MAKE_exp_hash_if (ret, c, f, res, res);
+		}
-	    CONS_id ( fid, funcs, funcs ) ;
+		funcs = TAIL_list(funcs);
+	}
-    }
-    if ( IS_NULL_type ( ret ) ) {
+	IGNORE define_exp_token(tid, res, 1);
-	/* Couldn't bring return types to common type */
-	ERROR err2 = ERR_over_match_best_common () ;
-	add_error ( err, err2 ) ;
-	ret = type_error ;
-    }
-    if ( err != KILL_err ) {
-	*err = list_candidates ( *err, p, RANK_VIABLE ) ;
-    }
-    /* Create list of argument types */
-    while ( !IS_NULL_list ( args ) ) {
-	TYPE t ;
-	EXP e = DEREF_exp ( HEAD_list ( args ) ) ;
-	if ( IS_NULL_exp ( e ) ) {
-	    t = et ;
-	    et = type_error ;
-	} else {
-	    t = DEREF_type ( exp_type ( e ) ) ;
-	    if ( IS_type_bitfield ( t ) ) {
-		t = promote_type ( t ) ;
-	    } else {
-		CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
-		if ( cv & cv_lvalue ) {
-		    MAKE_type_ref ( cv_none, t, t ) ;
-		}
-	    }
-	}
-	CONS_type ( t, types, types ) ;
-	args = TAIL_list ( args ) ;
-    }
-    types = REVERSE_list ( types ) ;
-    /* Check for previous instance */
-    tid = previous_ambig_func ( funcs, types, qual ) ;
-    if ( !IS_NULL_id ( tid ) ) {
-	DESTROY_list ( funcs, SIZE_id ) ;
-	DESTROY_list ( types, SIZE_type ) ;
-	free_exp_list ( conds, 1 ) ;
-	return ( tid ) ;
-    }
-    /* Create new instance */
-    all = xmalloc_one ( AMBIG_FUNCTION ) ;
-    all->id = NULL_id ;
-    all->funcs = funcs ;
-    all->types = types ;
-    all->qual = qual ;
-    all->next = all_ambig_funcs ;
-    all_ambig_funcs = all ;
-    /* Scan through argument types */
-    crt_id_qualifier = qual_none ;
-    crt_templ_qualifier = 0 ;
-    have_type_declaration = TYPE_DECL_NONE ;
-    decl_loc = crt_loc ;
-    begin_param ( id ) ;
-    mt = types ;
-    while ( !IS_NULL_list ( mt ) ) {
-	HASHID pnm = lookup_anon () ;
-	IDENTIFIER pid = DEREF_id ( hashid_id ( pnm ) ) ;
-	TYPE t = DEREF_type ( HEAD_list ( mt ) ) ;
-	pid = make_param_decl ( dspec_none, t, pid, CONTEXT_PARAMETER ) ;
-	init_param ( pid, NULL_exp ) ;
-	mt = TAIL_list ( mt ) ;
-    }
-    fn = make_func_type ( ret, FUNC_NONE, cv_none, empty_type_set ) ;
-    if ( tag != id_function_tag ) {
-	mt = DEREF_list ( type_func_ptypes ( fn ) ) ;
-	mt = TAIL_list ( mt ) ;
-	COPY_list ( type_func_ptypes ( fn ), mt ) ;
-    }
-    end_param () ;
-    /* Create a function identifier */
-    ds = ( dspec_static | dspec_token | dspec_reserve ) ;
-    MAKE_id_function_etc ( tag, nm, ds, ns, crt_loc, fn, NULL_id, id ) ;
-    /* Create token identifier */
-    ns = token_namespace ;
-    nm = lookup_anon () ;
-    mem = search_member ( ns, nm, 1 ) ;
-    MAKE_tok_func ( fn, tok ) ;
-    MAKE_id_token ( nm, ds, ns, crt_loc, tok, id, tid ) ;
-    MAKE_type_token ( cv_none, tid, NULL_list ( TOKEN ), form ) ;
-    COPY_type ( id_function_etc_form ( id ), form ) ;
-    set_member ( mem, tid ) ;
-    tok = func_proc_token ( tok ) ;
-    /* Define token */
-    res = install_error ( &crt_loc, ERR_over_match_best_install () ) ;
-    while ( !IS_NULL_list ( funcs ) ) {
-	EXP c, f ;
-	LIST ( EXP ) fargs = NULL_list ( EXP ) ;
-	LIST ( IDENTIFIER ) pids = DEREF_list ( tok_proc_bids ( tok ) ) ;
-	IDENTIFIER fid = DEREF_id ( HEAD_list ( funcs ) ) ;
-	DESTROY_CONS_exp ( destroy, c, conds, conds ) ;
-	while ( !IS_NULL_list ( pids ) ) {
-	    /* Build up argument list */
-	    TYPE t ;
-	    int prom = 0 ;
-	    LIST ( TYPE ) pt ;
-	    IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
-	    EXP e = apply_exp_token ( pid, NULL_list ( TOKEN ), 0 ) ;
-	    e = convert_reference ( e, REF_NORMAL ) ;
-	    t = DEREF_type ( exp_type ( e ) ) ;
-	    pt = possible_types ( t, &prom ) ;
-	    if ( !IS_NULL_list ( pt ) ) {
-		/* Mark target dependent arguments */
-		MAKE_exp_paren ( t, e, e ) ;
-	    }
-	    CONS_exp ( e, fargs, fargs ) ;
-	    pids = TAIL_list ( pids ) ;
-	}
-	fargs = REVERSE_list ( fargs ) ;
-	if ( IS_id_builtin ( fid ) ) {
-	    f = apply_builtin ( fid, fargs ) ;
-	} else {
-	    HASHID fnm = DEREF_hashid ( id_name ( fid ) ) ;
-	    use_func_id ( fid, 1, 0 ) ;
-	    if ( IS_hashid_constr ( fnm ) ) {
-		f = apply_constr ( fid, fargs ) ;
-	    } else {
-		f = apply_func_id ( fid, qual, NULL_graph, fargs ) ;
-	    }
-	}
-	if ( !IS_type_top_etc ( ret ) ) {
-	    /* Convert to common return type */
-	    ERROR err2 = NULL_err ;
-	    f = convert_reference ( f, REF_ASSIGN ) ;
-	    f = cast_exp ( ret, f, &err2, CAST_IMPLICIT ) ;
-	    if ( !IS_NULL_err ( err2 ) ) report ( crt_loc, err2 ) ;
-	}
-	if ( IS_NULL_exp ( res ) ) {
-	    free_exp ( c, 1 ) ;
-	    res = f ;
-	} else {
-	    MAKE_exp_hash_if ( ret, c, f, res, res ) ;
-	}
-	funcs = TAIL_list ( funcs ) ;
-    }
-    IGNORE define_exp_token ( tid, res, 1 ) ;
-    /* Restore previous state */
+	/* Restore previous state */
-    have_type_declaration = td ;
+	have_type_declaration = td;
-    crt_templ_qualifier = tq ;
+	crt_templ_qualifier = tq;
-    crt_id_qualifier = cq ;
+	crt_id_qualifier = cq;
-    all->id = id ;
+	all->id = id;
-    return ( id ) ;
+	return (id);
 }
 /*
     IS AN IDENTIFIER A FUNCTION TEMPLATE?
     This routine returns true if id is a function template.  In this case
     overload resolution is always done even if id is not overloaded.
 */
-static int is_template_func
+static int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_template_func(IDENTIFIER id)
 {
-    if ( IS_id_function_etc ( id ) ) {
+	if (IS_id_function_etc(id)) {
-	TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+		TYPE fn = DEREF_type(id_function_etc_type(id));
-	if ( IS_type_templ ( fn ) ) return ( 1 ) ;
+		if (IS_type_templ(fn)) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     RESOLVE AN OVERLOADED FUNCTION CALL
     This routine resolves the overloaded function call 'id ( args )' where
     id is an identifier expression.  dep is true when id is a simple
     identifier returned is the first of the viable functions to be declared
     (this is a side effect of the algorithm in resolve_overload and the
     way in which overloaded functions are represented).
 */
-IDENTIFIER resolve_call
+IDENTIFIER
-    PROTO_N ( ( id, args, qual, dep ) )
-    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args X QUALIFIER qual X int dep )
+resolve_call(IDENTIFIER id, LIST(EXP) args, QUALIFIER qual, int dep)
+{
-    /* Build up candidate list */
+	/* Build up candidate list */
-    unsigned sz ;
+	unsigned sz;
-    IDENTIFIER fid = id ;
+	IDENTIFIER fid = id;
-    CANDIDATE_LIST *p = &candidates ;
+	CANDIDATE_LIST *p = &candidates;
-    p->size = 0 ;
+	p->size = 0;
-    if ( dep ) {
+	if (dep) {
-	/* Allow for argument dependent look-up */
+		/* Allow for argument dependent look-up */
-	LIST ( EXP ) q = args ;
+		LIST(EXP) q = args;
-	while ( !IS_NULL_list ( q ) ) {
+		while (!IS_NULL_list(q)) {
-	    EXP a = DEREF_exp ( HEAD_list ( q ) ) ;
+			EXP a = DEREF_exp(HEAD_list(q));
-	    if ( !IS_NULL_exp ( a ) ) {
+			if (!IS_NULL_exp(a)) {
-		TYPE t = DEREF_type ( exp_type ( a ) ) ;
+				TYPE t = DEREF_type(exp_type(a));
-		IGNORE koenig_candidates ( p, fid, t, KIND_FUNC ) ;
+				IGNORE koenig_candidates(p, fid, t, KIND_FUNC);
-	    }
+			}
-	    q = TAIL_list ( q ) ;
+			q = TAIL_list(q);
-	}
+		}
-    }
+	}
-    add_candidates ( p, fid, 1, KIND_FUNC ) ;
+	add_candidates(p, fid, 1, KIND_FUNC);
-    sz = p->size ;
+	sz = p->size;
-    if ( sz == 0 ) {
+	if (sz == 0) {
-	/* No candidates */
+		/* No candidates */
-	EXP a ;
+		EXP a;
-	int fn = 2 ;
+		int fn = 2;
-	QUALIFIER cq = crt_id_qualifier ;
+		QUALIFIER cq = crt_id_qualifier;
-	crt_id_qualifier = ( qual & qual_explicit ) ;
+		crt_id_qualifier = (qual & qual_explicit);
-	if ( qual & qual_mark ) fn = 1 ;
+		if (qual & qual_mark) {
+			fn = 1;
+		}
-	a = implicit_id_exp ( fid, fn ) ;
+		a = implicit_id_exp(fid, fn);
-	if ( IS_exp_identifier_etc ( a ) ) {
+		if (IS_exp_identifier_etc(a)) {
-	    fid = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
+			fid = DEREF_id(exp_identifier_etc_id(a));
-	    add_candidates ( p, fid, 1, KIND_FUNC ) ;
+			add_candidates(p, fid, 1, KIND_FUNC);
-	    sz = p->size ;
+			sz = p->size;
-	    if ( sz != 0 ) fid = p->elem [0].func ;
-	}
-	crt_id_qualifier = cq ;
-    } else {
+			if (sz != 0) {
-	fid = p->elem [0].func ;
+				fid = p->elem[0].func;
-    }
-    /* Resolve overloaded functions */
-    if ( sz > 1 ) {
-	CANDIDATE *q = resolve_overload ( p, args, NULL_type, 0 ) ;
-	IDENTIFIER qid = q->func ;
-	unsigned rank = q->rank ;
-	int kind = q->kind ;
-	if ( rank == RANK_BEST ) {
-	    /* Unambiguous resolution */
-	    if ( match_no_viable > 1 ) {
-		ERROR err = ERR_over_match_call_ok ( qid ) ;
-		if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-	    }
-	} else if ( rank == RANK_VIABLE ) {
-	    /* Ambiguous resolution */
-	    q = resolve_ambiguous ( p, args, NULL_type, 0 ) ;
-	    qid = q->func ;
-	    rank = q->rank ;
-	    if ( rank == RANK_TARGET ) {
-		ERROR err = ERR_over_match_call_target ( id ) ;
-		qid = make_ambig_func ( p, qid, args, qual, &err ) ;
-		kind = KIND_FUNC ;
-		report ( crt_loc, err ) ;
-	    } else if ( rank == RANK_VIABLE ) {
-		ERROR err = ERR_over_match_call_ambig ( id ) ;
-		err = list_candidates ( err, p, RANK_VIABLE ) ;
-		report ( crt_loc, err ) ;
-	    }
-	} else {
-	    /* Unviable resolution */
-	    report ( crt_loc, ERR_over_match_viable_none ( id ) ) ;
-	}
+			}
-	resolved_kind = kind ;
-	return ( qid ) ;
-    }
-    /* Check template functions */
-    if ( is_template_func ( fid ) ) {
-	ERROR err = NULL_err ;
-	IDENTIFIER qid = deduce_args ( fid, args, 2, 0, 1, &err ) ;
-	if ( IS_NULL_id ( qid ) ) {
-	    /* No viable resolution */
-	    err = concat_error ( err, ERR_over_match_viable_none ( id ) ) ;
-	    qid = fid ;
-	}
+		}
-	if ( !IS_NULL_err ( err ) ) {
-	    /* Report any argument deduction errors */
-	    err = concat_error ( err, ERR_temp_deduct_fail ( id ) ) ;
-	    report ( crt_loc, err ) ;
+		crt_id_qualifier = cq;
 	} else {
-	    /* Successful argument deduction */
+		fid = p->elem[0].func;
-	    report ( crt_loc, ERR_over_match_call_ok ( qid ) ) ;
+	}
+	/* Resolve overloaded functions */
+	if (sz > 1) {
+		CANDIDATE *q = resolve_overload(p, args, NULL_type, 0);
+		IDENTIFIER qid = q->func;
+		unsigned rank = q->rank;
+		int kind = q->kind;
+		if (rank == RANK_BEST) {
+			/* Unambiguous resolution */
+			if (match_no_viable > 1) {
+				ERROR err = ERR_over_match_call_ok(qid);
+				if (!IS_NULL_err(err)) {
+					report(crt_loc, err);
+				}
+			}
+		} else if (rank == RANK_VIABLE) {
+			/* Ambiguous resolution */
+			q = resolve_ambiguous(p, args, NULL_type, 0);
+			qid = q->func;
+			rank = q->rank;
+			if (rank == RANK_TARGET) {
+				ERROR err = ERR_over_match_call_target(id);
+				qid = make_ambig_func(p, qid, args, qual, &err);
+				kind = KIND_FUNC;
+				report(crt_loc, err);
+			} else if (rank == RANK_VIABLE) {
+				ERROR err = ERR_over_match_call_ambig(id);
+				err = list_candidates(err, p, RANK_VIABLE);
+				report(crt_loc, err);
+			}
+		} else {
+			/* Unviable resolution */
+			report(crt_loc, ERR_over_match_viable_none(id));
+		}
+		resolved_kind = kind;
+		return (qid);
+	}
+	/* Check template functions */
+	if (is_template_func(fid)) {
+		ERROR err = NULL_err;
+		IDENTIFIER qid = deduce_args(fid, args, 2, 0, 1, &err);
+		if (IS_NULL_id(qid)) {
+			/* No viable resolution */
+			err = concat_error(err, ERR_over_match_viable_none(id));
+			qid = fid;
+		}
+		if (!IS_NULL_err(err)) {
+			/* Report any argument deduction errors */
+			err = concat_error(err, ERR_temp_deduct_fail(id));
+			report(crt_loc, err);
+		} else {
+			/* Successful argument deduction */
+			report(crt_loc, ERR_over_match_call_ok(qid));
+		}
-	fid = qid ;
+		fid = qid;
-    }
+	}
-    /* Don't check non-overloaded functions */
+	/* Don't check non-overloaded functions */
-    match_no_args = 0 ;
+	match_no_args = 0;
-    match_no_viable = 0 ;
+	match_no_viable = 0;
-    resolved_kind = KIND_FUNC ;
+	resolved_kind = KIND_FUNC;
-    return ( fid ) ;
+	return (fid);
+}
 /*
     RESOLVE AN AMBIGUOUS FUNCTION ADDRESS
     This routine resolves the list of functions ids to see which is the
     best under the template specialisation rules.  If no one best candidate
     is found the null identifier is returned.  This rule is not actually
     in ISO C++, but it could have been.
 */
-static IDENTIFIER resolve_ambig_func
+static IDENTIFIER
-    PROTO_N ( ( ids, depth ) )
-    PROTO_T ( LIST ( IDENTIFIER ) ids X int depth )
+resolve_ambig_func(LIST(IDENTIFIER) ids, int depth)
 {
-    if ( !IS_NULL_list ( ids ) ) {
+	if (!IS_NULL_list(ids)) {
-	int cmp ;
+		int cmp;
-	IDENTIFIER rid, sid ;
+		IDENTIFIER rid, sid;
-	LIST ( IDENTIFIER ) pids = ids ;
+		LIST(IDENTIFIER) pids = ids;
-	/* Find the first two functions */
+		/* Find the first two functions */
-	rid = DEREF_id ( HEAD_list ( pids ) ) ;
+		rid = DEREF_id(HEAD_list(pids));
-	pids = TAIL_list ( pids ) ;
+		pids = TAIL_list(pids);
-	if ( IS_NULL_list ( pids ) ) return ( rid ) ;
+		if (IS_NULL_list(pids)) {
+			return (rid);
+		}
-	sid = DEREF_id ( HEAD_list ( pids ) ) ;
+		sid = DEREF_id(HEAD_list(pids));
-	pids = TAIL_list ( pids ) ;
+		pids = TAIL_list(pids);
-	/* Compare them */
+		/* Compare them */
-	cmp = compare_funcs ( rid, sid ) ;
+		cmp = compare_funcs(rid, sid);
-	if ( cmp == 2 ) {
+		if (cmp == 2) {
-	    rid = sid ;
+			rid = sid;
-	} else if ( cmp != 1 ) {
+		} else if (cmp != 1) {
-	    rid = NULL_id ;
+			rid = NULL_id;
-	}
+		}
-	/* Compare the winner against the best of the rest */
+		/* Compare the winner against the best of the rest */
-	sid = resolve_ambig_func ( pids, depth + 1 ) ;
+		sid = resolve_ambig_func(pids, depth + 1);
-	cmp = compare_funcs ( rid, sid ) ;
+		cmp = compare_funcs(rid, sid);
-	if ( cmp == 2 ) {
+		if (cmp == 2) {
-	    rid = sid ;
+			rid = sid;
-	} else if ( cmp != 1 ) {
+		} else if (cmp != 1) {
-	    rid = NULL_id ;
+			rid = NULL_id;
-	}
+		}
-	/* Check overall winner */
+		/* Check overall winner */
-	if ( depth == 0 && !IS_NULL_id ( rid ) ) {
+		if (depth == 0 && !IS_NULL_id(rid)) {
-	    pids = ids ;
+			pids = ids;
-	    while ( !IS_NULL_list ( pids ) ) {
+			while (!IS_NULL_list(pids)) {
-		sid = DEREF_id ( HEAD_list ( pids ) ) ;
+				sid = DEREF_id(HEAD_list(pids));
-		if ( !EQ_id ( rid, sid ) ) {
+				if (!EQ_id(rid, sid)) {
-		    cmp = compare_funcs ( rid, sid ) ;
+					cmp = compare_funcs(rid, sid);
+					if (cmp != 1) {
-		    if ( cmp != 1 ) return ( NULL_id ) ;
+						return (NULL_id);
+					}
-		}
+				}
-		pids = TAIL_list ( pids ) ;
+				pids = TAIL_list(pids);
-	    }
+			}
+		}
+		return (rid);
+	}
-	return ( rid ) ;
-    }
-    return ( NULL_id ) ;
+	return (NULL_id);
+}
 /*
     FIND AN OVERLOADED FUNCTION OF A GIVEN TYPE
     occurs if res is true).  If there is a match ignoring linkage
     specifiers then this is returned, the value of eq_func_type for the
     result is assigned to peq.
 */
-IDENTIFIER resolve_func
+IDENTIFIER
-    PROTO_N ( ( id, t, templ, res, pids, peq ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X int templ X int res X
+resolve_func(IDENTIFIER id, TYPE t, int templ, int res, LIST(IDENTIFIER) pids,
-	      LIST ( IDENTIFIER ) pids X int *peq )
+	     int *peq)
+{
-    int best = 2 ;
+	int best = 2;
-    IDENTIFIER rid = NULL_id ;
+	IDENTIFIER rid = NULL_id;
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_function_tag :
+	case id_function_tag:
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag: {
-	    /* Check overloaded functions */
+		/* Check overloaded functions */
-	    IDENTIFIER fid = id ;
+		IDENTIFIER fid = id;
-	    int have_templates = 0 ;
+		int have_templates = 0;
-	    LIST ( IDENTIFIER ) rids = NULL_list ( IDENTIFIER ) ;
+		LIST(IDENTIFIER) rids = NULL_list(IDENTIFIER);
-	    while ( !IS_NULL_id ( fid ) ) {
+		while (!IS_NULL_id(fid)) {
-		TYPE s ;
+			TYPE s;
-		int d = 0 ;
+			int d = 0;
-		int eq = 0 ;
+			int eq = 0;
-		IDENTIFIER tid = fid ;
+			IDENTIFIER tid = fid;
-		if ( !IS_NULL_list ( pids ) ) {
+			if (!IS_NULL_list(pids)) {
-		    /* Save template parameter values */
+				/* Save template parameter values */
-		    d = save_token_args ( pids, NULL_list ( TOKEN ) ) ;
+				d = save_token_args(pids, NULL_list(TOKEN));
-		}
+			}
-		s = DEREF_type ( id_function_etc_type ( fid ) ) ;
+			s = DEREF_type(id_function_etc_type(fid));
-		if ( IS_type_templ ( s ) && templ ) {
+			if (IS_type_templ(s) && templ) {
-		    /* Template functions */
+				/* Template functions */
-		    tid = deduce_func ( tid, t, &eq ) ;
+				tid = deduce_func(tid, t, &eq);
-		    if ( !IS_NULL_id ( tid ) ) have_templates = 1 ;
+				if (!IS_NULL_id(tid)) {
+					have_templates = 1;
+				}
-		} else {
+			} else {
-		    /* Simple functions */
+				/* Simple functions */
 #if LANGUAGE_CPP
-		    eq = eq_func_type ( s, t, 1, 0 ) ;
+				eq = eq_func_type(s, t, 1, 0);
 #else
-		    TYPE r = type_composite ( s, t, 1, 0, KILL_err, 0 ) ;
+				TYPE r = type_composite(s, t, 1, 0, KILL_err,
+);
-		    if ( !IS_NULL_type ( r ) ) eq = 3 ;
+				if (!IS_NULL_type(r)) {
+					eq = 3;
+				}
 #endif
 /*
     CREATE A RESOLVED OVERLOADED FUNCTION EXPRESSION
     This routine creates a resolved overloaded function expression for
     the function id.
 */
-static EXP make_resolved_exp
+static EXP
-    PROTO_N ( ( id, q, b, addr, paren ) )
-    PROTO_T ( IDENTIFIER id X QUALIFIER q X EXP b X int addr X int paren )
+make_resolved_exp(IDENTIFIER id, QUALIFIER q, EXP b, int addr, int paren)
 {
-    EXP e ;
+	EXP e;
-    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+	TYPE fn = DEREF_type(id_function_etc_type(id));
-    if ( IS_id_mem_func ( id ) ) {
+	if (IS_id_mem_func(id)) {
-	if ( !IS_NULL_exp ( b ) ) {
+		if (!IS_NULL_exp(b)) {
-	    report ( crt_loc, ERR_expr_ref_call () ) ;
+			report(crt_loc, ERR_expr_ref_call());
-	    q = qual_nested ;
+			q = qual_nested;
+		}
+		MAKE_exp_member(fn, id, q, e);
+	} else {
+		MAKE_exp_identifier(fn, id, q, e);
+		if (!IS_NULL_exp(b)) {
+			e = join_exp(b, e);
+		}
+	}
-	MAKE_exp_member ( fn, id, q, e ) ;
-    } else {
+	if (addr) {
-	MAKE_exp_identifier ( fn, id, q, e ) ;
-	if ( !IS_NULL_exp ( b ) ) e = join_exp ( b, e ) ;
-    }
-    if ( addr ) {
+		if (paren) {
-	if ( paren ) e = make_paren_exp ( e ) ;
+			e = make_paren_exp(e);
+		}
-	e = make_ref_exp ( e, 1 ) ;
+		e = make_ref_exp(e, 1);
-    }
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     RESOLVE THE ADDRESS OF AN OVERLOADED FUNCTION
     The result is the appropriate version of e.  Note that member
     expressions which resolve to static function members are replaced
     by identifier expressions at this stage (see make_id_exp).
 */
-EXP resolve_cast
+EXP
-    PROTO_N ( ( t, e, err, use, rescan, pids ) )
-    PROTO_T ( TYPE t X EXP e X ERROR *err X int use X int rescan X
+resolve_cast(TYPE t, EXP e, ERROR *err, int use, int rescan,
-	      LIST ( IDENTIFIER ) pids )
+	     LIST(IDENTIFIER) pids)
+{
-    /* Check for identifier expressions */
+	/* Check for identifier expressions */
-    EXP a = e ;
+	EXP a = e;
-    QUALIFIER q ;
+	QUALIFIER q;
-    int addr = 0 ;
+	int addr = 0;
-    int paren = 0 ;
+	int paren = 0;
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    EXP b = NULL_exp ;
+	EXP b = NULL_exp;
-    unsigned tag = TAG_exp ( a ) ;
+	unsigned tag = TAG_exp(a);
-    while ( tag == exp_paren_tag ) {
+	while (tag == exp_paren_tag) {
-	a = DEREF_exp ( exp_paren_arg ( a ) ) ;
+		a = DEREF_exp(exp_paren_arg(a));
-	tag = TAG_exp ( a ) ;
+		tag = TAG_exp(a);
-    }
+	}
-    if ( tag == exp_address_tag ) {
+	if (tag == exp_address_tag) {
-	/* Address expression */
+		/* Address expression */
-	a = DEREF_exp ( exp_address_arg ( a ) ) ;
+		a = DEREF_exp(exp_address_arg(a));
-	tag = TAG_exp ( a ) ;
+		tag = TAG_exp(a);
-	addr = 1 ;
+		addr = 1;
-    } else if ( tag == exp_address_mem_tag ) {
+	} else if (tag == exp_address_mem_tag) {
-	/* Address of member expression */
+		/* Address of member expression */
-	paren = DEREF_int ( exp_address_mem_paren ( a ) ) ;
+		paren = DEREF_int(exp_address_mem_paren(a));
-	a = DEREF_exp ( exp_address_mem_arg ( a ) ) ;
+		a = DEREF_exp(exp_address_mem_arg(a));
-	tag = TAG_exp ( a ) ;
+		tag = TAG_exp(a);
-	addr = 1 ;
+		addr = 1;
-    } else if ( tag == exp_op_tag ) {
+	} else if (tag == exp_op_tag) {
-	/* Check for undetermined address expressions */
+		/* Check for undetermined address expressions */
-	int op = DEREF_int ( exp_op_lex ( a ) ) ;
+		int op = DEREF_int(exp_op_lex(a));
-	EXP c = DEREF_exp ( exp_op_arg2 ( a ) ) ;
+		EXP c = DEREF_exp(exp_op_arg2(a));
-	if ( op == lex_and_H1 && IS_NULL_exp ( c ) ) {
+		if (op == lex_and_H1 && IS_NULL_exp(c)) {
-	    a = DEREF_exp ( exp_op_arg1 ( a ) ) ;
+			a = DEREF_exp(exp_op_arg1(a));
-	    tag = TAG_exp ( a ) ;
+			tag = TAG_exp(a);
-	    addr = 1 ;
+			addr = 1;
-	}
+		}
-    }
+	}
-    while ( tag == exp_paren_tag ) {
+	while (tag == exp_paren_tag) {
-	a = DEREF_exp ( exp_paren_arg ( a ) ) ;
+		a = DEREF_exp(exp_paren_arg(a));
-	paren = 1 ;
+		paren = 1;
-	tag = TAG_exp ( a ) ;
+		tag = TAG_exp(a);
-    }
+	}
-    if ( tag == exp_call_tag ) {
+	if (tag == exp_call_tag) {
-	/* Member reference expression */
+		/* Member reference expression */
-	b = DEREF_exp ( exp_call_arg ( a ) ) ;
+		b = DEREF_exp(exp_call_arg(a));
-	a = DEREF_exp ( exp_call_ptr ( a ) ) ;
+		a = DEREF_exp(exp_call_ptr(a));
-    }
+	}
-    if ( !IS_exp_identifier_etc ( a ) ) {
+	if (!IS_exp_identifier_etc(a)) {
-	/* Not an identifier expression */
+		/* Not an identifier expression */
-	return ( e ) ;
+		return (e);
-    }
-    /* Mark identifiers as resolved */
-    id = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
-    q = DEREF_qual ( exp_identifier_etc_qual ( a ) ) ;
-    if ( q & qual_mark ) return ( e ) ;
-    if ( rescan ) {
-	/* Rescan function name if necessary */
-	id = rescan_func_id ( id, q ) ;
-    }
-    q |= qual_mark ;
+	}
-    /* Check for overloaded functions */
-    tag = TAG_id ( id ) ;
-    switch ( tag ) {
-	case id_function_tag :
-	case id_mem_func_tag :
-	case id_stat_mem_func_tag :
-	function_lab : {
-	    /* Check functions for overloading */
+	/* Mark identifiers as resolved */
-	    TYPE s ;
-	    IDENTIFIER over ;
-	    if ( rescan ) goto overload_lab ;
-	    if ( dependent_cast ( id, t ) ) {
-		/* Allow for template parameters */
-		if ( !IS_type_func ( t ) ) t = rvalue_type ( t ) ;
-		MAKE_exp_op ( t, lex_function, e, NULL_exp, e ) ;
-		return ( e ) ;
-	    }
-	    over = DEREF_id ( id_function_etc_over ( id ) ) ;
-	    if ( !IS_NULL_id ( over ) ) goto overload_lab ;
-	    s = DEREF_type ( id_function_etc_type ( id ) ) ;
+	id = DEREF_id(exp_identifier_etc_id(a));
-	    if ( IS_type_templ ( s ) ) goto overload_lab ;
-	    if ( tag == id_mem_func_tag ) {
-		if ( !IS_NULL_exp ( b ) || addr ) {
-		    /* Force error in this case */
-		    e = make_resolved_exp ( id, q, b, addr, paren ) ;
-		}
-	    }
-	    if ( use ) {
-		COPY_qual ( exp_identifier_etc_qual ( a ), q ) ;
+	q = DEREF_qual(exp_identifier_etc_qual(a));
-		use_id ( id, suppress_usage ) ;
-	    }
-	    break ;
-	}
-	case id_ambig_tag :
-	case id_undef_tag :
-	overload_lab : {
+	if (q & qual_mark) {
-	    /* Overloaded and ambiguous functions */
-	    TYPE fn = find_func_type ( t ) ;
-	    if ( !IS_NULL_type ( fn ) ) {
-		/* Overload resolution */
-		int eq = 0 ;
-		IDENTIFIER rid ;
-		if ( dependent_cast ( id, t ) ) {
-		    /* Allow for template parameters */
-		    if ( !IS_type_func ( t ) ) t = rvalue_type ( t ) ;
-		    MAKE_exp_op ( t, lex_function, e, NULL_exp, e ) ;
-		    return ( e ) ;
+		return (e);
-		}
+	}
-		if ( tag == id_undef_tag ) goto default_lab ;
-		rid = resolve_func ( id, fn, 1, 0, pids, &eq ) ;
-		if ( !IS_NULL_id ( rid ) ) {
-		    if ( IS_id_ambig ( rid ) ) {
-			/* Ambiguous resolution */
-			if ( use ) {
+	if (rescan) {
-			    /* Select one function */
+		/* Rescan function name if necessary */
-			    LIST ( IDENTIFIER ) ids ;
-			    IGNORE report_ambiguous ( rid, 0, 0, 0 ) ;
-			    ids = DEREF_list ( id_ambig_ids ( rid ) ) ;
-			    rid = resolve_ambig_func ( ids, 0 ) ;
+		id = rescan_func_id(id, q);
-			    if ( IS_NULL_id ( rid ) ) {
-				rid = DEREF_id ( HEAD_list ( ids ) ) ;
-			    }
-			} else {
-			    e = NULL_exp ;
-			    rid = NULL_id ;
-			}
-		    }
-		    if ( !IS_NULL_id ( rid ) ) {
-			/* Unique resolution */
-			report ( crt_loc, ERR_over_over_ok ( rid ) ) ;
-			e = make_resolved_exp ( rid, q, b, addr, paren ) ;
-			if ( use ) use_id ( rid, suppress_usage ) ;
-		    }
-		} else {
-		    /* Unsuccessful resolution */
-		    if ( use ) {
-			add_error ( err, ERR_over_over_none ( id, fn ) ) ;
-			e = make_error_exp ( 0 ) ;
-		    } else {
-			e = NULL_exp ;
-		    }
-		}
-	    } else {
-		/* No context for resolution */
-		if ( tag == id_undef_tag ) goto default_lab ;
-		if ( use ) {
-		    add_error ( err, ERR_over_over_context ( id ) ) ;
-		    e = make_error_exp ( 0 ) ;
-		} else {
-		    e = NULL_exp ;
-		}
-	    }
-	    break ;
+	}
+	q |= qual_mark;
+	/* Check for overloaded functions */
+	tag = TAG_id(id);
+	switch (tag) {
+	case id_function_tag:
+	case id_mem_func_tag:
+	case id_stat_mem_func_tag:
+function_lab: {
+		       /* Check functions for overloading */
+		       TYPE s;
+		       IDENTIFIER over;
+		       if (rescan) {
+			       goto overload_lab;
+		       }
+		       if (dependent_cast(id, t)) {
+			       /* Allow for template parameters */
+			       if (!IS_type_func(t)) {
+				       t = rvalue_type(t);
+			       }
+			       MAKE_exp_op(t, lex_function, e, NULL_exp, e);
+			       return (e);
+		       }
+		       over = DEREF_id(id_function_etc_over(id));
+		       if (!IS_NULL_id(over)) {
+			       goto overload_lab;
+		       }
+		       s = DEREF_type(id_function_etc_type(id));
+		       if (IS_type_templ(s)) {
+			       goto overload_lab;
+		       }
+		       if (tag == id_mem_func_tag) {
+			       if (!IS_NULL_exp(b) || addr) {
+				       /* Force error in this case */
+				       e = make_resolved_exp(id, q, b, addr,
+							     paren);
+			       }
+		       }
+		       if (use) {
+			       COPY_qual(exp_identifier_etc_qual(a), q);
+			       use_id(id, suppress_usage);
+		       }
+		       break;
+	       }
+	case id_ambig_tag:
+	case id_undef_tag:
+overload_lab: {
+		      /* Overloaded and ambiguous functions */
+		      TYPE fn = find_func_type(t);
+		      if (!IS_NULL_type(fn)) {
+			      /* Overload resolution */
+			      int eq = 0;
+			      IDENTIFIER rid;
+			      if (dependent_cast(id, t)) {
+				      /* Allow for template parameters */
+				      if (!IS_type_func(t)) {
+					      t = rvalue_type(t);
+				      }
+				      MAKE_exp_op(t, lex_function, e, NULL_exp,
+						  e);
+				      return (e);
+			      }
+			      if (tag == id_undef_tag) {
+				      goto default_lab;
+			      }
+			      rid = resolve_func(id, fn, 1, 0, pids, &eq);
+			      if (!IS_NULL_id(rid)) {
+				      if (IS_id_ambig(rid)) {
+					      /* Ambiguous resolution */
+					      if (use) {
+						      /* Select one function */
+						      LIST(IDENTIFIER) ids;
+						      IGNORE report_ambiguous(rid, 0, 0, 0);
+						      ids = DEREF_list(id_ambig_ids(rid));
+						      rid = resolve_ambig_func(ids, 0);
+						      if (IS_NULL_id(rid)) {
+							      rid = DEREF_id(HEAD_list(ids));
+						      }
+					      } else {
+						      e = NULL_exp;
+						      rid = NULL_id;
+					      }
+				      }
+				      if (!IS_NULL_id(rid)) {
+					      /* Unique resolution */
+					      report(crt_loc, ERR_over_over_ok(rid));
+					      e = make_resolved_exp(rid, q, b, addr, paren);
+					      if (use) {
+						      use_id(rid, suppress_usage);
+					      }
+				      }
+			      } else {
+				      /* Unsuccessful resolution */
+				      if (use) {
+					      add_error(err, ERR_over_over_none(id, fn));
+					      e = make_error_exp(0);
+				      } else {
+					      e = NULL_exp;
+				      }
+			      }
+		      } else {
+			      /* No context for resolution */
+			      if (tag == id_undef_tag) {
+				      goto default_lab;
+			      }
+			      if (use) {
+				      add_error(err, ERR_over_over_context(id));
+				      e = make_error_exp(0);
+			      } else {
+				      e = NULL_exp;
+			      }
+		      }
+		      break;
+	      }
-	default :
+	default:
-	default_lab : {
+default_lab:
-	    /* Other identifiers */
+	      /* Other identifiers */
-	    if ( rescan ) {
+	      if (rescan) {
-		if ( use ) {
+		      if (use) {
-		    EXP c = implicit_id_exp ( id, 1 ) ;
+			      EXP c = implicit_id_exp(id, 1);
-		    if ( IS_exp_identifier_etc ( c ) ) {
+			      if (IS_exp_identifier_etc(c)) {
-			id = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
+				      id = DEREF_id(exp_identifier_etc_id(a));
-			if ( IS_id_function_etc ( id ) ) {
+				      if (IS_id_function_etc(id)) {
-			    goto function_lab ;
+					      goto function_lab;
-			}
+				      }
-		    }
+			      }
-		} else {
+		      } else {
-		    e = NULL_exp ;
+			      e = NULL_exp;
-		}
+		      }
-	    }
+	      }
-	    break ;
+	      break;
+	}
-    }
-    return ( e ) ;
+	return (e);
+}

Subversion Repositories tendra.SVN

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