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

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997, 1998
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
     This routine creates an error expression.  The result is an lvalue
     if lv is true.
 */
-EXP make_error_exp
+EXP
-    PROTO_N ( ( lv ) )
-    PROTO_T ( int lv )
+make_error_exp(int lv)
+{
-    EXP a ;
+	EXP a;
-    TYPE t = type_error ;
+	TYPE t = type_error;
+	if (lv) {
-    if ( lv ) t = lvalue_type ( t ) ;
+		t = lvalue_type(t);
+	}
-    MAKE_exp_value ( t, a ) ;
+	MAKE_exp_value(t, a);
-    return ( a ) ;
+	return (a);
+}
 /*
     CONSTRUCT A NULL POINTER CONSTANT
     anything other than a plain literal '0' for the null pointer (for
     example '1 - 1') is considered bad practice, so there is a test
     for this.  The null expression is returns if a is non-zero.
 */
-EXP make_null_ptr
+EXP
-    PROTO_N ( ( a, t ) )
-    PROTO_T ( EXP a X TYPE t )
+make_null_ptr(EXP a, TYPE t)
+{
-    EXP e = NULL_exp ;
+	EXP e = NULL_exp;
-    if ( IS_NULL_exp ( a ) ) {
+	if (IS_NULL_exp(a)) {
-	/* Allow null expressions */
+		/* Allow null expressions */
-	MAKE_exp_null ( t, e ) ;
+		MAKE_exp_null(t, e);
-    } else {
-	if ( is_zero_exp ( a ) ) {
-	    if ( !is_literal ( a ) ) {
-		/* Report complex literals */
-		report ( crt_loc, ERR_conv_ptr_null_complex () ) ;
-	    }
-	    MAKE_exp_null ( t, e ) ;
 	} else {
+		if (is_zero_exp(a)) {
+			if (!is_literal(a)) {
+				/* Report complex literals */
+				report(crt_loc, ERR_conv_ptr_null_complex());
+			}
+			MAKE_exp_null(t, e);
+		} else {
-	    if ( in_template_decl && IS_exp_int_lit ( a ) ) {
+			if (in_template_decl && IS_exp_int_lit(a)) {
-		if ( depends_on_exp ( a, any_templ_param, 0 ) ) {
+				if (depends_on_exp(a, any_templ_param, 0)) {
-		    /* Check for template parameters */
+					/* Check for template parameters */
+					report(crt_loc,
-		    report ( crt_loc, ERR_conv_ptr_null_complex () ) ;
+					       ERR_conv_ptr_null_complex());
-		    MAKE_exp_op ( t, lex_pointer, a, NULL_exp, e ) ;
+					MAKE_exp_op(t, lex_pointer, a,
+						    NULL_exp, e);
+				}
+			}
+		}
-	    }
+	}
-    }
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A PARENTHESISED EXPRESSION
     This routine constructs the expression '( a )'.  Note that parentheses
     are only needed in order to perform analysis for odd precedence in
     expressions.  It is otherwise just an identity operation.
 */
-EXP make_paren_exp
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+make_paren_exp(EXP a)
 {
-    EXP e ;
+	EXP e;
-    TYPE ta = DEREF_type ( exp_type ( a ) ) ;
+	TYPE ta = DEREF_type(exp_type(a));
-    if ( IS_exp_int_lit ( a ) ) {
+	if (IS_exp_int_lit(a)) {
-	/* Deal with integer constant expressions */
+		/* Deal with integer constant expressions */
-	unsigned etag = DEREF_unsigned ( exp_int_lit_etag ( a ) ) ;
+		unsigned etag = DEREF_unsigned(exp_int_lit_etag(a));
-	switch ( etag ) {
+		switch (etag) {
-	    case exp_int_lit_tag :
+		case exp_int_lit_tag:
-	    case exp_null_tag :
+		case exp_null_tag:
-	    case exp_identifier_tag : {
+		case exp_identifier_tag: {
-		/* Don't bother with literals and enumerators */
+			/* Don't bother with literals and enumerators */
-		e = a ;
+			e = a;
-		break ;
+			break;
-	    }
+		}
-	    default : {
+		default: {
-		/* Mark other values as parenthesised */
+			/* Mark other values as parenthesised */
-		NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+			NAT n = DEREF_nat(exp_int_lit_nat(a));
-		MAKE_exp_int_lit ( ta, n, exp_paren_tag, e ) ;
+			MAKE_exp_int_lit(ta, n, exp_paren_tag, e);
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-    } else {
+	} else {
-	MAKE_exp_paren ( ta, a, e ) ;
+		MAKE_exp_paren(ta, a, e);
-    }
+	}
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A TYPE OFFSET
     This routine constructs an offset of a times the offset of the type t.
     This is negated if neg is true.
 */
-OFFSET make_off_mult
+OFFSET
-    PROTO_N ( ( t, a, neg ) )
-    PROTO_T ( TYPE t X EXP a X int neg )
+make_off_mult(TYPE t, EXP a, int neg)
 {
-    OFFSET off ;
+	OFFSET off;
-    if ( IS_type_top_etc ( t ) ) {
+	if (IS_type_top_etc(t)) {
-	/* Map 'void *' to 'char *' */
+		/* Map 'void *' to 'char *' */
-	t = type_char ;
+		t = type_char;
-    }
+	}
-    if ( IS_exp_int_lit ( a ) ) {
+	if (IS_exp_int_lit(a)) {
-	/* Constant offsets */
+		/* Constant offsets */
-	int neg1 = neg ;
+		int neg1 = neg;
-	NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(a));
-	if ( IS_nat_neg ( n ) ) {
+		if (IS_nat_neg(n)) {
-	    n = DEREF_nat ( nat_neg_arg ( n ) ) ;
+			n = DEREF_nat(nat_neg_arg(n));
-	    neg1 = !neg1 ;
+			neg1 = !neg1;
-	}
+		}
-	if ( IS_nat_small ( n ) ) {
+		if (IS_nat_small(n)) {
-	    unsigned v = DEREF_unsigned ( nat_small_value ( n ) ) ;
+			unsigned v = DEREF_unsigned(nat_small_value(n));
-	    if ( v < 100 ) {
+			if (v < 100) {
-		if ( v == 0 ) {
+				if (v == 0) {
-		    MAKE_off_zero ( t, off ) ;
+					MAKE_off_zero(t, off);
-		} else if ( v == 1 ) {
+				} else if (v == 1) {
-		    MAKE_off_type ( t, off ) ;
+					MAKE_off_type(t, off);
-		} else {
+				} else {
-		    MAKE_type_array ( cv_none, t, n, t ) ;
+					MAKE_type_array(cv_none, t, n, t);
-		    MAKE_off_type ( t, off ) ;
+					MAKE_off_type(t, off);
-		}
+				}
+				if (neg1) {
-		if ( neg1 ) MAKE_off_negate ( off, off ) ;
+					MAKE_off_negate(off, off);
+				}
-		return ( off ) ;
+				return (off);
-	    }
+			}
+		}
+	}
+	MAKE_off_type(t, off);
+	MAKE_off_mult(off, a, off);
+	if (neg) {
+		MAKE_off_negate(off, off);
+	}
-    }
-    MAKE_off_type ( t, off ) ;
-    MAKE_off_mult ( off, a, off ) ;
-    if ( neg ) MAKE_off_negate ( off, off ) ;
-    return ( off ) ;
+	return (off);
+}
 /*
     CREATE AN ADD-TO-POINTER EXPRESSION
     This routine creates a pointer of type t by adding the offset off to
     the pointer expression a.  For pointers of type 'void *' conversions
     are performed to and from 'char *'.
 */
-EXP make_add_ptr
+EXP
-    PROTO_N ( ( t, a, off ) )
-    PROTO_T ( TYPE t X EXP a X OFFSET off )
+make_add_ptr(TYPE t, EXP a, OFFSET off)
+{
-    EXP e ;
+	EXP e;
-    if ( IS_type_ptr ( t ) ) {
+	if (IS_type_ptr(t)) {
-	TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_sub(t));
-	if ( IS_type_top_etc ( s ) ) {
+		if (IS_type_top_etc(s)) {
-	    TYPE p = type_char_star ;
+			TYPE p = type_char_star;
-	    MAKE_exp_cast ( p, ( CONV_PTR_VOID | CONV_REVERSE ), a, e ) ;
+			MAKE_exp_cast(p,(CONV_PTR_VOID | CONV_REVERSE), a, e);
-	    e = make_add_ptr ( p, e, off ) ;
+			e = make_add_ptr(p, e, off);
-	    MAKE_exp_cast ( t, CONV_PTR_VOID, e, e ) ;
+			MAKE_exp_cast(t, CONV_PTR_VOID, e, e);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
-    MAKE_exp_add_ptr ( t, a, off, 0, e ) ;
+	MAKE_exp_add_ptr(t, a, off, 0, e);
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT AN INDEX EXPRESSION
     an integer constant then bounds checks are applied to the operation.
     However once an array has been converted into a pointer any associated
     bounds information is lost.
 */
-EXP make_index_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_index_exp(EXP a, EXP b)
+{
-    TYPE t ;
+	TYPE t;
-    EXP e, p ;
+	EXP e, p;
-    int z = 0 ;
+	int z = 0;
-    OFFSET off ;
+	OFFSET off;
-    TYPE ta, tb ;
+	TYPE ta, tb;
-    unsigned ca, cb ;
+	unsigned ca, cb;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    TYPE sa = DEREF_type ( exp_type ( a ) ) ;
+	TYPE sa = DEREF_type(exp_type(a));
-    TYPE sb = DEREF_type ( exp_type ( b ) ) ;
+	TYPE sb = DEREF_type(exp_type(b));
-    /* Do reference conversions */
+	/* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    b = convert_reference ( b, REF_NORMAL ) ;
+	b = convert_reference(b, REF_NORMAL);
-    /* Find the operand types */
+	/* Find the operand types */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    cb = type_category ( &tb ) ;
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = binary_overload ( lex_array_Hop, a, b ) ;
+			e = binary_overload(lex_array_Hop, a, b);
-	    return ( e ) ;
+			return (e);
-	}
-    }
-#endif
-    /* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
-	a = convert_lvalue ( a ) ;
-	ta = DEREF_type ( exp_type ( a ) ) ;
-	ca = type_category ( &ta ) ;
-    }
-    if ( IS_TYPE_ADDRESS ( cb ) ) {
-	b = convert_lvalue ( b ) ;
-	tb = DEREF_type ( exp_type ( b ) ) ;
-	cb = type_category ( &tb ) ;
-    }
-    /* Swap operands if the second is a pointer */
-    if ( IS_TYPE_PTR ( cb ) ) {
-	/* Alright because order of evaluation is undefined */
-	EXP c = a ;
-	TYPE tc = ta ;
-	unsigned cc = ca ;
-	a = b ;
-	b = c ;
-	ta = tb ;
-	tb = tc ;
-	ca = cb ;
-	cb = cc ;
-	sa = sb ;
-    }
-    /* The first operand should now be a pointer */
-    if ( !IS_TYPE_PTR ( ca ) ) {
-	if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
-	    report ( crt_loc, ERR_expr_sub_ptr_op ( ta, tb ) ) ;
-	}
-	return ( make_error_exp ( 0 ) ) ;
-    }
-    /* The second operand should be integral */
-    if ( !IS_TYPE_INT ( cb ) ) {
-	if ( !IS_TYPE_ERROR ( cb ) ) {
-	    report ( crt_loc, ERR_expr_sub_int_op ( tb ) ) ;
-	}
-	/* Continue with zero index */
-	z = 1 ;
-    }
-    /* Check index value */
-    if ( IS_exp_int_lit ( b ) ) {
-	if ( IS_type_array ( sa ) ) {
-	    check_bounds ( lex_array_Hop, sa, b ) ;
-	}
+		}
-	z = is_zero_exp ( b ) ;
-    } else {
-	if ( eq_type_unqual ( tb, type_char ) ) {
-	    report ( crt_loc, ERR_expr_sub_char_op ( tb ) ) ;
+	}
-    }
-    /* The pointer must be to a complete object type */
-    t = check_pointer ( ta, &err ) ;
-    if ( !IS_NULL_err ( err ) ) {
-	err = concat_error ( err, ERR_expr_sub_incompl () ) ;
-	report ( crt_loc, err ) ;
-    }
-    /* Construct pointer to the result */
-    if ( z ) {
-	/* Zero offset */
-	p = a ;
-    } else {
-	/* Non-zero offset */
-	if ( IS_TYPE_BITF ( cb ) ) b = convert_bitfield ( b ) ;
-	off = make_off_mult ( t, b, 0 ) ;
-	p = make_add_ptr ( ta, a, off ) ;
-    }
-    /* The result is an lvalue */
-    t = lvalue_type ( t ) ;
-    /* Construct the result */
-    MAKE_exp_indir ( t, p, e ) ;
-    COPY_int ( exp_indir_index ( e ), 1 ) ;
-    return ( e ) ;
-}
-/*
-    CONSTRUCT A INDIRECTION EXPRESSION
-    This routine constructs the indirection expression '*a'.  The result
-    is an lvalue.
-*/
-EXP make_indir_exp
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
-{
-    EXP e ;
-    TYPE ta ;
-    unsigned ca ;
-    /* Do reference conversion */
-    a = convert_reference ( a, REF_NORMAL ) ;
-    /* Find operand type */
-    ta = DEREF_type ( exp_type ( a ) ) ;
-    ca = type_category ( &ta ) ;
-    /* Check for overloading */
-#if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) ) {
-	if ( overload_depth == 0 ) {
-	    e = unary_overload ( lex_star, a ) ;
-	    return ( e ) ;
-	}
-    }
 #endif
-    /* Do lvalue conversion */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-	ta = DEREF_type ( exp_type ( a ) ) ;
+		ta = DEREF_type(exp_type(a));
-	ca = type_category ( &ta ) ;
+		ca = type_category(&ta);
+	}
+	if (IS_TYPE_ADDRESS(cb)) {
+		b = convert_lvalue(b);
+		tb = DEREF_type(exp_type(b));
+		cb = type_category(&tb);
+	}
+	/* Swap operands if the second is a pointer */
+	if (IS_TYPE_PTR(cb)) {
+		/* Alright because order of evaluation is undefined */
+		EXP c = a;
+		TYPE tc = ta;
+		unsigned cc = ca;
+		a = b;
+		b = c;
+		ta = tb;
+		tb = tc;
+		ca = cb;
+		cb = cc;
+		sa = sb;
+	}
+	/* The first operand should now be a pointer */
+	if (!IS_TYPE_PTR(ca)) {
+		if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
+			report(crt_loc, ERR_expr_sub_ptr_op(ta, tb));
+		}
+		return (make_error_exp(0));
+	}
+	/* The second operand should be integral */
+	if (!IS_TYPE_INT(cb)) {
+		if (!IS_TYPE_ERROR(cb)) {
+			report(crt_loc, ERR_expr_sub_int_op(tb));
+		}
+		/* Continue with zero index */
+		z = 1;
+	}
+	/* Check index value */
+	if (IS_exp_int_lit(b)) {
+		if (IS_type_array(sa)) {
+			check_bounds(lex_array_Hop, sa, b);
+		}
+		z = is_zero_exp(b);
+	} else {
+		if (eq_type_unqual(tb, type_char)) {
+			report(crt_loc, ERR_expr_sub_char_op(tb));
-    }
+		}
+	}
-    /* Operand can be pointer ... */
+	/* The pointer must be to a complete object type */
-    if ( IS_TYPE_PTR ( ca ) ) {
-	TYPE t = check_pointer ( ta, KILL_err ) ;
+	t = check_pointer(ta, &err);
-	if ( IS_type_top_etc ( t ) ) {
-	    /* The pointer cannot be 'void *' */
-	    report ( crt_loc, ERR_expr_unary_op_indir_void ( ta ) ) ;
-	}
-	if ( IS_exp_null ( a ) ) {
+	if (!IS_NULL_err(err)) {
-	    /* Check for obvious null pointers */
-	    report ( crt_loc, ERR_expr_unary_op_indir_null ( lex_star ) ) ;
-	}
-	/* The result is an lvalue */
-	t = lvalue_type ( t ) ;
-	/* Construct the result */
-	MAKE_exp_indir ( t, a, e ) ;
-	return ( e ) ;
-    }
-    /* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) ) {
-	report ( crt_loc, ERR_expr_unary_op_indir_op ( ta ) ) ;
+		err = concat_error(err, ERR_expr_sub_incompl());
-    }
-    return ( make_error_exp ( 1 ) ) ;
-}
-/*
-    CONSTRUCT A REFERENCE TO AN OBJECT
-    This routine constructs a pointer to the expression a which designates
-    an object.  Any errors arising are added to err.
-*/
-EXP make_ref_object
-    PROTO_N ( ( a, err ) )
-    PROTO_T ( EXP a X ERROR *err )
-{
-    EXP e ;
-    TYPE p ;
-    TYPE ta = DEREF_type ( exp_type ( a ) ) ;
-    unsigned ca = type_category ( &ta ) ;
-    if ( IS_TYPE_ERROR ( ca ) ) {
-	/* Error progagation */
-	e = make_error_exp ( 0 ) ;
-	return ( e ) ;
+		report(crt_loc, err);
-    }
-    if ( !IS_TYPE_LVALUE ( ca ) ) {
-	/* Operand should be an lvalue */
-	add_error ( err, ERR_expr_unary_op_ref_lvalue () ) ;
-    }
-    if ( IS_TYPE_BITF ( ca ) ) {
-	/* Can't apply to a bitfield */
-	add_error ( err, ERR_expr_unary_op_ref_bitf () ) ;
-	ta = find_bitfield_type ( ta ) ;
-    }
-    if ( option ( OPT_addr_register ) && used_register ) {
-	/* Can't apply to a register variable in C */
-	EXP b = NULL_exp ;
-	DECL_SPEC ds = find_exp_linkage ( a, &b, 1 ) ;
-	if ( ( ds & dspec_register ) && !( ds & dspec_temp ) ) {
-	    if ( IS_exp_identifier ( b ) ) {
-		IDENTIFIER id = DEREF_id ( exp_identifier_id ( b ) ) ;
-		add_error ( err, ERR_expr_unary_op_ref_register ( id ) ) ;
-	    }
+	}
-    }
-    if ( IS_type_top_etc ( ta ) ) {
+	/* Construct pointer to the result */
+	if (z) {
-	/* Can't apply to void */
+		/* Zero offset */
-	add_error ( err, ERR_expr_unary_op_ref_void ( ta ) ) ;
+		p = a;
-    } else {
+	} else {
-	/* Check for incomplete types */
+		/* Non-zero offset */
-	ERROR err2 = check_incomplete ( ta ) ;
+		if (IS_TYPE_BITF(cb)) {
-	if ( !IS_NULL_err ( err2 ) ) {
+			b = convert_bitfield(b);
+		}
-	    add_error ( err, err2 ) ;
+		off = make_off_mult(t, b, 0);
-	    add_error ( err, ERR_expr_unary_op_ref_incompl () ) ;
+		p = make_add_ptr(ta, a, off);
+	}
-    }
+	/* The result is an lvalue */
+	t = lvalue_type(t);
+	/* Construct the result */
+	MAKE_exp_indir(t, p, e);
+	COPY_int(exp_indir_index(e), 1);
+	return (e);
+}
+/*
+    CONSTRUCT A INDIRECTION EXPRESSION
+    This routine constructs the indirection expression '*a'.  The result
+    is an lvalue.
+*/
+EXP
+make_indir_exp(EXP a)
+{
+	EXP e;
+	TYPE ta;
+	unsigned ca;
+	/* Do reference conversion */
+	a = convert_reference(a, REF_NORMAL);
+	/* Find operand type */
+	ta = DEREF_type(exp_type(a));
+	ca = type_category(&ta);
+	/* Check for overloading */
+#if LANGUAGE_CPP
+	if (IS_TYPE_OVERLOAD(ca)) {
+		if (overload_depth == 0) {
+			e = unary_overload(lex_star, a);
+			return (e);
+		}
+	}
+#endif
+	/* Do lvalue conversion */
+	if (IS_TYPE_ADDRESS(ca)) {
+		a = convert_lvalue(a);
+		ta = DEREF_type(exp_type(a));
+		ca = type_category(&ta);
+	}
+	/* Operand can be pointer ... */
+	if (IS_TYPE_PTR(ca)) {
+		TYPE t = check_pointer(ta, KILL_err);
+		if (IS_type_top_etc(t)) {
+			/* The pointer cannot be 'void *' */
+			report(crt_loc, ERR_expr_unary_op_indir_void(ta));
+		}
+		if (IS_exp_null(a)) {
+			/* Check for obvious null pointers */
+			report(crt_loc, ERR_expr_unary_op_indir_null(lex_star));
+		}
+		/* The result is an lvalue */
+		t = lvalue_type(t);
-    /* Construct the result */
+		/* Construct the result */
+		MAKE_exp_indir(t, a, e);
+		return (e);
+	}
+	/* ... and nothing else */
+	if (!IS_TYPE_ERROR(ca)) {
+		report(crt_loc, ERR_expr_unary_op_indir_op(ta));
+	}
+	return (make_error_exp(1));
+}
+/*
+    CONSTRUCT A REFERENCE TO AN OBJECT
+    This routine constructs a pointer to the expression a which designates
+    an object.  Any errors arising are added to err.
+*/
+EXP
+make_ref_object(EXP a, ERROR *err)
+{
+	EXP e;
+	TYPE p;
+	TYPE ta = DEREF_type(exp_type(a));
+	unsigned ca = type_category(&ta);
+	if (IS_TYPE_ERROR(ca)) {
+		/* Error progagation */
+		e = make_error_exp(0);
+		return (e);
+	}
+	if (!IS_TYPE_LVALUE(ca)) {
+		/* Operand should be an lvalue */
+		add_error(err, ERR_expr_unary_op_ref_lvalue());
+	}
+	if (IS_TYPE_BITF(ca)) {
+		/* Can't apply to a bitfield */
+		add_error(err, ERR_expr_unary_op_ref_bitf());
+		ta = find_bitfield_type(ta);
+	}
+	if (option(OPT_addr_register) && used_register) {
+		/* Can't apply to a register variable in C */
+		EXP b = NULL_exp;
+		DECL_SPEC ds = find_exp_linkage(a, &b, 1);
+		if ((ds & dspec_register) && !(ds & dspec_temp)) {
+			if (IS_exp_identifier(b)) {
+				IDENTIFIER id = DEREF_id(exp_identifier_id(b));
+				add_error(err,
+					  ERR_expr_unary_op_ref_register(id));
+			}
+		}
+	}
+	if (IS_type_top_etc(ta)) {
+		/* Can't apply to void */
+		add_error(err, ERR_expr_unary_op_ref_void(ta));
+	} else {
+		/* Check for incomplete types */
+		ERROR err2 = check_incomplete(ta);
+		if (!IS_NULL_err(err2)) {
+			add_error(err, err2);
+			add_error(err, ERR_expr_unary_op_ref_incompl());
+		}
+	}
+	/* Construct the result */
-    ta = rvalue_type ( ta ) ;
+	ta = rvalue_type(ta);
-    MAKE_type_ptr ( cv_none, ta, p ) ;
+	MAKE_type_ptr(cv_none, ta, p);
-    MAKE_exp_address ( p, a, e ) ;
+	MAKE_exp_address(p, a, e);
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A REFERENCE TO A MEMBER
     This routine constructs a pointer to the expression a which designates
     a class member.  Note that a can represent an overloaded member function
     in which case the actual result type can only be determined after
     overload resolution.  Also the type of an inherited member is that
     of its base class rather than its derived class.
 */
 #if LANGUAGE_CPP
-static EXP make_ref_member
+static EXP
-    PROTO_N ( ( a, paren, res ) )
-    PROTO_T ( EXP a X int paren X int res )
+make_ref_member(EXP a, int paren, int res)
 {
-    EXP e ;
+	EXP e;
-    TYPE p ;
+	TYPE p;
-    DECL_SPEC ds ;
+	DECL_SPEC ds;
-    /* Find the base class */
+	/* Find the base class */
-    IDENTIFIER id = DEREF_id ( exp_member_id ( a ) ) ;
+	IDENTIFIER id = DEREF_id(exp_member_id(a));
-    IDENTIFIER uid = DEREF_id ( id_alias ( id ) ) ;
+	IDENTIFIER uid = DEREF_id(id_alias(id));
-    CLASS_TYPE tc = parent_class ( uid ) ;
+	CLASS_TYPE tc = parent_class(uid);
-    /* Find the result type */
+	/* Find the result type */
-    TYPE ta = DEREF_type ( exp_type ( a ) ) ;
+	TYPE ta = DEREF_type(exp_type(a));
-    ta = rvalue_type ( ta ) ;
+	ta = rvalue_type(ta);
-    if ( IS_type_bitfield ( ta ) ) {
+	if (IS_type_bitfield(ta)) {
-	/* Can't apply to a bitfield */
+		/* Can't apply to a bitfield */
-	report ( crt_loc, ERR_expr_unary_op_ref_bitf () ) ;
+		report(crt_loc, ERR_expr_unary_op_ref_bitf());
-	ta = find_bitfield_type ( ta ) ;
+		ta = find_bitfield_type(ta);
-    }
+	}
-    MAKE_type_ptr_mem ( cv_none, tc, ta, p ) ;
+	MAKE_type_ptr_mem(cv_none, tc, ta, p);
-    /* Construct the result */
+	/* Construct the result */
-    if ( !EQ_id ( id, uid ) ) {
+	if (!EQ_id(id, uid)) {
-	QUALIFIER qual = DEREF_qual ( exp_member_qual ( a ) ) ;
+		QUALIFIER qual = DEREF_qual(exp_member_qual(a));
-	MAKE_exp_member ( ta, uid, qual, a ) ;
+		MAKE_exp_member(ta, uid, qual, a);
-    }
+	}
-    MAKE_exp_address_mem ( p, a, paren, e ) ;
+	MAKE_exp_address_mem(p, a, paren, e);
-    if ( res ) {
+	if (res) {
-	/* Mark identifier as used */
+		/* Mark identifier as used */
-	if ( res == 2 ) {
+		if (res == 2) {
-	    use_id ( id, suppress_usage ) ;
+			use_id(id, suppress_usage);
-	} else {
+		} else {
-	    reuse_id ( id, suppress_usage ) ;
+			reuse_id(id, suppress_usage);
-	}
+		}
-	ds = DEREF_dspec ( id_storage ( id ) ) ;
+		ds = DEREF_dspec(id_storage(id));
-	if ( ds & dspec_trivial ) {
+		if (ds & dspec_trivial) {
-	    /* Can take the address of a trivial function */
+			/* Can take the address of a trivial function */
-	    CONS_id ( id, pending_funcs, pending_funcs ) ;
+			CONS_id(id, pending_funcs, pending_funcs);
-	}
+		}
-    }
+	}
-    return ( e ) ;
+	return (e);
 }
 #endif
 /*
     CONSTRUCT A REFERENCE EXPRESSION
     This routine constructs the expression '&a' for constructing a pointer
     to a or a pointer member to a.  The res argument is true to indicate
     that any overloaded functions in a have been resolved.
 */
-EXP make_ref_exp
+EXP
-    PROTO_N ( ( a, res ) )
-    PROTO_T ( EXP a X int res )
+make_ref_exp(EXP a, int res)
 {
-    EXP e ;
+	EXP e;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
 #if LANGUAGE_CPP
-    TYPE ta ;
+	TYPE ta;
-    unsigned ca ;
+	unsigned ca;
-    int paren = IS_exp_paren ( a ) ;
+	int paren = IS_exp_paren(a);
-    /* Perform reference conversions */
+	/* Perform reference conversions */
-    a = convert_reference ( a, REF_ADDRESS ) ;
+	a = convert_reference(a, REF_ADDRESS);
-    /* Check for members */
+	/* Check for members */
-    if ( IS_exp_member ( a ) ) {
+	if (IS_exp_member(a)) {
-	int is_mem = 1 ;
+		int is_mem = 1;
-	IDENTIFIER id = DEREF_id ( exp_member_id ( a ) ) ;
+		IDENTIFIER id = DEREF_id(exp_member_id(a));
-	QUALIFIER idtype = DEREF_qual ( exp_member_qual ( a ) ) ;
+		QUALIFIER idtype = DEREF_qual(exp_member_qual(a));
-	idtype &= ~qual_mark ;
+		idtype &= ~qual_mark;
-	if ( !( idtype & qual_explicit ) ) {
+		if (!(idtype & qual_explicit)) {
-	    EXP b = make_this_field ( id ) ;
+			EXP b = make_this_field(id);
-	    if ( !IS_NULL_exp ( b ) ) {
+			if (!IS_NULL_exp(b)) {
-		a = convert_reference ( b, REF_ADDRESS ) ;
+				a = convert_reference(b, REF_ADDRESS);
-		is_mem = 0 ;
+				is_mem = 0;
-	    }
+			}
-	}
+		}
-	if ( is_mem ) {
+		if (is_mem) {
-	    if ( IS_id_member ( id ) ) res = 2 ;
+			if (IS_id_member(id))res = 2;
-	    if ( res ) {
+			if (res) {
-		if ( idtype == qual_none ) {
+				if (idtype == qual_none) {
-		    /* Identifiers must be qualified */
+					/* Identifiers must be qualified */
+					report(crt_loc,
-		    report ( crt_loc, ERR_expr_unary_op_ref_unqual () ) ;
+					       ERR_expr_unary_op_ref_unqual());
-		} else {
+				} else {
-		    if ( idtype != qual_nested ) {
+					if (idtype != qual_nested) {
+						/* Shouldn't have fully
-			/* Shouldn't have fully qualified identifier */
+						 * qualified identifier */
-			report ( crt_loc, ERR_expr_unary_op_ref_full () ) ;
+						report(crt_loc, ERR_expr_unary_op_ref_full());
-		    }
+					}
-		    if ( paren ) {
+					if (paren) {
-			/* Identifier can't be parenthesised */
+						/* Identifier can't be
+						 * parenthesised */
-			report ( crt_loc, ERR_expr_unary_op_ref_paren () ) ;
+						report(crt_loc, ERR_expr_unary_op_ref_paren());
-			paren = 0 ;
+						paren = 0;
-		    }
+					}
+				}
+			}
+			e = make_ref_member(a, paren, res);
+			return (e);
+		}
+	}
+	/* Get operand type */
+	ta = DEREF_type(exp_type(a));
+	ca = type_category(&ta);
+	if (IS_TYPE_OVERLOAD(ca)) {
+		/* Check for overloading */
+		if (overload_depth == 0) {
+			e = unary_overload(lex_and_H1, a);
+			return (e);
+		}
+		if (IS_type_compound(ta)) {
+			/* Mark class types */
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(ta));
+			CLASS_USAGE cu = DEREF_cusage(ctype_usage(ct));
+			cu |= cusage_address;
+			COPY_cusage(ctype_usage(ct), cu);
+		}
-	    }
-	    e = make_ref_member ( a, paren, res ) ;
-	    return ( e ) ;
+	}
-    }
-    /* Get operand type */
-    ta = DEREF_type ( exp_type ( a ) ) ;
-    ca = type_category ( &ta ) ;
-    if ( IS_TYPE_OVERLOAD ( ca ) ) {
-	/* Check for overloading */
-	if ( overload_depth == 0 ) {
-	    e = unary_overload ( lex_and_H1, a ) ;
-	    return ( e ) ;
-	}
-	if ( IS_type_compound ( ta ) ) {
-	    /* Mark class types */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( ta ) ) ;
-	    CLASS_USAGE cu = DEREF_cusage ( ctype_usage ( ct ) ) ;
-	    cu |= cusage_address ;
-	    COPY_cusage ( ctype_usage ( ct ), cu ) ;
-	}
-    }
 #else
-    /* Perform reference conversions */
+	/* Perform reference conversions */
-    a = convert_reference ( a, REF_ADDRESS ) ;
+	a = convert_reference(a, REF_ADDRESS);
-    UNUSED ( res ) ;
+	UNUSED(res);
 #endif
-    /* Construct the result */
+	/* Construct the result */
-    e = make_ref_object ( a, &err ) ;
+	e = make_ref_object(a, &err);
-    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+	if (!IS_NULL_err(err)) {
+		report(crt_loc, err);
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A UNARY ARITHMETIC EXPRESSION
     '+a' the expression constructed is '( a )' rather than 'a'.  This is
     to prevent expressions like 'a << +( b + c )' confusing the dubious
     parenthesis checks.
 */
-EXP make_uminus_exp
+EXP
-    PROTO_N ( ( op, a ) )
-    PROTO_T ( int op X EXP a )
+make_uminus_exp(int op, EXP a)
+{
-    TYPE ta ;
+	TYPE ta;
-    unsigned ca ;
+	unsigned ca;
-    /* Find operation information */
+	/* Find operation information */
-    unsigned cb = CTYPE_ARITH ;
+	unsigned cb = CTYPE_ARITH;
-    unsigned tag = exp_negate_tag ;
+	unsigned tag = exp_negate_tag;
-    switch ( op ) {
+	switch (op) {
-	case lex_plus : {
+	case lex_plus: {
-	    tag = exp_paren_tag ;
+		tag = exp_paren_tag;
 #if LANGUAGE_CPP
-	    cb = CTYPE_SCALAR ;
+		cb = CTYPE_SCALAR;
 #endif
-	    break ;
+		break;
+	}
-	case lex_compl_H1 : {
+	case lex_compl_H1: {
-	    tag = exp_compl_tag ;
+		tag = exp_compl_tag;
-	    cb = CTYPE_INT ;
+		cb = CTYPE_INT;
-	    break ;
+		break;
+	}
-	case lex_abs : {
+	case lex_abs: {
-	    tag = exp_abs_tag ;
+		tag = exp_abs_tag;
-	    break ;
+		break;
+	}
+	}
+	/* Do reference conversion */
+	a = convert_reference(a, REF_NORMAL);
+	/* Find the operand type */
+	ta = DEREF_type(exp_type(a));
+	ca = type_category(&ta);
+	/* Check for overloading */
+#if LANGUAGE_CPP
+	if (IS_TYPE_OVERLOAD(ca)) {
+		if (overload_depth == 0) {
+			EXP e = unary_overload(op, a);
+			return (e);
+		}
+	}
+#endif
+	/* Do lvalue conversion */
+	if (IS_TYPE_ADDRESS(ca)) {
+		a = convert_lvalue(a);
+		ta = DEREF_type(exp_type(a));
+		ca = type_category(&ta);
+	}
-    }
-    /* Do reference conversion */
-    a = convert_reference ( a, REF_NORMAL ) ;
-    /* Find the operand type */
+	/* Check operand type ... */
+	if (ca & cb) {
+		EXP e;
-    ta = DEREF_type ( exp_type ( a ) ) ;
+		TYPE pta = promote_type(ta);
+		a = convert_promote(pta, a);
+		if (tag == exp_paren_tag) {
-    ca = type_category ( &ta ) ;
+			e = make_paren_exp(a);
+		} else {
+			if (IS_exp_int_lit(a)) {
+				e = make_unary_nat(tag, a);
+			} else {
+				MAKE_exp_negate_etc(tag, pta, a, e);
+			}
+		}
+		return (e);
+	}
-    /* Check for overloading */
-#if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) ) {
-	if ( overload_depth == 0 ) {
-	    EXP e = unary_overload ( op, a ) ;
-	    return ( e ) ;
-	}
-    }
-#endif
-    /* Do lvalue conversion */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
-	a = convert_lvalue ( a ) ;
-	ta = DEREF_type ( exp_type ( a ) ) ;
-	ca = type_category ( &ta ) ;
-    }
-    /* Check operand type ... */
-    if ( ca & cb ) {
-	EXP e ;
-	TYPE pta = promote_type ( ta ) ;
-	a = convert_promote ( pta, a ) ;
-	if ( tag == exp_paren_tag ) {
-	    e = make_paren_exp ( a ) ;
-	} else {
-	    if ( IS_exp_int_lit ( a ) ) {
-		e = make_unary_nat ( tag, a ) ;
-	    } else {
-		MAKE_exp_negate_etc ( tag, pta, a, e ) ;
-	    }
-	}
-	return ( e ) ;
-    }
-    /* ... and report error otherwise */
+	/* ... and report error otherwise */
-    if ( !IS_TYPE_ERROR ( ca ) ) {
+	if (!IS_TYPE_ERROR(ca)) {
-	ERROR err ;
+		ERROR err;
-	if ( cb == CTYPE_SCALAR ) {
+		if (cb == CTYPE_SCALAR) {
-	    err = ERR_expr_unary_op_uplus_op ( op, ta ) ;
+			err = ERR_expr_unary_op_uplus_op(op, ta);
-	} else if ( cb == CTYPE_ARITH ) {
+		} else if (cb == CTYPE_ARITH) {
-	    err = ERR_expr_unary_op_uminus_op ( op, ta ) ;
+			err = ERR_expr_unary_op_uminus_op(op, ta);
-	} else {
+		} else {
-	    err = ERR_expr_unary_op_compl_op ( op, ta ) ;
+			err = ERR_expr_unary_op_compl_op(op, ta);
-	}
+		}
-	report ( crt_loc, err ) ;
+		report(crt_loc, err);
-    }
+	}
-    return ( make_error_exp ( 0 ) ) ;
+	return (make_error_exp(0));
+}
 /*
     CONSTRUCT A LOGICAL NEGATION EXPRESSION
     This routine constructs the expression '!a'.
 */
-EXP make_not_exp
+EXP
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+make_not_exp(EXP a)
 {
-    TYPE ta ;
+	TYPE ta;
-    EXP e, b ;
+	EXP e, b;
-    unsigned ca ;
+	unsigned ca;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    unsigned tag = TAG_exp ( a ) ;
+	unsigned tag = TAG_exp(a);
-    /* Do reference conversion */
+	/* Do reference conversion */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    /* Find the operand type */
+	/* Find the operand type */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) ) {
+	if (IS_TYPE_OVERLOAD(ca)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = unary_overload ( lex_not_H1, a ) ;
+			e = unary_overload(lex_not_H1, a);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-    }
+	}
 #endif
-    /* Do lvalue conversion */
+	/* Do lvalue conversion */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-    }
+	}
-    /* Convert the operand to a boolean */
+	/* Convert the operand to a boolean */
-    b = convert_boolean ( a, tag, &err ) ;
+	b = convert_boolean(a, tag, &err);
-    if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	err = concat_error ( err, ERR_expr_unary_op_not_op () ) ;
+		err = concat_error(err, ERR_expr_unary_op_not_op());
-	report ( crt_loc, err ) ;
+		report(crt_loc, err);
-    }
+	}
-    /* Construct the result */
+	/* Construct the result */
-    if ( IS_exp_int_lit ( b ) ) {
+	if (IS_exp_int_lit(b)) {
-	e = make_unary_nat ( exp_not_tag, b ) ;
+		e = make_unary_nat(exp_not_tag, b);
-    } else {
+	} else {
-	MAKE_exp_not ( type_bool, b, e ) ;
+		MAKE_exp_not(type_bool, b, e);
-    }
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     DIVISION MODE
     operations.  The values 0, 1 and 2 correspond to the TDF operations
     div0, div1 and div2 and rem0, rem1 and rem2 respectively.  The value 3
     indicates that the decision should be postponed to the installers.
 */
-int division_mode = 3 ;
+int division_mode = 3;
 /*
     CHECK FOR DUBIOUS DIVISION EXPRESSIONS
     dubious constant operands.  All the necessary operand and arithmetic
     type conversions have already been performed on a and b.  The routine
     returns 1 if both operands are integer constants and b is not zero.
 */
-int check_div_exp
+int
-    PROTO_N ( ( op, a, b ) )
-    PROTO_T ( int op X EXP a X EXP b )
+check_div_exp(int op, EXP a, EXP b)
+{
-    int eval = 1 ;
+	int eval = 1;
-    int div_mode = division_mode ;
+	int div_mode = division_mode;
-    if ( IS_exp_int_lit ( b ) ) {
+	if (IS_exp_int_lit(b)) {
-	/* Check the second operand */
+		/* Check the second operand */
-	NAT n = DEREF_nat ( exp_int_lit_nat ( b ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(b));
-	if ( is_zero_nat ( n ) ) {
+		if (is_zero_nat(n)) {
-	    /* Report division by zero */
+			/* Report division by zero */
-	    report ( crt_loc, ERR_expr_mul_div_zero ( op ) ) ;
+			report(crt_loc, ERR_expr_mul_div_zero(op));
-	    return ( 0 ) ;
+			return (0);
+		}
+		if (div_mode != 1 && div_mode != 2) {
+			if (is_negative_nat(n) && !divides_nat(a, b)) {
+				/* Division by negative is undefined */
+				report(crt_loc, ERR_expr_mul_div_neg(op, n));
+			}
+		}
+	} else {
+		eval = 0;
+	}
-	if ( div_mode != 1 && div_mode != 2 ) {
-	    if ( is_negative_nat ( n ) && !divides_nat ( a, b ) ) {
-		/* Division by negative is undefined */
-		report ( crt_loc, ERR_expr_mul_div_neg ( op, n ) ) ;
-	    }
-	}
-    } else {
-	eval = 0 ;
-    }
-    if ( IS_exp_int_lit ( a ) ) {
+	if (IS_exp_int_lit(a)) {
-	/* Check the first operand */
+		/* Check the first operand */
-	if ( div_mode != 1 && div_mode != 2 ) {
+		if (div_mode != 1 && div_mode != 2) {
-	    NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+			NAT n = DEREF_nat(exp_int_lit_nat(a));
-	    if ( is_negative_nat ( n ) && !divides_nat ( a, b ) ) {
+			if (is_negative_nat(n) && !divides_nat(a, b)) {
-		/* Division of negative is undefined */
+				/* Division of negative is undefined */
-		report ( crt_loc, ERR_expr_mul_div_neg ( op, n ) ) ;
+				report(crt_loc, ERR_expr_mul_div_neg(op, n));
-	    }
+			}
+		}
+	} else {
+		eval = 0;
+	}
-    } else {
-	eval = 0 ;
-    }
-    return ( eval ) ;
+	return (eval);
+}
 /*
     CONSTRUCT A MULTIPLICATION OR DIVISION EXPRESSION
     This routine constructs the expressions 'a * b' and 'a / b'.
 */
-EXP make_mult_exp
+EXP
-    PROTO_N ( ( op, a, b ) )
-    PROTO_T ( int op X EXP a X EXP b )
+make_mult_exp(int op, EXP a, EXP b)
 {
-    TYPE ta, tb ;
+	TYPE ta, tb;
-    unsigned ca, cb ;
+	unsigned ca, cb;
-    /* Do reference conversions */
+	/* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    b = convert_reference ( b, REF_NORMAL ) ;
+	b = convert_reference(b, REF_NORMAL);
-    /* Find operand types */
+	/* Find operand types */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    cb = type_category ( &tb ) ;
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    EXP e = binary_overload ( op, a, b ) ;
+			EXP e = binary_overload(op, a, b);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-    }
+	}
 #endif
-    /* Do lvalue conversions */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-	ta = DEREF_type ( exp_type ( a ) ) ;
+		ta = DEREF_type(exp_type(a));
-	ca = type_category ( &ta ) ;
+		ca = type_category(&ta);
-    }
+	}
-    if ( IS_TYPE_ADDRESS ( cb ) ) {
+	if (IS_TYPE_ADDRESS(cb)) {
-	b = convert_lvalue ( b ) ;
+		b = convert_lvalue(b);
-	tb = DEREF_type ( exp_type ( b ) ) ;
+		tb = DEREF_type(exp_type(b));
-	cb = type_category ( &tb ) ;
+		cb = type_category(&tb);
-    }
+	}
-    /* Operands can be arithmetic ... */
+	/* Operands can be arithmetic ... */
-    if ( IS_TYPE_ARITH ( ca ) && IS_TYPE_ARITH ( cb ) ) {
+	if (IS_TYPE_ARITH(ca) && IS_TYPE_ARITH(cb)) {
-	EXP e ;
+		EXP e;
-	unsigned tag ;
+		unsigned tag;
-	TYPE t = arith_type ( ta, tb, a, b ) ;
+		TYPE t = arith_type(ta, tb, a, b);
-	a = convert_arith ( t, a, op, 1 ) ;
+		a = convert_arith(t, a, op, 1);
-	b = convert_arith ( t, b, op, 2 ) ;
+		b = convert_arith(t, b, op, 2);
-	/* Check for constant operands */
+		/* Check for constant operands */
-	if ( op == lex_div ) {
+		if (op == lex_div) {
-	    tag = exp_div_tag ;
+			tag = exp_div_tag;
-	    if ( check_div_exp ( op, a, b ) ) {
+			if (check_div_exp(op, a, b)) {
-		e = make_binary_nat ( tag, a, b ) ;
+				e = make_binary_nat(tag, a, b);
-		return ( e ) ;
+				return (e);
-	    }
+			}
-	} else {
+		} else {
-	    if ( op == lex_star ) {
+			if (op == lex_star) {
-		tag = exp_mult_tag ;
+				tag = exp_mult_tag;
-	    } else if ( op == lex_max ) {
+			} else if (op == lex_max) {
-		tag = exp_max_tag ;
+				tag = exp_max_tag;
-	    } else {
+			} else {
-		tag = exp_min_tag ;
+				tag = exp_min_tag;
-	    }
+			}
-	    if ( IS_exp_int_lit ( a ) && IS_exp_int_lit ( b ) ) {
+			if (IS_exp_int_lit(a) && IS_exp_int_lit(b)) {
-		e = make_binary_nat ( tag, a, b ) ;
+				e = make_binary_nat(tag, a, b);
-		return ( e ) ;
+				return (e);
-	    }
+			}
-	}
+		}
-	/* Construct the result */
-	MAKE_exp_plus_etc ( tag, t, a, b, e ) ;
-	return ( e ) ;
-    }
+		/* Construct the result */
+		MAKE_exp_plus_etc(tag, t, a, b, e);
+		return (e);
+	}
-    /* ... and nothing else */
+	/* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
+	if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
-	report ( crt_loc, ERR_expr_mul_mul_op ( op, ta, tb ) ) ;
+		report(crt_loc, ERR_expr_mul_mul_op(op, ta, tb));
-    }
+	}
-    return ( make_error_exp ( 0 ) ) ;
+	return (make_error_exp(0));
+}
 /*
     CONSTRUCT A REMAINDER EXPRESSION
     This routine constructs the expression 'a % b'.
 */
-EXP make_rem_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_rem_exp(EXP a, EXP b)
+{
-    TYPE ta, tb ;
+	TYPE ta, tb;
-    unsigned ca, cb ;
+	unsigned ca, cb;
-    /* Do reference conversions */
+	/* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    b = convert_reference ( b, REF_NORMAL ) ;
+	b = convert_reference(b, REF_NORMAL);
-    /* Find operand types */
+	/* Find operand types */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    cb = type_category ( &tb ) ;
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    EXP e = binary_overload ( lex_rem, a, b ) ;
+			EXP e = binary_overload(lex_rem, a, b);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-    }
+	}
 #endif
-    /* Do lvalue conversions */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-	ta = DEREF_type ( exp_type ( a ) ) ;
+		ta = DEREF_type(exp_type(a));
-	ca = type_category ( &ta ) ;
+		ca = type_category(&ta);
-    }
+	}
-    if ( IS_TYPE_ADDRESS ( cb ) ) {
+	if (IS_TYPE_ADDRESS(cb)) {
-	b = convert_lvalue ( b ) ;
+		b = convert_lvalue(b);
-	tb = DEREF_type ( exp_type ( b ) ) ;
+		tb = DEREF_type(exp_type(b));
-	cb = type_category ( &tb ) ;
+		cb = type_category(&tb);
-    }
+	}
-    /* Operands can be integral ... */
+	/* Operands can be integral ... */
-    if ( IS_TYPE_INT ( ca ) && IS_TYPE_INT ( cb ) ) {
+	if (IS_TYPE_INT(ca) && IS_TYPE_INT(cb)) {
-	EXP e ;
+		EXP e;
-	TYPE t = arith_type ( ta, tb, a, b ) ;
+		TYPE t = arith_type(ta, tb, a, b);
-	a = convert_arith ( t, a, lex_rem, 1 ) ;
+		a = convert_arith(t, a, lex_rem, 1);
-	b = convert_arith ( t, b, lex_rem, 2 ) ;
+		b = convert_arith(t, b, lex_rem, 2);
+		/* Check for constant operands */
+		if (check_div_exp(lex_rem, a, b)) {
+			e = make_binary_nat(exp_rem_tag, a, b);
+			return (e);
+		}
+		/* Construct the result */
+		MAKE_exp_rem(t, a, b, e);
+		return (e);
+	}
-	/* Check for constant operands */
+	/* ... and nothing else */
-	if ( check_div_exp ( lex_rem, a, b ) ) {
+	if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
-	    e = make_binary_nat ( exp_rem_tag, a, b ) ;
+		report(crt_loc, ERR_expr_mul_rem_op(lex_rem, ta, tb));
-	    return ( e ) ;
+	}
-	/* Construct the result */
-	MAKE_exp_rem ( t, a, b, e ) ;
-	return ( e ) ;
-    }
-    /* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
-	report ( crt_loc, ERR_expr_mul_rem_op ( lex_rem, ta, tb ) ) ;
-    }
-    return ( make_error_exp ( 0 ) ) ;
+	return (make_error_exp(0));
+}
 /*
     CONSTRUCT AN ADDITION EXPRESSION
     This routine constructs the expression 'a + b'.
 	/* Do bounds checks */
-	if ( IS_exp_int_lit ( b ) && IS_type_array ( sa ) ) {
+	if (IS_exp_int_lit(b) && IS_type_array(sa)) {
-	    check_bounds ( op, sa, b ) ;
+		check_bounds(op, sa, b);
 	}
 	/* The pointer must be to a complete object type */
-	t = check_pointer ( ta, &err ) ;
+	t = check_pointer(ta, &err);
-	if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	    err = concat_error ( err, ERR_expr_add_incompl ( op ) ) ;
+		err = concat_error(err, ERR_expr_add_incompl(op));
-	    report ( crt_loc, err ) ;
+		report(crt_loc, err);
+	}
 	/* Construct the result */
 /*
     CHECK FOR DUBIOUS SHIFT EXPRESSIONS
     This routine checks the shift operation 'a << b' or 'a >> b' for
     dubious constant operands.  All the necessary operand and arithmetic
     type conversions have already been performed on a and b, and the type
     of a is passed in as t.  The routine returns 1 if both operands are
     integer constants.
 */
-int check_shift_exp
+int
-    PROTO_N ( ( op, t, a, b ) )
-    PROTO_T ( int op X TYPE t X EXP a X EXP b )
+check_shift_exp(int op, TYPE t, EXP a, EXP b)
 {
-    int ret = 1 ;
+	int ret = 1;
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    /* Check first operand */
+	/* Check first operand */
-    if ( IS_exp_int_lit ( a ) ) {
+	if (IS_exp_int_lit(a)) {
-	NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(a));
-	if ( is_negative_nat ( n ) ) {
+		if (is_negative_nat(n)) {
-	    err = ERR_expr_shift_op1_neg ( op, n ) ;
+			err = ERR_expr_shift_op1_neg(op, n);
-	}
+		}
-    } else {
+	} else {
-	if ( check_int_type ( t, btype_signed ) ) {
+		if (check_int_type(t, btype_signed)) {
-	    err = ERR_expr_shift_op1_sign ( op ) ;
+			err = ERR_expr_shift_op1_sign(op);
+		}
+		ret = 0;
 	}
+	/* Check second operand */
+	if (IS_exp_int_lit(b)) {
+		NAT n = DEREF_nat(exp_int_lit_nat(b));
+		if (is_negative_nat(n)) {
+			err = concat_error(err, ERR_expr_shift_op2_neg(op, n));
+		} else if (check_type_size(t, n) >= 0) {
+			err = concat_error(err,
+					   ERR_expr_shift_op2_big(op, n, t));
+		}
+	} else {
-	ret = 0 ;
+		ret = 0;
-    }
+	}
-    /* Check second operand */
+	/* Report any accumulated errors */
-    if ( IS_exp_int_lit ( b ) ) {
+	if (!IS_NULL_err(err)) {
-	NAT n = DEREF_nat ( exp_int_lit_nat ( b ) ) ;
-	if ( is_negative_nat ( n ) ) {
+		report(crt_loc, err);
-	    err = concat_error ( err, ERR_expr_shift_op2_neg ( op, n ) ) ;
-	} else if ( check_type_size ( t, n ) >= 0 ) {
-	    err = concat_error ( err, ERR_expr_shift_op2_big ( op, n, t ) ) ;
+	}
-    } else {
-	ret = 0 ;
-    }
-    /* Report any accumulated errors */
-    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CONSTRUCT A SHIFT EXPRESSION
     This routine constructs the expressions 'a << b' and 'a >> b'.  Note
     that this has a lower priority than plus and minus.
 */
-EXP make_shift_exp
+EXP
-    PROTO_N ( ( op, a, b ) )
-    PROTO_T ( int op X EXP a X EXP b )
+make_shift_exp(int op, EXP a, EXP b)
+{
-    EXP e ;
+	EXP e;
-    TYPE ta, tb ;
+	TYPE ta, tb;
-    unsigned ca, cb ;
+	unsigned ca, cb;
-    /* Check for non-obvious resolutions */
+	/* Check for non-obvious resolutions */
+	if (option(OPT_paren)) {
-    if ( option ( OPT_paren ) ) check_paren ( PAREN_PLUS, op, a, b ) ;
+		check_paren(PAREN_PLUS, op, a, b);
+	}
-    /* Do reference conversions */
+	/* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    b = convert_reference ( b, REF_NORMAL ) ;
+	b = convert_reference(b, REF_NORMAL);
-    /* Find operand types */
+	/* Find operand types */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    cb = type_category ( &tb ) ;
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = binary_overload ( op, a, b ) ;
+			e = binary_overload(op, a, b);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
 #endif
-    /* Do lvalue conversions */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-	ta = DEREF_type ( exp_type ( a ) ) ;
+		ta = DEREF_type(exp_type(a));
-	ca = type_category ( &ta ) ;
+		ca = type_category(&ta);
-    }
+	}
-    if ( IS_TYPE_ADDRESS ( cb ) ) {
+	if (IS_TYPE_ADDRESS(cb)) {
-	b = convert_lvalue ( b ) ;
+		b = convert_lvalue(b);
-	tb = DEREF_type ( exp_type ( b ) ) ;
+		tb = DEREF_type(exp_type(b));
-	cb = type_category ( &tb ) ;
+		cb = type_category(&tb);
-    }
+	}
-    /* Operands can be integral ... */
+	/* Operands can be integral ... */
-    if ( IS_TYPE_INT ( ca ) && IS_TYPE_INT ( cb ) ) {
+	if (IS_TYPE_INT(ca) && IS_TYPE_INT(cb)) {
-	unsigned tag ;
+		unsigned tag;
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	TYPE pta = promote_type ( ta ) ;
+		TYPE pta = promote_type(ta);
-	TYPE ptb = promote_type ( tb ) ;
+		TYPE ptb = promote_type(tb);
-	a = convert_promote ( pta, a ) ;
+		a = convert_promote(pta, a);
-	b = convert_promote ( ptb, b ) ;
+		b = convert_promote(ptb, b);
-	tag = ( op == lex_lshift ? exp_lshift_tag : exp_rshift_tag ) ;
+		tag = (op == lex_lshift ? exp_lshift_tag : exp_rshift_tag);
-	/* Check for dubious shifts */
+		/* Check for dubious shifts */
-	if ( check_shift_exp ( op, pta, a, b ) ) {
+		if (check_shift_exp(op, pta, a, b)) {
-	    /* Allow for constant evaluation */
+			/* Allow for constant evaluation */
-	    if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
+			if (!IS_NULL_err(err)) {
+				report(crt_loc, err);
+			}
-	    e = make_binary_nat ( tag, a, b ) ;
+			e = make_binary_nat(tag, a, b);
-	    return ( e ) ;
+			return (e);
-	}
+		}
-	/* Construct the result */
+		/* Construct the result */
-	MAKE_exp_plus_etc ( tag, pta, a, b, e ) ;
+		MAKE_exp_plus_etc(tag, pta, a, b, e);
-	return ( e ) ;
+		return (e);
-    }
+	}
-    /* ... and nothing else */
+	/* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
+	if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
-	report ( crt_loc, ERR_expr_shift_op ( op, ta, tb ) ) ;
+		report(crt_loc, ERR_expr_shift_op(op, ta, tb));
-    }
+	}
-    return ( make_error_exp ( 0 ) ) ;
+	return (make_error_exp(0));
+}
 /*
     CONSTRUCT A RELATIONAL OPERATOR
     This routine converts the lexical token op to a relational operator.
 */
-static NTEST make_ntest
+static NTEST
-    PROTO_N ( ( op ) )
-    PROTO_T ( int op )
+make_ntest(int op)
 {
-    switch ( op ) {
+	switch (op) {
+	case lex_eq:
-	case lex_eq : return ( ntest_eq ) ;
+		return (ntest_eq);
+	case lex_not_Heq_H1:
-	case lex_not_Heq_H1 : return ( ntest_not_eq ) ;
+		return (ntest_not_eq);
+	case lex_less:
-	case lex_less : return ( ntest_less ) ;
+		return (ntest_less);
+	case lex_less_Heq:
-	case lex_less_Heq : return ( ntest_less_eq ) ;
+		return (ntest_less_eq);
+	case lex_greater:
-	case lex_greater : return ( ntest_greater ) ;
+		return (ntest_greater);
+	case lex_greater_Heq:
-	case lex_greater_Heq : return ( ntest_greater_eq ) ;
+		return (ntest_greater_eq);
-    }
+	}
-    return ( ntest_none ) ;
+	return (ntest_none);
 }
 /*
     CONSTRUCT A RELATIONAL EXPRESSION
     This routine constructs the expressions 'a < b', 'a > b', 'a <= b' and
     'a >= b'.
 /*
     CONSTRUCT AN EQUALITY EXPRESSION
     This routine constructs the expressions 'a == b' and 'a != b'.
+	}
+#if LANGUAGE_CPP
+	/* ... or both pointers to members ... */
+	if (IS_TYPE_PTR_MEM(ca)) {
+		if (IS_TYPE_PTR_MEM(cb)) {
+			int suspect = 0;
+			TYPE t = ptr_mem_common_type(ta, tb, &suspect);
+			if (suspect == -1) {
+				/* Allow for template types */
+				MAKE_exp_op(type_bool, op, a, b, e);
+				return (e);
+			}
+			if (suspect == 2) {
+				ERROR err = ERR_basic_link_incompat(ta, tb);
+				err = concat_error(err, ERR_conv_mem_common());
+				err = concat_error(err, ERR_expr_eq_mptr(op));
+				report(crt_loc, err);
+			} else {
+				a = convert_ptr_mem_common(t, a, op, 1);
+				b = convert_ptr_mem_common(t, b, op, 2);
+			}
+			if (IS_exp_null(a)) {
+				/* Make null pointer the second argument */
+				EXP c = a;
+				a = b;
+				b = c;
+			}
+			tst = make_ntest(op);
+			MAKE_exp_compare(type_bool, tst, a, b, e);
+			return (e);
+		}
-	if ( IS_TYPE_INT ( cb ) ) {
+		if (IS_TYPE_INT(cb)) {
-	    /* Allow zero integer as a null pointer member */
+			/* Allow zero integer as a null pointer member */
-	    b = make_null_ptr ( b, ta ) ;
+			b = make_null_ptr(b, ta);
-	    if ( IS_NULL_exp ( b ) ) {
+			if (IS_NULL_exp(b)) {
+				report(crt_loc,
-		report ( crt_loc, ERR_expr_eq_nonzero ( op, ta, tb ) ) ;
+				       ERR_expr_eq_nonzero(op, ta, tb));
-		b = make_null_ptr ( NULL_exp, ta ) ;
+				b = make_null_ptr(NULL_exp, ta);
-	    }
+			}
-	    tst = make_ntest ( op ) ;
+			tst = make_ntest(op);
-	    MAKE_exp_compare ( type_bool, tst, a, b, e ) ;
+			MAKE_exp_compare(type_bool, tst, a, b, e);
+			return (e);
+		}
+	} else if (IS_TYPE_PTR_MEM(cb)) {
+		if (IS_TYPE_INT(ca)) {
+			/* Allow zero integer as a null pointer member */
+			a = make_null_ptr(a, tb);
+			if (IS_NULL_exp(a)) {
+				report(crt_loc,
+				       ERR_expr_eq_nonzero(op, tb, ta));
+				a = make_null_ptr(NULL_exp, tb);
+			}
+			tst = make_ntest(op);
+			MAKE_exp_compare(type_bool, tst, b, a, e);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    } else if ( IS_TYPE_PTR_MEM ( cb ) ) {
-	if ( IS_TYPE_INT ( ca ) ) {
-	    /* Allow zero integer as a null pointer member */
-	    a = make_null_ptr ( a, tb ) ;
-	    if ( IS_NULL_exp ( a ) ) {
-		report ( crt_loc, ERR_expr_eq_nonzero ( op, tb, ta ) ) ;
-		a = make_null_ptr ( NULL_exp, tb ) ;
-	    }
-	    tst = make_ntest ( op ) ;
-	    MAKE_exp_compare ( type_bool, tst, b, a, e ) ;
-	    return ( e ) ;
-	}
-    }
 #endif
-    /* ... and nothing else */
+	/* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
+	if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
-	report ( crt_loc, ERR_expr_eq_op ( op, ta, tb ) ) ;
+		report(crt_loc, ERR_expr_eq_op(op, ta, tb));
-    }
+	}
-    tst = make_ntest ( op ) ;
+	tst = make_ntest(op);
-    MAKE_exp_compare ( type_bool, tst, a, b, e ) ;
+	MAKE_exp_compare(type_bool, tst, a, b, e);
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A BIT EXPRESSION
     This routine constructs the expressions 'a & b', 'a ^ b' and 'a | b'.
 */
-static EXP make_bit_exp
+static EXP
-    PROTO_N ( ( op, tag, a, b ) )
-    PROTO_T ( int op X unsigned tag X EXP a X EXP b )
+make_bit_exp(int op, unsigned tag, EXP a, EXP b)
+{
-    EXP e ;
+	EXP e;
-    TYPE ta, tb ;
+	TYPE ta, tb;
-    unsigned ca, cb ;
+	unsigned ca, cb;
-    /* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
-    b = convert_reference ( b, REF_NORMAL ) ;
-    /* Find operand types */
+	/* Do reference conversions */
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	a = convert_reference(a, REF_NORMAL);
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	b = convert_reference(b, REF_NORMAL);
-    ca = type_category ( &ta ) ;
-    cb = type_category ( &tb ) ;
+	/* Find operand types */
+	ta = DEREF_type(exp_type(a));
+	tb = DEREF_type(exp_type(b));
+	ca = type_category(&ta);
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = binary_overload ( op, a, b ) ;
+			e = binary_overload(op, a, b);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
 #endif
-    /* Do lvalue conversions */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) {
+	if (IS_TYPE_ADDRESS(ca)) {
-	a = convert_lvalue ( a ) ;
+		a = convert_lvalue(a);
-	ta = DEREF_type ( exp_type ( a ) ) ;
+		ta = DEREF_type(exp_type(a));
-	ca = type_category ( &ta ) ;
+		ca = type_category(&ta);
-    }
+	}
-    if ( IS_TYPE_ADDRESS ( cb ) ) {
+	if (IS_TYPE_ADDRESS(cb)) {
-	b = convert_lvalue ( b ) ;
+		b = convert_lvalue(b);
-	tb = DEREF_type ( exp_type ( b ) ) ;
+		tb = DEREF_type(exp_type(b));
-	cb = type_category ( &tb ) ;
+		cb = type_category(&tb);
-    }
+	}
-    /* Operands can both be integral ... */
+	/* Operands can both be integral ... */
-    if ( IS_TYPE_INT ( ca ) && IS_TYPE_INT ( cb ) ) {
+	if (IS_TYPE_INT(ca) && IS_TYPE_INT(cb)) {
-	TYPE t = arith_type ( ta, tb, a, b ) ;
+		TYPE t = arith_type(ta, tb, a, b);
-	a = convert_arith ( t, a, op, 1 ) ;
+		a = convert_arith(t, a, op, 1);
-	b = convert_arith ( t, b, op, 2 ) ;
+		b = convert_arith(t, b, op, 2);
-	if ( IS_exp_int_lit ( a ) && IS_exp_int_lit ( b ) ) {
+		if (IS_exp_int_lit(a) && IS_exp_int_lit(b)) {
-	    e = make_binary_nat ( tag, a, b ) ;
+			e = make_binary_nat(tag, a, b);
-	} else {
+		} else {
-	    MAKE_exp_plus_etc ( tag, t, a, b, e ) ;
+			MAKE_exp_plus_etc(tag, t, a, b, e);
-	}
+		}
-	return ( e ) ;
+		return (e);
-    }
-    /* ... and nothing else */
-    if ( !IS_TYPE_ERROR ( ca ) && !IS_TYPE_ERROR ( cb ) ) {
-	switch ( tag ) {
-	    case exp_and_tag : {
-		report ( crt_loc, ERR_expr_bit_and_op ( op, ta, tb ) ) ;
-		break ;
-	    }
-	    case exp_or_tag : {
-		report ( crt_loc, ERR_expr_or_op ( op, ta, tb ) ) ;
-		break ;
-	    }
-	    case exp_xor_tag : {
-		report ( crt_loc, ERR_expr_xor_op ( op, ta, tb ) ) ;
-		break ;
-	    }
+	}
+	/* ... and nothing else */
+	if (!IS_TYPE_ERROR(ca) && !IS_TYPE_ERROR(cb)) {
+		switch (tag) {
+		case exp_and_tag: {
+			report(crt_loc, ERR_expr_bit_and_op(op, ta, tb));
+			break;
-    }
+		}
+		case exp_or_tag: {
+			report(crt_loc, ERR_expr_or_op(op, ta, tb));
+			break;
+		}
+		case exp_xor_tag: {
+			report(crt_loc, ERR_expr_xor_op(op, ta, tb));
+			break;
+		}
+		}
+	}
-    return ( make_error_exp ( 0 ) ) ;
+	return (make_error_exp(0));
 }
 /*
     CONSTRUCT A BITWISE AND EXPRESSION
     This routine constructs the expression 'a & b'.  Note that this
     has lower priority than plus or minus and the equality operators.
 */
-EXP make_and_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_and_exp(EXP a, EXP b)
 {
-    EXP e ;
+	EXP e;
-    int op = lex_and_H1 ;
+	int op = lex_and_H1;
+	if (option(OPT_paren)) {
-    if ( option ( OPT_paren ) ) check_paren ( PAREN_EQUALITY, op, a, b ) ;
+		check_paren(PAREN_EQUALITY, op, a, b);
+	}
-    e = make_bit_exp ( op, exp_and_tag, a, b ) ;
+	e = make_bit_exp(op, exp_and_tag, a, b);
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A BITWISE XOR EXPRESSION
     This routine constructs the expression 'a ^ b'.  Note that this has
     a lower priority than bitwise and, plus and minus.
 */
-EXP make_xor_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_xor_exp(EXP a, EXP b)
 {
-    EXP e ;
+	EXP e;
-    int op = lex_xor_H1 ;
+	int op = lex_xor_H1;
+	if (option(OPT_paren)) {
-    if ( option ( OPT_paren ) ) check_paren ( PAREN_AND, op, a, b ) ;
+		check_paren(PAREN_AND, op, a, b);
+	}
-    e = make_bit_exp ( op, exp_xor_tag, a, b ) ;
+	e = make_bit_exp(op, exp_xor_tag, a, b);
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A BITWISE OR EXPRESSION
     This routine constructs the expression 'a | b'.  Note that this has
     a lower priority than bitwise and, bitwise xor, plus and minus.
 */
-EXP make_or_exp
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
-{
-    EXP e ;
-    int op = lex_or_H1 ;
-    if ( option ( OPT_paren ) ) check_paren ( PAREN_XOR, op, a, b ) ;
-    e = make_bit_exp ( op, exp_or_tag, a, b ) ;
-    return ( e ) ;
-}
-/*
-    CONSTRUCT A LOGICAL EXPRESSION
-    This routine constructs the expressions 'a && b' and 'a || b'.
-*/
+EXP
-static EXP make_logic_exp
-    PROTO_N ( ( op, tag, a, b ) )
+make_or_exp(EXP a, EXP b)
-    PROTO_T ( int op X unsigned tag X EXP a X EXP b )
+{
-    EXP e ;
+	EXP e;
-    TYPE ta, tb ;
+	int op = lex_or_H1;
-    unsigned ca, cb ;
+	if (option(OPT_paren)) {
-    ERROR err = NULL_err ;
+		check_paren(PAREN_XOR, op, a, b);
+	}
-    unsigned taga = TAG_exp ( a ) ;
+	e = make_bit_exp(op, exp_or_tag, a, b);
-    unsigned tagb = TAG_exp ( b ) ;
+	return (e);
+}
-    /* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
-    b = convert_reference ( b, REF_NORMAL ) ;
+/*
-    /* Find operand types */
-    ta = DEREF_type ( exp_type ( a ) ) ;
-    tb = DEREF_type ( exp_type ( b ) ) ;
-    ca = type_category ( &ta ) ;
-    cb = type_category ( &tb ) ;
+    CONSTRUCT A LOGICAL EXPRESSION
+    This routine constructs the expressions 'a && b' and 'a || b'.
+*/
+static EXP
+make_logic_exp(int op, unsigned tag, EXP a, EXP b)
+{
+	EXP e;
+	TYPE ta, tb;
+	unsigned ca, cb;
+	ERROR err = NULL_err;
+	unsigned taga = TAG_exp(a);
+	unsigned tagb = TAG_exp(b);
+	/* Do reference conversions */
+	a = convert_reference(a, REF_NORMAL);
+	b = convert_reference(b, REF_NORMAL);
+	/* Find operand types */
+	ta = DEREF_type(exp_type(a));
+	tb = DEREF_type(exp_type(b));
+	ca = type_category(&ta);
+	cb = type_category(&tb);
-    /* Check for overloading */
+	/* Check for overloading */
 #if LANGUAGE_CPP
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
-	if ( overload_depth == 0 ) {
+		if (overload_depth == 0) {
-	    e = binary_overload ( op, a, b ) ;
+			e = binary_overload(op, a, b);
-	    return ( e ) ;
+			return (e);
+		}
+	}
-    }
 #endif
-    /* Do lvalue conversions */
+	/* Do lvalue conversions */
-    if ( IS_TYPE_ADDRESS ( ca ) ) a = convert_lvalue ( a ) ;
+	if (IS_TYPE_ADDRESS(ca)) {
+		a = convert_lvalue(a);
+	}
-    if ( IS_TYPE_ADDRESS ( cb ) ) b = convert_lvalue ( b ) ;
+	if (IS_TYPE_ADDRESS(cb)) {
+		b = convert_lvalue(b);
+	}
-    /* Convert first operand to a boolean */
+	/* Convert first operand to a boolean */
-    a = convert_boolean ( a, taga, &err ) ;
+	a = convert_boolean(a, taga, &err);
+	if (!IS_NULL_err(err)) {
+		ERROR err2;
+		if (tag == exp_log_and_tag) {
+			err2 = ERR_expr_log_and_op(op);
+		} else {
+			err2 = ERR_expr_log_or_op(op);
+		}
+		err = concat_error(err, err2);
+		report(crt_loc, err);
+		err = NULL_err;
+	}
+	/* Convert second operand to a boolean */
+	b = convert_boolean(b, tagb, &err);
-    if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	ERROR err2 ;
+		ERROR err2;
-	if ( tag == exp_log_and_tag ) {
+		if (tag == exp_log_and_tag) {
-	    err2 = ERR_expr_log_and_op ( op ) ;
+			err2 = ERR_expr_log_and_op(op);
-	} else {
+		} else {
-	    err2 = ERR_expr_log_or_op ( op ) ;
+			err2 = ERR_expr_log_or_op(op);
+		}
+		err = concat_error(err, err2);
+		report(crt_loc, err);
+	}
-	err = concat_error ( err, err2 ) ;
-	report ( crt_loc, err ) ;
-	err = NULL_err ;
-    }
-    /* Convert second operand to a boolean */
+	/* Construct the result */
-    b = convert_boolean ( b, tagb, &err ) ;
-    if ( !IS_NULL_err ( err ) ) {
-	ERROR err2 ;
-	if ( tag == exp_log_and_tag ) {
+	if (IS_exp_int_lit(a) && IS_exp_int_lit(b)) {
-	    err2 = ERR_expr_log_and_op ( op ) ;
+		e = make_binary_nat(tag, a, b);
 	} else {
-	    err2 = ERR_expr_log_or_op ( op ) ;
+		MAKE_exp_plus_etc(tag, type_bool, a, b, e);
 	}
-	err = concat_error ( err, err2 ) ;
-	report ( crt_loc, err ) ;
-    }
-    /* Construct the result */
-    if ( IS_exp_int_lit ( a ) && IS_exp_int_lit ( b ) ) {
-	e = make_binary_nat ( tag, a, b ) ;
-    } else {
-	MAKE_exp_plus_etc ( tag, type_bool, a, b, e ) ;
-    }
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A LOGICAL AND EXPRESSION
     This routine constructs the expression 'a && b'.
 */
-EXP make_log_and_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_log_and_exp(EXP a, EXP b)
+{
-    EXP e ;
+	EXP e;
-    e = make_logic_exp ( lex_logical_Hand_H1, exp_log_and_tag, a, b ) ;
+	e = make_logic_exp(lex_logical_Hand_H1, exp_log_and_tag, a, b);
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A LOGICAL OR EXPRESSION
     This routine constructs the expression 'a || b'.  Note that this
     has a lower priority than logical and.
 */
-EXP make_log_or_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+make_log_or_exp(EXP a, EXP b)
+{
-    EXP e ;
+	EXP e;
-    if ( option ( OPT_paren ) ) check_logic ( a, b ) ;
+	if (option(OPT_paren)) {
+		check_logic(a, b);
+	}
-    e = make_logic_exp ( lex_logical_Hor_H1, exp_log_or_tag, a, b ) ;
+	e = make_logic_exp(lex_logical_Hor_H1, exp_log_or_tag, a, b);
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A TEMPLATE DEPENDENT CONDITIONAL EXPRESSION
     This routine constructs the expression 'a ? b : c' where one of b
     and c depends on a template parameter.
 */
 #if LANGUAGE_CPP
-static EXP make_templ_cond
+static EXP
-    PROTO_N ( ( a, b, c ) )
-    PROTO_T ( EXP a X EXP b X EXP c )
+make_templ_cond(EXP a, EXP b, EXP c)
+{
-    EXP e ;
+	EXP e;
-    TYPE t = type_templ_param ;
+	TYPE t = type_templ_param;
-    LIST ( EXP ) p = NULL_list ( EXP ) ;
+	LIST(EXP)p = NULL_list(EXP);
-    CONS_exp ( c, p, p ) ;
+	CONS_exp(c, p, p);
-    CONS_exp ( b, p, p ) ;
+	CONS_exp(b, p, p);
-    CONS_exp ( a, p, p ) ;
+	CONS_exp(a, p, p);
-    MAKE_exp_opn ( t, lex_cond_Hop, p, e ) ;
+	MAKE_exp_opn(t, lex_cond_Hop, p, e);
-    return ( e ) ;
+	return (e);
+}
 #endif
     This routine is used to turn the throw expression a into an expression
     of type t.  This is required so that a conditional involving a throw
     expression satisfies the shape requirements of a TDF conditional
     construct.
 */
-static EXP make_except_value
+static EXP
-    PROTO_N ( ( t, a ) )
-    PROTO_T ( TYPE t X EXP a )
+make_except_value(TYPE t, EXP a)
 {
-    if ( !IS_type_top_etc ( t ) ) {
+	if (!IS_type_top_etc(t)) {
-	EXP b ;
+		EXP b;
-	MAKE_exp_value ( t, b ) ;
+		MAKE_exp_value(t, b);
-	a = join_exp ( a, b ) ;
+		a = join_exp(a, b);
-    }
+	}
-    return ( a ) ;
+	return (a);
 }
 /*
     CONSTRUCT A CONDITIONAL EXPRESSION
     This routine constructs the expression 'a ? b : c'.  Although '?:'
     cannot be overloaded, user-defined conversions which bring the second
     and third operands to a common type are considered.  This is done
     using a dummy binary operation 'b : c' given by 'NULL_exp ? b : c'.
 /*
     JOIN TWO EXPRESSIONS
     This routine joins the expressions a and b by forming a comma
     expression, 'a, b'.
 */
-EXP join_exp
+EXP
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+join_exp(EXP a, EXP b)
 {
-    EXP e ;
+	EXP e;
-    TYPE t ;
+	TYPE t;
-    LIST ( EXP ) p ;
+	LIST(EXP)p;
-    if ( IS_NULL_exp ( a ) ) return ( b ) ;
+	if (IS_NULL_exp(a)) {
+		return (b);
+	}
-    if ( IS_NULL_exp ( b ) ) return ( a ) ;
+	if (IS_NULL_exp(b)) {
+		return (a);
+	}
-    CONS_exp ( b, NULL_list ( EXP ), p ) ;
+	CONS_exp(b, NULL_list(EXP), p);
-    CONS_exp ( a, p, p ) ;
+	CONS_exp(a, p, p);
-    t = DEREF_type ( exp_type ( b ) ) ;
+	t = DEREF_type(exp_type(b));
-    MAKE_exp_comma ( t, p, e ) ;
+	MAKE_exp_comma(t, p, e);
-    return ( e ) ;
+	return (e);
 }
 /*
     CONSTRUCT A SIMPLE COMMA EXPRESSION
     This routine constructs the simple comma expression 'a, b'.  If started
     is true and a is itself a comma expression then b is added to the end
     of a.  Otherwise a new comma expression is created.  Note that discard
     analysis is applied to a, and unreached code analysis to b.
 */
-static EXP make_comma_simple
+static EXP
-    PROTO_N ( ( a, b, started ) )
-    PROTO_T ( EXP a X EXP b X int started )
+make_comma_simple(EXP a, EXP b, int started)
 {
-    EXP e ;
+	EXP e;
-    int uc ;
+	int uc;
-    TYPE ta, tb ;
+	TYPE ta, tb;
 #if LANGUAGE_CPP
-    unsigned ca, cb ;
+	unsigned ca, cb;
 #endif
-    /* Do reference conversions */
+	/* Do reference conversions */
-    a = convert_reference ( a, REF_NORMAL ) ;
+	a = convert_reference(a, REF_NORMAL);
-    b = convert_reference ( b, REF_NORMAL ) ;
+	b = convert_reference(b, REF_NORMAL);
-    /* Find operand types */
+	/* Find operand types */
 #if LANGUAGE_CPP
-    ta = DEREF_type ( exp_type ( a ) ) ;
+	ta = DEREF_type(exp_type(a));
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    ca = type_category ( &ta ) ;
+	ca = type_category(&ta);
-    cb = type_category ( &tb ) ;
+	cb = type_category(&tb);
-    /* Check for overloading */
-    if ( IS_TYPE_OVERLOAD ( ca ) || IS_TYPE_OVERLOAD ( cb ) ) {
-	if ( overload_depth == 0 ) {
-	    e = binary_overload ( lex_comma, a, b ) ;
-	    if ( !IS_NULL_exp ( e ) ) return ( e ) ;
-	}
-	/* Continue if not overloaded */
-    }
-#endif
-    /* Do discard analysis on first operand */
-    uc = unreached_code ;
-    a = make_exp_stmt ( a ) ;
-    ta = DEREF_type ( exp_type ( a ) ) ;
-    if ( IS_type_bottom ( ta ) ) {
-	if ( !unreached_last ) {
-	    /* Report unreached code */
-            report ( crt_loc, ERR_stmt_stmt_unreach () ) ;
-            unreached_last = 1 ;
-        }
-    }
-    unreached_code = uc ;
+	/* Check for overloading */
+	if (IS_TYPE_OVERLOAD(ca) || IS_TYPE_OVERLOAD(cb)) {
+		if (overload_depth == 0) {
+			e = binary_overload(lex_comma, a, b);
+			if (!IS_NULL_exp(e)) {
+				return (e);
+			}
+		}
+		/* Continue if not overloaded */
+	}
+#endif
+	/* Do discard analysis on first operand */
+	uc = unreached_code;
+	a = make_exp_stmt(a);
+	ta = DEREF_type(exp_type(a));
+	if (IS_type_bottom(ta)) {
+		if (!unreached_last) {
+			/* Report unreached code */
+			report(crt_loc, ERR_stmt_stmt_unreach());
+			unreached_last = 1;
+		}
+	}
+	unreached_code = uc;
-    /* Check second operand */
+	/* Check second operand */
 #if LANGUAGE_C
-    b = convert_lvalue ( b ) ;
+	b = convert_lvalue(b);
 #endif
-    b = convert_none ( b ) ;
+	b = convert_none(b);
-    tb = DEREF_type ( exp_type ( b ) ) ;
+	tb = DEREF_type(exp_type(b));
-    /* Construct the result */
+	/* Construct the result */
-    if ( started && IS_exp_comma ( a ) ) {
+	if (started && IS_exp_comma(a)) {
-	LIST ( EXP ) q ;
+		LIST(EXP)q;
-	LIST ( EXP ) p = DEREF_list ( exp_comma_args ( a ) ) ;
+		LIST(EXP)p = DEREF_list(exp_comma_args(a));
-	CONS_exp ( b, NULL_list ( EXP ), q ) ;
+		CONS_exp(b, NULL_list(EXP), q);
-	p = APPEND_list ( p, q ) ;
+		p = APPEND_list(p, q);
-	COPY_list ( exp_comma_args ( a ), p ) ;
+		COPY_list(exp_comma_args(a), p);
-	COPY_type ( exp_type ( a ), tb ) ;
+		COPY_type(exp_type(a), tb);
-	e = a ;
+		e = a;
-    } else {
+	} else {
-	LIST ( EXP ) p ;
+		LIST(EXP)p;
-	CONS_exp ( b, NULL_list ( EXP ), p ) ;
+		CONS_exp(b, NULL_list(EXP), p);
-	CONS_exp ( a, p, p ) ;
+		CONS_exp(a, p, p);
-	MAKE_exp_comma ( tb, p, e ) ;
+		MAKE_exp_comma(tb, p, e);
-    }
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     CONSTRUCT A COMMA EXPRESSION
     This routine constructs the n-ary comma expression 'p1, p2, ..., pn' for
     the expression list p = ( p1, p2, ..., pn ).  Note that this groups from
     left to right as '( ( ... ( p1, p2 ), ... ), pn )'.
 */
-EXP make_comma_exp
+EXP
-    PROTO_N ( ( p ) )
-    PROTO_T ( LIST ( EXP ) p )
+make_comma_exp(LIST(EXP)p)
+{
-    EXP e ;
+	EXP e;
-    if ( IS_NULL_list ( p ) ) {
+	if (IS_NULL_list(p)) {
-	/* This shouldn't happen */
+		/* This shouldn't happen */
-	e = make_error_exp ( LANGUAGE_CPP ) ;
+		e = make_error_exp(LANGUAGE_CPP);
-    } else {
+	} else {
-	int started = 0 ;
+		int started = 0;
-	DESTROY_CONS_exp ( destroy, e, p, p ) ;
+		DESTROY_CONS_exp(destroy, e, p, p);
-	while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-	    EXP a ;
+			EXP a;
-	    DESTROY_CONS_exp ( destroy, a, p, p ) ;
+			DESTROY_CONS_exp(destroy, a, p, p);
-	    e = make_comma_simple ( e, a, started ) ;
+			e = make_comma_simple(e, a, started);
-	    started = 1 ;
+			started = 1;
-	}
+		}
-	if ( !started ) {
+		if (!started) {
-	    /* This shouldn't happen */
+			/* This shouldn't happen */
-	    e = convert_reference ( e, REF_NORMAL ) ;
+			e = convert_reference(e, REF_NORMAL);
+		}
+	}
-    }
-    return ( e ) ;
+	return (e);
+}

Subversion Repositories tendra.SVN

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