WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/check.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 "literal.h"
 #include "merge.h"
 #include "namespace.h"
 #include "syntax.h"
 #include "tokdef.h"
 /*
     ARE TWO OFFSETS EQUAL?
     This routine checks whether the offsets a and b are equal.  The co
     argument is passed through to eq_exp.
 */
-int eq_offset
+int
-    PROTO_N ( ( a, b, co ) )
-    PROTO_T ( OFFSET a X OFFSET b X int co )
+eq_offset(OFFSET a, OFFSET b, int co)
 {
-    unsigned taga, tagb ;
+	unsigned taga, tagb;
-    /* Check for obvious equality */
+	/* Check for obvious equality */
-    if ( EQ_off ( a, b ) ) return ( 1 ) ;
+	if (EQ_off(a, b)) {
+		return (1);
+	}
-    if ( IS_NULL_off ( a ) ) return ( 0 ) ;
+	if (IS_NULL_off(a)) {
+		return (0);
+	}
-    if ( IS_NULL_off ( b ) ) return ( 0 ) ;
+	if (IS_NULL_off(b)) {
+		return (0);
+	}
-    /* Check tags */
+	/* Check tags */
-    taga = TAG_off ( a ) ;
+	taga = TAG_off(a);
-    tagb = TAG_off ( b ) ;
+	tagb = TAG_off(b);
-    if ( taga != tagb ) return ( 0 ) ;
+	if (taga != tagb) {
+		return (0);
+	}
-    /* Check individual cases */
+	/* Check individual cases */
-    ASSERT ( ORDER_off == 13 ) ;
+	ASSERT(ORDER_off == 13);
-    switch ( TAG_off ( a ) ) {
+	switch (TAG_off(a)) {
-	case off_zero_tag : {
+	case off_zero_tag: {
-	    /* Zero offsets */
+		/* Zero offsets */
-	    TYPE ta = DEREF_type ( off_zero_type ( a ) ) ;
+		TYPE ta = DEREF_type(off_zero_type(a));
-	    TYPE tb = DEREF_type ( off_zero_type ( b ) ) ;
+		TYPE tb = DEREF_type(off_zero_type(b));
-	    return ( eq_type_offset ( ta, tb ) ) ;
+		return (eq_type_offset(ta, tb));
 	}
-	case off_type_tag : {
+	case off_type_tag: {
-	    /* Type offsets */
+		/* Type offsets */
-	    TYPE ta = DEREF_type ( off_type_type ( a ) ) ;
+		TYPE ta = DEREF_type(off_type_type(a));
-	    TYPE tb = DEREF_type ( off_type_type ( b ) ) ;
+		TYPE tb = DEREF_type(off_type_type(b));
-	    return ( eq_type_offset ( ta, tb ) ) ;
+		return (eq_type_offset(ta, tb));
 	}
-	case off_extra_tag : {
+	case off_extra_tag: {
-	    /* Extra allocator offsets */
+		/* Extra allocator offsets */
-	    TYPE ta = DEREF_type ( off_extra_type ( a ) ) ;
+		TYPE ta = DEREF_type(off_extra_type(a));
-	    TYPE tb = DEREF_type ( off_extra_type ( b ) ) ;
+		TYPE tb = DEREF_type(off_extra_type(b));
-	    int na = DEREF_int ( off_extra_scale ( a ) ) ;
+		int na = DEREF_int(off_extra_scale(a));
-	    int nb = DEREF_int ( off_extra_scale ( b ) ) ;
+		int nb = DEREF_int(off_extra_scale(b));
-	    return ( na == nb && eq_type_offset ( ta, tb ) ) ;
+		return (na == nb && eq_type_offset(ta, tb));
 	}
-	case off_array_tag : {
+	case off_array_tag: {
-	    /* Array offsets */
+		/* Array offsets */
-	    TYPE ta = DEREF_type ( off_array_type ( a ) ) ;
+		TYPE ta = DEREF_type(off_array_type(a));
-	    TYPE tb = DEREF_type ( off_array_type ( b ) ) ;
+		TYPE tb = DEREF_type(off_array_type(b));
-	    unsigned na = DEREF_unsigned ( off_array_arg ( a ) ) ;
+		unsigned na = DEREF_unsigned(off_array_arg(a));
-	    unsigned nb = DEREF_unsigned ( off_array_arg ( b ) ) ;
+		unsigned nb = DEREF_unsigned(off_array_arg(b));
-	    return ( na == nb && eq_type_offset ( ta, tb ) ) ;
+		return (na == nb && eq_type_offset(ta, tb));
 	}
-	case off_base_tag : {
+	case off_base_tag: {
-	    /* Base class offsets */
+		/* Base class offsets */
-	    GRAPH ga = DEREF_graph ( off_base_graph ( a ) ) ;
+		GRAPH ga = DEREF_graph(off_base_graph(a));
-	    GRAPH gb = DEREF_graph ( off_base_graph ( b ) ) ;
+		GRAPH gb = DEREF_graph(off_base_graph(b));
-	    return ( eq_graph ( ga, gb ) ) ;
+		return (eq_graph(ga, gb));
 	}
-	case off_deriv_tag : {
+	case off_deriv_tag: {
-	    /* Derived class offsets */
+		/* Derived class offsets */
-	    GRAPH ga = DEREF_graph ( off_deriv_graph ( a ) ) ;
+		GRAPH ga = DEREF_graph(off_deriv_graph(a));
-	    GRAPH gb = DEREF_graph ( off_deriv_graph ( b ) ) ;
+		GRAPH gb = DEREF_graph(off_deriv_graph(b));
-	    return ( eq_graph ( ga, gb ) ) ;
+		return (eq_graph(ga, gb));
+	}
+	case off_member_tag: {
+		/* Member offsets */
+		IDENTIFIER ia = DEREF_id(off_member_id(a));
+		IDENTIFIER ib = DEREF_id(off_member_id(b));
+		return (EQ_id(ia, ib));
+	}
+	case off_ptr_mem_tag: {
+		/* Pointer member offsets */
+		EXP xa = DEREF_exp(off_ptr_mem_arg(a));
+		EXP xb = DEREF_exp(off_ptr_mem_arg(b));
+		return (eq_exp(xa, xb, co));
+	}
-	case off_member_tag : {
+	case off_negate_tag: {
-	    /* Member offsets */
+		/* Offset negation */
-	    IDENTIFIER ia = DEREF_id ( off_member_id ( a ) ) ;
+		OFFSET sa = DEREF_off(off_negate_arg(a));
-	    IDENTIFIER ib = DEREF_id ( off_member_id ( b ) ) ;
+		OFFSET sb = DEREF_off(off_negate_arg(b));
-	    return ( EQ_id ( ia, ib ) ) ;
+		return (eq_offset(sa, sb, co));
+	}
+	case off_plus_tag: {
+		/* Offset addition */
+		OFFSET sa = DEREF_off(off_plus_arg1(a));
+		OFFSET sb = DEREF_off(off_plus_arg1(b));
+		OFFSET ta = DEREF_off(off_plus_arg2(a));
+		OFFSET tb = DEREF_off(off_plus_arg2(b));
+		if (eq_offset(sa, sb, co) && eq_offset(ta, tb, co)) {
+			return (1);
+		}
+		if (co && eq_offset(sa, tb, 1) && eq_offset(ta, sb, 1)) {
+			return (1);
+		}
+		return (0);
+	}
-	case off_ptr_mem_tag : {
+	case off_mult_tag: {
-	    /* Pointer member offsets */
+		/* Offset multiplication */
+		OFFSET sa = DEREF_off(off_mult_arg1(a));
+		OFFSET sb = DEREF_off(off_mult_arg1(b));
-	    EXP xa = DEREF_exp ( off_ptr_mem_arg ( a ) ) ;
+		EXP za = DEREF_exp(off_mult_arg2(a));
-	    EXP xb = DEREF_exp ( off_ptr_mem_arg ( b ) ) ;
+		EXP zb = DEREF_exp(off_mult_arg2(b));
-	    return ( eq_exp ( xa, xb, co ) ) ;
+		return (eq_offset(sa, sb, co) && eq_exp(za, zb, co));
+	}
-	case off_negate_tag : {
+	case off_ptr_diff_tag: {
-	    /* Offset negation */
+		/* Pointer difference */
+		EXP xa = DEREF_exp(off_ptr_diff_ptr1(a));
+		EXP xb = DEREF_exp(off_ptr_diff_ptr1(b));
-	    OFFSET sa = DEREF_off ( off_negate_arg ( a ) ) ;
+		EXP za = DEREF_exp(off_ptr_diff_ptr2(a));
-	    OFFSET sb = DEREF_off ( off_negate_arg ( b ) ) ;
+		EXP zb = DEREF_exp(off_ptr_diff_ptr2(b));
-	    return ( eq_offset ( sa, sb, co ) ) ;
+		return (eq_exp(xa, xb, co) && eq_exp(za, zb, co));
+	}
-	case off_plus_tag : {
+	case off_token_tag: {
-	    /* Offset addition */
+		/* Token application */
-	    OFFSET sa = DEREF_off ( off_plus_arg1 ( a ) ) ;
+		IDENTIFIER ia = DEREF_id(off_token_tok(a));
-	    OFFSET sb = DEREF_off ( off_plus_arg1 ( b ) ) ;
+		IDENTIFIER ib = DEREF_id(off_token_tok(b));
-	    OFFSET ta = DEREF_off ( off_plus_arg2 ( a ) ) ;
+		LIST(TOKEN)pa = DEREF_list(off_token_args(a));
-	    OFFSET tb = DEREF_off ( off_plus_arg2 ( b ) ) ;
+		LIST(TOKEN)pb = DEREF_list(off_token_args(b));
-	    if ( eq_offset ( sa, sb, co ) && eq_offset ( ta, tb, co ) ) {
+		return (eq_token_args(ia, ib, pa, pb));
-		return ( 1 ) ;
-	    }
-	    if ( co && eq_offset ( sa, tb, 1 ) && eq_offset ( ta, sb, 1 ) ) {
-		return ( 1 ) ;
-	    }
-	    return ( 0 ) ;
+	}
-	case off_mult_tag : {
-	    /* Offset multiplication */
-	    OFFSET sa = DEREF_off ( off_mult_arg1 ( a ) ) ;
-	    OFFSET sb = DEREF_off ( off_mult_arg1 ( b ) ) ;
-	    EXP za = DEREF_exp ( off_mult_arg2 ( a ) ) ;
-	    EXP zb = DEREF_exp ( off_mult_arg2 ( b ) ) ;
-	    return ( eq_offset ( sa, sb, co ) && eq_exp ( za, zb, co ) ) ;
+	}
-	case off_ptr_diff_tag : {
-	    /* Pointer difference */
-	    EXP xa = DEREF_exp ( off_ptr_diff_ptr1 ( a ) ) ;
-	    EXP xb = DEREF_exp ( off_ptr_diff_ptr1 ( b ) ) ;
-	    EXP za = DEREF_exp ( off_ptr_diff_ptr2 ( a ) ) ;
-	    EXP zb = DEREF_exp ( off_ptr_diff_ptr2 ( b ) ) ;
-	    return ( eq_exp ( xa, xb, co ) && eq_exp ( za, zb, co ) ) ;
-	}
-	case off_token_tag : {
-	    /* Token application */
-	    IDENTIFIER ia = DEREF_id ( off_token_tok ( a ) ) ;
-	    IDENTIFIER ib = DEREF_id ( off_token_tok ( b ) ) ;
-	    LIST ( TOKEN ) pa = DEREF_list ( off_token_args ( a ) ) ;
-	    LIST ( TOKEN ) pb = DEREF_list ( off_token_args ( b ) ) ;
-	    return ( eq_token_args ( ia, ib, pa, pb ) ) ;
-	}
-    }
-    return ( 0 ) ;
+	return (0);
 }
 /*
     ARE TWO LISTS OF EXPRESSIONS EQUAL?
     This routine checks whether the expression lists p and q are equal,
     in the sense that each of their components is equal.  The co argument
     is passed through to eq_exp.
 */
-static int eq_exp_list
+static int
-    PROTO_N ( ( p, q, co ) )
-    PROTO_T ( LIST ( EXP ) p X LIST ( EXP ) q X int co )
+eq_exp_list(LIST(EXP)p, LIST(EXP)q, int co)
+{
-    unsigned np = LENGTH_list ( p ) ;
+	unsigned np = LENGTH_list(p);
-    unsigned nq = LENGTH_list ( q ) ;
+	unsigned nq = LENGTH_list(q);
-    if ( np != nq ) return ( 0 ) ;
+	if (np != nq) {
+		return (0);
+	}
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP a = DEREF_exp(HEAD_list(p));
-	EXP b = DEREF_exp ( HEAD_list ( q ) ) ;
+		EXP b = DEREF_exp(HEAD_list(q));
-	if ( !eq_exp ( a, b, co ) ) return ( 0 ) ;
+		if (!eq_exp(a, b, co)) {
+			return (0);
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-	q = TAIL_list ( q ) ;
+		q = TAIL_list(q);
-    }
+	}
-    return ( 1 ) ;
+	return (1);
+}
 /*
     CHECK EXPRESSION EQUALITY
     This is an auxiliary routine for eq_exp which checks whether the
     expressions a and b, which have the same tag value, are equal.
+	}
-	case exp_minus_tag :
-	case exp_div_tag :
+	case exp_op_tag: {
-	case exp_rem_tag :
+		/* Undetermined expressions */
-	case exp_lshift_tag :
+		int ca = DEREF_int(exp_op_lex(a));
-	case exp_rshift_tag : {
-	    /* Non-commutative binary expressions */
+		int cb = DEREF_int(exp_op_lex(b));
-	    EXP ra = DEREF_exp ( exp_plus_etc_arg1 ( a ) ) ;
+		EXP ra = DEREF_exp(exp_op_arg1(a));
-	    EXP rb = DEREF_exp ( exp_plus_etc_arg1 ( b ) ) ;
+		EXP rb = DEREF_exp(exp_op_arg1(b));
-	    EXP sa = DEREF_exp ( exp_plus_etc_arg2 ( a ) ) ;
+		EXP sa = DEREF_exp(exp_op_arg2(a));
-	    EXP sb = DEREF_exp ( exp_plus_etc_arg2 ( b ) ) ;
+		EXP sb = DEREF_exp(exp_op_arg2(b));
+		if (ca != cb) {
+			return (0);
+		}
-	    return ( eq_exp ( ra, rb, co ) && eq_exp ( sa, sb, co ) ) ;
+		return (eq_exp(ra, rb, co) && eq_exp(sa, sb, co));
+	}
-	case exp_test_tag : {
+	case exp_opn_tag: {
-	    /* Test expressions */
+		/* Undetermined expressions */
-	    NTEST ca = DEREF_ntest ( exp_test_tst ( a ) ) ;
+		int ca = DEREF_int(exp_opn_lex(a));
-	    NTEST cb = DEREF_ntest ( exp_test_tst ( b ) ) ;
+		int cb = DEREF_int(exp_opn_lex(b));
-	    EXP sa = DEREF_exp ( exp_test_arg ( a ) ) ;
+		LIST(EXP)pa = DEREF_list(exp_opn_args(a));
-	    EXP sb = DEREF_exp ( exp_test_arg ( b ) ) ;
+		LIST(EXP)pb = DEREF_list(exp_opn_args(b));
-	    if ( ca != cb ) return ( 0 ) ;
+		if (ca != cb) {
+			return (0);
+		}
-	    return ( eq_exp ( sa, sb, co ) ) ;
+		return (eq_exp_list(pa, pb, co));
+	}
-	case exp_compare_tag : {
+	case exp_assembler_tag: {
-	    /* Comparison expressions */
+		/* Assembler expressions */
-	    NTEST ca = DEREF_ntest ( exp_compare_tst ( a ) ) ;
+		STRING ca = DEREF_str(exp_assembler_op(a));
-	    NTEST cb = DEREF_ntest ( exp_compare_tst ( b ) ) ;
+		STRING cb = DEREF_str(exp_assembler_op(b));
-	    EXP ra = DEREF_exp ( exp_compare_arg1 ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_compare_arg1 ( b ) ) ;
+		if (EQ_str(ca, cb) || eq_string_lit(ca, cb)) {
-	    EXP sa = DEREF_exp ( exp_compare_arg2 ( a ) ) ;
+			LIST(EXP)pa = DEREF_list(exp_assembler_args(a));
-	    EXP sb = DEREF_exp ( exp_compare_arg2 ( b ) ) ;
+			LIST(EXP)pb = DEREF_list(exp_assembler_args(b));
-	    if ( ca != cb ) return ( 0 ) ;
-	    if ( eq_exp ( ra, rb, co ) && eq_exp ( sa, sb, co ) ) {
-		return ( 1 ) ;
+			return (eq_exp_list(pa, pb, co));
-	    }
-	    if ( co && ( ca == ntest_eq || ca == ntest_not_eq ) ) {
-		/* Commutative comparisons */
-		if ( eq_exp ( ra, sb, 1 ) && eq_exp ( sa, rb, 1 ) ) {
-		    return ( 1 ) ;
+		}
-	    }
-	    return ( 0 ) ;
-	}
-	case exp_cast_tag : {
-	    /* Cast expressions */
-	    EXP sa = DEREF_exp ( exp_cast_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_cast_arg ( b ) ) ;
-	    unsigned va = DEREF_unsigned ( exp_cast_conv ( a ) ) ;
-	    unsigned vb = DEREF_unsigned ( exp_cast_conv ( b ) ) ;
-	    return ( va == vb && eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_base_cast_tag : {
-	    /* Base cast expressions */
-	    EXP ra = DEREF_exp ( exp_base_cast_arg ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_base_cast_arg ( b ) ) ;
-	    OFFSET za = DEREF_off ( exp_base_cast_off ( a ) ) ;
-	    OFFSET zb = DEREF_off ( exp_base_cast_off ( b ) ) ;
-	    unsigned va = DEREF_unsigned ( exp_base_cast_conv ( a ) ) ;
-	    unsigned vb = DEREF_unsigned ( exp_base_cast_conv ( b ) ) ;
-	    if ( va != vb ) return ( 0 ) ;
-	    return ( eq_exp ( ra, rb, co ) && eq_offset ( za, zb, co ) ) ;
-	}
-	case exp_dyn_cast_tag : {
-	    /* Dynamic cast expressions */
-	    EXP sa = DEREF_exp ( exp_dyn_cast_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_dyn_cast_arg ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_dyn_cast_except ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_dyn_cast_except ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) && eq_exp ( ra, rb, co ) ) ;
-	}
-	case exp_add_ptr_tag : {
-	    /* Pointer addition expressions */
-	    EXP ra = DEREF_exp ( exp_add_ptr_ptr ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_add_ptr_ptr ( b ) ) ;
-	    OFFSET za = DEREF_off ( exp_add_ptr_off ( a ) ) ;
-	    OFFSET zb = DEREF_off ( exp_add_ptr_off ( b ) ) ;
-	    return ( eq_exp ( ra, rb, co ) && eq_offset ( za, zb, co ) ) ;
-	}
-	case exp_offset_size_tag : {
-	    /* Offset size expressions */
-	    OFFSET xa = DEREF_off ( exp_offset_size_off ( a ) ) ;
-	    OFFSET xb = DEREF_off ( exp_offset_size_off ( b ) ) ;
-	    TYPE sa = DEREF_type ( exp_offset_size_step ( a ) ) ;
-	    TYPE sb = DEREF_type ( exp_offset_size_step ( b ) ) ;
-	    return ( eq_offset ( xa, xb, co ) && eq_type_offset ( sa, sb ) ) ;
-	}
-	case exp_constr_tag : {
-	    /* Constructors */
-	    EXP sa = DEREF_exp ( exp_constr_call ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_constr_call ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_destr_tag : {
-	    /* Destructors */
-	    EXP sa = DEREF_exp ( exp_destr_call ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_destr_call ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_alloc_tag : {
-	    /* Allocators */
-	    EXP sa = DEREF_exp ( exp_alloc_call ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_alloc_call ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_alloc_init ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_alloc_init ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) && eq_exp ( ra, rb, co ) ) ;
-	}
-	case exp_dealloc_tag : {
-	    /* Deallocators */
-	    EXP sa = DEREF_exp ( exp_dealloc_call ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_dealloc_call ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_dealloc_term ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_dealloc_term ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) && eq_exp ( ra, rb, co ) ) ;
-	}
-	case exp_rtti_tag : {
-	    /* Run-time type information */
-	    EXP sa = DEREF_exp ( exp_rtti_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_rtti_arg ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_rtti_except ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_rtti_except ( b ) ) ;
-	    int ia = DEREF_int ( exp_rtti_op ( a ) ) ;
-	    int ib = DEREF_int ( exp_rtti_op ( b ) ) ;
-	    if ( ia != ib ) return ( 0 ) ;
-	    return ( eq_exp ( sa, sb, co ) && eq_exp ( ra, rb, co ) ) ;
-	}
-	case exp_rtti_type_tag : {
-	    /* Run-time type information */
-	    TYPE sa = DEREF_type ( exp_rtti_type_arg ( a ) ) ;
-	    TYPE sb = DEREF_type ( exp_rtti_type_arg ( b ) ) ;
-	    int ia = DEREF_int ( exp_rtti_type_op ( a ) ) ;
-	    int ib = DEREF_int ( exp_rtti_type_op ( b ) ) ;
-	    if ( ia != ib ) return ( 0 ) ;
-	    if ( eq_type ( sa, sb ) == 1 ) return ( 1 ) ;
-	    return ( 0 ) ;
-	}
-	case exp_rtti_no_tag : {
-	    /* Link-time type information */
-	    TYPE sa = DEREF_type ( exp_rtti_no_arg ( a ) ) ;
-	    TYPE sb = DEREF_type ( exp_rtti_no_arg ( b ) ) ;
-	    if ( eq_type ( sa, sb ) == 1 ) return ( 1 ) ;
-	    return ( 0 ) ;
-	}
-	case exp_dynamic_tag : {
-	    /* Dynamic initialisers */
-	    EXP sa = DEREF_exp ( exp_dynamic_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_dynamic_arg ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_aggregate_tag : {
-	    /* Aggregate initialisers */
-	    LIST ( EXP ) pa = DEREF_list ( exp_aggregate_args ( a ) ) ;
-	    LIST ( EXP ) pb = DEREF_list ( exp_aggregate_args ( b ) ) ;
-	    return ( eq_exp_list ( pa, pb, co ) ) ;
-	}
-	case exp_initialiser_tag : {
-	    /* Function style initialisers */
-	    LIST ( EXP ) pa = DEREF_list ( exp_initialiser_args ( a ) ) ;
-	    LIST ( EXP ) pb = DEREF_list ( exp_initialiser_args ( b ) ) ;
-	    return ( eq_exp_list ( pa, pb, co ) ) ;
-	}
-	case exp_nof_tag : {
-	    /* Array initialisers */
-	    EXP ra = DEREF_exp ( exp_nof_start ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_nof_start ( b ) ) ;
-	    EXP sa = DEREF_exp ( exp_nof_pad ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_nof_pad ( b ) ) ;
-	    NAT na = DEREF_nat ( exp_nof_size ( a ) ) ;
-	    NAT nb = DEREF_nat ( exp_nof_size ( b ) ) ;
-	    EXP ua = DEREF_exp ( exp_nof_end ( a ) ) ;
-	    EXP ub = DEREF_exp ( exp_nof_end ( b ) ) ;
-	    if ( !EQ_nat ( na, nb ) ) {
-		if ( !eq_nat ( na, nb ) ) return ( 0 ) ;
-	    }
+		break;
-	    if ( !eq_exp ( sa, sb, co ) ) return ( 0 ) ;
-	    return ( eq_exp ( ra, rb, co ) && eq_exp ( ua, ub, co ) ) ;
-	}
-	case exp_comma_tag : {
-	    /* Comma expressions */
-	    LIST ( EXP ) pa = DEREF_list ( exp_comma_args ( a ) ) ;
-	    LIST ( EXP ) pb = DEREF_list ( exp_comma_args ( b ) ) ;
-	    return ( eq_exp_list ( pa, pb, co ) ) ;
-	}
-	case exp_set_tag :
-	case exp_unused_tag : {
-	    /* Flow analysis expressions */
-	    EXP sa = DEREF_exp ( exp_set_etc_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_set_etc_arg ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_if_stmt_tag : {
-	    /* Conditional expressions */
-	    EXP ca = DEREF_exp ( exp_if_stmt_cond ( a ) ) ;
-	    EXP cb = DEREF_exp ( exp_if_stmt_cond ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_if_stmt_true_code ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_if_stmt_true_code ( b ) ) ;
-	    EXP sa = DEREF_exp ( exp_if_stmt_false_code ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_if_stmt_false_code ( b ) ) ;
-	    if ( !eq_exp ( ca, cb, co ) ) return ( 0 ) ;
-	    return ( eq_exp ( ra, rb, co ) && eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_exception_tag : {
-	    /* Throw expressions */
-	    EXP sa = DEREF_exp ( exp_exception_arg ( a ) ) ;
-	    EXP sb = DEREF_exp ( exp_exception_arg ( b ) ) ;
-	    return ( eq_exp ( sa, sb, co ) ) ;
+	}
-	case exp_thrown_tag : {
+	case exp_location_tag: {
-	    /* Thrown expressions */
+		/* Location expressions */
-	    TYPE ta = DEREF_type ( exp_type ( a ) ) ;
-	    TYPE tb = DEREF_type ( exp_type ( b ) ) ;
-	    if ( eq_type ( ta, tb ) == 1 ) return ( 1 ) ;
-	    return ( 0 ) ;
-	}
-	case exp_op_tag : {
-	    /* Undetermined expressions */
-	    int ca = DEREF_int ( exp_op_lex ( a ) ) ;
-	    int cb = DEREF_int ( exp_op_lex ( b ) ) ;
-	    EXP ra = DEREF_exp ( exp_op_arg1 ( a ) ) ;
-	    EXP rb = DEREF_exp ( exp_op_arg1 ( b ) ) ;
-	    EXP sa = DEREF_exp ( exp_op_arg2 ( a ) ) ;
+		EXP sa = DEREF_exp(exp_location_arg(a));
-	    EXP sb = DEREF_exp ( exp_op_arg2 ( b ) ) ;
+		EXP sb = DEREF_exp(exp_location_arg(b));
-	    if ( ca != cb ) return ( 0 ) ;
-	    return ( eq_exp ( ra, rb, co ) && eq_exp ( sa, sb, co ) ) ;
-	}
-	case exp_opn_tag : {
-	    /* Undetermined expressions */
-	    int ca = DEREF_int ( exp_opn_lex ( a ) ) ;
-	    int cb = DEREF_int ( exp_opn_lex ( b ) ) ;
-	    LIST ( EXP ) pa = DEREF_list ( exp_opn_args ( a ) ) ;
-	    LIST ( EXP ) pb = DEREF_list ( exp_opn_args ( b ) ) ;
-	    if ( ca != cb ) return ( 0 ) ;
-	    return ( eq_exp_list ( pa, pb, co ) ) ;
-	}
-	case exp_assembler_tag : {
-	    /* Assembler expressions */
-	    STRING ca = DEREF_str ( exp_assembler_op ( a ) ) ;
-	    STRING cb = DEREF_str ( exp_assembler_op ( b ) ) ;
-	    if ( EQ_str ( ca, cb ) || eq_string_lit ( ca, cb ) ) {
-		LIST ( EXP ) pa = DEREF_list ( exp_assembler_args ( a ) ) ;
-		LIST ( EXP ) pb = DEREF_list ( exp_assembler_args ( b ) ) ;
-		return ( eq_exp_list ( pa, pb, co ) ) ;
+		return (eq_exp(sa, sb, co));
-	    }
-	    break ;
+	}
-	case exp_location_tag : {
+	case exp_token_tag: {
-	    /* Location expressions */
+		/* Token application */
+		IDENTIFIER ia = DEREF_id(exp_token_tok(a));
+		IDENTIFIER ib = DEREF_id(exp_token_tok(b));
-	    EXP sa = DEREF_exp ( exp_location_arg ( a ) ) ;
+		LIST(TOKEN)pa = DEREF_list(exp_token_args(a));
-	    EXP sb = DEREF_exp ( exp_location_arg ( b ) ) ;
+		LIST(TOKEN)pb = DEREF_list(exp_token_args(b));
-	    return ( eq_exp ( sa, sb, co ) ) ;
+		return (eq_token_args(ia, ib, pa, pb));
+	}
-	case exp_token_tag : {
+	case exp_dummy_tag: {
-	    /* Token application */
+		/* Dummy expressions */
-	    IDENTIFIER ia = DEREF_id ( exp_token_tok ( a ) ) ;
+		EXP sa = DEREF_exp(exp_dummy_value(a));
-	    IDENTIFIER ib = DEREF_id ( exp_token_tok ( b ) ) ;
+		EXP sb = DEREF_exp(exp_dummy_value(b));
-	    LIST ( TOKEN ) pa = DEREF_list ( exp_token_args ( a ) ) ;
-	    LIST ( TOKEN ) pb = DEREF_list ( exp_token_args ( b ) ) ;
-	    return ( eq_token_args ( ia, ib, pa, pb ) ) ;
+		return (eq_exp(sa, sb, co));
+	}
+	case exp_reach_tag:
+	case exp_unreach_tag:
+	case exp_sequence_tag:
+	case exp_solve_stmt_tag:
+	case exp_decl_stmt_tag:
+	case exp_while_stmt_tag:
-	case exp_dummy_tag : {
+	case exp_do_stmt_tag:
+	case exp_switch_stmt_tag:
+	case exp_hash_if_tag:
-	    /* Dummy expressions */
+	case exp_return_stmt_tag:
+	case exp_goto_stmt_tag:
+	case exp_label_stmt_tag:
-	    EXP sa = DEREF_exp ( exp_dummy_value ( a ) ) ;
+	case exp_try_block_tag:
+	case exp_handler_tag:
-	    EXP sb = DEREF_exp ( exp_dummy_value ( b ) ) ;
+	case exp_uncompiled_tag:
+	case exp_fail_tag: {
-	    return ( eq_exp ( sa, sb, co ) ) ;
+		/* Statements are never equal */
+		return (0);
+	}
-	case exp_reach_tag :
-	case exp_unreach_tag :
-	case exp_sequence_tag :
-	case exp_solve_stmt_tag :
-	case exp_decl_stmt_tag :
-	case exp_while_stmt_tag :
-	case exp_do_stmt_tag :
-	case exp_switch_stmt_tag :
-	case exp_hash_if_tag :
-	case exp_return_stmt_tag :
-	case exp_goto_stmt_tag :
-	case exp_label_stmt_tag :
-	case exp_try_block_tag :
-	case exp_handler_tag :
-	case exp_uncompiled_tag :
-	case exp_fail_tag : {
-	    /* Statements are never equal */
-	    return ( 0 ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     UNIFY TWO EXPRESSIONS
     necessary.  It returns true if a value is assigned to a token.  Note
     that it is necessary to consider integer constant tokens as well as
     expression tokens.
 */
-static int unify_exp
+static int
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+unify_exp(EXP a, EXP b)
+{
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    LIST ( TOKEN ) args ;
+	LIST(TOKEN)args;
-    switch ( TAG_exp ( a ) ) {
+	switch (TAG_exp(a)) {
-	case exp_token_tag : {
+	case exp_token_tag: {
-	    id = DEREF_id ( exp_token_tok ( a ) ) ;
+		id = DEREF_id(exp_token_tok(a));
-	    args = DEREF_list ( exp_token_args ( a ) ) ;
+		args = DEREF_list(exp_token_args(a));
-	    break ;
+		break;
+	}
-	case exp_int_lit_tag : {
+	case exp_int_lit_tag: {
-	    NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(a));
-	    if ( !IS_nat_token ( n ) ) return ( 0 ) ;
+		if (!IS_nat_token(n)) {
+			return (0);
+		}
-	    id = DEREF_id ( nat_token_tok ( n ) ) ;
+		id = DEREF_id(nat_token_tok(n));
-	    args = DEREF_list ( nat_token_args ( n ) ) ;
+		args = DEREF_list(nat_token_args(n));
-	    break ;
+		break;
 	}
-	default : {
+	default:
-	    return ( 0 ) ;
+		return (0);
 	}
-    }
-    if ( IS_NULL_list ( args ) && defining_token ( id ) ) {
+	if (IS_NULL_list(args) && defining_token(id)) {
-	return ( define_exp_token ( id, b, 1 ) ) ;
+		return (define_exp_token(id, b, 1));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     ARE TWO EXPRESSIONS EQUAL?
     This routine checks whether the expressions a and b are equal.  If
     co is true then commutivity and other such relations are taken
     into account.
 */
-int eq_exp
+int
-    PROTO_N ( ( a, b, co ) )
-    PROTO_T ( EXP a X EXP b X int co )
+eq_exp(EXP a, EXP b, int co)
 {
-    /* Check for obvious equality */
+	/* Check for obvious equality */
-    unsigned ta, tb ;
+	unsigned ta, tb;
-    if ( EQ_exp ( a, b ) ) return ( 1 ) ;
+	if (EQ_exp(a, b)) {
+		return (1);
+	}
-    if ( IS_NULL_exp ( a ) ) return ( 0 ) ;
+	if (IS_NULL_exp(a)) {
+		return (0);
+	}
-    if ( IS_NULL_exp ( b ) ) return ( 0 ) ;
+	if (IS_NULL_exp(b)) {
+		return (0);
+	}
-    /* Allow for parentheses */
+	/* Allow for parentheses */
-    ta = TAG_exp ( a ) ;
+	ta = TAG_exp(a);
-    while ( ta == exp_paren_tag || ta == exp_copy_tag ) {
+	while (ta == exp_paren_tag || ta == exp_copy_tag) {
-	a = DEREF_exp ( exp_paren_etc_arg ( a ) ) ;
+		a = DEREF_exp(exp_paren_etc_arg(a));
-	ta = TAG_exp ( a ) ;
+		ta = TAG_exp(a);
-    }
+	}
-    tb = TAG_exp ( b ) ;
+	tb = TAG_exp(b);
-    while ( tb == exp_paren_tag || tb == exp_copy_tag ) {
+	while (tb == exp_paren_tag || tb == exp_copy_tag) {
-	b = DEREF_exp ( exp_paren_etc_arg ( b ) ) ;
+		b = DEREF_exp(exp_paren_etc_arg(b));
-	tb = TAG_exp ( b ) ;
+		tb = TAG_exp(b);
-    }
+	}
-    /* Check equality of expressions */
+	/* Check equality of expressions */
-    if ( ta == tb && eq_exp_aux ( a, b, co ) ) return ( 1 ) ;
+	if (ta == tb && eq_exp_aux(a, b, co)) {
+		return (1);
+	}
-    if ( force_tokdef || force_template || expand_tokdef ) {
+	if (force_tokdef || force_template || expand_tokdef) {
-	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));
-	if ( eq_type ( sa, sb ) == 1 ) {
+		if (eq_type(sa, sb) == 1) {
-	    if ( unify_exp ( a, b ) ) return ( 1 ) ;
+			if (unify_exp(a, b)) {
+				return (1);
+			}
-	    if ( unify_exp ( b, a ) ) return ( 1 ) ;
+			if (unify_exp(b, a)) {
+				return (1);
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     ARE TWO EXPRESSIONS PRECISELY EQUAL?
     This routine is similar to eq_exp, but it disallows token and template
     unification and does not allow for commutivity relations.
 */
-int eq_exp_exact
+int
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( EXP a X EXP b )
+eq_exp_exact(EXP a, EXP b)
 {
-    int eq ;
+	int eq;
-    int tok = force_tokdef ;
+	int tok = force_tokdef;
-    int templ = force_template ;
+	int templ = force_template;
-    force_tokdef = 0 ;
+	force_tokdef = 0;
-    force_template = 0 ;
+	force_template = 0;
-    eq = eq_exp ( a, b, 0 ) ;
+	eq = eq_exp(a, b, 0);
-    force_template = templ ;
+	force_template = templ;
-    force_tokdef = tok ;
+	force_tokdef = tok;
-    return ( eq ) ;
+	return (eq);
 }
 /*
     ARE TWO TOKENS EQUAL?
     This routine checks whether the tokens a and b are equal.
 */
-int eq_token
+int
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( TOKEN a X TOKEN b )
+eq_token(TOKEN a, TOKEN b)
+{
-    unsigned na, nb ;
+	unsigned na, nb;
-    if ( EQ_tok ( a, b ) ) return ( 1 ) ;
-    if ( IS_NULL_tok ( a ) ) return ( 0 ) ;
-    if ( IS_NULL_tok ( b ) ) return ( 0 ) ;
-    na = TAG_tok ( a ) ;
-    nb = TAG_tok ( b ) ;
+	if (EQ_tok(a, b)) {
-    if ( na != nb ) return ( 0 ) ;
-    switch ( na ) {
+		return (1);
-	case tok_exp_tag : {
-	    EXP va = DEREF_exp ( tok_exp_value ( a ) ) ;
-	    EXP vb = DEREF_exp ( tok_exp_value ( b ) ) ;
-	    return ( eq_exp ( va, vb, 0 ) ) ;
+	}
-	case tok_stmt_tag : {
+	if (IS_NULL_tok(a)) {
-	    EXP va = DEREF_exp ( tok_stmt_value ( a ) ) ;
-	    EXP vb = DEREF_exp ( tok_stmt_value ( b ) ) ;
-	    return ( eq_exp ( va, vb, 0 ) ) ;
+		return (0);
+	}
+	if (IS_NULL_tok(b)) {
+		return (0);
+	}
+	na = TAG_tok(a);
+	nb = TAG_tok(b);
+	if (na != nb) {
+		return (0);
+	}
+	switch (na) {
+	case tok_exp_tag: {
+		EXP va = DEREF_exp(tok_exp_value(a));
+		EXP vb = DEREF_exp(tok_exp_value(b));
+		return (eq_exp(va, vb, 0));
+	}
+	case tok_stmt_tag: {
+		EXP va = DEREF_exp(tok_stmt_value(a));
+		EXP vb = DEREF_exp(tok_stmt_value(b));
+		return (eq_exp(va, vb, 0));
+	}
-	case tok_nat_tag :
+	case tok_nat_tag:
-	case tok_snat_tag : {
+	case tok_snat_tag: {
-	    NAT va = DEREF_nat ( tok_nat_etc_value ( a ) ) ;
+		NAT va = DEREF_nat(tok_nat_etc_value(a));
-	    NAT vb = DEREF_nat ( tok_nat_etc_value ( b ) ) ;
+		NAT vb = DEREF_nat(tok_nat_etc_value(b));
-	    if ( compare_nat ( va, vb ) == 0 ) return ( 1 ) ;
+		if (compare_nat(va, vb) == 0) {
+			return (1);
+		}
-	    break ;
+		break;
+	}
+	case tok_type_tag: {
+		TYPE va = DEREF_type(tok_type_value(a));
+		TYPE vb = DEREF_type(tok_type_value(b));
+		if (eq_type(va, vb) == 1) {
+			return (1);
+		}
+		return (0);
+	}
-	case tok_type_tag : {
+	case tok_member_tag: {
-	    TYPE va = DEREF_type ( tok_type_value ( a ) ) ;
+		OFFSET va = DEREF_off(tok_member_value(a));
-	    TYPE vb = DEREF_type ( tok_type_value ( b ) ) ;
+		OFFSET vb = DEREF_off(tok_member_value(b));
-	    if ( eq_type ( va, vb ) == 1 ) return ( 1 ) ;
+		return (eq_offset(va, vb, 0));
-	    return ( 0 ) ;
+	}
-	case tok_member_tag : {
+	case tok_class_tag: {
-	    OFFSET va = DEREF_off ( tok_member_value ( a ) ) ;
+		IDENTIFIER ia = DEREF_id(tok_class_value(a));
-	    OFFSET vb = DEREF_off ( tok_member_value ( b ) ) ;
+		IDENTIFIER ib = DEREF_id(tok_class_value(b));
-	    return ( eq_offset ( va, vb, 0 ) ) ;
+		return (EQ_id(ia, ib));
+	}
-	case tok_class_tag : {
-	    IDENTIFIER ia = DEREF_id ( tok_class_value ( a ) ) ;
-	    IDENTIFIER ib = DEREF_id ( tok_class_value ( b ) ) ;
-	    return ( EQ_id ( ia, ib ) ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     ARE TWO TOKEN APPLICATIONS EQUAL?
     This routine checks whether the token applications ia ( pa ) and
     ib ( pb ) are equal.
 */
-int eq_token_args
+int
-    PROTO_N ( ( ia, ib, pa, pb ) )
-    PROTO_T ( IDENTIFIER ia X IDENTIFIER ib X
+eq_token_args(IDENTIFIER ia, IDENTIFIER ib, LIST(TOKEN)pa, LIST(TOKEN)pb)
-	      LIST ( TOKEN ) pa X LIST ( TOKEN ) pb )
+{
-    if ( !EQ_id ( ia, ib ) ) {
+	if (!EQ_id(ia, ib)) {
-	/* Check that tokens are the same */
+		/* Check that tokens are the same */
-	ia = DEREF_id ( id_alias ( ia ) ) ;
+		ia = DEREF_id(id_alias(ia));
-	ib = DEREF_id ( id_alias ( ib ) ) ;
+		ib = DEREF_id(id_alias(ib));
-	if ( !EQ_id ( ia, ib ) ) {
+		if (!EQ_id(ia, ib)) {
-	    if ( !force_merge || !merge_type ( ia, ib ) ) {
+			if (!force_merge || !merge_type(ia, ib)) {
-		return ( 0 ) ;
+				return (0);
-	    }
+			}
-	}
+		}
-    }
+	}
-    if ( EQ_list ( pa, pb ) ) return ( 1 ) ;
+	if (EQ_list(pa, pb)) {
+		return (1);
+	}
-    if ( LENGTH_list ( pa ) != LENGTH_list ( pb ) ) return ( 0 ) ;
+	if (LENGTH_list(pa)!= LENGTH_list(pb)) {
+		return (0);
+	}
-    while ( !IS_NULL_list ( pa ) ) {
+	while (!IS_NULL_list(pa)) {
-	TOKEN a, b ;
+		TOKEN a, b;
-	if ( EQ_list ( pa, pb ) ) return ( 1 ) ;
+		if (EQ_list(pa, pb)) {
+			return (1);
+		}
-	a = DEREF_tok ( HEAD_list ( pa ) ) ;
+		a = DEREF_tok(HEAD_list(pa));
-	b = DEREF_tok ( HEAD_list ( pb ) ) ;
+		b = DEREF_tok(HEAD_list(pb));
-	if ( !eq_token ( a, b ) ) return ( 0 ) ;
+		if (!eq_token(a, b)) {
+			return (0);
+		}
-	pb = TAIL_list ( pb ) ;
+		pb = TAIL_list(pb);
-	pa = TAIL_list ( pa ) ;
+		pa = TAIL_list(pa);
-    }
+	}
-    return ( 1 ) ;
+	return (1);
 }
 /*
     IS A TOKEN APPLICATION A CONSTANT?
     This routine checks whether the token id applied to the arguments args
     is a constant.
 */
-static int is_const_token
+static int
-    PROTO_N ( ( id, args, c ) )
-    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int c )
+is_const_token(IDENTIFIER id, LIST(TOKEN)args, int c)
 {
-    TOKEN tok = DEREF_tok ( id_token_sort ( id ) ) ;
+	TOKEN tok = DEREF_tok(id_token_sort(id));
-    if ( IS_tok_proc ( tok ) ) {
+	if (IS_tok_proc(tok)) {
-	/* Allow for procedure tokens */
+		/* Allow for procedure tokens */
-	tok = DEREF_tok ( tok_proc_res ( tok ) ) ;
+		tok = DEREF_tok(tok_proc_res(tok));
-    }
+	}
-    switch ( TAG_tok ( tok ) ) {
+	switch (TAG_tok(tok)) {
-	case tok_exp_tag : {
+	case tok_exp_tag: {
-	    /* Check for constant expression tokens */
+		/* Check for constant expression tokens */
-	    int cn = DEREF_int ( tok_exp_constant ( tok ) ) ;
+		int cn = DEREF_int(tok_exp_constant(tok));
-	    if ( cn ) {
+		if (cn) {
-		/* Constant token */
+			/* Constant token */
-		return ( 1 ) ;
+			return (1);
-	    }
+		}
-	    if ( c >= 0 ) {
+		if (c >= 0) {
-		/* Constant expression expected */
+			/* Constant expression expected */
-		report ( crt_loc, ERR_token_const ( id ) ) ;
+			report(crt_loc, ERR_token_const(id));
-	    }
+		}
-	    if ( option ( OPT_token_const ) == OPTION_DISALLOW ) {
+		if (option(OPT_token_const) == OPTION_DISALLOW) {
-		/* Non-constant tokens not allowed */
+			/* Non-constant tokens not allowed */
-		return ( 0 ) ;
+			return (0);
-	    }
+		}
-	    break ;
+		break;
 	}
-	case tok_nat_tag : {
+	case tok_nat_tag: {
-	    /* Integer constants */
+		/* Integer constants */
-	    return ( 1 ) ;
+		return (1);
 	}
-	case tok_stmt_tag : {
+	case tok_stmt_tag: {
-	    /* Statements are not constant */
+		/* Statements are not constant */
-	    return ( 0 ) ;
+		return (0);
 	}
-    }
+	}
-    /* Check all token arguments */
+	/* Check all token arguments */
-    while ( !IS_NULL_list ( args ) ) {
+	while (!IS_NULL_list(args)) {
-	TOKEN a = DEREF_tok ( HEAD_list ( args ) ) ;
+		TOKEN a = DEREF_tok(HEAD_list(args));
-	if ( !IS_NULL_tok ( a ) ) {
+		if (!IS_NULL_tok(a)) {
-	    switch ( TAG_tok ( a ) ) {
+			switch (TAG_tok(a)) {
-		case tok_exp_tag : {
+			case tok_exp_tag: {
-		    EXP e = DEREF_exp ( tok_exp_value ( a ) ) ;
+				EXP e = DEREF_exp(tok_exp_value(a));
-		    if ( !is_const_exp ( e, c ) ) return ( 0 ) ;
+				if (!is_const_exp(e, c)) {
+					return (0);
+				}
-		    break ;
+				break;
-		}
+			}
-		case tok_stmt_tag : {
+			case tok_stmt_tag: {
-		    EXP e = DEREF_exp ( tok_stmt_value ( a ) ) ;
+				EXP e = DEREF_exp(tok_stmt_value(a));
-		    if ( !is_const_exp ( e, c ) ) return ( 0 ) ;
+				if (!is_const_exp(e, c)) {
+					return (0);
+				}
-		    break ;
+				break;
-		}
+			}
-		case tok_member_tag : {
+			case tok_member_tag: {
-		    OFFSET off = DEREF_off ( tok_member_value ( a ) ) ;
+				OFFSET off = DEREF_off(tok_member_value(a));
-		    if ( !is_const_offset ( off, c, 1 ) ) return ( 0 ) ;
+				if (!is_const_offset(off, c, 1)) {
+					return (0);
+				}
-		    break ;
+				break;
-		}
+			}
-	    }
+			}
-	}
+		}
-	args = TAIL_list ( args ) ;
+		args = TAIL_list(args);
-    }
+	}
-    return ( 1 ) ;
+	return (1);
+}
 /*
     IS AN OFFSET A CONSTANT?
     This routine checks whether the offset off is a constant offset.  virt
     is true if virtual base classes are to be taken into account.
 */
-int is_const_offset
+int
-    PROTO_N ( ( off, c, virt ) )
-    PROTO_T ( OFFSET off X int c X int virt )
+is_const_offset(OFFSET off, int c, int virt)
+{
-    ASSERT ( ORDER_off == 13 ) ;
+	ASSERT(ORDER_off == 13);
-    switch ( TAG_off ( off ) ) {
+	switch (TAG_off(off)) {
-	case off_zero_tag :
+	case off_zero_tag:
-	case off_type_tag :
+	case off_type_tag:
-	case off_extra_tag :
+	case off_extra_tag:
-	case off_array_tag :
+	case off_array_tag:
-	case off_member_tag : {
+	case off_member_tag: {
-	    /* Constant offsets */
+		/* Constant offsets */
-	    return ( 1 ) ;
-	}
-	case off_base_tag : {
-	    /* Base class offsets */
-	    if ( virt ) {
-		GRAPH gr = DEREF_graph ( off_base_graph ( off ) ) ;
-		DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
-		if ( !( acc & dspec_mutable ) ) return ( 1 ) ;
-	    } else {
-		return ( 1 ) ;
-	    }
-	    break ;
-	}
-	case off_deriv_tag : {
-	    /* Derived class offsets */
-	    if ( virt ) {
-		GRAPH gr = DEREF_graph ( off_deriv_graph ( off ) ) ;
-		DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
-		if ( !( acc & dspec_mutable ) ) return ( 1 ) ;
-	    } else {
-		return ( 1 ) ;
+		return (1);
-	    }
-	    break ;
-	}
-	case off_ptr_mem_tag : {
-	    /* Pointer member offsets */
-	    EXP a = DEREF_exp ( off_ptr_mem_arg ( off ) ) ;
-	    return ( is_const_exp ( a, c ) ) ;
-	}
-	case off_negate_tag : {
-	    /* Offset negation */
-	    OFFSET off1 = DEREF_off ( off_negate_arg ( off ) ) ;
-	    return ( is_const_offset ( off1, c, 1 ) ) ;
+	}
+	case off_base_tag: {
+		/* Base class offsets */
+		if (virt) {
+			GRAPH gr = DEREF_graph(off_base_graph(off));
+			DECL_SPEC acc = DEREF_dspec(graph_access(gr));
+			if (!(acc & dspec_mutable)) {
+				return (1);
+			}
+		} else {
+			return (1);
+		}
+		break;
+	}
+	case off_deriv_tag: {
+		/* Derived class offsets */
+		if (virt) {
+			GRAPH gr = DEREF_graph(off_deriv_graph(off));
+			DECL_SPEC acc = DEREF_dspec(graph_access(gr));
+			if (!(acc & dspec_mutable)) {
+				return (1);
+			}
+		} else {
+			return (1);
+		}
+		break;
+	}
+	case off_ptr_mem_tag: {
+		/* Pointer member offsets */
+		EXP a = DEREF_exp(off_ptr_mem_arg(off));
+		return (is_const_exp(a, c));
+	}
+	case off_negate_tag: {
+		/* Offset negation */
+		OFFSET off1 = DEREF_off(off_negate_arg(off));
+		return (is_const_offset(off1, c, 1));
+	}
-	case off_plus_tag : {
+	case off_plus_tag: {
-	    /* Offset addition */
+		/* Offset addition */
-	    OFFSET off1 = DEREF_off ( off_plus_arg1 ( off ) ) ;
+		OFFSET off1 = DEREF_off(off_plus_arg1(off));
-	    OFFSET off2 = DEREF_off ( off_plus_arg2 ( off ) ) ;
+		OFFSET off2 = DEREF_off(off_plus_arg2(off));
-	    if ( !is_const_offset ( off1, c, 1 ) ) return ( 0 ) ;
+		if (!is_const_offset(off1, c, 1)) {
+			return (0);
+		}
-	    return ( is_const_offset ( off2, c, 1 ) ) ;
+		return (is_const_offset(off2, c, 1));
 	}
-	case off_mult_tag : {
+	case off_mult_tag: {
-	    /* Offset multiplication */
+		/* Offset multiplication */
-	    OFFSET off1 = DEREF_off ( off_mult_arg1 ( off ) ) ;
+		OFFSET off1 = DEREF_off(off_mult_arg1(off));
-	    EXP a = DEREF_exp ( off_mult_arg2 ( off ) ) ;
+		EXP a = DEREF_exp(off_mult_arg2(off));
-	    if ( !is_const_offset ( off1, c, 1 ) ) return ( 0 ) ;
+		if (!is_const_offset(off1, c, 1)) {
+			return (0);
+		}
-	    return ( is_const_exp ( a, c ) ) ;
+		return (is_const_exp(a, c));
+	}
-	case off_ptr_diff_tag : {
+	case off_ptr_diff_tag: {
-	    /* Pointer difference */
+		/* Pointer difference */
-	    EXP a = DEREF_exp ( off_ptr_diff_ptr1 ( off ) ) ;
+		EXP a = DEREF_exp(off_ptr_diff_ptr1(off));
-	    EXP b = DEREF_exp ( off_ptr_diff_ptr2 ( off ) ) ;
+		EXP b = DEREF_exp(off_ptr_diff_ptr2(off));
-	    if ( is_const_exp ( a, c ) && is_const_exp ( b, c ) ) {
+		if (is_const_exp(a, c) && is_const_exp(b, c)) {
-		/* Only allow pointers from same array */
+			/* Only allow pointers from same array */
-		EXP pa = NULL_exp ;
+			EXP pa = NULL_exp;
-		EXP pb = NULL_exp ;
+			EXP pb = NULL_exp;
-		IGNORE find_exp_linkage ( a, &pa, 1 ) ;
+			IGNORE find_exp_linkage(a, &pa, 1);
-		IGNORE find_exp_linkage ( b, &pb, 1 ) ;
+			IGNORE find_exp_linkage(b, &pb, 1);
-		if ( !IS_NULL_exp ( pa ) && !IS_exp_string_lit ( pa ) ) {
+			if (!IS_NULL_exp(pa) && !IS_exp_string_lit(pa)) {
-		    return ( eq_exp ( pa, pb, 0 ) ) ;
+				return (eq_exp(pa, pb, 0));
+			}
+		}
+		break;
-	    }
+	}
-	    break ;
+	case off_token_tag: {
+		/* All member tokens are constant */
+		IDENTIFIER id = DEREF_id(off_token_tok(off));
+		LIST(TOKEN)args = DEREF_list(off_token_args(off));
+		return (is_const_token(id, args, c));
+	}
-	case off_token_tag : {
-	    /* All member tokens are constant */
-	    IDENTIFIER id = DEREF_id ( off_token_tok ( off ) ) ;
-	    LIST ( TOKEN ) args = DEREF_list ( off_token_args ( off ) ) ;
-	    return ( is_const_token ( id, args, c ) ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     IS AN EXPRESSION AN ADDRESS CONSTANT?
     This routine checks whether the address of e is a constant expression.
     c will be nonzero.
 */
-static int is_const_addr
+static int
-    PROTO_N ( ( e, c ) )
-    PROTO_T ( EXP e X int c )
+is_const_addr(EXP e, int c)
+{
-    if ( IS_NULL_exp ( e ) ) return ( 1 ) ;
+	if (IS_NULL_exp(e)) {
-    switch ( TAG_exp ( e ) ) {
-	case exp_identifier_tag : {
-	    /* Identifier expressions */
-	    IDENTIFIER id = DEREF_id ( exp_identifier_id ( e ) ) ;
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    if ( !( ds & dspec_auto ) ) {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
-		if ( !IS_type_ref ( t ) ) return ( 1 ) ;
-	    }
-	    break ;
+		return (1);
+	}
+	switch (TAG_exp(e)) {
+	case exp_identifier_tag: {
+		/* Identifier expressions */
+		IDENTIFIER id = DEREF_id(exp_identifier_id(e));
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		if (!(ds & dspec_auto)) {
+			TYPE t = DEREF_type(exp_type(e));
+			if (!IS_type_ref(t)) {
+				return (1);
+			}
+		}
+		break;
+	}
-	case exp_indir_tag : {
+	case exp_indir_tag: {
-	    /* Indirection expressions */
+		/* Indirection expressions */
-	    EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
+		EXP a = DEREF_exp(exp_indir_ptr(e));
-	    return ( is_const_exp ( a, c ) ) ;
+		return (is_const_exp(a, c));
 	}
-	case exp_member_tag :
+	case exp_member_tag:
-	case exp_string_lit_tag :
+	case exp_string_lit_tag:
-	case exp_rtti_type_tag : {
+	case exp_rtti_type_tag: {
-	    /* lvalue expressions */
+		/* lvalue expressions */
-	    return ( 1 ) ;
+		return (1);
 	}
-	case exp_token_tag : {
+	case exp_token_tag: {
-	    /* Tokenised expressions */
+		/* Tokenised expressions */
-	    return ( is_const_exp ( e, c ) ) ;
+		return (is_const_exp(e, c));
 	}
-	case exp_comma_tag : {
+	case exp_comma_tag: {
-	    /* Comma expressions (not allowed) */
+		/* Comma expressions (not allowed) */
-	    if ( c < 0 ) {
+		if (c < 0) {
-		LIST ( EXP ) p = DEREF_list ( exp_comma_args ( e ) ) ;
+			LIST(EXP)p = DEREF_list(exp_comma_args(e));
-		while ( !IS_NULL_list ( p ) ) {
+			while (!IS_NULL_list(p)) {
-		    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+				EXP a = DEREF_exp(HEAD_list(p));
-		    p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
-		    if ( IS_NULL_list ( p ) ) {
+				if (IS_NULL_list(p)) {
-			return ( is_const_addr ( a, c ) ) ;
+					return (is_const_addr(a, c));
-		    }
+				}
-		    if ( !is_const_exp ( a, c ) ) break ;
+				if (!is_const_exp(a, c)) {
+					break;
+				}
-		}
+			}
-	    }
+		}
-	    break ;
+		break;
 	}
-	case exp_if_stmt_tag : {
+	case exp_if_stmt_tag: {
-	    /* Conditional expressions */
+		/* Conditional expressions */
-	    EXP d = DEREF_exp ( exp_if_stmt_cond ( e ) ) ;
+		EXP d = DEREF_exp(exp_if_stmt_cond(e));
-	    EXP a = DEREF_exp ( exp_if_stmt_true_code ( e ) ) ;
+		EXP a = DEREF_exp(exp_if_stmt_true_code(e));
-	    EXP b = DEREF_exp ( exp_if_stmt_false_code ( e ) ) ;
+		EXP b = DEREF_exp(exp_if_stmt_false_code(e));
-	    if ( !is_const_exp ( d, c ) ) break ;
+		if (!is_const_exp(d, c)) {
+			break;
+		}
-	    if ( !is_const_addr ( a, c ) ) break ;
+		if (!is_const_addr(a, c)) {
+			break;
+		}
-	    return ( is_const_addr ( b, c ) ) ;
+		return (is_const_addr(b, c));
 	}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     IS AN EXPRESSION CONSTANT?
     This routine checks whether e is a constant expression.  Note that
     most integer constant expressions are dealt with in a bottom-up
     fashion by means of the constant evaluation routines.  Other
     constants are dealt with in a top-down fashion by this routine.  If
     c is 0 then only valid integer constant expressions are allowed; c
     is -1 then only a check is intended.
 /*
     DOES AN EXPRESSION CONTAIN AN OVERFLOW?
     Certain evaluations on integer constant expressions are only valid
     if it can be shown that the operands cannot raise an exception.
     evaluation of a does not overflow.  This routine returns true if
     the evaluation of the expression a may raise an overflow exception
     or contains some other side effect.
 */
-int overflow_exp
+int
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+overflow_exp(EXP a)
+{
-    if ( IS_NULL_exp ( a ) ) return ( 0 ) ;
+	if (IS_NULL_exp(a)) {
-    switch ( TAG_exp ( a ) ) {
-	case exp_int_lit_tag : {
-	    /* Check integer constant expressions */
-	    NAT n = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
-	    unsigned etag = DEREF_unsigned ( exp_int_lit_etag ( a ) ) ;
-	    switch ( etag ) {
-		case exp_char_lit_tag :
-		case exp_offset_size_tag : {
-		    /* These never overflow */
-		    return ( 0 ) ;
+		return (0);
-		}
-	    }
-	    return ( is_calc_nat ( n ) ) ;
-	}
-	case exp_identifier_tag :
-	case exp_member_tag :
-	case exp_char_lit_tag :
-	case exp_value_tag :
-	case exp_null_tag :
-	case exp_zero_tag : {
-	    return ( 0 ) ;
+	}
+	switch (TAG_exp(a)) {
+	case exp_int_lit_tag: {
+		/* Check integer constant expressions */
+		NAT n = DEREF_nat(exp_int_lit_nat(a));
+		unsigned etag = DEREF_unsigned(exp_int_lit_etag(a));
+		switch (etag) {
+		case exp_char_lit_tag:
+		case exp_offset_size_tag: {
+			/* These never overflow */
+			return (0);
+		}
+		}
+		return (is_calc_nat(n));
+	}
+	case exp_identifier_tag:
+	case exp_member_tag:
+	case exp_char_lit_tag:
+	case exp_value_tag:
+	case exp_null_tag:
+	case exp_zero_tag: {
+		return (0);
+	}
-	case exp_string_lit_tag : {
+	case exp_string_lit_tag: {
-	    /* String literals deliberately excluded */
+		/* String literals deliberately excluded */
-	    return ( 1 ) ;
+		return (1);
 	}
-	case exp_paren_tag :
+	case exp_paren_tag:
-	case exp_copy_tag : {
+	case exp_copy_tag: {
-	    EXP b = DEREF_exp ( exp_paren_etc_arg ( a ) ) ;
+		EXP b = DEREF_exp(exp_paren_etc_arg(a));
+		return (overflow_exp(b));
+	}
+	case exp_address_tag: {
+		EXP b = DEREF_exp(exp_address_arg(a));
+		return (overflow_exp(b));
+	}
+	case exp_address_mem_tag: {
+		EXP b = DEREF_exp(exp_address_mem_arg(a));
+		return (overflow_exp(b));
+	}
+	case exp_cast_tag: {
+		/* Cast expressions */
+		unsigned c = DEREF_unsigned(exp_cast_conv(a));
+		if (c == CONV_ELLIPSIS) {
+			EXP b = DEREF_exp(exp_cast_arg(a));
-	    return ( overflow_exp ( b ) ) ;
+			return (overflow_exp(b));
+		}
+		break;
+	}
-	case exp_address_tag : {
+	case exp_comma_tag: {
-	    EXP b = DEREF_exp ( exp_address_arg ( a ) ) ;
+		LIST(EXP)p = DEREF_list(exp_comma_args(a));
+		while (!IS_NULL_list(p)) {
+			EXP b = DEREF_exp(HEAD_list(p));
-	    return ( overflow_exp ( b ) ) ;
+			if (overflow_exp(b)) {
+				return (1);
+			}
+			p = TAIL_list(p);
+		}
+		return (0);
+	}
-	case exp_address_mem_tag : {
+	case exp_aggregate_tag: {
-	    EXP b = DEREF_exp ( exp_address_mem_arg ( a ) ) ;
+		LIST(EXP)p = DEREF_list(exp_aggregate_args(a));
-	    return ( overflow_exp ( b ) ) ;
-	}
-	case exp_cast_tag : {
+		while (!IS_NULL_list(p)) {
-	    /* Cast expressions */
-	    unsigned c = DEREF_unsigned ( exp_cast_conv ( a ) ) ;
+			EXP b = DEREF_exp(HEAD_list(p));
-	    if ( c == CONV_ELLIPSIS ) {
+			if (overflow_exp(b)) {
-		EXP b = DEREF_exp ( exp_cast_arg ( a ) ) ;
+				return (1);
+			}
-		return ( overflow_exp ( b ) ) ;
+			p = TAIL_list(p);
-	    }
+		}
-	    break ;
+		return (0);
+	}
-	case exp_comma_tag : {
+	case exp_nof_tag: {
-	    LIST ( EXP ) p = DEREF_list ( exp_comma_args ( a ) ) ;
+		EXP b = DEREF_exp(exp_nof_start(a));
-	    while ( !IS_NULL_list ( p ) ) {
+		EXP c = DEREF_exp(exp_nof_pad(a));
-		EXP b = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP d = DEREF_exp(exp_nof_end(a));
-		if ( overflow_exp ( b ) ) return ( 1 ) ;
+		NAT n = DEREF_nat(exp_nof_size(a));
-		p = TAIL_list ( p ) ;
+		if (overflow_exp(b)) {
-	    }
-	    return ( 0 ) ;
+			return (1);
-	}
+		}
-	case exp_aggregate_tag : {
+		if (overflow_exp(c)) {
-	    LIST ( EXP ) p = DEREF_list ( exp_aggregate_args ( a ) ) ;
-	    while ( !IS_NULL_list ( p ) ) {
+			return (1);
-		EXP b = DEREF_exp ( HEAD_list ( p ) ) ;
+		}
-		if ( overflow_exp ( b ) ) return ( 1 ) ;
+		if (overflow_exp(d)) {
-		p = TAIL_list ( p ) ;
+			return (1);
-	    }
+		}
-	    return ( 0 ) ;
+		return (is_calc_nat(n));
+	}
-	case exp_nof_tag : {
-	    EXP b = DEREF_exp ( exp_nof_start ( a ) ) ;
-	    EXP c = DEREF_exp ( exp_nof_pad ( a ) ) ;
-	    EXP d = DEREF_exp ( exp_nof_end ( a ) ) ;
-	    NAT n = DEREF_nat ( exp_nof_size ( a ) ) ;
-	    if ( overflow_exp ( b ) ) return ( 1 ) ;
-	    if ( overflow_exp ( c ) ) return ( 1 ) ;
-	    if ( overflow_exp ( d ) ) return ( 1 ) ;
-	    return ( is_calc_nat ( n ) ) ;
+	}
-    }
-    return ( 1 ) ;
+	return (1);
+}
 /*
     FIND THE LINKAGE OF AN EXPRESSION
     This routine checks the linkage of the expression a.  If vol is true
     then the result is or-ed with dspec_implicit if a is derived from
     an implicitly volatile external identifier and or-ed with dspec_pure
     if a is derived from an implicitly const string literal.  The
     component of a which determines the linkage is returned via pa.
     IS AN OFFSET ZERO?
     This routine checks whether the offset off is zero.  The only
     non-trivial case is for base class offsets where the single
     inheritance (zero offset) cases are marked using dspec_ignore.
 */
-int is_zero_offset
+int
-    PROTO_N ( ( off ) )
-    PROTO_T ( OFFSET off )
+is_zero_offset(OFFSET off)
 {
-    if ( IS_NULL_off ( off ) ) return ( 1 ) ;
+	if (IS_NULL_off(off)) {
+		return (1);
+	}
-    ASSERT ( ORDER_off == 13 ) ;
+	ASSERT(ORDER_off == 13);
-    switch ( TAG_off ( off ) ) {
+	switch (TAG_off(off)) {
-	case off_zero_tag : {
+	case off_zero_tag: {
-	    /* Zero offsets */
+		/* Zero offsets */
-	    return ( 1 ) ;
+		return (1);
 	}
-	case off_array_tag : {
+	case off_array_tag: {
-	    /* Array offsets */
+		/* Array offsets */
-	    unsigned n = DEREF_unsigned ( off_array_arg ( off ) ) ;
+		unsigned n = DEREF_unsigned(off_array_arg(off));
-	    if ( n == 0 ) return ( 1 ) ;
+		if (n == 0) {
+			return (1);
+		}
-	    break ;
+		break;
 	}
-	case off_base_tag : {
+	case off_base_tag: {
-	    /* Base class offsets */
+		/* Base class offsets */
-	    GRAPH gr = DEREF_graph ( off_base_graph ( off ) ) ;
+		GRAPH gr = DEREF_graph(off_base_graph(off));
-	    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+		DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-	    if ( acc & dspec_ignore ) return ( 1 ) ;
+		if (acc & dspec_ignore) {
+			return (1);
+		}
-	    break ;
+		break;
 	}
-	case off_deriv_tag : {
+	case off_deriv_tag: {
-	    /* Derived class offsets */
+		/* Derived class offsets */
-	    GRAPH gr = DEREF_graph ( off_deriv_graph ( off ) ) ;
+		GRAPH gr = DEREF_graph(off_deriv_graph(off));
-	    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+		DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-	    if ( acc & dspec_ignore ) return ( 1 ) ;
+		if (acc & dspec_ignore) {
+			return (1);
+		}
-	    break ;
+		break;
 	}
-	case off_negate_tag : {
+	case off_negate_tag: {
-	    /* Offset negations */
+		/* Offset negations */
-	    OFFSET a = DEREF_off ( off_negate_arg ( off ) ) ;
+		OFFSET a = DEREF_off(off_negate_arg(off));
-	    return ( is_zero_offset ( a ) ) ;
+		return (is_zero_offset(a));
 	}
-	case off_plus_tag : {
+	case off_plus_tag: {
-	    /* Offset additions */
+		/* Offset additions */
-	    OFFSET a = DEREF_off ( off_plus_arg1 ( off ) ) ;
+		OFFSET a = DEREF_off(off_plus_arg1(off));
-	    OFFSET b = DEREF_off ( off_plus_arg2 ( off ) ) ;
+		OFFSET b = DEREF_off(off_plus_arg2(off));
-	    return ( is_zero_offset ( a ) && is_zero_offset ( b ) ) ;
+		return (is_zero_offset(a) && is_zero_offset(b));
+	}
+	case off_mult_tag: {
+		/* Offset multiplications */
+		OFFSET a = DEREF_off(off_mult_arg1(off));
+		return (is_zero_offset(a));
+	}
-	case off_mult_tag : {
-	    /* Offset multiplications */
-	    OFFSET a = DEREF_off ( off_mult_arg1 ( off ) ) ;
-	    return ( is_zero_offset ( a ) ) ;
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     IS THE TYPE OF AN OFFSET STATICALLY DETERMINED?
     This routine checks whether the type of a pointer plus the offset off
     can be statically determined.  It returns 2 if the type is known
     independent of the value of the pointer, 1 if it is known if the
     type of the pointer is known, and 0 otherwise.
 */
-static int know_offset
+static int
-    PROTO_N ( ( off ) )
-    PROTO_T ( OFFSET off )
+know_offset(OFFSET off)
+{
-    if ( !IS_NULL_off ( off ) ) {
+	if (!IS_NULL_off(off)) {
-	switch ( TAG_off ( off ) ) {
+		switch (TAG_off(off)) {
-	    case off_base_tag :
+		case off_base_tag:
-	    case off_deriv_tag :
+		case off_deriv_tag:
-	    case off_ptr_mem_tag : {
+		case off_ptr_mem_tag: {
-		/* Base class offsets */
+			/* Base class offsets */
-		return ( 0 ) ;
+			return (0);
-	    }
+		}
-	    case off_member_tag : {
+		case off_member_tag: {
-		/* Member offsets */
+			/* Member offsets */
-		return ( 2 ) ;
+			return (2);
-	    }
+		}
-	    case off_plus_tag : {
+		case off_plus_tag: {
-		/* Check for derived member offsets */
+			/* Check for derived member offsets */
-		off = DEREF_off ( off_plus_arg2 ( off ) ) ;
+			off = DEREF_off(off_plus_arg2(off));
-		if ( IS_off_member ( off ) ) return ( 2 ) ;
+			if (IS_off_member(off)) {
+				return (2);
+			}
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    return ( 1 ) ;
+	return (1);
+}
 /*
     IS THE TYPE OF AN EXPRESSION STATICALLY DETERMINED?
     This routine checks whether the expression of class type or pointer to
     class type, e, is derived from an object so that its type can be
     statically determined.  It is used to check whether the virtual call
     mechanism and virtual base class conversions can be bypassed for e.
     A value of 2 is returned for non-obvious known types.
 */
-int know_type
+int
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+know_type(EXP e)
+{
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	unsigned tag = TAG_exp ( e ) ;
+		unsigned tag = TAG_exp(e);
-	switch ( tag ) {
+		switch (tag) {
-	    case exp_address_tag : {
+		case exp_address_tag: {
-		EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
+			EXP a = DEREF_exp(exp_address_arg(e));
-		tag = TAG_exp ( a ) ;
+			tag = TAG_exp(a);
-		if ( tag == exp_identifier_tag ) {
+			if (tag == exp_identifier_tag) {
-		    return ( 1 ) ;
+				return (1);
-		}
+			}
-		if ( tag == exp_indir_tag ) {
+			if (tag == exp_indir_tag) {
-		    EXP b = DEREF_exp ( exp_indir_ptr ( a ) ) ;
+				EXP b = DEREF_exp(exp_indir_ptr(a));
-		    return ( know_type ( b ) ) ;
+				return (know_type(b));
+			}
+			if (tag == exp_dummy_tag) {
+				EXP b = DEREF_exp(exp_dummy_value(a));
+				if (IS_NULL_exp(b)) {
+					int v = DEREF_int(exp_dummy_virt(a));
+					if (!v) {
+						return (1);
+					}
+				}
+			}
+			break;
+		}
-		if ( tag == exp_dummy_tag ) {
+		case exp_indir_tag: {
-		    EXP b = DEREF_exp ( exp_dummy_value ( a ) ) ;
+			EXP a = DEREF_exp(exp_indir_ptr(e));
-		    if ( IS_NULL_exp ( b ) ) {
-			int v = DEREF_int ( exp_dummy_virt ( a ) ) ;
-			if ( !v ) return ( 1 ) ;
+			return (know_type(a));
-		    }
+		}
-		break ;
-	    }
-	    case exp_indir_tag : {
+		case exp_add_ptr_tag: {
-		EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
+			OFFSET off = DEREF_off(exp_add_ptr_off(e));
-		return ( know_type ( a ) ) ;
+			int k = know_offset(off);
+			if (k == 2) {
+				return (1);
-	    }
+			}
-	    case exp_add_ptr_tag : {
+			if (k == 1) {
-		OFFSET off = DEREF_off ( exp_add_ptr_off ( e ) ) ;
+				EXP a = DEREF_exp(exp_add_ptr_ptr(e));
-		int k = know_offset ( off ) ;
+				return (know_type(a));
-		if ( k == 2 ) {
+			}
-		    return ( 1 ) ;
+			break;
+		}
-		if ( k == 1 ) {
+		case exp_contents_tag: {
-		    EXP a = DEREF_exp ( exp_add_ptr_ptr ( e ) ) ;
+			e = DEREF_exp(exp_contents_ptr(e));
-		    return ( know_type ( a ) ) ;
+			if (IS_exp_identifier(e)) {
+				goto identifier_lab;
+			}
+			break;
+		}
-		break ;
-	    }
-	    case exp_contents_tag : {
-		e = DEREF_exp ( exp_contents_ptr ( e ) ) ;
-		if ( IS_exp_identifier ( e ) ) goto identifier_lab ;
-		break ;
-	    }
-	    case exp_identifier_tag :
+		case exp_identifier_tag:
-	    identifier_lab : {
+identifier_lab: {
-		IDENTIFIER id = DEREF_id ( exp_identifier_id ( e ) ) ;
+			 IDENTIFIER id = DEREF_id(exp_identifier_id(e));
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			 HASHID nm = DEREF_hashid(id_name(id));
-		if ( EQ_KEYWORD ( nm, lex_this_Hname ) ) {
+			 if (EQ_KEYWORD(nm, lex_this_Hname)) {
-		    /* A 'this' expression */
+				 /* A 'this' expression */
-		    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+				 NAMESPACE ns = DEREF_nspace(id_parent(id));
-		    id = DEREF_id ( nspace_name ( ns ) ) ;
+				 id = DEREF_id(nspace_name(ns));
-		    nm = DEREF_hashid ( id_name ( id ) ) ;
+				 nm = DEREF_hashid(id_name(id));
-		    if ( IS_hashid_constr ( nm ) ) {
+				 if (IS_hashid_constr(nm)) {
-			/* Function is a constructor */
+					 /* Function is a constructor */
-			return ( 2 ) ;
+					 return (2);
-		    }
+				 }
-		    if ( IS_hashid_destr ( nm ) ) {
+				 if (IS_hashid_destr(nm)) {
-			/* Function is a destructor */
+					 /* Function is a destructor */
-			return ( 2 ) ;
+					 return (2);
-		    }
+				 }
+			 }
+			 break;
+		 }
+		}
-		break ;
-	    }
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}

Subversion Repositories tendra.SVN

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