WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/convert.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 "config.h"
 #include "c_types.h"
 #include "ctype_ops.h"
 #include "etype_ops.h"
 #include "exp_ops.h"
     first constructed.  Enumeration types and bitfield types are promoted
     according to their underlying types.  Other types (including floating
     point types) are their own promotions.
 */
-TYPE promote_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+promote_type(TYPE t)
+{
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    /* Retrieve the promotion of an integral type */
+		/* Retrieve the promotion of an integral type */
-	    INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	    t = DEREF_type ( itype_prom ( it ) ) ;
+		t = DEREF_type(itype_prom(it));
-	    break ;
+		break;
+	}
-	case type_enumerate_tag : {
+	case type_enumerate_tag: {
-	    /* Find the underlying type of an enumeration */
+		/* Find the underlying type of an enumeration */
-	    ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+		ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
-	    t = DEREF_type ( etype_rep ( et ) ) ;
+		t = DEREF_type(etype_rep(et));
-	    t = promote_type ( t ) ;
+		t = promote_type(t);
-	    break ;
+		break;
+	}
-	case type_bitfield_tag : {
+	case type_bitfield_tag: {
-	    /* Retrieve the promotion of a bitfield type */
+		/* Retrieve the promotion of a bitfield type */
-	    INT_TYPE it = DEREF_itype ( type_bitfield_defn ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_bitfield_defn(t));
-	    t = DEREF_type ( itype_prom ( it ) ) ;
+		t = DEREF_type(itype_prom(it));
-	    break ;
+		break;
+	}
-    }
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     FIND THE ARGUMENT PROMOTION OF A TYPE
     This routine finds the argument promotion type for the type t.  This
     is identical to the normal arithmetic promotion type for integral types,
     but differs for floating point types (float promotes to double etc.).
     Any errors are added to the end of err.
 */
-TYPE arg_promote_type
+TYPE
-    PROTO_N ( ( t, err ) )
-    PROTO_T ( TYPE t X ERROR *err )
+arg_promote_type(TYPE t, ERROR *err)
 {
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_integer_tag :
+	case type_integer_tag:
-	case type_enumerate_tag :
+	case type_enumerate_tag:
-	case type_bitfield_tag : {
+	case type_bitfield_tag: {
-	    /* Promote integral types */
+		/* Promote integral types */
-	    t = promote_type ( t ) ;
+		t = promote_type(t);
-	    break ;
+		break;
 	}
-	case type_floating_tag : {
+	case type_floating_tag: {
-	    /* Retrieve the promotion of a floating point type */
+		/* Retrieve the promotion of a floating point type */
-	    FLOAT_TYPE ft = DEREF_ftype ( type_floating_rep ( t ) ) ;
+		FLOAT_TYPE ft = DEREF_ftype(type_floating_rep(t));
-	    t = DEREF_type ( ftype_arg_prom ( ft ) ) ;
+		t = DEREF_type(ftype_arg_prom(ft));
-	    break ;
+		break;
 	}
-	case type_top_tag :
+	case type_top_tag:
-	case type_bottom_tag : {
+	case type_bottom_tag: {
-	    /* Can't have 'void' arguments */
+		/* Can't have 'void' arguments */
-	    add_error ( err, ERR_basic_fund_void_exp ( t ) ) ;
+		add_error(err, ERR_basic_fund_void_exp(t));
-	    break ;
+		break;
 	}
-	case type_func_tag : {
+	case type_func_tag: {
-	    /* Apply function-to-pointer conversion */
+		/* Apply function-to-pointer conversion */
-	    MAKE_type_ptr ( cv_none, t, t ) ;
+		MAKE_type_ptr(cv_none, t, t);
-	    break ;
+		break;
+	}
-	case type_array_tag : {
+	case type_array_tag: {
-	    /* Apply array-to-pointer conversion */
+		/* Apply array-to-pointer conversion */
-	    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_array_sub(t));
-	    MAKE_type_ptr ( cv_none, s, t ) ;
+		MAKE_type_ptr(cv_none, s, t);
+		break;
+	}
+	case type_compound_tag: {
+		/* Types with constructors are suspicious */
+		if (pass_complex_type(t)) {
+			add_error(err, ERR_expr_call_struct(t));
+		}
-	    break ;
+		break;
+	}
-	case type_compound_tag : {
-	    /* Types with constructors are suspicious */
-	    if ( pass_complex_type ( t ) ) {
-		add_error ( err, ERR_expr_call_struct ( t ) ) ;
-	    }
-	    break ;
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     IS A TYPE EQUAL TO ITS ARGUMENT PROMOTION TYPE?
     This routine checks whether the integral or floating point type t is
     equal to its argument promotion type.
 */
-int is_arg_promote
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+is_arg_promote(TYPE t)
+{
-    int eq = 1 ;
+	int eq = 1;
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	t = expand_type ( t, 1 ) ;
+		t = expand_type(t, 1);
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_integer_tag :
+		case type_integer_tag:
-	    case type_floating_tag : {
+		case type_floating_tag: {
-		TYPE s = arg_promote_type ( t, KILL_err ) ;
+			TYPE s = arg_promote_type(t, KILL_err);
-		if ( !EQ_type ( s, t ) ) {
+			if (!EQ_type(s, t)) {
-		    int ft = force_tokdef ;
+				int ft = force_tokdef;
-		    force_tokdef = 0 ;
+				force_tokdef = 0;
-		    eq = eq_type_unqual ( s, t ) ;
+				eq = eq_type_unqual(s, t);
-		    force_tokdef = ft ;
+				force_tokdef = ft;
+			}
+			break;
+		}
+		}
-		break ;
-	    }
+	}
-    }
-    return ( eq ) ;
+	return (eq);
+}
 /*
     FIND THE TYPE WHICH PROMOTES TO A GIVEN TYPE
     This routine is a partial inverse to arg_promote_type which finds a
     type whose promotion is t.
 */
-TYPE unpromote_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+unpromote_type(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_integer_tag : {
+		case type_integer_tag: {
-		INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+			INT_TYPE it = DEREF_itype(type_integer_rep(t));
-		INT_TYPE is = DEREF_itype ( type_integer_sem ( t ) ) ;
+			INT_TYPE is = DEREF_itype(type_integer_sem(t));
+			if (!EQ_itype(is, it)) {
-		if ( !EQ_itype ( is, it ) ) t = make_itype ( is, is ) ;
+				t = make_itype(is, is);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case type_floating_tag : {
+		case type_floating_tag: {
-		FLOAT_TYPE ft = DEREF_ftype ( type_floating_rep ( t ) ) ;
+			FLOAT_TYPE ft = DEREF_ftype(type_floating_rep(t));
-		FLOAT_TYPE fs = DEREF_ftype ( type_floating_sem ( t ) ) ;
+			FLOAT_TYPE fs = DEREF_ftype(type_floating_sem(t));
+			if (!EQ_ftype(fs, ft)) {
-		if ( !EQ_ftype ( fs, ft ) ) t = make_ftype ( fs, fs ) ;
+				t = make_ftype(fs, fs);
+			}
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     FIND THE TYPE FOR AN ARITHMETIC OPERATION
     This routine performs finds the result type for an arithmetic operation
     involving operands of types t and s.  These will always be arithmetic
     types.  The operands a and b are passed in order to help determine the
     semantic type of the result.
 */
-TYPE arith_type
+TYPE
-    PROTO_N ( ( t, s, a, b ) )
-    PROTO_T ( TYPE t X TYPE s X EXP a X EXP b )
+arith_type(TYPE t, TYPE s, EXP a, EXP b)
+{
-    TYPE r ;
+	TYPE r;
-    if ( EQ_type ( t, s ) ) {
+	if (EQ_type(t, s)) {
-	/* Equal types, promote the result */
+		/* Equal types, promote the result */
-	r = promote_type ( t ) ;
+		r = promote_type(t);
-    } else {
-	unsigned nt = TAG_type ( t ) ;
-	unsigned ns = TAG_type ( s ) ;
-	if ( nt == type_floating_tag ) {
-	    if ( ns == type_floating_tag ) {
-		/* Two floating point types */
-		r = arith_ftype ( t, s ) ;
-	    } else {
-		/* If there is one floating type, this is the result */
-		r = t ;
-	    }
 	} else {
-	    if ( ns == type_floating_tag ) {
+		unsigned nt = TAG_type(t);
-		/* If there is one floating type, this is the result */
+		unsigned ns = TAG_type(s);
-		r = s ;
+		if (nt == type_floating_tag) {
-	    } else {
+			if (ns == type_floating_tag) {
-		/* Two integer types, promote them both */
+				/* Two floating point types */
-		TYPE pt = promote_type ( t ) ;
+				r = arith_ftype(t, s);
+			} else {
-		TYPE ps = promote_type ( s ) ;
+				/* If there is one floating type, this is the
-		if ( EQ_type ( pt, ps ) ) {
+				 * result */
-		    r = pt ;
+				r = t;
+			}
 		} else {
+			if (ns == type_floating_tag) {
+				/* If there is one floating type, this is the
+				 * result */
+				r = s;
+			} else {
+				/* Two integer types, promote them both */
+				TYPE pt = promote_type(t);
+				TYPE ps = promote_type(s);
+				if (EQ_type(pt, ps)) {
+					r = pt;
+				} else {
-		    r = arith_itype ( pt, ps, a, b ) ;
+					r = arith_itype(pt, ps, a, b);
+				}
+			}
+		}
-	    }
+	}
-    }
-    return ( r ) ;
+	return (r);
+}
 /*
     QUALIFIER DEPTH
     are 0 (the types are identically qualified) and 1 (the conversion
     is of the form 'cv1 T *' to 'cv2 T *').  The value qualifier_diff
     gives the qualifiers added at this stage.
 */
-int qualifier_depth = 0 ;
+int qualifier_depth = 0;
-static CV_SPEC qualifier_diff = cv_none ;
+static CV_SPEC qualifier_diff = cv_none;
 /*
     CHECK QUALIFICATION CONVERSIONS
     This routine checks for qualification conversions from the pointer or
     rules are slightly different.  Only one level of pointers is
     considered and the types pointed to must be compatible.  Note that
     for pointer to member types it is not checked that the underlying
     classes are the same at the top level.  This is to allow base class
     pointer to member conversion to be checked elsewhere.
+}
 /*
     FIND THE TYPE FOR A POINTER OPERATION
     depth 1 qualification conversions are applied.  If t and s cannot be
     brought to a common type then the suspect flag is set to 2 and
     qualified 'void *' is returned.  suspect is set to 1 if precisely
     one of the types is 'void *'.  The routine also operates on reference
     types except that it returns a null type in the 'void *' case.
 */
-TYPE ptr_common_type
+TYPE
-    PROTO_N ( ( t, s, base, suspect ) )
-    PROTO_T ( TYPE t X TYPE s X int base X int *suspect )
+ptr_common_type(TYPE t, TYPE s, int base, int *suspect)
 {
-    CV_SPEC qt, qs ;
+	CV_SPEC qt, qs;
-    TYPE r = NULL_type ;
+	TYPE r = NULL_type;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    TYPE pt = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+	TYPE pt = DEREF_type(type_ptr_etc_sub(t));
-    TYPE ps = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
+	TYPE ps = DEREF_type(type_ptr_etc_sub(s));
-    unsigned nt = TAG_type ( pt ) ;
+	unsigned nt = TAG_type(pt);
-    unsigned ns = TAG_type ( ps ) ;
+	unsigned ns = TAG_type(ps);
-    /* Find the common type */
+	/* Find the common type */
-    if ( nt == ns ) {
+	if (nt == ns) {
-	if ( eq_type_unqual ( pt, ps ) ) {
+		if (eq_type_unqual(pt, ps)) {
-	    /* Pointers to the same type */
+			/* Pointers to the same type */
-	    r = pt ;
+			r = pt;
-	} else if ( nt == type_compound_tag && base ) {
+		} else if (nt == type_compound_tag && base) {
-	    /* Check for base class conversions */
+			/* Check for base class conversions */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( pt ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(pt));
-	    CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( ps ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(type_compound_defn(ps));
-	    CLASS_TYPE cr = compare_base_class ( ct, cs, 1 ) ;
+			CLASS_TYPE cr = compare_base_class(ct, cs, 1);
-	    if ( EQ_ctype ( cr, ct ) ) {
+			if (EQ_ctype(cr, ct)) {
-		/* p is a base class of q */
+				/* p is a base class of q */
-		r = pt ;
+				r = pt;
-	    } else if ( EQ_ctype ( cr, cs ) ) {
+			} else if (EQ_ctype(cr, cs)) {
-		/* q is a base class of p */
+				/* q is a base class of p */
-		r = ps ;
+				r = ps;
-	    }
+			}
-	}
+		}
-    } else if ( nt == type_top_tag || nt == type_bottom_tag ) {
+	} else if (nt == type_top_tag || nt == type_bottom_tag) {
-	/* One pointer is 'void *' */
+		/* One pointer is 'void *' */
-	*suspect = 1 ;
+		*suspect = 1;
-	r = pt ;
+		r = pt;
-    } else if ( ns == type_top_tag || ns == type_bottom_tag ) {
+	} else if (ns == type_top_tag || ns == type_bottom_tag) {
-	/* One pointer is 'void *' */
+		/* One pointer is 'void *' */
-	*suspect = 1 ;
+		*suspect = 1;
-	r = ps ;
+		r = ps;
-    }
+	}
 #if LANGUAGE_C
-    if ( IS_NULL_type ( r ) ) {
+	if (IS_NULL_type(r)) {
-	/* In C, compatible types are allowed */
+		/* In C, compatible types are allowed */
-	r = type_composite ( pt, ps, 1, 0, KILL_err, 1 ) ;
+		r = type_composite(pt, ps, 1, 0, KILL_err, 1);
-    }
+	}
 #endif
-    if ( IS_NULL_type ( r ) ) {
+	if (IS_NULL_type(r)) {
-	/* Can't bring to common pointer type */
+		/* Can't bring to common pointer type */
-	if ( is_templ_type ( t ) || is_templ_type ( s ) ) {
+		if (is_templ_type(t) || is_templ_type(s)) {
-	    *suspect = -1 ;
+			*suspect = -1;
-	} else {
+		} else {
-	    *suspect = 2 ;
+			*suspect = 2;
-	}
+		}
-	if ( tag == type_ref_tag ) {
+		if (tag == type_ref_tag) {
-	    /* There are no generic references */
+			/* There are no generic references */
-	    return ( NULL_type ) ;
+			return (NULL_type);
-	}
+		}
-	r = type_void ;
+		r = type_void;
-    }
+	}
-    /* Qualify the common type appropriately */
-    qt = find_cv_qual ( pt ) ;
-    qs = find_cv_qual ( ps ) ;
-    r = qualify_type ( r, ( qt | qs ), 0 ) ;
+	/* Qualify the common type appropriately */
+	qt = find_cv_qual(pt);
+	qs = find_cv_qual(ps);
+	r = qualify_type(r,(qt | qs), 0);
-    /* Form the result type */
+	/* Form the result type */
-    if ( EQ_type ( r, pt ) ) return ( t ) ;
+	if (EQ_type(r, pt)) {
+		return (t);
+	}
-    if ( EQ_type ( r, ps ) ) return ( s ) ;
+	if (EQ_type(r, ps)) {
+		return (s);
+	}
-    MAKE_type_ptr_etc ( tag, cv_none, r, r ) ;
+	MAKE_type_ptr_etc(tag, cv_none, r, r);
-    return ( r ) ;
+	return (r);
+}
 /*
     FIND THE TYPE FOR A POINTER MEMBER OPERATION
     type then suspect is set to 2 and the error type is returned.  If
     the cv-qualifier of the common type is not equal to the cv-qualifier
     of either t or s then suspect is set to 1.
 */
-TYPE ptr_mem_common_type
+TYPE
-    PROTO_N ( ( t, s, suspect ) )
-    PROTO_T ( TYPE t X TYPE s X int *suspect )
+ptr_mem_common_type(TYPE t, TYPE s, int *suspect)
+{
-    /* Check for base class conversions */
+	/* Check for base class conversions */
-    CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+	CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
-    CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( s ) ) ;
+	CLASS_TYPE cs = DEREF_ctype(type_ptr_mem_of(s));
-    CLASS_TYPE cr = compare_base_class ( ct, cs, 1 ) ;
+	CLASS_TYPE cr = compare_base_class(ct, cs, 1);
-    if ( !IS_NULL_ctype ( cr ) ) {
+	if (!IS_NULL_ctype(cr)) {
-	TYPE pr ;
+		TYPE pr;
-	TYPE pt = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+		TYPE pt = DEREF_type(type_ptr_mem_sub(t));
-	TYPE ps = DEREF_type ( type_ptr_mem_sub ( s ) ) ;
+		TYPE ps = DEREF_type(type_ptr_mem_sub(s));
-	if ( EQ_ctype ( cr, ct ) ) {
+		if (EQ_ctype(cr, ct)) {
-	    cr = cs ;
+			cr = cs;
-	    pr = ps ;
+			pr = ps;
-	} else {
+		} else {
-	    cr = ct ;
+			cr = ct;
-	    pr = pt ;
+			pr = pt;
+		}
+		/* Check that underlying types are the same */
+		if (eq_type_unqual(pt, ps)) {
+			/* Form the result type */
+			CV_SPEC qt = find_cv_qual(pt);
+			CV_SPEC qs = find_cv_qual(ps);
+			CV_SPEC qr = (qt | qs);
+			pr = qualify_type(pr, qr, 0);
+			if (qt != qs && qr != qs) {
+				*suspect = 1;
+			}
+			if (EQ_ctype(cr, ct) && EQ_type(pr, pt)) {
+				return (t);
+			}
+			if (EQ_ctype(cr, cs) && EQ_type(pr, ps)) {
+				return (s);
+			}
+			MAKE_type_ptr_mem(cv_none, cr, pr, pr);
+			return (pr);
+		}
+	}
-	/* Check that underlying types are the same */
-	if ( eq_type_unqual ( pt, ps ) ) {
-	    /* Form the result type */
-	    CV_SPEC qt = find_cv_qual ( pt ) ;
-	    CV_SPEC qs = find_cv_qual ( ps ) ;
-	    CV_SPEC qr = ( qt | qs ) ;
-	    pr = qualify_type ( pr, qr, 0 ) ;
-	    if ( qt != qs && qr != qs ) *suspect = 1 ;
-	    if ( EQ_ctype ( cr, ct ) && EQ_type ( pr, pt ) ) return ( t ) ;
-	    if ( EQ_ctype ( cr, cs ) && EQ_type ( pr, ps ) ) return ( s ) ;
-	    MAKE_type_ptr_mem ( cv_none, cr, pr, pr ) ;
-	    return ( pr ) ;
-	}
-    }
-    /* Can't bring to common pointer member type */
+	/* Can't bring to common pointer member type */
-    if ( is_templ_type ( t ) || is_templ_type ( s ) ) {
+	if (is_templ_type(t) || is_templ_type(s)) {
-	*suspect = -1 ;
+		*suspect = -1;
-    } else {
+	} else {
-	*suspect = 2 ;
+		*suspect = 2;
-    }
+	}
-    return ( type_error ) ;
+	return (type_error);
+}
 /*
     FIND A COMMON TYPE
     The null type is returned if the common type cannot be formed and
     suspect is set accordingly.  The rules are essentially the same as
     for the '?:' operation.
 */
-TYPE common_type
+TYPE
-    PROTO_N ( ( t, s, suspect ) )
-    PROTO_T ( TYPE t X TYPE s X int *suspect )
+common_type(TYPE t, TYPE s, int *suspect)
+{
-    unsigned nt, ns ;
+	unsigned nt, ns;
-    TYPE r = NULL_type ;
+	TYPE r = NULL_type;
-    if ( IS_NULL_type ( t ) ) return ( s ) ;
+	if (IS_NULL_type(t)) {
+		return (s);
+	}
-    if ( IS_NULL_type ( s ) ) return ( t ) ;
+	if (IS_NULL_type(s)) {
+		return (t);
+	}
-    nt = TAG_type ( t ) ;
+	nt = TAG_type(t);
-    ns = TAG_type ( s ) ;
+	ns = TAG_type(s);
-    if ( nt == ns ) {
+	if (nt == ns) {
-	switch ( nt ) {
+		switch (nt) {
-	    case type_ptr_tag :
+		case type_ptr_tag:
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		/* Common pointer or reference type */
+			/* Common pointer or reference type */
-		r = ptr_common_type ( t, s, 1, suspect ) ;
+			r = ptr_common_type(t, s, 1, suspect);
-		if ( *suspect != 2 ) return ( r ) ;
+			if (*suspect != 2) {
+				return (r);
+			}
-		r = NULL_type ;
+			r = NULL_type;
-		break ;
+			break;
-	    }
+		}
-	    case type_ptr_mem_tag : {
+		case type_ptr_mem_tag: {
-		/* Common pointer to member type */
+			/* Common pointer to member type */
-		r = ptr_mem_common_type ( t, s, suspect ) ;
+			r = ptr_mem_common_type(t, s, suspect);
-		if ( *suspect != 2 ) return ( r ) ;
+			if (*suspect != 2) {
+				return (r);
+			}
-		r = NULL_type ;
+			r = NULL_type;
-		break ;
+			break;
-	    }
+		}
-	    default : {
+		default:
-		/* Other types */
+			/* Other types */
-		if ( eq_type_unqual ( t, s ) ) {
+			if (eq_type_unqual(t, s)) {
-		    CV_SPEC qt = find_cv_qual ( t ) ;
+				CV_SPEC qt = find_cv_qual(t);
-		    CV_SPEC qs = find_cv_qual ( s ) ;
+				CV_SPEC qs = find_cv_qual(s);
-		    if ( qt != qs ) {
+				if (qt != qs) {
-			*suspect = 1 ;
+					*suspect = 1;
-			t = qualify_type ( t, ( qt | qs ), 0 ) ;
+					t = qualify_type(t,(qt | qs), 0);
-		    }
+				}
-		    return ( t ) ;
+				return (t);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
 	}
-    }
-    switch ( nt ) {
+	switch (nt) {
-	case type_integer_tag :
+	case type_integer_tag:
-	case type_enumerate_tag :
+	case type_enumerate_tag:
-	case type_bitfield_tag :
+	case type_bitfield_tag:
-	case type_floating_tag : {
+	case type_floating_tag: {
-	    switch ( ns ) {
+		switch (ns) {
-		case type_integer_tag :
+		case type_integer_tag:
-		case type_enumerate_tag :
+		case type_enumerate_tag:
-		case type_bitfield_tag :
+		case type_bitfield_tag:
-		case type_floating_tag : {
+		case type_floating_tag: {
-		    /* Common arithmetic type */
+			/* Common arithmetic type */
-		    r = arith_type ( t, s, NULL_exp, NULL_exp ) ;
+			r = arith_type(t, s, NULL_exp, NULL_exp);
-		    return ( r ) ;
+			return (r);
 		}
-	    }
+		}
 	}
-    }
+	}
 #if LANGUAGE_C
-    if ( IS_NULL_type ( r ) ) {
+	if (IS_NULL_type(r)) {
-	r = type_composite ( t, s, 1, 0, KILL_err, 1 ) ;
+		r = type_composite(t, s, 1, 0, KILL_err, 1);
-	if ( !IS_NULL_type ( r ) ) return ( r ) ;
+		if (!IS_NULL_type(r)) {
+			return (r);
-    }
+		}
+	}
 #endif
-    if ( nt == type_error_tag ) return ( s ) ;
+	if (nt == type_error_tag) {
+		return (s);
+	}
-    if ( ns == type_error_tag ) return ( t ) ;
+	if (ns == type_error_tag) {
+		return (t);
+	}
-    *suspect = 2 ;
+	*suspect = 2;
-    return ( r ) ;
+	return (r);
+}
 /*
     CONVERT AN EXPRESSION TO ITS PROMOTED TYPE
     This routine converts the expression e to its promoted type, t
     (previously calculated using promote_type).  Note that there is no
     effect unless t is an integral type.
 */
-EXP convert_promote
+EXP
-    PROTO_N ( ( t, e ) )
-    PROTO_T ( TYPE t X EXP e )
+convert_promote(TYPE t, EXP e)
 {
-    if ( IS_type_integer ( t ) ) {
+	if (IS_type_integer(t)) {
-	TYPE s = DEREF_type ( exp_type ( e ) ) ;
+		TYPE s = DEREF_type(exp_type(e));
-	if ( !EQ_type ( t, s ) ) {
+		if (!EQ_type(t, s)) {
-	    /* Perform non-trivial integral promotions */
+			/* Perform non-trivial integral promotions */
-	    e = cast_int_int ( t, e, KILL_err, CAST_IMPLICIT, 0 ) ;
+			e = cast_int_int(t, e, KILL_err, CAST_IMPLICIT, 0);
+		}
+	}
-    }
-    return ( e ) ;
+	return (e);
+}
 /*
     CONVERT AN EXPRESSION TO ITS ARITHMETIC TYPE
     This routine converts the expression e to an arithmetic result type, t,
     formed by arith_type using the type of e as its nth argument.  Note that
     there are three cases: integer->integer, integer->float and float->float.
 */
-EXP convert_arith
+EXP
-    PROTO_N ( ( t, e, op, n ) )
-    PROTO_T ( TYPE t X EXP e X int op X int n )
+convert_arith(TYPE t, EXP e, int op, int n)
 {
-    TYPE s = DEREF_type ( exp_type ( e ) ) ;
+	TYPE s = DEREF_type(exp_type(e));
-    if ( !EQ_type ( t, s ) ) {
+	if (!EQ_type(t, s)) {
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	if ( IS_type_floating ( t ) ) {
+		if (IS_type_floating(t)) {
-	    unsigned tag = TAG_type ( s ) ;
+			unsigned tag = TAG_type(s);
-	    if ( tag == type_floating_tag ) {
+			if (tag == type_floating_tag) {
-		e = cast_float_float ( t, e, &err, CAST_IMPLICIT ) ;
+				e = cast_float_float(t, e, &err, CAST_IMPLICIT);
-	    } else {
+			} else {
-		if ( tag == type_bitfield_tag ) {
+				if (tag == type_bitfield_tag) {
-		    s = find_bitfield_type ( s ) ;
+					s = find_bitfield_type(s);
-		    e = cast_int_int ( s, e, &err, CAST_IMPLICIT, -1 ) ;
+					e = cast_int_int(s, e, &err,
+							 CAST_IMPLICIT, -1);
-		}
+				}
-		e = cast_int_float ( t, e, &err, CAST_IMPLICIT ) ;
+				e = cast_int_float(t, e, &err, CAST_IMPLICIT);
-	    }
+			}
-	} else {
+		} else {
-	    e = cast_int_int ( t, e, &err, CAST_IMPLICIT, -1 ) ;
+			e = cast_int_int(t, e, &err, CAST_IMPLICIT, -1);
-	}
+		}
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    unsigned m = ( unsigned ) n ;
+			unsigned m = (unsigned)n;
-	    err = concat_error ( err, ERR_expr_convert_op ( m, op ) ) ;
+			err = concat_error(err, ERR_expr_convert_op(m, op));
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
-	}
+		}
-    }
+	}
-    return ( e ) ;
+	return (e);
 }
 /*
     CONVERT A POINTER TO A COMMON POINTER TYPE
     This routine converts the pointer expression e to a common pointer
     type, t, formed by ptr_common_type using the type of e as its nth
     argument.
 */
-EXP convert_ptr_common
+EXP
-    PROTO_N ( ( t, e, op, n ) )
-    PROTO_T ( TYPE t X EXP e X int op X int n )
+convert_ptr_common(TYPE t, EXP e, int op, int n)
 {
-    TYPE s = DEREF_type ( exp_type ( e ) ) ;
+	TYPE s = DEREF_type(exp_type(e));
-    if ( !EQ_type ( t, s ) ) {
+	if (!EQ_type(t, s)) {
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	e = cast_ptr_ptr ( t, e, &err, CAST_IMPLICIT, 1, 1 ) ;
+		e = cast_ptr_ptr(t, e, &err, CAST_IMPLICIT, 1, 1);
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    unsigned m = ( unsigned ) n ;
+			unsigned m = (unsigned)n;
-	    err = concat_error ( err, ERR_expr_convert_op ( m, op ) ) ;
+			err = concat_error(err, ERR_expr_convert_op(m, op));
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
-	}
+		}
-    }
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     CONVERT A POINTER MEMBER TO A COMMON POINTER MEMBER TYPE
     This routine converts the pointer member expression e to a common
     pointer to member type, t, formed by ptr_mem_common_type using the
     type of e as its nth argument.
 */
-EXP convert_ptr_mem_common
+EXP
-    PROTO_N ( ( t, e, op, n ) )
-    PROTO_T ( TYPE t X EXP e X int op X int n )
+convert_ptr_mem_common(TYPE t, EXP e, int op, int n)
 {
-    TYPE s = DEREF_type ( exp_type ( e ) ) ;
+	TYPE s = DEREF_type(exp_type(e));
-    if ( !EQ_type ( t, s ) ) {
+	if (!EQ_type(t, s)) {
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	e = cast_ptr_mem_ptr_mem ( t, e, &err, CAST_IMPLICIT, 1, 1 ) ;
+		e = cast_ptr_mem_ptr_mem(t, e, &err, CAST_IMPLICIT, 1, 1);
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    unsigned m = ( unsigned ) n ;
+			unsigned m = (unsigned)n;
-	    err = concat_error ( err, ERR_expr_convert_op ( m, op ) ) ;
+			err = concat_error(err, ERR_expr_convert_op(m, op));
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
-	}
+		}
-    }
+	}
-    return ( e ) ;
+	return (e);
 }
 /*
     CHECK FOR ASSIGNMENT IN A BOOLEAN
     This routine checks whether the expression a, which is to be converted
     to a boolean, is an assignment.  A warning is issued for 'x = y' and
     'x /= y' because of possible confusion with 'x == y' and 'x != y'
     respectively.  If the original expression was enclosed in brackets
     (as indicated by tag) then no warning is issued.
 */
-static void boolean_assign
+static void
-    PROTO_N ( ( a, tag ) )
-    PROTO_T ( EXP a X unsigned tag )
+boolean_assign(EXP a, unsigned tag)
+{
-    if ( tag != exp_paren_tag && !suppress_quality ) {
+	if (tag != exp_paren_tag && !suppress_quality) {
-	if ( IS_exp_assign ( a ) ) {
+		if (IS_exp_assign(a)) {
-	    report ( crt_loc, ERR_conv_bool_assign () ) ;
+			report(crt_loc, ERR_conv_bool_assign());
-	} else if ( IS_exp_preinc ( a ) ) {
+		} else if (IS_exp_preinc(a)) {
-	    int op = DEREF_int ( exp_preinc_becomes ( a ) ) ;
+			int op = DEREF_int(exp_preinc_becomes(a));
-	    if ( op == lex_assign || op == lex_div_Heq ) {
+			if (op == lex_assign || op == lex_div_Heq) {
-		report ( crt_loc, ERR_conv_bool_assign () ) ;
+				report(crt_loc, ERR_conv_bool_assign());
-	    }
+			}
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     CONVERT AN EXPRESSION TO A BOOLEAN
     returning the corresponding boolean expression.  Any error arising are
     added to the position indicated by the err argument.  User-defined
     conversions are handled elsewhere.
 */
-EXP convert_boolean
+EXP
-    PROTO_N ( ( a, tag, err ) )
-    PROTO_T ( EXP a X unsigned tag X ERROR *err )
+convert_boolean(EXP a, unsigned tag, ERROR *err)
+{
-    EXP e ;
+	EXP e;
-    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+	TYPE t = DEREF_type(exp_type(a));
-    switch ( TAG_exp ( a ) ) {
+	switch (TAG_exp(a)) {
-	case exp_int_lit_tag : {
+	case exp_int_lit_tag: {
-	    /* Check for integer literals */
+		/* Check for integer literals */
-	    e = make_test_nat ( a ) ;
+		e = make_test_nat(a);
-	    return ( e ) ;
+		return (e);
+	}
-	case exp_float_lit_tag : {
+	case exp_float_lit_tag: {
-	    /* Check for floating-point literals */
+		/* Check for floating-point literals */
-	    FLOAT f = DEREF_flt ( exp_float_lit_flt ( a ) ) ;
+		FLOAT f = DEREF_flt(exp_float_lit_flt(a));
-	    NAT n = round_float_lit ( f, crt_round_mode ) ;
+		NAT n = round_float_lit(f, crt_round_mode);
-	    if ( !IS_NULL_nat ( n ) && IS_nat_small ( n ) ) {
+		if (!IS_NULL_nat(n) && IS_nat_small(n)) {
-		unsigned v = DEREF_unsigned ( nat_small_value ( n ) ) ;
+			unsigned v = DEREF_unsigned(nat_small_value(n));
-		if ( v < 2 ) {
+			if (v < 2) {
-		    v = BOOL_VALUE ( v ) ;
+				v = BOOL_VALUE(v);
-		    e = make_bool_exp ( v, exp_float_lit_tag ) ;
+				e = make_bool_exp(v, exp_float_lit_tag);
-		    return ( e ) ;
+				return (e);
-		}
+			}
-	    }
+		}
-	    MAKE_exp_test ( type_bool, ntest_not_eq, a, e ) ;
+		MAKE_exp_test(type_bool, ntest_not_eq, a, e);
-	    MAKE_nat_calc ( e, n ) ;
+		MAKE_nat_calc(e, n);
-	    MAKE_exp_int_lit ( type_bool, n, exp_test_tag, e ) ;
+		MAKE_exp_int_lit(type_bool, n, exp_test_tag, e);
-	    return ( e ) ;
+		return (e);
 	}
-	case exp_contents_tag : {
+	case exp_contents_tag: {
-	    /* Check for assignment in boolean */
+		/* Check for assignment in boolean */
-	    EXP b = DEREF_exp ( exp_contents_ptr ( a ) ) ;
+		EXP b = DEREF_exp(exp_contents_ptr(a));
-	    switch ( TAG_exp ( b ) ) {
+		switch (TAG_exp(b)) {
-		case exp_assign_tag :
+		case exp_assign_tag:
-		case exp_preinc_tag :
+		case exp_preinc_tag:
-		case exp_postinc_tag : {
+		case exp_postinc_tag: {
-		    boolean_assign ( b, tag ) ;
+			boolean_assign(b, tag);
-		    break ;
+			break;
 		}
-	    }
+		}
+		break;
+	}
+	case exp_assign_tag:
+	case exp_preinc_tag:
+	case exp_postinc_tag: {
+		/* Check for assignment in boolean */
+		boolean_assign(a, tag);
-	    break ;
+		break;
+	}
-	case exp_assign_tag :
-	case exp_preinc_tag :
-	case exp_postinc_tag : {
-	    /* Check for assignment in boolean */
-	    boolean_assign ( a, tag ) ;
-	    break ;
+	}
-    }
-    /* Perform the conversion */
+	/* Perform the conversion */
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    /* Integral types are allowed */
+		/* Integral types are allowed */
-	    if ( check_int_type ( t, btype_bool ) ) return ( a ) ;
+		if (check_int_type(t, btype_bool)) {
+			return (a);
+		}
-	    break ;
+		break;
+	}
-	case type_bitfield_tag : {
+	case type_bitfield_tag: {
-	    /* Convert bitfields to integers */
+		/* Convert bitfields to integers */
-	    a = convert_bitfield ( a ) ;
+		a = convert_bitfield(a);
-	    break ;
+		break;
+	}
-	case type_enumerate_tag :
+	case type_enumerate_tag:
-	case type_floating_tag :
+	case type_floating_tag:
-	case type_ptr_tag :
+	case type_ptr_tag:
-	case type_ptr_mem_tag : {
+	case type_ptr_mem_tag: {
-	    /* These types are allowed */
+		/* These types are allowed */
-	    break ;
+		break;
+	}
-	case type_error_tag : {
+	case type_error_tag: {
-	    /* Allow for error propagation */
+		/* Allow for error propagation */
-	    break ;
+		break;
+	}
-	default : {
+	default:
-	    /* These types are not allowed */
+		/* These types are not allowed */
-	    add_error ( err, ERR_conv_bool_cast ( t ) ) ;
+		add_error(err, ERR_conv_bool_cast(t));
-	    break ;
+		break;
+	}
-    }
-    MAKE_exp_test ( type_bool, ntest_not_eq, a, e ) ;
+	MAKE_exp_test(type_bool, ntest_not_eq, a, e);
-    return ( e ) ;
+	return (e);
+}
 /*
     REPORT OVERLOADED FUNCTIONS
     overloaded function.  If it represents a non-overloaded function which
     has not already resolved using resolve_cast then the function is
     marked as used.
 */
-static int is_overloaded
+static int
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+is_overloaded(EXP e)
+{
-    if ( !IS_NULL_exp ( e ) && IS_exp_identifier_etc ( e ) ) {
+	if (!IS_NULL_exp(e) && IS_exp_identifier_etc(e)) {
-	IDENTIFIER id = DEREF_id ( exp_identifier_etc_id ( e ) ) ;
+		IDENTIFIER id = DEREF_id(exp_identifier_etc_id(e));
-	if ( IS_id_function_etc ( id ) ) {
+		if (IS_id_function_etc(id)) {
-	    QUALIFIER q = DEREF_qual ( exp_identifier_etc_qual ( e ) ) ;
+			QUALIFIER q = DEREF_qual(exp_identifier_etc_qual(e));
-	    if ( !( q & qual_mark ) ) {
+			if (!(q & qual_mark)) {
-		/* Not already resolved */
+				/* Not already resolved */
-		TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
+				TYPE fn = DEREF_type(id_function_etc_type(id));
+				IDENTIFIER over =
-		IDENTIFIER over = DEREF_id ( id_function_etc_over ( id ) ) ;
+				    DEREF_id(id_function_etc_over(id));
-		if ( !IS_NULL_id ( over ) || IS_type_templ ( fn ) ) {
+				if (!IS_NULL_id(over) || IS_type_templ(fn)) {
-		    /* Overloaded function */
+					/* Overloaded function */
+					report(crt_loc,
-		    report ( crt_loc, ERR_over_over_context ( id ) ) ;
+					       ERR_over_over_context(id));
-		    return ( 1 ) ;
+					return (1);
+				}
+				use_id(id, suppress_usage);
+			}
+		}
-		use_id ( id, suppress_usage ) ;
-	    }
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     PERFORM QUALIFICATION CONVERSIONS ON A TYPE
     This routine removes any type qualifiers from a rvalue, non-class
     type t.  Class types maintain their type qualifiers, lvalue types
     lose theirs in convert_lvalue.
 */
-TYPE convert_qual_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+convert_qual_type(TYPE t)
+{
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( qual && !( qual & cv_lvalue ) ) {
+	if (qual && !(qual & cv_lvalue)) {
 #if LANGUAGE_CPP
-	if ( IS_type_compound ( t ) ) return ( t ) ;
+		if (IS_type_compound(t)) {
+			return (t);
+		}
 #endif
-	t = qualify_type ( t, cv_none, 0 ) ;
+		t = qualify_type(t, cv_none, 0);
-    }
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     EVALUATE A CONST VARIABLE
     This routine evaluates the 'const' variable expression a, so that
     for example, if 'const int c = 5 ;' then 'c' is evaluated to '5'.
 */
-EXP convert_const
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+convert_const(EXP a)
 {
 #if LANGUAGE_CPP
-    IDENTIFIER id = DEREF_id ( exp_identifier_id ( a ) ) ;
+	IDENTIFIER id = DEREF_id(exp_identifier_id(a));
-    EXP e = DEREF_exp ( id_variable_etc_init ( id ) ) ;
+	EXP e = DEREF_exp(id_variable_etc_init(id));
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	switch ( TAG_exp ( e ) ) {
+		switch (TAG_exp(e)) {
-	    case exp_int_lit_tag : {
+		case exp_int_lit_tag: {
-		/* Propagate simple constants */
+			/* Propagate simple constants */
-		NAT n ;
+			NAT n;
-		TYPE t ;
+			TYPE t;
-		unsigned tag ;
+			unsigned tag;
-		DECONS_exp_int_lit ( t, n, tag, e ) ;
+			DECONS_exp_int_lit(t, n, tag, e);
-		MAKE_exp_int_lit ( t, n, tag, e ) ;
+			MAKE_exp_int_lit(t, n, tag, e);
-		return ( e ) ;
+			return (e);
-	    }
+		}
-	    case exp_null_tag : {
+		case exp_null_tag: {
-		/* Propagate null constants */
+			/* Propagate null constants */
-		TYPE t ;
+			TYPE t;
-		DECONS_exp_null ( t, e ) ;
+			DECONS_exp_null(t, e);
-		MAKE_exp_null ( t, e ) ;
+			MAKE_exp_null(t, e);
-		return ( e ) ;
+			return (e);
-	    }
+		}
-	}
+		}
-    }
+	}
 #endif
-    return ( a ) ;
+	return (a);
 }
 /*
     PERFORM ARRAY TO POINTER CONVERSION
     This routine performs array to pointer conversion on the array
     expression a.  If a is a string literal and str is true then the
     const qualifiers are removed from the string.  A warning is also
     added to err if str is 2.
 */
-EXP convert_array
+EXP
-    PROTO_N ( ( a, str, err ) )
-    PROTO_T ( EXP a X int str X ERROR *err )
+convert_array(EXP a, int str, ERROR *err)
+{
-    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+	TYPE t = DEREF_type(exp_type(a));
-    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+	TYPE s = DEREF_type(type_array_sub(t));
-    if ( str && IS_exp_string_lit ( a ) ) {
+	if (str && IS_exp_string_lit(a)) {
-	/* Remove const from string literals */
+		/* Remove const from string literals */
-	CV_SPEC cv = DEREF_cv ( type_qual ( s ) ) ;
+		CV_SPEC cv = DEREF_cv(type_qual(s));
-	if ( cv & cv_const ) {
+		if (cv & cv_const) {
-	    cv &= ~cv_const ;
+			cv &= ~cv_const;
-	    s = qualify_type ( s, cv, 0 ) ;
+			s = qualify_type(s, cv, 0);
+			if (str == 2) {
-	    if ( str == 2 ) add_error ( err, ERR_conv_array_string () ) ;
+				add_error(err, ERR_conv_array_string());
+			}
-	}
+		}
-    } else if ( option ( OPT_addr_register ) && used_register ) {
+	} else if (option(OPT_addr_register) && used_register) {
-	/* Can't apply to a register variable in C */
+		/* Can't apply to a register variable in C */
-	EXP b = NULL_exp ;
+		EXP b = NULL_exp;
-	DECL_SPEC ds = find_exp_linkage ( a, &b, 1 ) ;
+		DECL_SPEC ds = find_exp_linkage(a, &b, 1);
-	if ( ( ds & dspec_register ) && !( ds & dspec_temp ) ) {
+		if ((ds & dspec_register) && !(ds & dspec_temp)) {
-	    if ( IS_exp_identifier ( b ) ) {
+			if (IS_exp_identifier(b)) {
-		IDENTIFIER id = DEREF_id ( exp_identifier_id ( b ) ) ;
+				IDENTIFIER id = DEREF_id(exp_identifier_id(b));
+				add_error(err,
-		add_error ( err, ERR_expr_unary_op_ref_register ( id ) ) ;
+					  ERR_expr_unary_op_ref_register(id));
-	    }
+			}
+		}
+	}
-    }
-    MAKE_type_ptr ( cv_none, s, t ) ;
+	MAKE_type_ptr(cv_none, s, t);
-    MAKE_exp_address ( t, a, a ) ;
+	MAKE_exp_address(t, a, a);
-    return ( a ) ;
+	return (a);
+}
 /*
     PERFORM LVALUE CONVERSIONS
     function-to-pointer conversions are applied to transform it into an
     rvalue.  Checks for overloaded functions are also applied at this
     stage to both lvalues and rvalues.
 */
-EXP convert_lvalue
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+convert_lvalue(EXP a)
+{
-    EXP e = a ;
+	EXP e = a;
-    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+	TYPE t = DEREF_type(exp_type(a));
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( qual & cv_lvalue ) {
+	if (qual & cv_lvalue) {
-	CV_SPEC cv = cv_none ;
+		CV_SPEC cv = cv_none;
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_array_tag : {
+		case type_array_tag: {
-		/* Array-to-pointer conversion */
+			/* Array-to-pointer conversion */
-		ERROR err = NULL_err ;
+			ERROR err = NULL_err;
-		e = convert_array ( a, 0, &err ) ;
+			e = convert_array(a, 0, &err);
-		if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+			if (!IS_NULL_err(err)) {
+				report(crt_loc, err);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case type_func_tag : {
+		case type_func_tag: {
-		/* Function-to-pointer conversion */
+			/* Function-to-pointer conversion */
-		if ( is_overloaded ( a ) ) {
+			if (is_overloaded(a)) {
-		    e = make_error_exp ( 0 ) ;
+				e = make_error_exp(0);
-		    break ;
+				break;
+			}
+			if (IS_exp_member(a)) {
+				goto default_lab;
+			}
+			MAKE_type_ptr(cv_none, t, t);
+			MAKE_exp_address(t, a, e);
+			break;
+		}
-		if ( IS_exp_member ( a ) ) goto default_lab ;
-		MAKE_type_ptr ( cv_none, t, t ) ;
-		MAKE_exp_address ( t, a, e ) ;
-		break ;
-	    }
 #if LANGUAGE_CPP
-	    case type_compound_tag : {
+		case type_compound_tag: {
-		/* Classes preserve qualifiers in lvalue conversion */
+			/* Classes preserve qualifiers in lvalue conversion */
-		cv = ( qual & cv_qual ) ;
+			cv = (qual & cv_qual);
-		goto default_lab ;
+			goto default_lab;
-	    }
+		}
 #endif
-	    case type_templ_tag : {
+		case type_templ_tag: {
-		/* Can't have template expressions */
+			/* Can't have template expressions */
-		if ( !is_overloaded ( a ) ) {
+			if (!is_overloaded(a)) {
-		    report ( crt_loc, ERR_temp_local_not ( t ) ) ;
+				report(crt_loc, ERR_temp_local_not(t));
+			}
+			e = make_error_exp(0);
+			break;
+		}
+		default :
+default_lab: {
+		     /* Lvalue-to-rvalue conversion */
+		     ERROR err;
+		     if (qual == (cv_const | cv_lvalue)) {
+			     /* Check for constants at this stage */
+			     if (IS_exp_identifier(a)) {
+				     e = convert_const(a);
+				     if (!EQ_exp(e, a)) {
+					     return (e);
+				     }
+			     }
+		     }
+		     t = qualify_type(t, cv, 0);
+		     err = check_incomplete(t);
+		     if (!IS_NULL_err(err)) {
+			     err = concat_error(err, ERR_conv_lval_incompl());
+			     report(crt_loc, err);
+		     }
+		     MAKE_exp_contents(t, a, e);
+		     break;
+	     }
+		}
-		e = make_error_exp ( 0 ) ;
-		break ;
-	    }
-	    default :
-	    default_lab : {
-		/* Lvalue-to-rvalue conversion */
-		ERROR err ;
-		if ( qual == ( cv_const | cv_lvalue ) ) {
-		    /* Check for constants at this stage */
-		    if ( IS_exp_identifier ( a ) ) {
-			e = convert_const ( a ) ;
-			if ( !EQ_exp ( e, a ) ) return ( e ) ;
-		    }
-		}
-		t = qualify_type ( t, cv, 0 ) ;
-		err = check_incomplete ( t ) ;
-		if ( !IS_NULL_err ( err ) ) {
-		    err = concat_error ( err, ERR_conv_lval_incompl () ) ;
-		    report ( crt_loc, err ) ;
-		}
-		MAKE_exp_contents ( t, a, e ) ;
-		break ;
-	    }
-	}
-    } else {
+	} else {
-	/* Check rvalues for overloaded functions */
+		/* Check rvalues for overloaded functions */
-	switch ( TAG_exp ( e ) ) {
+		switch (TAG_exp(e)) {
-	    case exp_address_tag : {
+		case exp_address_tag: {
-		/* Address of object or function */
+			/* Address of object or function */
-		EXP b = DEREF_exp ( exp_address_arg ( a ) ) ;
+			EXP b = DEREF_exp(exp_address_arg(a));
+			if (is_overloaded(b)) {
-		if ( is_overloaded ( b ) ) e = make_error_exp ( 0 ) ;
+				e = make_error_exp(0);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case exp_address_mem_tag : {
+		case exp_address_mem_tag: {
-		/* Address of member or member function */
+			/* Address of member or member function */
-		EXP b = DEREF_exp ( exp_address_mem_arg ( a ) ) ;
+			EXP b = DEREF_exp(exp_address_mem_arg(a));
+			if (is_overloaded(b)) {
-		if ( is_overloaded ( b ) ) e = make_error_exp ( 0 ) ;
+				e = make_error_exp(0);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case exp_token_tag : {
+		case exp_token_tag: {
-		/* Check for tokenised arrays */
+			/* Check for tokenised arrays */
-		if ( IS_type_array ( t ) ) {
+			if (IS_type_array(t)) {
-		    ERROR err = NULL_err ;
+				ERROR err = NULL_err;
-		    e = convert_array ( a, 0, &err ) ;
+				e = convert_array(a, 0, &err);
-		    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+				if (!IS_NULL_err(err)) {
+					report(crt_loc, err);
+				}
+			}
+			break;
+		}
+		}
-		break ;
-	    }
+	}
-    }
-    return ( e ) ;
+	return (e);
+}
 /*
     CHECK AMBIGUOUS IDENTIFIERS
     This routine checks whether the identifier id represents a non-member
     function or an ambiguous set of such functions.  It is required because
     overload resolution is used to distinguish between the ambiguous cases
     for non-member functions, whereas it is an error otherwise.
 */
-int is_ambiguous_func
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+is_ambiguous_func(IDENTIFIER id)
+{
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_ambig_tag : {
+	case id_ambig_tag: {
-	    /* Deal with ambiguous identifiers */
+		/* Deal with ambiguous identifiers */
-	    LIST ( IDENTIFIER ) p = DEREF_list ( id_ambig_ids ( id ) ) ;
+		LIST(IDENTIFIER)p = DEREF_list(id_ambig_ids(id));
-	    while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-		id = DEREF_id ( HEAD_list ( p ) ) ;
+			id = DEREF_id(HEAD_list(p));
-		if ( !is_ambiguous_func ( id ) ) return ( 0 ) ;
+			if (!is_ambiguous_func(id)) {
+				return (0);
+			}
-		p = TAIL_list ( p ) ;
+			p = TAIL_list(p);
-	    }
+		}
+		return (1);
+	}
+	case id_function_tag: {
+		/* These are functions */
-	    return ( 1 ) ;
+		return (1);
+	}
-	case id_function_tag : {
-	    /* These are functions */
-	    return ( 1 ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     PERFORM REFERENCE CONVERSIONS
     parentheses are removed, undeclared variables are reported, and
     constants are evaluated.  The precise checks applied depend on context
     which can take one of the values from convert.h.
 */
-EXP convert_reference
+EXP
-    PROTO_N ( ( a, context ) )
-    PROTO_T ( EXP a X int context )
+convert_reference(EXP a, int context)
+{
-    /* Check for reference conversions */
+	/* Check for reference conversions */
-    if ( IS_type_ref ( t ) ) {
+	if (IS_type_ref(t)) {
-	/* Reference to t becomes lvalue t */
+		/* Reference to t becomes lvalue t */
-	if ( etag == exp_indir_tag ) {
+		if (etag == exp_indir_tag) {
-	    /* Can't have two indirections in a row */
+			/* Can't have two indirections in a row */
-	    MAKE_exp_contents ( t, a, a ) ;
+			MAKE_exp_contents(t, a, a);
+		}
+		t = DEREF_type(type_ref_sub(t));
+		/* Note that t is already an lvalue */
+		MAKE_exp_indir(t, a, a);
+	}
-	t = DEREF_type ( type_ref_sub ( t ) ) ;
-	/* Note that t is already an lvalue */
-	MAKE_exp_indir ( t, a, a ) ;
-    }
-    return ( a ) ;
+	return (a);
+}
 /*
     PROMOTE BITFIELD EXPRESSIONS
     In certain expressions, even though an integral operand is not subject
     to integer promotion, bitfield expressions need to be converted to
     integral expressions by promotion.  This routine performs this conversion
     for the expression a.
 */
-EXP convert_bitfield
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+convert_bitfield(EXP a)
 {
-    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+	TYPE t = DEREF_type(exp_type(a));
-    if ( IS_type_bitfield ( t ) ) {
+	if (IS_type_bitfield(t)) {
-	t = promote_type ( t ) ;
+		t = promote_type(t);
-	a = convert_promote ( t, a ) ;
+		a = convert_promote(t, a);
-    }
+	}
-    return ( a ) ;
+	return (a);
 }
 /*
     CONVERT OPERAND WHERE NO CONTEXT IS GIVEN
     This routine performs conversions on the operand a in contexts where
     there is no information to resolve overloaded functions etc.  It also
     introduces temporary variables for constructor call expressions.
 */
-EXP convert_none
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+convert_none(EXP a)
 {
-    if ( !IS_NULL_exp ( a ) ) {
+	if (!IS_NULL_exp(a)) {
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	if ( IS_exp_constr ( a ) ) {
+		if (IS_exp_constr(a)) {
-	    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+			TYPE t = DEREF_type(exp_type(a));
-	    a = make_temporary ( t, a, NULL_exp, 0, &err ) ;
+			a = make_temporary(t, a, NULL_exp, 0, &err);
-	    a = convert_lvalue ( a ) ;
+			a = convert_lvalue(a);
-	} else {
+		} else {
-	    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
+			LIST(IDENTIFIER)pids = NULL_list(IDENTIFIER);
-	    a = resolve_cast ( type_void, a, &err, 1, 0, pids ) ;
+			a = resolve_cast(type_void, a, &err, 1, 0, pids);
+		}
+		if (!IS_NULL_err(err)) {
+			report(crt_loc, err);
+		}
+	}
-	if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-    }
-    return ( a ) ;
+	return (a);
+}
 /*
     QUALIFICATION CONVERSIONS
     cv_strlit is used to represent the removal of const from a string
     literal.  cv_multi is used to represent qualifications which add
     qualifiers at more than one level.
 */
-#define cv_strlit	( ( CV_SPEC ) 0x10 )
+#define cv_strlit	((CV_SPEC)0x10)
-#define cv_multi	( ( CV_SPEC ) 0x20 )
+#define cv_multi	((CV_SPEC)0x20)
 /*
     CHECK FOR OVERLOADED FUNCTION CONVERSION SEQUENCES
     This routine checks for conversion sequences between the overloaded
     function id and the pointer or pointer to member (of the correct class)
     type t.
 */
-static unsigned overload_convert_seq
+static unsigned
-    PROTO_N ( ( t, id, p ) )
-    PROTO_T ( TYPE t X IDENTIFIER id X CONVERSION *p )
+overload_convert_seq(TYPE t, IDENTIFIER id, CONVERSION *p)
+{
-    /* Check arguments */
+	/* Check arguments */
-    TYPE fn ;
+	TYPE fn;
-    int eq = 0 ;
+	int eq = 0;
-    CV_SPEC cv ;
+	CV_SPEC cv;
-    unsigned conv = CONV_EXACT ;
+	unsigned conv = CONV_EXACT;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    if ( tag == type_ptr_tag ) {
+	if (tag == type_ptr_tag) {
-	fn = DEREF_type ( type_ptr_sub ( t ) ) ;
+		fn = DEREF_type(type_ptr_sub(t));
-    } else {
+	} else {
-	fn = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+		fn = DEREF_type(type_ptr_mem_sub(t));
-    }
+	}
-    if ( !IS_type_func ( fn ) ) return ( CONV_NONE ) ;
+	if (!IS_type_func(fn)) {
+		return (CONV_NONE);
+	}
-    cv = DEREF_cv ( type_qual ( fn ) ) ;
+	cv = DEREF_cv(type_qual(fn));
-    cv &= cv_qual ;
+	cv &= cv_qual;
-    if ( cv != cv_none ) conv = CONV_QUAL ;
+	if (cv != cv_none) {
+		conv = CONV_QUAL;
+	}
-    p->qual = cv ;
+	p->qual = cv;
-    /* Check for matching overload function */
+	/* Check for matching overload function */
-    id = resolve_func ( id, fn, 1, 0, NULL_list ( IDENTIFIER ), &eq ) ;
+	id = resolve_func(id, fn, 1, 0, NULL_list(IDENTIFIER), &eq);
-    if ( !IS_NULL_id ( id ) && eq == 3 ) {
+	if (!IS_NULL_id(id) && eq == 3) {
-	switch ( TAG_id ( id ) ) {
+		switch (TAG_id(id)) {
-	    case id_mem_func_tag : {
+		case id_mem_func_tag: {
-		/* A member function gives a pointer to member */
+			/* A member function gives a pointer to member */
-		if ( tag == type_ptr_mem_tag ) return ( conv ) ;
+			if (tag == type_ptr_mem_tag) {
+				return (conv);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case id_function_tag :
+		case id_function_tag:
-	    case id_stat_mem_func_tag : {
+		case id_stat_mem_func_tag: {
-		/* Other functions give pointers */
+			/* Other functions give pointers */
-		if ( tag == type_ptr_tag ) return ( conv ) ;
+			if (tag == type_ptr_tag) {
+				return (conv);
+			}
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    return ( CONV_NONE ) ;
+	return (CONV_NONE);
+}
 /*
     CHECK FOR REFERENCE CONVERSION SEQUENCES
     rvalue reference bindings.  Values of 2 and 3 allow rvalues of
     related types to be bound to any reference (not just const references),
     with 2 further regarding any base class conversions as exact matches.
 */
-static unsigned ref_convert_seq
+static unsigned
-    PROTO_N ( ( p, e, bind, std ) )
-    PROTO_T ( CONVERSION *p X EXP e X int bind X int std )
+ref_convert_seq(CONVERSION *p, EXP e, int bind, int std)
+{
-    unsigned conv ;
+	unsigned conv;
-    TYPE t = DEREF_type ( type_ref_sub ( p->to ) ) ;
+	TYPE t = DEREF_type(type_ref_sub(p->to));
-    TYPE s = p->from ;
+	TYPE s = p->from;
-    unsigned nt = TAG_type ( t ) ;
+	unsigned nt = TAG_type(t);
-    unsigned ns = TAG_type ( s ) ;
+	unsigned ns = TAG_type(s);
-    CV_SPEC qs = DEREF_cv ( type_qual ( s ) ) ;
+	CV_SPEC qs = DEREF_cv(type_qual(s));
-    if ( qs & cv_lvalue ) {
+	if (qs & cv_lvalue) {
-	CV_SPEC cv = cv_compare ( t, s ) ;
+		CV_SPEC cv = cv_compare(t, s);
-	if ( cv == cv_none ) {
+		if (cv == cv_none) {
-	    /* Qualifiers are alright */
+			/* Qualifiers are alright */
-	    cv = cv_compare ( s, t ) ;
+			cv = cv_compare(s, t);
-	    p->qual = cv ;
+			p->qual = cv;
-	    if ( eq_type_unqual ( s, t ) ) {
+			if (eq_type_unqual(s, t)) {
-		if ( cv == cv_none ) {
+				if (cv == cv_none) {
-		    conv = CONV_EXACT ;
+					conv = CONV_EXACT;
-		} else {
+				} else {
-		    conv = CONV_QUAL ;
+					conv = CONV_QUAL;
-		}
+				}
-		return ( conv ) ;
+				return (conv);
-	    }
+			}
+			if (ns == type_compound_tag &&
-	    if ( ns == type_compound_tag && nt == type_compound_tag ) {
+			    nt == type_compound_tag) {
+				CLASS_TYPE ct =
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				    DEREF_ctype(type_compound_defn(t));
+				CLASS_TYPE cs =
-		CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
+				    DEREF_ctype(type_compound_defn(s));
-		if ( eq_ctype ( ct, cs ) ) {
+				if (eq_ctype(ct, cs)) {
-		    /* Classes match */
+					/* Classes match */
-		    if ( cv == cv_none ) {
+					if (cv == cv_none) {
-			conv = CONV_EXACT ;
+						conv = CONV_EXACT;
-		    } else {
+					} else {
-			conv = CONV_QUAL ;
+						conv = CONV_QUAL;
-		    }
+					}
-		    return ( conv ) ;
+					return (conv);
-		} else {
+				} else {
-		    /* Check for base classes */
+					/* Check for base classes */
-		    GRAPH gr = find_base_class ( cs, ct, 0 ) ;
+					GRAPH gr = find_base_class(cs, ct, 0);
-		    if ( !IS_NULL_graph ( gr ) ) {
+					if (!IS_NULL_graph(gr)) {
-			/* Base class conversion */
+						/* Base class conversion */
-			p->base = gr ;
+						p->base = gr;
-			if ( bind == 2 ) {
+						if (bind == 2) {
+							/* Base class
-			    /* Base class conversions match exactly */
+							 * conversions match
+							 * exactly */
-			    if ( cv == cv_none ) {
+							if (cv == cv_none) {
+								conv =
-				conv = CONV_EXACT ;
+								    CONV_EXACT;
-			    } else {
+							} else {
+								conv =
-				conv = CONV_QUAL ;
+								    CONV_QUAL;
-			    }
+							}
+						} else {
+							conv = CONV_BASE;
+						}
+						return (conv);
+					}
+				}
+			}
+		}
+	}
+	if (bind == 0) {
+		/* Default - only const references allowed */
+		CV_SPEC qt = find_cv_qual(t);
+		if (qt != (cv_lvalue | cv_const)) {
+			return (CONV_NONE);
+		}
+		qs = find_cv_qual(s);
+		if (qs & cv_volatile) {
+			return (CONV_NONE);
+		}
+	} else if (bind == 1) {
+		/* No references allowed */
+		return (CONV_NONE);
+	} else {
+		/* All references allowed */
+		std = 1;
+	}
+	p->to = t;
+	p->from = s;
+	if (std) {
+		conv = std_convert_seq(p, e, bind, 1);
+	} else {
+		conv = convert_seq(p, e, bind, 1);
+	}
+	if (bind == 2) {
+		/* Base class conversions match exactly */
+		if (conv == CONV_BASE) {
+			if (p->qual == cv_none) {
+				conv = CONV_EXACT;
 			} else {
-			    conv = CONV_BASE ;
+				conv = CONV_QUAL;
+			}
-			return ( conv ) ;
-		    }
+		}
-	    }
+	}
-    }
-    if ( bind == 0 ) {
-	/* Default - only const references allowed */
-	CV_SPEC qt = find_cv_qual ( t ) ;
-	if ( qt != ( cv_lvalue | cv_const ) ) return ( CONV_NONE ) ;
-	qs = find_cv_qual ( s ) ;
-	if ( qs & cv_volatile ) return ( CONV_NONE ) ;
-    } else if ( bind == 1 ) {
-	/* No references allowed */
-	return ( CONV_NONE ) ;
-    } else {
-	/* All references allowed */
-	std = 1 ;
-    }
-    p->to = t ;
-    p->from = s ;
-    if ( std ) {
-	conv = std_convert_seq ( p, e, bind, 1 ) ;
-    } else {
-	conv = convert_seq ( p, e, bind, 1 ) ;
-    }
-    if ( bind == 2 ) {
-	/* Base class conversions match exactly */
-	if ( conv == CONV_BASE ) {
-	    if ( p->qual == cv_none ) {
-		conv = CONV_EXACT ;
-	    } else {
-		conv = CONV_QUAL ;
-	    }
-	}
-    }
-    return ( conv ) ;
+	return (conv);
+}
 /*
     CHECK FOR STANDARD CONVERSION SEQUENCES
     This routine checks whether there is a standard conversion sequence
     between the types given by p.  e gives the argument being converted
     the canonical sequence, lvalue transformations, promotions, conversions
     and qualification adjustments.  The routine returns the value indicating
     the rank of this conversion.
 */
-unsigned std_convert_seq
+unsigned
-    PROTO_N ( ( p, e, bind, ref ) )
-    PROTO_T ( CONVERSION *p X EXP e X int bind X int ref )
+std_convert_seq(CONVERSION *p, EXP e, int bind, int ref)
+{
-    CV_SPEC qs ;
+	CV_SPEC qs;
-    int str = 0 ;
+	int str = 0;
-    unsigned etag ;
+	unsigned etag;
-    TYPE t = p->to ;
+	TYPE t = p->to;
-    TYPE s = p->from ;
+	TYPE s = p->from;
-    unsigned nt, ns ;
+	unsigned nt, ns;
-    unsigned conv = CONV_NONE ;
+	unsigned conv = CONV_NONE;
-    /* Conversion to the null type counts as exact */
-    if ( IS_NULL_type ( t ) ) return ( CONV_EXACT ) ;
-    /* Conversion from the error type counts as ellipsis */
-    ns = TAG_type ( s ) ;
-    if ( ns == type_error_tag ) return ( CONV_ELLIPSIS ) ;
-    qs = DEREF_cv ( type_qual ( s ) ) ;
-    /* Reference conversion */
-    if ( ns == type_ref_tag ) {
-	s = DEREF_type ( type_ref_sub ( s ) ) ;
-	p->from = s ;
-	ns = TAG_type ( s ) ;
-	if ( ns == type_error_tag ) return ( CONV_ELLIPSIS ) ;
-	qs = DEREF_cv ( type_qual ( s ) ) ;
-    }
-    /* Deal with conversions to reference types */
-    nt = TAG_type ( t ) ;
-    if ( nt == type_ref_tag ) {
-	conv = ref_convert_seq ( p, e, bind, 1 ) ;
-	return ( conv ) ;
-    }
-    /* Examine expression */
-    etag = ( IS_NULL_exp ( e ) ? null_tag : TAG_exp ( e ) ) ;
-    /* Lvalue transformations */
-    if ( qs & cv_lvalue ) {
-	if ( ns == type_func_tag ) {
-	    /* Function to pointer conversion */
-	    if ( etag != exp_member_tag ) {
-		TYPE ps = s ;
-		s = type_temp_star ;
-		COPY_type ( type_ptr_sub ( s ), ps ) ;
-		ns = type_ptr_tag ;
-	    }
-	} else if ( ns == type_array_tag ) {
-	    /* Array to pointer conversion */
-	    TYPE ps = DEREF_type ( type_array_sub ( s ) ) ;
-	    s = type_temp_star ;
-	    COPY_type ( type_ptr_sub ( s ), ps ) ;
-	    ns = type_ptr_tag ;
-	} else {
-	    /* lvalue to rvalue conversion */
-	    if ( etag == exp_identifier_tag ) {
-		if ( qs == ( cv_lvalue | cv_const ) ) {
-		    IDENTIFIER id = DEREF_id ( exp_identifier_id ( e ) ) ;
-		    EXP d = DEREF_exp ( id_variable_etc_init ( id ) ) ;
-		    if ( is_zero_exp ( d ) ) {
-			/* Propagate zero constants */
-			e = d ;
-		    }
-		}
-	    }
-	}
-    }
-    /* Promotions and conversions */
-    switch ( ns ) {
-	case type_integer_tag :
-	case type_enumerate_tag :
-	integral_lab : {
-	    /* Integral and similar arguments */
-	    if ( nt == ns && eq_type_unqual ( t, s ) ) {
-		/* Exact match */
-		conv = CONV_EXACT ;
-	    } else {
-		TYPE ps = promote_type ( s ) ;
-		if ( !EQ_type ( ps, s ) && eq_type_unqual ( t, ps ) ) {
-		    /* Integral promotion */
-		    conv = CONV_INT_PROM ;
-		} else if ( nt == type_integer_tag ) {
-		    /* Integral conversions (subsumes booleans) */
-		    conv = CONV_INT_INT ;
-		} else if ( nt == type_floating_tag ) {
-		    /* Floating-integer conversions */
-		    conv = CONV_INT_FLT ;
-		} else if ( is_zero_exp ( e ) ) {
-		    if ( nt == type_ptr_tag ) {
-			/* Null pointers */
-			conv = CONV_PTR_NULL ;
-		    } else if ( nt == type_ptr_mem_tag ) {
-			/* Null pointer members */
-			conv = CONV_PTR_MEM_NULL ;
-		    }
-		}
-	    }
-	    break ;
-	}
-	case type_bitfield_tag : {
-	    /* Ignore any bitfield qualifiers */
-	    s = find_bitfield_type ( s ) ;
-	    ns = TAG_type ( s ) ;
-	    goto integral_lab ;
-	}
+	/* Conversion to the null type counts as exact */
+	if (IS_NULL_type(t)) {
+		return (CONV_EXACT);
+	}
+	/* Conversion from the error type counts as ellipsis */
+	ns = TAG_type(s);
-	case type_floating_tag : {
+	if (ns == type_error_tag) {
+		return (CONV_ELLIPSIS);
+	}
+	qs = DEREF_cv(type_qual(s));
-	    /* Floating point arguments */
+	/* Reference conversion */
+	if (ns == type_ref_tag) {
+		s = DEREF_type(type_ref_sub(s));
+		p->from = s;
+		ns = TAG_type(s);
+		if (ns == type_error_tag) {
+			return (CONV_ELLIPSIS);
+		}
+		qs = DEREF_cv(type_qual(s));
+	}
+	/* Deal with conversions to reference types */
+	nt = TAG_type(t);
-	    if ( nt == type_floating_tag ) {
+	if (nt == type_ref_tag) {
+		conv = ref_convert_seq(p, e, bind, 1);
+		return (conv);
+	}
+	/* Examine expression */
+	etag = (IS_NULL_exp(e)? null_tag : TAG_exp(e));
+	/* Lvalue transformations */
+	if (qs & cv_lvalue) {
-		if ( eq_type_unqual ( t, s ) ) {
+		if (ns == type_func_tag) {
+			/* Function to pointer conversion */
+			if (etag != exp_member_tag) {
+				TYPE ps = s;
-		    /* Exact match */
+				s = type_temp_star;
+				COPY_type(type_ptr_sub(s), ps);
-		    conv = CONV_EXACT ;
+				ns = type_ptr_tag;
+			}
+		} else if (ns == type_array_tag) {
+			/* Array to pointer conversion */
+			TYPE ps = DEREF_type(type_array_sub(s));
+			s = type_temp_star;
+			COPY_type(type_ptr_sub(s), ps);
+			ns = type_ptr_tag;
 		} else {
-		    TYPE ps = arg_promote_type ( s, KILL_err ) ;
+			/* lvalue to rvalue conversion */
-		    if ( !EQ_type ( ps, s ) && eq_type_unqual ( t, ps ) ) {
+			if (etag == exp_identifier_tag) {
-			/* Floating point promotion */
+				if (qs == (cv_lvalue | cv_const)) {
-			conv = CONV_FLT_PROM ;
+					IDENTIFIER id =
+					    DEREF_id(exp_identifier_id(e));
-		    } else {
+					EXP d =
+					    DEREF_exp(id_variable_etc_init(id));
+					if (is_zero_exp(d)) {
-			/* Floating point conversions */
+						/* Propagate zero constants */
-			conv = CONV_FLT_FLT ;
+						e = d;
-		    }
+					}
+				}
+			}
+		}
-	    } else if ( nt == type_integer_tag ) {
-		/* Floating-integer conversions (subsumes booleans) */
-		conv = CONV_FLT_INT ;
-	    }
-	    break ;
+	}
-	case type_ptr_tag :
+	/* Promotions and conversions */
-	pointer_lab : {
+	switch (ns) {
-	    /* Pointer arguments */
+	case type_integer_tag:
-	    if ( nt == type_ptr_tag ) {
+	case type_enumerate_tag:
-		/* Check for qualifier conversions */
+integral_lab:
-		unsigned qual = check_qualifier ( t, s, 0 ) ;
+		/* Integral and similar arguments */
-		if ( qualifier_depth <= 1 ) {
+		if (nt == ns && eq_type_unqual(t, s)) {
-		    CV_SPEC cv = qualifier_diff ;
+			/* Exact match */
-		    if ( str ) cv |= cv_strlit ;
-		    p->qual = cv ;
+			conv = CONV_EXACT;
 		} else {
-		    p->qual = cv_multi ;
+			TYPE ps = promote_type(s);
-		}
-		if ( qual == QUAL_EQUAL || qual == QUAL_EQ_FUNC ) {
+			if (!EQ_type(ps, s) && eq_type_unqual(t, ps)) {
-		    /* Exact match */
+				/* Integral promotion */
-		    conv = CONV_EXACT ;
+				conv = CONV_INT_PROM;
-		    if ( str ) conv = CONV_STRING ;
-		} else if ( qual == QUAL_OK ) {
+			} else if (nt == type_integer_tag) {
-		    /* Qualification conversion */
+				/* Integral conversions (subsumes booleans) */
-		    conv = CONV_QUAL ;
+				conv = CONV_INT_INT;
-		    if ( str ) conv = CONV_STRING ;
-		} else if ( qual == QUAL_CV ) {
+			} else if (nt == type_floating_tag) {
-		    /* Conversion preserves cv-qualifiers */
-		    TYPE pt = DEREF_type ( type_ptr_sub ( t ) ) ;
-		    TYPE ps = DEREF_type ( type_ptr_sub ( s ) ) ;
-		    nt = TAG_type ( pt ) ;
-		    ns = TAG_type ( ps ) ;
-		    if ( nt == type_compound_tag && ns == nt ) {
-			/* Pointer base class conversions */
+				/* Floating-integer conversions */
-			GRAPH gr ;
-			CLASS_TYPE ct, cs ;
-			ct = DEREF_ctype ( type_compound_defn ( pt ) ) ;
-			cs = DEREF_ctype ( type_compound_defn ( ps ) ) ;
-			gr = find_base_class ( cs, ct, 0 ) ;
-			if ( !IS_NULL_graph ( gr ) ) {
-			    /* Don't worry about ambiguity */
-			    p->base = gr ;
-			    conv = CONV_PTR_BASE ;
+				conv = CONV_INT_FLT;
-			}
-		    } else if ( nt == type_top_tag ) {
+			} else if (is_zero_exp(e)) {
-			if ( ns != type_func_tag ) {
+				if (nt == type_ptr_tag) {
-			    /* Pointer to 'void *' conversions */
+					/* Null pointers */
-			    conv = CONV_PTR_VOID ;
+					conv = CONV_PTR_NULL;
-			}
-		    } else if ( nt == type_bottom_tag ) {
+				} else if (nt == type_ptr_mem_tag) {
-			if ( ns != type_func_tag ) {
-			    /* Pointer to 'void *' conversions */
+					/* Null pointer members */
-			    conv = CONV_PTR_BOTTOM ;
+					conv = CONV_PTR_MEM_NULL;
-			}
+				}
-		    }
+			}
 		}
-		if ( conv == CONV_NONE ) {
+		break;
-		    /* Check for string literals */
+	case type_bitfield_tag: {
-		    if ( etag == exp_string_lit_tag && !str ) {
-			if ( !( qual & QUAL_CONST ) ) {
-			    TYPE ps = DEREF_type ( type_ptr_sub ( s ) ) ;
-			    ps = qualify_type ( ps, cv_none, 0 ) ;
+		/* Ignore any bitfield qualifiers */
-			    s = type_temp_star ;
+		s = find_bitfield_type(s);
-			    COPY_type ( type_ptr_sub ( s ), ps ) ;
-			    str = 1 ;
+		ns = TAG_type(s);
-			    goto pointer_lab ;
+		goto integral_lab;
-			}
+	}
-		    }
+	case type_floating_tag: {
-		    /* Check for overloaded functions */
+		/* Floating point arguments */
-		    if ( etag == exp_address_tag ) {
+		if (nt == type_floating_tag) {
-			e = DEREF_exp ( exp_address_arg ( e ) ) ;
+			if (eq_type_unqual(t, s)) {
+				/* Exact match */
-			etag = TAG_exp ( e ) ;
+				conv = CONV_EXACT;
-		    }
+			} else {
-		    if ( etag == exp_identifier_tag ) {
+				TYPE ps = arg_promote_type(s, KILL_err);
-			IDENTIFIER id = DEREF_id ( exp_identifier_id ( e ) ) ;
+				if (!EQ_type(ps, s) && eq_type_unqual(t, ps)) {
-			conv = overload_convert_seq ( t, id, p ) ;
+					/* Floating point promotion */
-		    } else if ( etag == exp_ambiguous_tag ) {
+					conv = CONV_FLT_PROM;
+				} else {
-			IDENTIFIER id = DEREF_id ( exp_ambiguous_id ( e ) ) ;
+					/* Floating point conversions */
-			conv = overload_convert_seq ( t, id, p ) ;
+					conv = CONV_FLT_FLT;
-		    }
+				}
-		}
+			}
-	    } else if ( nt == type_integer_tag ) {
+		} else if (nt == type_integer_tag) {
-		if ( check_int_type ( t, btype_bool ) ) {
+			/* Floating-integer conversions (subsumes booleans) */
-		    /* Boolean conversions */
-		    conv = CONV_BOOL ;
+			conv = CONV_FLT_INT;
+		}
-	    }
-	    break ;
+		break;
+	}
+	case type_ptr_tag:
+pointer_lab:
+		/* Pointer arguments */
+		if (nt == type_ptr_tag) {
+			/* Check for qualifier conversions */
+			unsigned qual = check_qualifier(t, s, 0);
+			if (qualifier_depth <= 1) {
+				CV_SPEC cv = qualifier_diff;
+				if (str) {
+					cv |= cv_strlit;
+				}
+				p->qual = cv;
+			} else {
+				p->qual = cv_multi;
+			}
+			if (qual == QUAL_EQUAL || qual == QUAL_EQ_FUNC) {
+				/* Exact match */
+				conv = CONV_EXACT;
+				if (str) {
+					conv = CONV_STRING;
+				}
+			} else if (qual == QUAL_OK) {
+				/* Qualification conversion */
+				conv = CONV_QUAL;
+				if (str) {
+					conv = CONV_STRING;
+				}
+			} else if (qual == QUAL_CV) {
+				/* Conversion preserves cv-qualifiers */
+				TYPE pt = DEREF_type(type_ptr_sub(t));
+				TYPE ps = DEREF_type(type_ptr_sub(s));
+				nt = TAG_type(pt);
+				ns = TAG_type(ps);
+				if (nt == type_compound_tag && ns == nt) {
+					/* Pointer base class conversions */
+					GRAPH gr;
+					CLASS_TYPE ct, cs;
+					ct =
+					    DEREF_ctype(type_compound_defn(pt));
+					cs =
+					    DEREF_ctype(type_compound_defn(ps));
+					gr = find_base_class(cs, ct, 0);
+					if (!IS_NULL_graph(gr)) {
+						/* Don't worry about
+						 * ambiguity */
+						p->base = gr;
+						conv = CONV_PTR_BASE;
+					}
+				} else if (nt == type_top_tag) {
+					if (ns != type_func_tag) {
+						/* Pointer to 'void *'
+						 * conversions */
+						conv = CONV_PTR_VOID;
+					}
+				} else if (nt == type_bottom_tag) {
+					if (ns != type_func_tag) {
+						/* Pointer to 'void *'
+						 * conversions */
+						conv = CONV_PTR_BOTTOM;
+					}
+				}
+			}
+			if (conv == CONV_NONE) {
+				/* Check for string literals */
+				if (etag == exp_string_lit_tag && !str) {
+					if (!(qual & QUAL_CONST)) {
+						TYPE ps =
+						    DEREF_type(type_ptr_sub(s));
+						ps = qualify_type(ps, cv_none,
+);
+						s = type_temp_star;
+						COPY_type(type_ptr_sub(s), ps);
+						str = 1;
+						goto pointer_lab;
+					}
+				}
-#if LANGUAGE_CPP
+				/* Check for overloaded functions */
-	case type_ptr_mem_tag : {
+				if (etag == exp_address_tag) {
-	    /* Pointer to member arguments */
+					e = DEREF_exp(exp_address_arg(e));
+					etag = TAG_exp(e);
+				}
-	    if ( nt == type_ptr_mem_tag ) {
+				if (etag == exp_identifier_tag) {
-		unsigned qual ;
+					IDENTIFIER id =
-		int ctype_match = 0 ;
+					    DEREF_id(exp_identifier_id(e));
-		CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+					conv = overload_convert_seq(t, id, p);
-		CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( s ) ) ;
+				} else if (etag == exp_ambiguous_tag) {
+					IDENTIFIER id =
-		if ( eq_ctype ( ct, cs ) ) {
+					    DEREF_id(exp_ambiguous_id(e));
-		    ctype_match = 2 ;
+					conv = overload_convert_seq(t, id, p);
-		} else {
+				}
+			}
-		    GRAPH gr = find_base_class ( ct, cs, 0 ) ;
+		} else if (nt == type_integer_tag) {
-		    if ( !IS_NULL_graph ( gr ) ) {
+			if (check_int_type(t, btype_bool)) {
-			ctype_match = 1 ;
+				/* Boolean conversions */
-			p->base = gr ;
+				conv = CONV_BOOL;
-		    }
+			}
+		}
+		break;
+#if LANGUAGE_CPP
+	case type_ptr_mem_tag: {
+		/* Pointer to member arguments */
+		if (nt == type_ptr_mem_tag) {
+			unsigned qual;
+			int ctype_match = 0;
+			CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
+			CLASS_TYPE cs = DEREF_ctype(type_ptr_mem_of(s));
+			if (eq_ctype(ct, cs)) {
+				ctype_match = 2;
+			} else {
+				GRAPH gr = find_base_class(ct, cs, 0);
+				if (!IS_NULL_graph(gr)) {
+					ctype_match = 1;
+					p->base = gr;
+				}
+			}
-		if ( ctype_match ) {
+			if (ctype_match) {
-		    if ( etag == exp_address_mem_tag ) {
+				if (etag == exp_address_mem_tag) {
-			/* Check overloaded functions */
+					/* Check overloaded functions */
-			IDENTIFIER id ;
+					IDENTIFIER id;
-			e = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
+					e = DEREF_exp(exp_address_mem_arg(e));
-			id = DEREF_id ( exp_member_id ( e ) ) ;
+					id = DEREF_id(exp_member_id(e));
-			if ( IS_id_function_etc ( id ) ) {
+					if (IS_id_function_etc(id)) {
-			    conv = overload_convert_seq ( t, id, p ) ;
+						conv = overload_convert_seq(t, id, p);
-			    if ( conv != CONV_NONE && ctype_match == 1 ) {
+						if (conv != CONV_NONE &&
+						    ctype_match == 1) {
-				conv = CONV_PTR_MEM_BASE ;
+							conv = CONV_PTR_MEM_BASE;
-			    }
+						}
-			    break ;
+						break;
+					}
+				}
+				/* Check other cases */
+				qual = check_qualifier(t, s, 0);
+				if (qualifier_depth <= 1) {
+					p->qual = qualifier_diff;
+				} else {
+					p->qual = cv_multi;
+				}
+				if (qual == QUAL_EQUAL ||
+				    qual == QUAL_EQ_FUNC) {
+					/* Exact match */
+					if (ctype_match == 2) {
+						conv = CONV_EXACT;
+					} else {
+						conv = CONV_PTR_MEM_BASE;
+					}
+				} else if (qual == QUAL_OK) {
+					/* Qualification conversion */
+					if (ctype_match == 2) {
+						conv = CONV_QUAL;
+					} else {
+						conv = CONV_PTR_MEM_BASE;
+					}
+				}
+			}
+		} else if (nt == type_integer_tag) {
+			if (check_int_type(t, btype_bool)) {
+				/* Boolean conversions */
+				conv = CONV_BOOL;
+			}
-		    }
-		    /* Check other cases */
-		    qual = check_qualifier ( t, s, 0 ) ;
-		    if ( qualifier_depth <= 1 ) {
+		} else if (nt == type_ptr_tag) {
-			p->qual = qualifier_diff ;
+			if (etag == exp_address_mem_tag) {
-		    } else {
-			p->qual = cv_multi ;
-		    }
-		    if ( qual == QUAL_EQUAL || qual == QUAL_EQ_FUNC ) {
-			/* Exact match */
+				/* Check overloaded functions */
-			if ( ctype_match == 2 ) {
-			    conv = CONV_EXACT ;
-			} else {
+				IDENTIFIER id;
-			    conv = CONV_PTR_MEM_BASE ;
-			}
-		    } else if ( qual == QUAL_OK ) {
+				e = DEREF_exp(exp_address_mem_arg(e));
-			/* Qualification conversion */
-			if ( ctype_match == 2 ) {
+				id = DEREF_id(exp_member_id(e));
-			    conv = CONV_QUAL ;
-			} else {
-			    conv = CONV_PTR_MEM_BASE ;
+				conv = overload_convert_seq(t, id, p);
+			}
-		    }
 		}
-	    } else if ( nt == type_integer_tag ) {
-		if ( check_int_type ( t, btype_bool ) ) {
-		    /* Boolean conversions */
-		    conv = CONV_BOOL ;
-		}
-	    } else if ( nt == type_ptr_tag ) {
-		if ( etag == exp_address_mem_tag ) {
-		    /* Check overloaded functions */
-		    IDENTIFIER id ;
-		    e = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
-		    id = DEREF_id ( exp_member_id ( e ) ) ;
-		    conv = overload_convert_seq ( t, id, p ) ;
-		}
-	    }
-	    break ;
+		break;
 	}
 #endif
-	case type_compound_tag : {
+	case type_compound_tag: {
-	    /* Class arguments */
+		/* Class arguments */
-	    if ( nt == type_compound_tag ) {
+		if (nt == type_compound_tag) {
-		CV_SPEC cv = cv_compare ( t, s ) ;
+			CV_SPEC cv = cv_compare(t, s);
-		if ( cv == cv_none || !ref ) {
+			if (cv == cv_none || !ref) {
-		    CLASS_TYPE ct, cs ;
+				CLASS_TYPE ct, cs;
-		    cv = cv_compare ( s, t ) ;
+				cv = cv_compare(s, t);
-		    p->qual = cv ;
+				p->qual = cv;
-		    ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				ct = DEREF_ctype(type_compound_defn(t));
-		    cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
+				cs = DEREF_ctype(type_compound_defn(s));
-		    if ( eq_ctype ( ct, cs ) ) {
+				if (eq_ctype(ct, cs)) {
-			/* Class types match */
+					/* Class types match */
-			if ( cv == cv_none ) {
+					if (cv == cv_none) {
-			    conv = CONV_EXACT ;
+						conv = CONV_EXACT;
-			} else {
+					} else {
-			    conv = CONV_QUAL ;
+						conv = CONV_QUAL;
+					}
+				} else {
+					/* Examine base classes */
+					GRAPH gr = find_base_class(cs, ct, 0);
+					if (!IS_NULL_graph(gr)) {
+						/* Base class conversion */
+						p->base = gr;
+						conv = CONV_BASE;
+					}
+				}
+			}
-		    } else {
-			/* Examine base classes */
-			GRAPH gr = find_base_class ( cs, ct, 0 ) ;
-			if ( !IS_NULL_graph ( gr ) ) {
-			    /* Base class conversion */
-			    p->base = gr ;
-			    conv = CONV_BASE ;
-			}
-		    }
+		}
+		break;
+	}
+	case type_func_tag: {
+		/* Address of overloaded static member function */
+		if (nt == type_ptr_tag && etag == exp_member_tag) {
+			IDENTIFIER id = DEREF_id(exp_member_id(e));
+			conv = overload_convert_seq(t, id, p);
-	    }
+		}
+		break;
+	}
+	case type_token_tag: {
+		/* Exact conversion on tokenised type */
+		if (nt == ns && eq_type_unqual(t, s)) {
+			conv = CONV_EXACT;
+		}
-	    break ;
+		break;
+	}
-	case type_func_tag : {
-	    /* Address of overloaded static member function */
-	    if ( nt == type_ptr_tag && etag == exp_member_tag ) {
-		IDENTIFIER id = DEREF_id ( exp_member_id ( e ) ) ;
-		conv = overload_convert_seq ( t, id, p ) ;
-	    }
-	    break ;
-	}
-	case type_token_tag : {
-	    /* Exact conversion on tokenised type */
-	    if ( nt == ns && eq_type_unqual ( t, s ) ) {
-		conv = CONV_EXACT ;
-	    }
-	    break ;
+	}
-    }
-    return ( conv ) ;
+	return (conv);
+}
 /*
     CHECK FOR CONVERSION SEQUENCES
     corresponding to p.  e gives the argument being converted.  It returns
     the value indicating the rank of this conversion.  This is used in
     overload resolution to determine the best viable function.
 */
-unsigned convert_seq
+unsigned
-    PROTO_N ( ( p, e, bind, ref ) )
-    PROTO_T ( CONVERSION *p X EXP e X int bind X int ref )
+convert_seq(CONVERSION *p, EXP e, int bind, int ref)
+{
 /*
     COMPARE TWO BASE CLASS CONVERSIONS
     This routine compares the base classes given by p and q.  It returns 1
     if p is a proper subgraph of q, 2 if q is a proper subgraph of p and
 otherwise.
 */
-static int base_compare_seq
+static int
-    PROTO_N ( ( p, q ) )
-    PROTO_T ( GRAPH p X GRAPH q )
+base_compare_seq(GRAPH p, GRAPH q)
 {
-    CLASS_TYPE ct ;
+	CLASS_TYPE ct;
-    CLASS_TYPE pa, pb ;
+	CLASS_TYPE pa, pb;
-    CLASS_TYPE qa, qb ;
+	CLASS_TYPE qa, qb;
-    /* Decompose p into pa > pb */
+	/* Decompose p into pa > pb */
-    pb = DEREF_ctype ( graph_head ( p ) ) ;
+	pb = DEREF_ctype(graph_head(p));
-    p = DEREF_graph ( graph_top ( p ) ) ;
+	p = DEREF_graph(graph_top(p));
-    pa = DEREF_ctype ( graph_head ( p ) ) ;
+	pa = DEREF_ctype(graph_head(p));
-    /* Decompose q into qa > qb */
+	/* Decompose q into qa > qb */
-    qb = DEREF_ctype ( graph_head ( q ) ) ;
+	qb = DEREF_ctype(graph_head(q));
-    q = DEREF_graph ( graph_top ( q ) ) ;
+	q = DEREF_graph(graph_top(q));
-    qa = DEREF_ctype ( graph_head ( q ) ) ;
+	qa = DEREF_ctype(graph_head(q));
-    if ( eq_ctype ( pa, qa ) ) {
+	if (eq_ctype(pa, qa)) {
-	/* Graph tops are equal, pa = qa */
+		/* Graph tops are equal, pa = qa */
-	if ( eq_ctype ( pb, qb ) ) {
+		if (eq_ctype(pb, qb)) {
-	    /* Graphs are equal */
+			/* Graphs are equal */
-	    return ( 0 ) ;
+			return (0);
-	}
+		}
-	ct = compare_base_class ( pb, qb, 0 ) ;
+		ct = compare_base_class(pb, qb, 0);
-	if ( EQ_ctype ( ct, pb ) ) {
+		if (EQ_ctype(ct, pb)) {
-	    /* pa = qa > qb > pb */
+			/* pa = qa > qb > pb */
-	    return ( 2 ) ;
+			return (2);
-	}
+		}
-	if ( EQ_ctype ( ct, qb ) ) {
+		if (EQ_ctype(ct, qb)) {
-	    /* pa = qa > pb > qb */
+			/* pa = qa > pb > qb */
-	    return ( 1 ) ;
+			return (1);
-	}
+		}
-    } else if ( eq_ctype ( pb, qb ) ) {
+	} else if (eq_ctype(pb, qb)) {
-	/* Graph bottoms are equal, pb = qb */
+		/* Graph bottoms are equal, pb = qb */
-	ct = compare_base_class ( pa, qa, 0 ) ;
+		ct = compare_base_class(pa, qa, 0);
-	if ( EQ_ctype ( ct, pa ) ) {
+		if (EQ_ctype(ct, pa)) {
-	    /* qa > pa > pb = qb */
+			/* qa > pa > pb = qb */
-	    return ( 1 ) ;
+			return (1);
-	}
+		}
-	if ( EQ_ctype ( ct, qa ) ) {
+		if (EQ_ctype(ct, qa)) {
-	    /* pa > qa > pb = qb */
+			/* pa > qa > pb = qb */
-	    return ( 2 ) ;
+			return (2);
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     COMPARE TWO QUALIFICATION CONVERSIONS
     This routine compares the qualification conversions given by p and q.
     It returns 3 if they are identical, 1 if p is better (in that every
     qualifier added by p is also added by q), 2 if q is better, and 0
     otherwise.  When qualifiers are added at only one level it is just
     a matter of comparing the added qualifiers.  If qualifiers are added
     at more than one level a trial conversion is carried out.
 */
-static int qual_compare_seq
+static int
-    PROTO_N ( ( p, q ) )
-    PROTO_T ( CONVERSION *p X CONVERSION *q )
+qual_compare_seq(CONVERSION *p, CONVERSION *q)
+{
-    CV_SPEC cp = p->qual ;
+	CV_SPEC cp = p->qual;
-    CV_SPEC cq = q->qual ;
+	CV_SPEC cq = q->qual;
-    if ( cp == cv_multi || cq == cv_multi ) {
+	if (cp == cv_multi || cq == cv_multi) {
-	/* Qualifiers at more than one level */
+		/* Qualifiers at more than one level */
-	TYPE t ;
+		TYPE t;
-	unsigned cmp ;
+		unsigned cmp;
-	CONVERSION r ;
+		CONVERSION r;
-	if ( EQ_type ( p->from, q->from ) ) {
+		if (EQ_type(p->from, q->from)) {
-	    /* Compare to-types */
+			/* Compare to-types */
-	    r.from = p->to ;
+			r.from = p->to;
-	    r.to = q->to ;
+			r.to = q->to;
-	} else if ( EQ_type ( p->to, q->to ) ) {
+		} else if (EQ_type(p->to, q->to)) {
-	    /* Compare from-types */
+			/* Compare from-types */
-	    r.from = q->from ;
+			r.from = q->from;
-	    r.to = p->from ;
+			r.to = p->from;
+		} else {
+			/* This shouldn't happen */
+			return (0);
+		}
+		cmp = std_convert_seq(&r, NULL_exp, 0, 0);
+		if (cmp == CONV_EXACT) {
+			return (3);
+		}
+		if (cmp != CONV_NONE) {
+			return (1);
+		}
+		t = r.from;
+		r.from = r.to;
+		r.to = t;
+		cmp = std_convert_seq(&r, NULL_exp, 0, 0);
+		if (cmp != CONV_NONE) {
+			return (2);
+		}
 	} else {
-	    /* This shouldn't happen */
+		/* Qualifiers at only one level */
+		CV_SPEC cr;
+		if (cp == cq) {
+			return (3);
+		}
+		cr = (cp | cq);
+		if (cr == cq) {
+			return (1);
+		}
+		if (cr == cp) {
-	    return ( 0 ) ;
+			return (2);
+		}
+	}
-	cmp = std_convert_seq ( &r, NULL_exp, 0, 0 ) ;
-	if ( cmp == CONV_EXACT ) return ( 3 ) ;
-	if ( cmp != CONV_NONE ) return ( 1 ) ;
-	t = r.from ;
-	r.from = r.to ;
-	r.to = t ;
-	cmp = std_convert_seq ( &r, NULL_exp, 0, 0 ) ;
-	if ( cmp != CONV_NONE ) return ( 2 ) ;
-    } else {
-	/* Qualifiers at only one level */
-	CV_SPEC cr ;
-	if ( cp == cq ) return ( 3 ) ;
-	cr = ( cp | cq ) ;
-	if ( cr == cq ) return ( 1 ) ;
-	if ( cr == cp ) return ( 2 ) ;
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     COMPARE TWO CONVERSION SEQUENCES
     the best viable function in overload resolution, it returns 1 if the
     first conversion is better, 2 if second is better, and some other
     value otherwise.
 */
-int compare_seq
+int
-    PROTO_N ( ( p1, p2 ) )
-    PROTO_T ( CONVERSION *p1 X CONVERSION *p2 )
+compare_seq(CONVERSION *p1, CONVERSION *p2)
+{
-    /* Compare the ranks of the conversions */
+	/* Compare the ranks of the conversions */
-    int cmp = 0 ;
+	int cmp = 0;
-    unsigned a1 = p1->rank ;
+	unsigned a1 = p1->rank;
-    unsigned a2 = p2->rank ;
+	unsigned a2 = p2->rank;
-    unsigned b1 = CONV_RANK ( a1 ) ;
+	unsigned b1 = CONV_RANK(a1);
-    unsigned b2 = CONV_RANK ( a2 ) ;
+	unsigned b2 = CONV_RANK(a2);
-    if ( b1 > b2 ) return ( 1 ) ;
+	if (b1 > b2) {
+		return (1);
+	}
-    if ( b1 < b2 ) return ( 2 ) ;
+	if (b1 < b2) {
+		return (2);
+	}
-    /* Check user-defined conversions */
+	/* Check user-defined conversions */
-    if ( a1 == CONV_USER && a2 == CONV_USER ) {
+	if (a1 == CONV_USER && a2 == CONV_USER) {
-	if ( !EQ_id ( p1->usr, p2->usr ) ) return ( 0 ) ;
+		if (!EQ_id(p1->usr, p2->usr)) {
+			return (0);
+		}
-	a1 = p1->std ;
+		a1 = p1->std;
-	a2 = p2->std ;
+		a2 = p2->std;
-	b1 = CONV_RANK ( a1 ) ;
+		b1 = CONV_RANK(a1);
-	b2 = CONV_RANK ( a2 ) ;
+		b2 = CONV_RANK(a2);
-	if ( b1 > b2 ) return ( 1 ) ;
+		if (b1 > b2) {
+			return (1);
+		}
-	if ( b1 < b2 ) return ( 2 ) ;
+		if (b1 < b2) {
+			return (2);
-    }
+		}
+	}
-    /* Compare standard conversions */
+	/* Compare standard conversions */
-    switch ( a1 ) {
+	switch (a1) {
-	case CONV_PTR_BASE : {
+	case CONV_PTR_BASE: {
-	    /* Pointer conversions */
+		/* Pointer conversions */
-	    if ( a2 == a1 ) {
+		if (a2 == a1) {
-		/* Compare base pointer conversions */
+			/* Compare base pointer conversions */
-		GRAPH g1 = p1->base ;
+			GRAPH g1 = p1->base;
-		GRAPH g2 = p2->base ;
+			GRAPH g2 = p2->base;
-		if ( eq_graph ( g1, g2 ) ) {
+			if (eq_graph(g1, g2)) {
-		    cmp = qual_compare_seq ( p1, p2 ) ;
+				cmp = qual_compare_seq(p1, p2);
-		} else {
+			} else {
-		    cmp = base_compare_seq ( g1, g2 ) ;
+				cmp = base_compare_seq(g1, g2);
-		}
+			}
-	    } else if ( a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM ) {
+		} else if (a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM) {
-		/* Base pointer conversion is better than 'void *' */
+			/* Base pointer conversion is better than 'void *' */
-		cmp = 1 ;
+			cmp = 1;
-	    } else if ( a2 == CONV_BOOL ) {
+		} else if (a2 == CONV_BOOL) {
-		/* Base pointer conversion is better than 'bool' */
+			/* Base pointer conversion is better than 'bool' */
-		cmp = 1 ;
+			cmp = 1;
-	    }
+		}
-	    break ;
+		break;
 	}
-	case CONV_PTR_VOID :
+	case CONV_PTR_VOID:
-	case CONV_PTR_BOTTOM : {
+	case CONV_PTR_BOTTOM: {
-	    /* Pointer to 'void *' conversions */
+		/* Pointer to 'void *' conversions */
-	    if ( a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM ) {
+		if (a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM) {
-		/* Compare pointer conversions */
+			/* Compare pointer conversions */
-		cmp = qual_compare_seq ( p1, p2 ) ;
+			cmp = qual_compare_seq(p1, p2);
-	    } else if ( a2 == CONV_PTR_BASE ) {
+		} else if (a2 == CONV_PTR_BASE) {
-		/* Base pointer conversion is better than 'void *' */
+			/* Base pointer conversion is better than 'void *' */
-		cmp = 2 ;
+			cmp = 2;
-	    } else if ( a2 == CONV_BOOL ) {
+		} else if (a2 == CONV_BOOL) {
-		/* Pointer conversion is better than 'bool' */
+			/* Pointer conversion is better than 'bool' */
-		cmp = 1 ;
+			cmp = 1;
-	    }
+		}
-	    break ;
+		break;
 	}
-	case CONV_PTR_MEM_BASE : {
+	case CONV_PTR_MEM_BASE: {
-	    /* Pointer member conversions */
+		/* Pointer member conversions */
-	    if ( a2 == a1 ) {
+		if (a2 == a1) {
-		/* Compare base pointer member conversions */
+			/* Compare base pointer member conversions */
-		GRAPH g1 = p1->base ;
+			GRAPH g1 = p1->base;
-		GRAPH g2 = p2->base ;
+			GRAPH g2 = p2->base;
-		if ( eq_graph ( g1, g2 ) ) {
+			if (eq_graph(g1, g2)) {
-		    cmp = qual_compare_seq ( p1, p2 ) ;
+				cmp = qual_compare_seq(p1, p2);
-		} else {
+			} else {
-		    int bmp = base_compare_seq ( g1, g2 ) ;
+				int bmp = base_compare_seq(g1, g2);
-		    if ( bmp ) {
+				if (bmp) {
-			cmp = qual_compare_seq ( p1, p2 ) ;
+					cmp = qual_compare_seq(p1, p2);
-			switch ( cmp ) {
+					switch (cmp) {
-			    case 1 : {
+					case 1: {
-				if ( bmp != 2 ) cmp = 0 ;
+						if (bmp != 2) {
+							cmp = 0;
+						}
-				break ;
+						break;
-			    }
+					}
-			    case 2 : {
+					case 2: {
-				if ( bmp != 1 ) cmp = 0 ;
+						if (bmp != 1) {
+							cmp = 0;
+						}
-				break ;
+						break;
-			    }
+					}
-			    case 3 : {
+					case 3: {
-				cmp = bmp ;
+						cmp = bmp;
-				break ;
+						break;
+					}
-			    }
+					}
+				}
+			}
+		} else if (a2 == CONV_BOOL) {
+			/* Pointer conversion is better than 'bool' */
+			cmp = 1;
+		}
+		break;
+	}
+	case CONV_BASE: {
+		/* Base class conversions */
+		if (a2 == a1) {
+			/* Compare base class conversions */
+			GRAPH g1 = p1->base;
+			GRAPH g2 = p2->base;
+			if (eq_graph(g1, g2)) {
+				cmp = qual_compare_seq(p1, p2);
+			} else {
+				cmp = base_compare_seq(g1, g2);
+			}
-		    }
 		}
-	    } else if ( a2 == CONV_BOOL ) {
-		/* Pointer conversion is better than 'bool' */
-		cmp = 1 ;
-	    }
-	    break ;
+		break;
 	}
-	case CONV_BASE : {
+	case CONV_BOOL: {
-	    /* Base class conversions */
+		/* Boolean conversions */
-	    if ( a2 == a1 ) {
-		/* Compare base class conversions */
+		if (a2 == CONV_PTR_BASE || a2 == CONV_PTR_MEM_BASE ||
-		GRAPH g1 = p1->base ;
-		GRAPH g2 = p2->base ;
-		if ( eq_graph ( g1, g2 ) ) {
+		    a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM) {
-		    cmp = qual_compare_seq ( p1, p2 ) ;
+			/* Pointer conversion is better than 'bool' */
-		} else {
+			cmp = 2;
-		    cmp = base_compare_seq ( g1, g2 ) ;
 		}
-	    }
-	    break ;
+		break;
+	}
-	case CONV_BOOL : {
+	case CONV_STRING: {
-	    /* Boolean conversions */
+		/* String literal conversions */
+		if (a2 == a1) {
-	    if ( a2 == CONV_PTR_BASE || a2 == CONV_PTR_MEM_BASE ||
+			cmp = qual_compare_seq(p1, p2);
-		 a2 == CONV_PTR_VOID || a2 == CONV_PTR_BOTTOM ) {
+		} else if (a2 == CONV_QUAL) {
-		/* Pointer conversion is better than 'bool' */
+			/* Qualification conversion is better than string */
-		cmp = 2 ;
+			cmp = 2;
-	    }
+		}
-	    break ;
+		break;
+	}
-	case CONV_STRING : {
+	case CONV_QUAL: {
-	    /* String literal conversions */
+		/* Qualification conversions */
-	    if ( a2 == a1 ) {
+		if (a2 == a1) {
-		cmp = qual_compare_seq ( p1, p2 ) ;
+			cmp = qual_compare_seq(p1, p2);
-	    } else if ( a2 == CONV_QUAL ) {
+		} else if (a2 == CONV_STRING) {
-		/* Qualification conversion is better than string */
+			/* Qualification conversion is better than string */
-		cmp = 2 ;
+			cmp = 1;
-	    }
+		}
-	    break ;
+		break;
+	}
-	case CONV_QUAL : {
-	    /* Qualification conversions */
-	    if ( a2 == a1 ) {
-		cmp = qual_compare_seq ( p1, p2 ) ;
-	    } else if ( a2 == CONV_STRING ) {
-		/* Qualification conversion is better than string */
-		cmp = 1 ;
-	    }
-	    break ;
+	}
-    }
-    return ( cmp ) ;
+	return (cmp);
+}

Subversion Repositories tendra.SVN

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