WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/output/exp.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997, 1998
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "config.h"
 #include "version.h"
 #include "c_types.h"
 #include "ctype_ops.h"
 #include "exp_ops.h"
 #include "tok.h"
 #include "throw.h"
 #include "ustring.h"
 #include "virtual.h"
 #if TDF_OUTPUT
 /*
     ENCODE A SMALL TDF INTEGER CONSTANT
     This routine adds the small integer n to the bitstream bs as a TDF
     SIGNED_NAT.
 */
-BITSTREAM *enc_make_snat
+BITSTREAM *
-    PROTO_N ( ( bs, n ) )
-    PROTO_T ( BITSTREAM *bs X int n )
+enc_make_snat(BITSTREAM *bs, int n)
+{
-    ENC_make_signed_nat ( bs ) ;
+	ENC_make_signed_nat(bs);
-    if ( n >= 0 ) {
+	if (n >= 0) {
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-    } else {
+	} else {
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	n = -n ;
+		n = -n;
-    }
+	}
-    ENC_INT ( bs, n ) ;
+	ENC_INT(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A SMALL TDF INTEGER
     This routine adds the small integer n of type t to the bitstream bs
     as a TDF EXP.
 */
-BITSTREAM *enc_make_int
+BITSTREAM *
-    PROTO_N ( ( bs, t, n ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int n )
+enc_make_int(BITSTREAM *bs, TYPE t, int n)
+{
-    ENC_make_int ( bs ) ;
+	ENC_make_int(bs);
-    bs = enc_variety ( bs, t ) ;
+	bs = enc_variety(bs, t);
-    bs = enc_make_snat ( bs, n ) ;
+	bs = enc_make_snat(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A NULL TDF EXPRESSION
     This routine adds a null TDF EXP with shape corresponding to the type
     t to the bitstream bs.
 */
-BITSTREAM *enc_null_exp
+BITSTREAM *
-    PROTO_N ( ( bs, t ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t )
+enc_null_exp(BITSTREAM *bs, TYPE t)
 {
-    if ( IS_NULL_type ( t ) ) {
+	if (IS_NULL_type(t)) {
-	/* This shouldn't happen */
+		/* This shouldn't happen */
-	t = type_sint ;
+		t = type_sint;
-    }
+	}
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_integer_tag :
+	case type_integer_tag:
-	case type_enumerate_tag : {
+	case type_enumerate_tag: {
-	    /* Integral types */
+		/* Integral types */
-	    bs = enc_make_int ( bs, t, 0 ) ;
+		bs = enc_make_int(bs, t, 0);
-	    break ;
+		break;
 	}
-	case type_floating_tag : {
+	case type_floating_tag: {
-	    /* Floating types */
+		/* Floating types */
-	    bs = enc_float_int ( bs, 0, t ) ;
+		bs = enc_float_int(bs, 0, t);
-	    break ;
+		break;
 	}
-	case type_top_tag :
+	case type_top_tag:
-	case type_bottom_tag : {
+	case type_bottom_tag: {
-	    /* Top type */
+		/* Top type */
-	    ENC_make_top ( bs ) ;
+		ENC_make_top(bs);
-	    break ;
+		break;
 	}
-	case type_ptr_tag :
+	case type_ptr_tag:
-	case type_ref_tag : {
+	case type_ref_tag: {
-	    /* Pointer types */
+		/* Pointer types */
-	    TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_etc_sub(t));
-	    switch ( TAG_type ( s ) ) {
+		switch (TAG_type(s)) {
-		case type_top_tag :
+		case type_top_tag:
-		case type_bottom_tag : {
+		case type_bottom_tag: {
-		    /* Generic pointer */
+			/* Generic pointer */
-		    bs = enc_special ( bs, TOK_null_pv ) ;
+			bs = enc_special(bs, TOK_null_pv);
-		    break ;
+			break;
 		}
-		case type_func_tag : {
+		case type_func_tag: {
-		    /* Function pointer */
+			/* Function pointer */
-		    ENC_make_null_proc ( bs ) ;
+			ENC_make_null_proc(bs);
-		    break ;
+			break;
 		}
-		default : {
+		default: {
-		    /* Normal pointer */
+			/* Normal pointer */
-		    ENC_make_null_ptr ( bs ) ;
+			ENC_make_null_ptr(bs);
-		    bs = enc_alignment ( bs, s ) ;
+			bs = enc_alignment(bs, s);
-		    break ;
+			break;
 		}
-	    }
+		}
-	    break ;
+		break;
 	}
-	case type_ptr_mem_tag : {
+	case type_ptr_mem_tag: {
-	    /* Pointer to member types */
+		/* Pointer to member types */
-	    TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_mem_sub(t));
-	    if ( IS_type_func ( s ) ) {
+		if (IS_type_func(s)) {
-		if ( in_static_init ) {
+			if (in_static_init) {
+				bs = enc_special(bs, TOK_pmf_null);
+			} else {
-		    bs = enc_special ( bs, TOK_pmf_null ) ;
+				bs = enc_special(bs, TOK_pmf_null2);
+			}
+		} else {
+			bs = enc_special(bs, TOK_pm_null);
+		}
+		break;
+	}
+	case type_array_tag: {
+		/* Array types */
+		NAT n = DEREF_nat(type_array_size(t));
+		TYPE s = DEREF_type(type_array_sub(t));
+		ENC_n_copies(bs);
+		bs = enc_nat(bs, n, 1);
+		bs = enc_null_exp(bs, s);
+		break;
+	}
+	case type_bitfield_tag: {
+		/* Bitfield types */
+		TYPE s = find_bitfield_type(t);
+		ENC_change_int_to_bitfield(bs);
+		bs = enc_bfvar(bs, t);
+		bs = enc_null_exp(bs, s);
+		break;
+	}
+	case type_compound_tag: {
+		/* Compound types */
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+		TYPE s = DEREF_type(ctype_form(ct));
+		if (is_tokenised_class(s)) {
+			ENC_make_value(bs);
+			bs = enc_shape(bs, s);
 		} else {
-		    bs = enc_special ( bs, TOK_pmf_null2 ) ;
+			bs = enc_null_class(bs, ct);
+		}
-	    } else {
-		bs = enc_special ( bs, TOK_pm_null ) ;
-	    }
-	    break ;
+		break;
-	}
-	case type_array_tag : {
-	    /* Array types */
-	    NAT n = DEREF_nat ( type_array_size ( t ) ) ;
-	    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-	    ENC_n_copies ( bs ) ;
-	    bs = enc_nat ( bs, n, 1 ) ;
-	    bs = enc_null_exp ( bs, s ) ;
-	    break ;
-	}
-	case type_bitfield_tag : {
-	    /* Bitfield types */
-	    TYPE s = find_bitfield_type ( t ) ;
-	    ENC_change_int_to_bitfield ( bs ) ;
-	    bs = enc_bfvar ( bs, t ) ;
-	    bs = enc_null_exp ( bs, s ) ;
-	    break ;
+	}
-	case type_compound_tag : {
+	default: {
-	    /* Compound types */
+		/* Other types */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-	    TYPE s = DEREF_type ( ctype_form ( ct ) ) ;
-	    if ( is_tokenised_class ( s ) ) {
-		ENC_make_value ( bs ) ;
+		ENC_make_value(bs);
-		bs = enc_shape ( bs, s ) ;
+		bs = enc_shape(bs, t);
-	    } else {
-		bs = enc_null_class ( bs, ct ) ;
-	    }
-	    break ;
+		break;
+	}
-	default : {
-	    /* Other types */
-	    ENC_make_value ( bs ) ;
-	    bs = enc_shape ( bs, t ) ;
-	    break ;
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     CHECK ANONYMOUS UNION MEMBER EXPRESSION
     This routine checks whether the identifier expression a arises from a
     member of an anonymous union.  The routine also marks any external
     variables.
 */
-static int is_anon_exp
+static int
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+is_anon_exp(EXP a)
+{
-    IDENTIFIER id = DEREF_id ( exp_identifier_id ( a ) ) ;
+	IDENTIFIER id = DEREF_id(exp_identifier_id(a));
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    if ( !( ds & dspec_auto ) ) {
+	if (!(ds & dspec_auto)) {
-	/* Mark external variables */
+		/* Mark external variables */
-	IGNORE capsule_id ( id, VAR_tag ) ;
+		IGNORE capsule_id(id, VAR_tag);
-    }
+	}
-    if ( ds & dspec_reserve ) {
+	if (ds & dspec_reserve) {
-	/* Check for anonymous union members */
+		/* Check for anonymous union members */
-	return ( is_anon_member ( id ) ) ;
+		return (is_anon_member(id));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CREATE AN IDENTITY DECLARATION
     This routine adds the start of an identity declaration for the
     expression a to the bitstream bs.  The identity body will consist
     of a sequence of seq + 1 expressions.  The identity tag number is
     returned via pn.
 */
-static BITSTREAM *make_identity
+static BITSTREAM *
-    PROTO_N ( ( bs, a, pn, cnt, seq ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X ulong *pn X int cnt X int seq )
+make_identity(BITSTREAM *bs, EXP a, ulong *pn, int cnt, int seq)
 {
-    ulong n ;
+	ulong n;
-    if ( IS_exp_identifier ( a ) ) {
+	if (IS_exp_identifier(a)) {
-	/* No identity required in this case */
+		/* No identity required in this case */
-	IDENTIFIER id = DEREF_id ( exp_identifier_id ( a ) ) ;
+		IDENTIFIER id = DEREF_id(exp_identifier_id(a));
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( ( ds & dspec_auto ) && !is_anon_exp ( a ) ) {
+		if ((ds & dspec_auto) && !is_anon_exp(a)) {
-	    n = unit_no ( bs, id, VAR_tag, 0 ) ;
+			n = unit_no(bs, id, VAR_tag, 0);
+			if (seq) {
-	    if ( seq ) ENC_SEQUENCE ( bs, seq ) ;
+				ENC_SEQUENCE(bs, seq);
+			}
-	    *pn = n ;
+			*pn = n;
-	    return ( bs ) ;
+			return (bs);
-	}
+		}
-    }
+	}
-    /* Declare new identity */
+	/* Declare new identity */
-    n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+	n = unit_no(bs, NULL_id, VAR_tag, 1);
-    ENC_identify ( bs ) ;
+	ENC_identify(bs);
-    bs = enc_access ( bs, crt_func_access ) ;
+	bs = enc_access(bs, crt_func_access);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    if ( cnt ) {
+	if (cnt) {
-	bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
-    } else {
+	} else {
-	TYPE t = DEREF_type ( exp_type ( a ) ) ;
+		TYPE t = DEREF_type(exp_type(a));
-	bs = enc_addr_exp ( bs, t, a ) ;
+		bs = enc_addr_exp(bs, t, a);
-    }
+	}
+	if (seq) {
-    if ( seq ) ENC_SEQUENCE ( bs, seq ) ;
+		ENC_SEQUENCE(bs, seq);
+	}
-    *pn = n ;
+	*pn = n;
-    return ( bs ) ;
+	return (bs);
 }
 /*
     CREATE A POINTER TO MEMBER FUNCTION TAG
     This routine adds the start of an identity or variable declaration
     for the pointer to member function or similar expression a to the
     bitstream bs.  If var is true then a variable declaration is forced.
     The tag number is returned via pn.
 */
-static BITSTREAM *make_ptr_mem_func
+static BITSTREAM *
-    PROTO_N ( ( bs, a, pn, var ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X ulong *pn X int var )
+make_ptr_mem_func(BITSTREAM *bs, EXP a, ulong *pn, int var)
 {
-    if ( IS_exp_contents ( a ) && !var ) {
+	if (IS_exp_contents(a) && !var) {
-	EXP b = DEREF_exp ( exp_contents_ptr ( a ) ) ;
+		EXP b = DEREF_exp(exp_contents_ptr(a));
-	bs = make_identity ( bs, b, pn, 0, 0 ) ;
+		bs = make_identity(bs, b, pn, 0, 0);
-    } else {
+	} else {
-	ulong n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+		ulong n = unit_no(bs, NULL_id, VAR_tag, 1);
-	ENC_variable ( bs ) ;
+		ENC_variable(bs);
-	bs = enc_access ( bs, crt_func_access ) ;
+		bs = enc_access(bs, crt_func_access);
-	ENC_make_tag ( bs, n ) ;
+		ENC_make_tag(bs, n);
-	bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
-	*pn = n ;
+		*pn = n;
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE AN ASSIGNMENT OPERATOR
     This routine encodes an assignment operator for an expression of
     type t.  bf is set to true for bitfields.
 */
-BITSTREAM *enc_assign_op
+BITSTREAM *
-    PROTO_N ( ( bs, t, bf ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int *bf )
+enc_assign_op(BITSTREAM *bs, TYPE t, int *bf)
+{
-    CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC cv = DEREF_cv(type_qual(t));
-    if ( IS_type_bitfield ( t ) ) {
+	if (IS_type_bitfield(t)) {
-	if ( cv & cv_volatile ) {
+		if (cv & cv_volatile) {
-	    ENC_bitfield_assign_with_mode ( bs ) ;
+			ENC_bitfield_assign_with_mode(bs);
-	    ENC_volatile ( bs ) ;
+			ENC_volatile(bs);
+		} else {
+			ENC_bitfield_assign(bs);
+		}
+		*bf = 1;
 	} else {
+		if (cv & cv_volatile) {
+			ENC_assign_with_mode(bs);
+			ENC_volatile(bs);
+		} else {
-	    ENC_bitfield_assign ( bs ) ;
+			ENC_assign(bs);
+		}
+	}
-	*bf = 1 ;
-    } else {
-	if ( cv & cv_volatile ) {
-	    ENC_assign_with_mode ( bs ) ;
-	    ENC_volatile ( bs ) ;
-	} else {
-	    ENC_assign ( bs ) ;
-	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE THE ADDRESS OF A TDF EXPRESSION
     This routine adds the address of the expression e to the bitstream
     bs as a TDF EXP.
     ENCODE A CONTENTS OPERATOR
     This routine encodes a contents operator for an expression of type t.
     bf is set to true for bitfields.
 */
-BITSTREAM *enc_cont_op
+BITSTREAM *
-    PROTO_N ( ( bs, t, bf ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int *bf )
+enc_cont_op(BITSTREAM *bs, TYPE t, int *bf)
 {
-    CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC cv = DEREF_cv(type_qual(t));
-    if ( IS_type_bitfield ( t ) ) {
+	if (IS_type_bitfield(t)) {
-	if ( cv & cv_volatile ) {
+		if (cv & cv_volatile) {
-	    ENC_bitfield_contents_with_mode ( bs ) ;
+			ENC_bitfield_contents_with_mode(bs);
-	    ENC_volatile ( bs ) ;
+			ENC_volatile(bs);
-	} else {
+		} else {
-	    ENC_bitfield_contents ( bs ) ;
+			ENC_bitfield_contents(bs);
-	}
+		}
-	*bf = 1 ;
+		*bf = 1;
-    } else {
+	} else {
-	if ( cv & cv_volatile ) {
+		if (cv & cv_volatile) {
-	    ENC_contents_with_mode ( bs ) ;
+			ENC_contents_with_mode(bs);
-	    ENC_volatile ( bs ) ;
+			ENC_volatile(bs);
-	} else {
+		} else {
-	    ENC_contents ( bs ) ;
+			ENC_contents(bs);
+		}
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE THE CONTENTS OF A TDF EXPRESSION
     This routine adds the contents of the expression e of type t to the
     bitstream bs as a TDF EXP.
+	}
+	/* Encode a contents expression */
+	bs = enc_cont_op(bs, s, &bf);
+	if (bf) {
+		if (IS_NULL_off(off)) {
+			/* Find bitfield offset */
+			off = decons_bitf_exp(&e);
+		}
-	bs = enc_bfvar ( bs, t ) ;
+		bs = enc_bfvar(bs, t);
-	if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-	    bs = enc_addr_exp ( bs, t, e ) ;
+			bs = enc_addr_exp(bs, t, e);
+		} else {
+			ENC_obtain_tag(bs);
+			ENC_make_tag(bs, n);
+		}
+		bs = enc_offset(bs, off);
 	} else {
+		bs = enc_shape(bs, t);
+		if (n == LINK_NONE) {
+			bs = enc_exp(bs, e);
+		} else {
-	    ENC_obtain_tag ( bs ) ;
+			ENC_obtain_tag(bs);
-	    ENC_make_tag ( bs, n ) ;
+			ENC_make_tag(bs, n);
+		}
+	}
-	bs = enc_offset ( bs, off ) ;
-    } else {
-	bs = enc_shape ( bs, t ) ;
-	if ( n == LINK_NONE ) {
-	    bs = enc_exp ( bs, e ) ;
-	} else {
-	    ENC_obtain_tag ( bs ) ;
-	    ENC_make_tag ( bs, n ) ;
-	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LIST OF TDF EXPS
     This routines adds the expressions p to the bitstream bs as a list
     of TDF EXPs.
 */
-BITSTREAM *enc_exp_list
+BITSTREAM *
-    PROTO_N ( ( bs, p ) )
-    PROTO_T ( BITSTREAM *bs X LIST ( EXP ) p )
+enc_exp_list(BITSTREAM *bs, LIST(EXP)p)
+{
-    unsigned n = LENGTH_list ( p ) ;
+	unsigned n = LENGTH_list(p);
-    ENC_LIST ( bs, n ) ;
+	ENC_LIST(bs, n);
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	EXP e = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP e = DEREF_exp(HEAD_list(p));
-	bs = enc_exp ( bs, e ) ;
+		bs = enc_exp(bs, e);
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A TDF NTEST
     This routine adds the comparison operator tst to the bitstream bs as
     a TDF NTEST.  The macro ENC_NTEST exploits the correlation between
     the internal representation of NTESTs and the TDF encoding.
 */
-BITSTREAM *enc_ntest
+BITSTREAM *
-    PROTO_N ( ( bs, tst ) )
-    PROTO_T ( BITSTREAM *bs X NTEST tst )
+enc_ntest(BITSTREAM *bs, NTEST tst)
+{
-    ENC_NTEST ( bs, tst ) ;
+	ENC_NTEST(bs, tst);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A COMPARISON
     This routine adds a comparison expression to the bitstream bs for
     comparing a with b using test tst.  lab gives the destination label
     number.
 */
-BITSTREAM *enc_compare
+BITSTREAM *
-    PROTO_N ( ( bs, a, b, tst, lab, nlab ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X EXP b X NTEST tst X
+enc_compare(BITSTREAM *bs, EXP a, EXP b, NTEST tst, ulong lab, ulong nlab)
-	      ulong lab X ulong nlab )
+{
     SIMPLIFY A CONDITION
     This routine simplifies the condition e by removing any double
     negations.  sw is set to 1 if the result has the form 'a || b' or
     '!( a && b )'.
 */
-EXP simplify_cond
+EXP
-    PROTO_N ( ( e, sw ) )
-    PROTO_T ( EXP e X int *sw )
+simplify_cond(EXP e, int *sw)
 {
-    EXP a = e ;
+	EXP a = e;
-    unsigned tag = TAG_exp ( a ) ;
+	unsigned tag = TAG_exp(a);
-    if ( tag == exp_location_tag ) {
+	if (tag == exp_location_tag) {
-	/* Can have location markers */
+		/* Can have location markers */
-	EXP b ;
+		EXP b;
-	a = DEREF_exp ( exp_location_arg ( e ) ) ;
+		a = DEREF_exp(exp_location_arg(e));
-	b = simplify_cond ( a, sw ) ;
+		b = simplify_cond(a, sw);
-	if ( !EQ_exp ( b, a ) ) {
+		if (!EQ_exp(b, a)) {
-	    LOCATION loc ;
+			LOCATION loc;
-	    TYPE t = DEREF_type ( exp_type ( e ) ) ;
+			TYPE t = DEREF_type(exp_type(e));
-	    DEREF_loc ( exp_location_end ( e ), loc ) ;
+			DEREF_loc(exp_location_end(e), loc);
-	    MAKE_exp_location ( t, loc, b, e ) ;
+			MAKE_exp_location(t, loc, b, e);
-	}
+		}
-	return ( e ) ;
+		return (e);
-    }
+	}
-    while ( tag == exp_not_tag ) {
+	while (tag == exp_not_tag) {
-	EXP b = DEREF_exp ( exp_not_arg ( a ) ) ;
+		EXP b = DEREF_exp(exp_not_arg(a));
-	tag = TAG_exp ( b ) ;
+		tag = TAG_exp(b);
-	if ( tag != exp_not_tag ) {
+		if (tag != exp_not_tag) {
-	    if ( tag == exp_log_and_tag ) *sw = 1 ;
+			if (tag == exp_log_and_tag) {
+				*sw = 1;
+			}
-	    return ( a ) ;
+			return (a);
-	}
+		}
-	a = DEREF_exp ( exp_not_arg ( b ) ) ;
+		a = DEREF_exp(exp_not_arg(b));
-	tag = TAG_exp ( a ) ;
+		tag = TAG_exp(a);
-    }
+	}
-    if ( tag == exp_log_or_tag ) *sw = 1 ;
+	if (tag == exp_log_or_tag) {
+		*sw = 1;
+	}
-    return ( a ) ;
+	return (a);
 }
 /*
     ENCODE A CONDITION
     This routine adds the expression e as a conditional jump to the label
     lab if true or label nlab if false to the bitstream bs.  Either label
     may be LINK_NONE.
 */
-BITSTREAM *enc_condition
+BITSTREAM *
-    PROTO_N ( ( bs, e, lab, nlab ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X ulong lab X ulong nlab )
+enc_condition(BITSTREAM *bs, EXP e, ulong lab, ulong nlab)
 {
-    switch ( TAG_exp ( e ) ) {
+	switch (TAG_exp(e)) {
-	case exp_int_lit_tag : {
+	case exp_int_lit_tag: {
-	    /* Constant conditions */
+		/* Constant conditions */
-	    NAT n = DEREF_nat ( exp_int_lit_nat ( e ) ) ;
+		NAT n = DEREF_nat(exp_int_lit_nat(e));
-	    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 == BOOL_FALSE ) nlab = lab ;
+			if (v == BOOL_FALSE) {
+				nlab = lab;
+			}
-		if ( nlab == LINK_NONE ) {
+			if (nlab == LINK_NONE) {
-		    ENC_make_top ( bs ) ;
+				ENC_make_top(bs);
-		} else {
+			} else {
-		    ENC_goto ( bs ) ;
+				ENC_goto(bs);
-		    ENC_make_label ( bs, nlab ) ;
+				ENC_make_label(bs, nlab);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    if ( IS_nat_calc ( n ) ) {
+		if (IS_nat_calc(n)) {
-		EXP a = DEREF_exp ( nat_calc_value ( n ) ) ;
+			EXP a = DEREF_exp(nat_calc_value(n));
-		bs = enc_condition ( bs, a, lab, nlab ) ;
+			bs = enc_condition(bs, a, lab, nlab);
-		break ;
+			break;
-	    }
+		}
-	    goto default_lab ;
+		goto default_lab;
 	}
-	case exp_not_tag : {
+	case exp_not_tag: {
-	    /* Negated conditions */
+		/* Negated conditions */
-	    EXP a = DEREF_exp ( exp_not_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_not_arg(e));
-	    bs = enc_condition ( bs, a, nlab, lab ) ;
+		bs = enc_condition(bs, a, nlab, lab);
-	    break ;
+		break;
 	}
-	case exp_log_and_tag : {
+	case exp_log_and_tag: {
-	    /* Logical and conditions */
+		/* Logical and conditions */
-	    EXP a = DEREF_exp ( exp_log_and_arg1 ( e ) ) ;
+		EXP a = DEREF_exp(exp_log_and_arg1(e));
-	    EXP b = DEREF_exp ( exp_log_and_arg2 ( e ) ) ;
+		EXP b = DEREF_exp(exp_log_and_arg2(e));
-	    if ( lab == LINK_NONE ) {
+		if (lab == LINK_NONE) {
-		/* '!( a && b )' equals '!a || !b' */
+			/* '!( a && b )' equals '!a || !b' */
-		ulong mlab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+			ulong mlab = unit_no(bs, NULL_id, VAR_label, 1);
-		ENC_conditional ( bs ) ;
+			ENC_conditional(bs);
-		ENC_make_label ( bs, mlab ) ;
+			ENC_make_label(bs, mlab);
-		ENC_SEQ_SMALL ( bs, 1 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-		bs = enc_condition ( bs, a, mlab, LINK_NONE ) ;
+			bs = enc_condition(bs, a, mlab, LINK_NONE);
-		bs = enc_condition ( bs, b, LINK_NONE, nlab ) ;
+			bs = enc_condition(bs, b, LINK_NONE, nlab);
-		ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
-	    } else {
+		} else {
-		/* Encode 'a && b' */
+			/* Encode 'a && b' */
-		ENC_SEQ_SMALL ( bs, 1 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-		bs = enc_condition ( bs, a, lab, nlab ) ;
+			bs = enc_condition(bs, a, lab, nlab);
-		bs = enc_condition ( bs, b, lab, nlab ) ;
+			bs = enc_condition(bs, b, lab, nlab);
-	    }
+		}
-	    break ;
+		break;
+	}
-	case exp_log_or_tag : {
+	case exp_log_or_tag: {
-	    /* Logical or conditions */
+		/* Logical or conditions */
-	    EXP a = DEREF_exp ( exp_log_or_arg1 ( e ) ) ;
+		EXP a = DEREF_exp(exp_log_or_arg1(e));
-	    EXP b = DEREF_exp ( exp_log_or_arg2 ( e ) ) ;
+		EXP b = DEREF_exp(exp_log_or_arg2(e));
-	    if ( nlab == LINK_NONE ) {
+		if (nlab == LINK_NONE) {
-		/* Encode 'a || b' */
+			/* Encode 'a || b' */
-		ulong mlab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+			ulong mlab = unit_no(bs, NULL_id, VAR_label, 1);
-		ENC_conditional ( bs ) ;
+			ENC_conditional(bs);
-		ENC_make_label ( bs, mlab ) ;
+			ENC_make_label(bs, mlab);
-		ENC_SEQ_SMALL ( bs, 1 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-		bs = enc_condition ( bs, a, LINK_NONE, mlab ) ;
+			bs = enc_condition(bs, a, LINK_NONE, mlab);
-		bs = enc_condition ( bs, b, lab, LINK_NONE ) ;
+			bs = enc_condition(bs, b, lab, LINK_NONE);
-		ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
-	    } else {
+		} else {
-		/* '!( a || b )' equals '!a && !b' */
+			/* '!( a || b )' equals '!a && !b' */
-		ENC_SEQ_SMALL ( bs, 1 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-		bs = enc_condition ( bs, a, lab, nlab ) ;
+			bs = enc_condition(bs, a, lab, nlab);
-		bs = enc_condition ( bs, b, lab, nlab ) ;
+			bs = enc_condition(bs, b, lab, nlab);
-	    }
+		}
-	    break ;
+		break;
 	}
-	case exp_test_tag : {
+	case exp_test_tag: {
-	    /* Test conditions */
+		/* Test conditions */
-	    NTEST tst = DEREF_ntest ( exp_test_tst ( e ) ) ;
+		NTEST tst = DEREF_ntest(exp_test_tst(e));
-	    EXP a = DEREF_exp ( exp_test_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_test_arg(e));
-	    bs = enc_compare ( bs, a, NULL_exp, tst, lab, nlab ) ;
+		bs = enc_compare(bs, a, NULL_exp, tst, lab, nlab);
-	    break ;
+		break;
 	}
-	case exp_compare_tag : {
+	case exp_compare_tag: {
-	    /* Comparison conditions */
+		/* Comparison conditions */
-	    NTEST tst = DEREF_ntest ( exp_compare_tst ( e ) ) ;
+		NTEST tst = DEREF_ntest(exp_compare_tst(e));
-	    EXP a = DEREF_exp ( exp_compare_arg1 ( e ) ) ;
+		EXP a = DEREF_exp(exp_compare_arg1(e));
-	    EXP b = DEREF_exp ( exp_compare_arg2 ( e ) ) ;
+		EXP b = DEREF_exp(exp_compare_arg2(e));
-	    bs = enc_compare ( bs, a, b, tst, lab, nlab ) ;
+		bs = enc_compare(bs, a, b, tst, lab, nlab);
-	    break ;
+		break;
 	}
-	case exp_comma_tag : {
+	case exp_comma_tag: {
-	    /* Comma conditions */
+		/* Comma conditions */
-	    EXP a ;
+		EXP a;
-	    LIST ( EXP ) p = DEREF_list ( exp_comma_args ( e ) ) ;
+		LIST(EXP)p = DEREF_list(exp_comma_args(e));
-	    bs = enc_stmt_exp ( bs, e, type_void, -1 ) ;
+		bs = enc_stmt_exp(bs, e, type_void, -1);
-	    p = END_list ( p ) ;
+		p = END_list(p);
-	    a = DEREF_exp ( HEAD_list ( p ) ) ;
+		a = DEREF_exp(HEAD_list(p));
-	    bs = enc_condition ( bs, a, lab, nlab ) ;
+		bs = enc_condition(bs, a, lab, nlab);
-	    break ;
+		break;
 	}
-	case exp_location_tag : {
+	case exp_location_tag: {
-	    /* Location marker */
+		/* Location marker */
-	    PTR ( LOCATION ) loc = crt_enc_loc ;
+		PTR(LOCATION)loc = crt_enc_loc;
-	    EXP a = DEREF_exp ( exp_location_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_location_arg(e));
-            BITSTREAM *ts = enc_diag_begin ( &bs ) ;
+		BITSTREAM *ts = enc_diag_begin(&bs);
-	    ts = enc_condition ( ts, a, lab, nlab ) ;
+		ts = enc_condition(ts, a, lab, nlab);
-            crt_enc_loc = exp_location_end ( e ) ;
+		crt_enc_loc = exp_location_end(e);
-            bs = enc_diag_end ( bs, ts, a, 2 ) ;
+		bs = enc_diag_end(bs, ts, a, 2);
-            crt_enc_loc = loc ;
+		crt_enc_loc = loc;
-	    break ;
+		break;
 	}
-	default :
+	default:
-	default_lab : {
+default_lab: {
-	    /* Other conditions */
+		     /* Other conditions */
-	    NTEST tst = ntest_not_eq ;
+		     NTEST tst = ntest_not_eq;
-	    bs = enc_compare ( bs, e, NULL_exp, tst, lab, nlab ) ;
+		     bs = enc_compare(bs, e, NULL_exp, tst, lab, nlab);
-	    break ;
+		     break;
-	}
+	     }
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A LOGICAL EXPRESSION
     This routine adds the logical expression e of type t to the bitstream
     bs.  The code added is equivalent to '( e ? 1 : 0 )'.
 */
-static BITSTREAM *enc_logical
+static BITSTREAM *
-    PROTO_N ( ( bs, e, t ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X TYPE t )
+enc_logical(BITSTREAM *bs, EXP e, TYPE t)
+{
-    int sw = 0 ;
+	int sw = 0;
-    ulong nlab = LINK_NONE ;
+	ulong nlab = LINK_NONE;
-    ulong n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+	ulong n = unit_no(bs, NULL_id, VAR_tag, 1);
-    ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+	ulong lab = unit_no(bs, NULL_id, VAR_label, 1);
-    e = simplify_cond ( e, &sw ) ;
+	e = simplify_cond(e, &sw);
-    /* Introduce variable for boolean value */
-    ENC_variable ( bs ) ;
-    bs = enc_access ( bs, dspec_none ) ;
-    ENC_make_tag ( bs, n ) ;
-    bs = enc_make_int ( bs, t, sw ) ;
-    ENC_SEQ_SMALL ( bs, 1 ) ;
-    ENC_conditional ( bs ) ;
-    ENC_make_label ( bs, lab ) ;
-    ENC_SEQ_SMALL ( bs, 1 ) ;
-    /* Conditionally assign to boolean variable */
-    if ( sw ) {
-	nlab = lab ;
-	lab = LINK_NONE ;
-    }
-    bs = enc_condition ( bs, e, lab, nlab ) ;
-    ENC_assign ( bs ) ;
-    ENC_obtain_tag ( bs ) ;
-    ENC_make_tag ( bs, n ) ;
-    bs = enc_make_int ( bs, t, !sw ) ;
-    ENC_make_top ( bs ) ;
+	/* Introduce variable for boolean value */
+	ENC_variable(bs);
+	bs = enc_access(bs, dspec_none);
+	ENC_make_tag(bs, n);
+	bs = enc_make_int(bs, t, sw);
+	ENC_SEQ_SMALL(bs, 1);
+	ENC_conditional(bs);
+	ENC_make_label(bs, lab);
+	ENC_SEQ_SMALL(bs, 1);
+	/* Conditionally assign to boolean variable */
+	if (sw) {
+		nlab = lab;
+		lab = LINK_NONE;
+	}
+	bs = enc_condition(bs, e, lab, nlab);
+	ENC_assign(bs);
+	ENC_obtain_tag(bs);
+	ENC_make_tag(bs, n);
+	bs = enc_make_int(bs, t, !sw);
+	ENC_make_top(bs);
-    /* Return the contents of the boolean */
+	/* Return the contents of the boolean */
-    ENC_contents ( bs ) ;
+	ENC_contents(bs);
-    bs = enc_shape ( bs, t ) ;
+	bs = enc_shape(bs, t);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    return ( bs ) ;
+	return (bs);
 }
 /*
     CHECK FOR CONSTANT POINTER TO MEMBERS
     This routine checks whether the expression e consists of a cast of the
     address of a member of some class.  If so it returns the corresponding
     member identifier.
 */
-static IDENTIFIER is_const_ptr_mem
+static IDENTIFIER
-    PROTO_N ( ( e, rev ) )
-    PROTO_T ( EXP e X int rev )
+is_const_ptr_mem(EXP e, int rev)
 {
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	unsigned tag = TAG_exp ( e ) ;
+		unsigned tag = TAG_exp(e);
-	if ( tag == exp_address_mem_tag ) {
+		if (tag == exp_address_mem_tag) {
-	    /* Allow for addresses of members */
+			/* Allow for addresses of members */
-	    EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
+			EXP a = DEREF_exp(exp_address_mem_arg(e));
-	    IDENTIFIER id = DEREF_id ( exp_member_id ( a ) ) ;
+			IDENTIFIER id = DEREF_id(exp_member_id(a));
-	    return ( id ) ;
+			return (id);
-	} else if ( tag == exp_base_cast_tag ) {
+		} else if (tag == exp_base_cast_tag) {
-	    /* Allow for base casts */
+			/* Allow for base casts */
-	    EXP a = DEREF_exp ( exp_base_cast_arg ( e ) ) ;
+			EXP a = DEREF_exp(exp_base_cast_arg(e));
-	    unsigned conv = DEREF_unsigned ( exp_base_cast_conv ( e ) ) ;
+			unsigned conv = DEREF_unsigned(exp_base_cast_conv(e));
-	    if ( rev || !( conv & CONV_REVERSE ) ) {
+			if (rev || !(conv & CONV_REVERSE)) {
-		IDENTIFIER id = is_const_ptr_mem ( a, rev ) ;
+				IDENTIFIER id = is_const_ptr_mem(a, rev);
-		return ( id ) ;
+				return (id);
-	    }
+			}
-	} else if ( tag == exp_dummy_tag ) {
+		} else if (tag == exp_dummy_tag) {
-	    /* Allow for dummy expressions */
+			/* Allow for dummy expressions */
-	    EXP a = DEREF_exp ( exp_dummy_value ( e ) ) ;
+			EXP a = DEREF_exp(exp_dummy_value(e));
-	    IDENTIFIER id = is_const_ptr_mem ( a, rev ) ;
+			IDENTIFIER id = is_const_ptr_mem(a, rev);
-	    return ( id ) ;
+			return (id);
-	}
+		}
-    }
+	}
-    return ( NULL_id ) ;
+	return (NULL_id);
 }
 /*
     ENCODE A POINTER TO MEMBER
     This routine adds the address of the member id plus the base class
     offset gr, converted to type t, to the bitstream bs.
 */
-static BITSTREAM *enc_ptr_mem
+static BITSTREAM *
-    PROTO_N ( ( bs, t, id, gr ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X IDENTIFIER id X GRAPH gr )
+enc_ptr_mem(BITSTREAM *bs, TYPE t, IDENTIFIER id, GRAPH gr)
 {
-    BITSTREAM *ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+	BITSTREAM *ts = start_bitstream(NIL(FILE), bs->link);
-    if ( IS_id_mem_func ( id ) ) {
+	if (IS_id_mem_func(id)) {
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
-	ASSERT ( !( ds & dspec_inherit ) ) ;
+		ASSERT(!(ds & dspec_inherit));
-	if ( ds & dspec_virtual ) {
+		if (ds & dspec_virtual) {
-	    /* Virtual member function */
+			/* Virtual member function */
-	    ulong m ;
+			ulong m;
-	    ulong tok ;
+			ulong tok;
-	    VIRTUAL vt ;
+			VIRTUAL vt;
-	    OFFSET off ;
+			OFFSET off;
-	    IGNORE compile_class ( ct ) ;
+			IGNORE compile_class(ct);
-	    vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+			vt = DEREF_virt(ctype_virt(ct));
-	    off = DEREF_off ( virt_table_off ( vt ) ) ;
+			off = DEREF_off(virt_table_off(vt));
-	    tok = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+			tok = DEREF_ulong(virt_table_tok(vt));
-	    if ( !IS_NULL_graph ( gr ) ) {
+			if (!IS_NULL_graph(gr)) {
-		/* Allow for overriding virtual functions */
+				/* Allow for overriding virtual functions */
-		GRAPH gs = NULL_graph ;
+				GRAPH gs = NULL_graph;
-		VIRTUAL at = find_overrider ( ct, id, gr, &gs ) ;
+				VIRTUAL at = find_overrider(ct, id, gr, &gs);
-		if ( !IS_NULL_virt ( at ) ) {
+				if (!IS_NULL_virt(at)) {
-		    id = DEREF_id ( virt_func ( at ) ) ;
+					id = DEREF_id(virt_func(at));
-		}
+				}
-	    }
+			}
-	    m = virtual_no ( id, vt ) ;
+			m = virtual_no(id, vt);
-	    bs = enc_special ( bs, TOK_pmf_vmake ) ;
+			bs = enc_special(bs, TOK_pmf_vmake);
-	    ts = enc_make_snat ( ts, ( int ) m ) ;
+			ts = enc_make_snat(ts,(int)m);
-	    if ( !is_zero_offset ( off ) ) {
+			if (!is_zero_offset(off)) {
-		ENC_offset_add ( ts ) ;
+				ENC_offset_add(ts);
-		ts = enc_offset ( ts, off ) ;
+				ts = enc_offset(ts, off);
-	    }
+			}
-	    tok = link_no ( ts, tok, VAR_token ) ;
+			tok = link_no(ts, tok, VAR_token);
-	    ENC_exp_apply_token ( ts ) ;
+			ENC_exp_apply_token(ts);
-	    ENC_make_tok ( ts, tok ) ;
+			ENC_make_tok(ts, tok);
-	    ENC_LEN_SMALL ( ts, 0 ) ;
+			ENC_LEN_SMALL(ts, 0);
+			ENC_offset_zero(ts);
+			ts = enc_al_ctype(ts, ct);
+			ENC_offset_zero(ts);
+			ts = enc_al_ctype(ts, ct);
+		} else {
+			/* Member function */
+			bs = enc_special(bs, TOK_pmf_make);
+			ts = enc_member(ts, id);
+			if (IS_NULL_graph(gr)) {
-	    ENC_offset_zero ( ts ) ;
+				ENC_offset_zero(ts);
-	    ts = enc_al_ctype ( ts, ct ) ;
+				ts = enc_al_ctype(ts, ct);
+			} else {
+				ts = enc_base(ts, gr, 0);
+			}
-	    ENC_offset_zero ( ts ) ;
+			ENC_offset_zero(ts);
-	    ts = enc_al_ctype ( ts, ct ) ;
+			ts = enc_al_ctype(ts, ct);
+		}
 	} else {
-	    /* Member function */
+		/* Data member */
-	    bs = enc_special ( bs, TOK_pmf_make ) ;
+		bs = enc_special(bs, TOK_pm_make);
-	    ts = enc_member ( ts, id ) ;
-	    if ( IS_NULL_graph ( gr ) ) {
+		if (!IS_NULL_graph(gr)) {
-		ENC_offset_zero ( ts ) ;
+			DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-		ts = enc_al_ctype ( ts, ct ) ;
+			if (!(acc & dspec_ignore)) {
-	    } else {
+				ENC_offset_add(ts);
-		ts = enc_base ( ts, gr, 0 ) ;
+				ts = enc_base(ts, gr, 0);
-	    }
+			}
-	    ENC_offset_zero ( ts ) ;
+		}
-	    ts = enc_al_ctype ( ts, ct ) ;
+		ts = enc_member(ts, id);
+	}
-    } else {
-	/* Data member */
-	bs = enc_special ( bs, TOK_pm_make ) ;
-	if ( !IS_NULL_graph ( gr ) ) {
-	    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
-	    if ( !( acc & dspec_ignore ) ) {
-		ENC_offset_add ( ts ) ;
-		ts = enc_base ( ts, gr, 0 ) ;
-	    }
-	}
-	ts = enc_member ( ts, id ) ;
-    }
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A CAST EXPRESSION
     This routine adds a TDF EXP to the bitstream bs representing a cast
     of the expression e to the type t.  conv represents the conversion
     type (see cast.c).
 */
-static BITSTREAM *enc_cast_exp
+static BITSTREAM *
-    PROTO_N ( ( bs, t, e, conv ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X EXP e X unsigned conv )
+enc_cast_exp(BITSTREAM *bs, TYPE t, EXP e, unsigned conv)
+{
-    BITSTREAM *ts ;
+	BITSTREAM *ts;
-    switch ( conv ) {
+	switch (conv) {
-	case CONV_EXACT :
+	case CONV_EXACT:
-	case CONV_FUNC :
+	case CONV_FUNC:
-	case CONV_STRING :
+	case CONV_STRING:
-	case CONV_PTR_PTR_ALIGN :
+	case CONV_PTR_PTR_ALIGN:
-	case CONV_PTR_MEM_PTR_MEM : {
+	case CONV_PTR_MEM_PTR_MEM: {
-	    /* Trivial conversions */
+		/* Trivial conversions */
-	    bs = enc_exp ( bs, e ) ;
+		bs = enc_exp(bs, e);
-	    break ;
+		break;
 	}
-	case CONV_QUAL : {
+	case CONV_QUAL: {
-	    /* Qualification conversions */
+		/* Qualification conversions */
-	    if ( IS_exp_address ( e ) ) {
+		if (IS_exp_address(e)) {
-		EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
+			EXP a = DEREF_exp(exp_address_arg(e));
-		bs = enc_addr_exp ( bs, t, a ) ;
+			bs = enc_addr_exp(bs, t, a);
-	    } else {
+		} else {
-		bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-	    }
+		}
-	    break ;
+		break;
 	}
-	case CONV_ELLIPSIS : {
+	case CONV_ELLIPSIS: {
-	    /* Discarded expression */
+		/* Discarded expression */
-	    if ( overflow_exp ( e ) ) {
+		if (overflow_exp(e)) {
-		bs = enc_stmt_exp ( bs, e, t, 0 ) ;
+			bs = enc_stmt_exp(bs, e, t, 0);
-	    } else {
+		} else {
-		bs = enc_null_exp ( bs, t ) ;
+			bs = enc_null_exp(bs, t);
-	    }
-	    break ;
-	}
-	case CONV_INT_INT :
-	case CONV_ENUM : {
-	    /* Integer to integer conversion */
-	    TYPE u = DEREF_type ( exp_type ( e ) ) ;
-	    switch ( TAG_exp ( e ) ) {
-		case exp_char_lit_tag : {
-		    STRING s = DEREF_str ( exp_char_lit_str ( e ) ) ;
-		    bs = enc_char ( bs, s, t, u ) ;
-		    break ;
 		}
-		case exp_cast_tag : {
-		    conv = DEREF_unsigned ( exp_cast_conv ( e ) ) ;
-		    if ( conv == CONV_BITFIELD ) {
-			/* Elide following bitfield conversion */
-			e = DEREF_exp ( exp_cast_arg ( e ) ) ;
-			ENC_change_bitfield_to_int ( bs ) ;
-			bs = enc_variety ( bs, t ) ;
-			bs = enc_exp ( bs, e ) ;
-			break ;
+		break;
-		    }
-		    goto int_int_label ;
-		}
-		case exp_not_tag :
-		case exp_log_and_tag :
-		case exp_log_or_tag :
-		case exp_test_tag :
-		case exp_compare_tag : {
-		    /* Logical expressions */
-		    bs = enc_logical ( bs, e, t ) ;
-		    break ;
-		}
-		default :
-		int_int_label : {
-		    if ( !eq_type_rep ( u, t, 0 ) ) {
-			ENC_change_variety ( bs ) ;
-			bs = enc_error_treatment ( bs, t ) ;
-			bs = enc_variety ( bs, t ) ;
-		    }
-		    bs = enc_exp ( bs, e ) ;
-		    break ;
-		}
-	    }
-	    break ;
-	}
-	case CONV_BITFIELD : {
-	    /* Bitfield to integer conversion */
-	    ENC_change_bitfield_to_int ( bs ) ;
-	    bs = enc_variety ( bs, t ) ;
-	    bs = enc_exp ( bs, e ) ;
-	    break ;
-	}
-	case CONV_BITFIELD | CONV_REVERSE : {
-	    /* Integer to bitfield conversion */
-	    if ( IS_exp_cast ( e ) ) {
-		conv = DEREF_unsigned ( exp_cast_conv ( e ) ) ;
-		if ( conv == CONV_INT_INT ) {
-		    /* Elide following integer conversion */
-		    e = DEREF_exp ( exp_cast_arg ( e ) ) ;
-		}
-	    }
-	    ENC_change_int_to_bitfield ( bs ) ;
-	    bs = enc_bfvar ( bs, t ) ;
-	    bs = enc_exp ( bs, e ) ;
-	    break ;
-	}
-	case CONV_INT_FLT : {
-	    /* Integer to float conversion */
-	    if ( IS_exp_int_lit ( e ) ) {
-		NAT n = DEREF_nat ( exp_int_lit_nat ( e ) ) ;
-		unsigned long v = get_nat_value ( n ) ;
-		if ( v < SMALL_FLOAT_CONST ) {
-		    /* Small floating point constants */
-		    bs = enc_float_int ( bs, ( int ) v, t ) ;
-		    break ;
-		}
-	    }
-	    ENC_float_int ( bs ) ;
-	    ENC_impossible ( bs ) ;
-	    bs = enc_flvar ( bs, t ) ;
-	    bs = enc_exp ( bs, e ) ;
-	    break ;
-	}
-	case CONV_FLT_INT : {
-	    /* Float to integer conversion */
-	    ENC_round_with_mode ( bs ) ;
-	    ENC_impossible ( bs ) ;
-	    ENC_RMODE ( bs, crt_round_mode ) ;
-	    bs = enc_variety ( bs, t ) ;
-	    bs = enc_exp ( bs, e ) ;
-	    break ;
-	}
-	case CONV_FLT_FLT : {
-	    /* Float to float conversion */
-	    ENC_change_floating_variety ( bs ) ;
-	    ENC_impossible ( bs ) ;
-	    bs = enc_flvar ( bs, t ) ;
-	    bs = enc_exp ( bs, e ) ;
-	    break ;
-	}
-	case CONV_PTR_VOID :
-	case CONV_PTR_VOID | CONV_REVERSE :
-	pointer_void_label : {
-	    /* Object pointer and 'void *' conversions */
-	    if ( conv & CONV_REVERSE ) {
-		bs = enc_special ( bs, TOK_from_ptr_void ) ;
-	    } else {
-		bs = enc_special ( bs, TOK_to_ptr_void ) ;
-		t = DEREF_type ( exp_type ( e ) ) ;
-	    }
-	    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-	    t = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
-	    ts = enc_alignment ( ts, t ) ;
-	    ts = enc_exp ( ts, e ) ;
-	    bs = enc_bitstream ( bs, ts ) ;
-	    break ;
-	}
-	case CONV_PTR_PTR :
-	case CONV_PTR_BASE :
-	case CONV_PTR_PTR | CONV_REVERSE :
-	case CONV_PTR_BASE | CONV_REVERSE : {
-	    /* Pointer to pointer conversion */
-	    TYPE s = DEREF_type ( exp_type ( e ) ) ;
-	    TYPE ps = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
-	    TYPE pt = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
-	    switch ( TAG_type ( pt ) ) {
-		case type_top_tag :
-		case type_bottom_tag : {
-		    switch ( TAG_type ( ps ) ) {
-			case type_top_tag :
-			case type_bottom_tag : {
-			    /* 'void *' to 'void *' */
-			    bs = enc_exp ( bs, e ) ;
-			    break ;
-			}
-			case type_func_tag : {
-			    /* Function to 'void *' */
-			    bs = enc_special ( bs, TOK_f_to_pv ) ;
-			    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-			    ts = enc_exp ( ts, e ) ;
-			    bs = enc_bitstream ( bs, ts ) ;
-			    break ;
-			}
-			default : {
-			    /* Object pointer to 'void *' */
-			    conv = CONV_PTR_VOID ;
-			    goto pointer_void_label ;
-			}
-		    }
-		    break ;
-		}
-		case type_func_tag : {
-		    switch ( TAG_type ( ps ) ) {
-			case type_top_tag :
-			case type_bottom_tag : {
-			    /* 'void *' to function */
-			    bs = enc_special ( bs, TOK_pv_to_f ) ;
-			    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-			    ts = enc_exp ( ts, e ) ;
-			    bs = enc_bitstream ( bs, ts ) ;
-			    break ;
-			}
-			case type_func_tag : {
-			    /* Function to function */
-			    bs = enc_exp ( bs, e ) ;
-			    break ;
-			}
-			default : {
-			    /* Object pointer to function */
-			    BITSTREAM *us ;
-			    bs = enc_special ( bs, TOK_pv_to_f ) ;
-			    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-			    ts = enc_special ( ts, TOK_to_ptr_void ) ;
-			    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
-			    us = enc_alignment ( us, ps ) ;
-			    us = enc_exp ( us, e ) ;
-			    ts = enc_bitstream ( ts, us ) ;
-			    bs = enc_bitstream ( bs, ts ) ;
-			    break ;
-			}
-		    }
-		    break ;
-		}
-		default : {
-		    switch ( TAG_type ( ps ) ) {
-			case type_top_tag :
-			case type_bottom_tag : {
-			    /* 'void *' to object pointer */
-			    conv = ( CONV_PTR_VOID | CONV_REVERSE ) ;
-			    goto pointer_void_label ;
-			}
-			case type_func_tag : {
-			    /* Function to object pointer */
-			    BITSTREAM *us ;
-			    bs = enc_special ( bs, TOK_from_ptr_void ) ;
-			    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-			    ts = enc_alignment ( ts, pt ) ;
-			    ts = enc_special ( ts, TOK_f_to_pv ) ;
-			    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
-			    us = enc_exp ( us, e ) ;
-			    ts = enc_bitstream ( ts, us ) ;
-			    bs = enc_bitstream ( bs, ts ) ;
-			    break ;
-			}
-			default : {
-			    /* Object pointer to object pointer */
-			    if ( conv & CONV_REVERSE ) {
-				/* Force conversion in these cases */
-				/* EMPTY */
-			    } else {
-				if ( eq_type_rep ( ps, pt, 1 ) ) {
-				    bs = enc_exp ( bs, e ) ;
-				    break ;
-				}
-			    }
-			    bs = enc_special ( bs, TOK_ptr_to_ptr ) ;
-			    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-			    ts = enc_alignment ( ts, ps ) ;
-			    ts = enc_alignment ( ts, pt ) ;
-			    ts = enc_exp ( ts, e ) ;
-			    bs = enc_bitstream ( bs, ts ) ;
-			    break ;
-			}
-		    }
-		    break ;
-		}
-	    }
-	    break ;
-	}
-	case CONV_INT_PTR : {
-	    /* Integer to pointer conversion */
-	    TYPE s = DEREF_type ( exp_type ( e ) ) ;
-	    TYPE pt = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
-	    switch ( TAG_type ( pt ) ) {
-		case type_top_tag :
-		case type_bottom_tag : {
-		    /* Integer to 'void *' */
-		    bs = enc_special ( bs, TOK_i_to_pv ) ;
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		    ts = enc_variety ( ts, s ) ;
-		    ts = enc_exp ( ts, e ) ;
-		    bs = enc_bitstream ( bs, ts ) ;
-		    break ;
-		}
-		case type_func_tag : {
-		    /* Integer to function */
-		    BITSTREAM *us ;
-		    bs = enc_special ( bs, TOK_pv_to_f ) ;
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		    ts = enc_special ( ts, TOK_i_to_pv ) ;
-		    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
-		    us = enc_variety ( us, s ) ;
-		    us = enc_exp ( us, e ) ;
-		    ts = enc_bitstream ( ts, us ) ;
-		    bs = enc_bitstream ( bs, ts ) ;
-		    break ;
-		}
-		default : {
-		    /* Integer to object pointer */
-		    bs = enc_special ( bs, TOK_i_to_p ) ;
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		    ts = enc_variety ( ts, s ) ;
-		    ts = enc_alignment ( ts, pt ) ;
-		    ts = enc_exp ( ts, e ) ;
-		    bs = enc_bitstream ( bs, ts ) ;
-		    break ;
-		}
-	    }
-	    break ;
+	}
-	case CONV_PTR_INT : {
+	case CONV_INT_INT:
+	case CONV_ENUM: {
-	    /* Pointer to integer conversion */
+		/* Integer to integer conversion */
-	    TYPE s = DEREF_type ( exp_type ( e ) ) ;
+		TYPE u = DEREF_type(exp_type(e));
+		switch (TAG_exp(e)) {
+		case exp_char_lit_tag: {
-	    TYPE ps = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
+			STRING s = DEREF_str(exp_char_lit_str(e));
-	    switch ( TAG_type ( ps ) ) {
+			bs = enc_char(bs, s, t, u);
-		case type_top_tag :
+			break;
+		}
-		case type_bottom_tag : {
+		case exp_cast_tag: {
+			conv = DEREF_unsigned(exp_cast_conv(e));
-		    /* 'void *' to integer */
+			if (conv == CONV_BITFIELD) {
-		    bs = enc_special ( bs, TOK_pv_to_i ) ;
+				/* Elide following bitfield conversion */
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+				e = DEREF_exp(exp_cast_arg(e));
-		    ts = enc_variety ( ts, t ) ;
+				ENC_change_bitfield_to_int(bs);
-		    ts = enc_exp ( ts, e ) ;
+				bs = enc_variety(bs, t);
-		    bs = enc_bitstream ( bs, ts ) ;
+				bs = enc_exp(bs, e);
-		    break ;
+				break;
+			}
+			goto int_int_label;
+		}
-		case type_func_tag : {
+		case exp_not_tag:
-		    /* Function to integer */
+		case exp_log_and_tag:
-		    BITSTREAM *us ;
+		case exp_log_or_tag:
-		    bs = enc_special ( bs, TOK_pv_to_i ) ;
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		    ts = enc_variety ( ts, t ) ;
+		case exp_test_tag:
-		    ts = enc_special ( ts, TOK_f_to_pv ) ;
-		    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
-		    us = enc_exp ( us, e ) ;
+		case exp_compare_tag: {
-		    ts = enc_bitstream ( ts, us ) ;
+			/* Logical expressions */
-		    bs = enc_bitstream ( bs, ts ) ;
+			bs = enc_logical(bs, e, t);
-		    break ;
+			break;
 		}
-		default : {
+		default :
-		    /* Object pointer to integer */
+int_int_label: {
-		    bs = enc_special ( bs, TOK_p_to_i ) ;
+		       if (!eq_type_rep(u, t, 0)) {
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+			       ENC_change_variety(bs);
-		    ts = enc_alignment ( ts, ps ) ;
+			       bs = enc_error_treatment(bs, t);
-		    ts = enc_variety ( ts, t ) ;
+			       bs = enc_variety(bs, t);
+		       }
-		    ts = enc_exp ( ts, e ) ;
+		       bs = enc_exp(bs, e);
-		    bs = enc_bitstream ( bs, ts ) ;
+		       break;
-		    break ;
+	       }
+		}
-	    }
-	    break ;
+		break;
 	}
-	case CONV_NULL : {
+	case CONV_BITFIELD: {
-	    /* Null pointer conversion */
+		/* Bitfield to integer conversion */
+		ENC_change_bitfield_to_int(bs);
+		bs = enc_variety(bs, t);
+		bs = enc_exp(bs, e);
+		break;
+	}
+	case CONV_BITFIELD | CONV_REVERSE: {
+		/* Integer to bitfield conversion */
+		if (IS_exp_cast(e)) {
+			conv = DEREF_unsigned(exp_cast_conv(e));
+			if (conv == CONV_INT_INT) {
+				/* Elide following integer conversion */
+				e = DEREF_exp(exp_cast_arg(e));
+			}
+		}
+		ENC_change_int_to_bitfield(bs);
+		bs = enc_bfvar(bs, t);
-	    bs = enc_null_exp ( bs, t ) ;
+		bs = enc_exp(bs, e);
+		break;
+	}
+	case CONV_INT_FLT: {
+		/* Integer to float conversion */
+		if (IS_exp_int_lit(e)) {
+			NAT n = DEREF_nat(exp_int_lit_nat(e));
+			unsigned long v = get_nat_value(n);
+			if (v < SMALL_FLOAT_CONST) {
+				/* Small floating point constants */
+				bs = enc_float_int(bs,(int)v, t);
-	    break ;
+				break;
+			}
+		}
+		ENC_float_int(bs);
+		ENC_impossible(bs);
+		bs = enc_flvar(bs, t);
+		bs = enc_exp(bs, e);
+		break;
+	}
-	case CONV_PTR_MEM_FUNC : {
+	case CONV_FLT_INT: {
-	    /* Pointer to member function to function conversion */
+		/* Float to integer conversion */
-	    IDENTIFIER fn = is_const_ptr_mem ( e, 1 ) ;
-	    if ( !IS_NULL_id ( fn ) ) {
+		ENC_round_with_mode(bs);
-		/* Constant function */
+		ENC_impossible(bs);
-		ulong n = unit_no ( bs, fn, VAR_tag, 0 ) ;
+		ENC_RMODE(bs, crt_round_mode);
-		ENC_obtain_tag ( bs ) ;
+		bs = enc_variety(bs, t);
-		ENC_make_tag ( bs, n ) ;
+		bs = enc_exp(bs, e);
-	    } else {
+		break;
-		/* Non-constant function */
+	}
-		ulong n = LINK_NONE ;
+	case CONV_FLT_FLT: {
-		bs = make_ptr_mem_func ( bs, e, &n, 0 ) ;
+		/* Float to float conversion */
-		bs = enc_special ( bs, TOK_pmf_func ) ;
+		ENC_change_floating_variety(bs);
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		ENC_obtain_tag ( ts ) ;
+		ENC_impossible(bs);
-		ENC_make_tag ( ts, n ) ;
+		bs = enc_flvar(bs, t);
-		bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_exp(bs, e);
-	    }
-	    break ;
+		break;
+	}
+	case CONV_PTR_VOID:
+	case CONV_PTR_VOID | CONV_REVERSE :
+pointer_void_label: {
+			    /* Object pointer and 'void *' conversions */
+			    if (conv & CONV_REVERSE) {
+				    bs = enc_special(bs, TOK_from_ptr_void);
+			    } else {
+				    bs = enc_special(bs, TOK_to_ptr_void);
+				    t = DEREF_type(exp_type(e));
+			    }
+			    ts = start_bitstream(NIL(FILE), bs->link);
+			    t = DEREF_type(type_ptr_etc_sub(t));
+			    ts = enc_alignment(ts, t);
+			    ts = enc_exp(ts, e);
+			    bs = enc_bitstream(bs, ts);
+			    break;
+		    }
+	case CONV_PTR_PTR:
+	case CONV_PTR_BASE:
+	case CONV_PTR_PTR | CONV_REVERSE :
+	case CONV_PTR_BASE | CONV_REVERSE: {
+		/* Pointer to pointer conversion */
+		TYPE s = DEREF_type(exp_type(e));
+		TYPE ps = DEREF_type(type_ptr_etc_sub(s));
+		TYPE pt = DEREF_type(type_ptr_etc_sub(t));
+		switch (TAG_type(pt)) {
+		case type_top_tag:
+		case type_bottom_tag: {
+			switch (TAG_type(ps)) {
+			case type_top_tag:
+			case type_bottom_tag: {
+				/* 'void *' to 'void *' */
+				bs = enc_exp(bs, e);
+				break;
+			}
+			case type_func_tag: {
+				/* Function to 'void *' */
+				bs = enc_special(bs, TOK_f_to_pv);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				ts = enc_exp(ts, e);
+				bs = enc_bitstream(bs, ts);
+				break;
+			}
+			default: {
+				/* Object pointer to 'void *' */
+				conv = CONV_PTR_VOID;
+				goto pointer_void_label;
+			}
+			}
+			break;
+		}
+		case type_func_tag: {
+			switch (TAG_type(ps)) {
+			case type_top_tag:
+			case type_bottom_tag: {
+				/* 'void *' to function */
+				bs = enc_special(bs, TOK_pv_to_f);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				ts = enc_exp(ts, e);
+				bs = enc_bitstream(bs, ts);
+				break;
+			}
+			case type_func_tag: {
+				/* Function to function */
+				bs = enc_exp(bs, e);
+				break;
+			}
+			default: {
+				/* Object pointer to function */
+				BITSTREAM *us;
+				bs = enc_special(bs, TOK_pv_to_f);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				ts = enc_special(ts, TOK_to_ptr_void);
+				us = start_bitstream(NIL(FILE), ts->link);
+				us = enc_alignment(us, ps);
+				us = enc_exp(us, e);
+				ts = enc_bitstream(ts, us);
+				bs = enc_bitstream(bs, ts);
+				break;
+			}
+			}
+			break;
+		}
+		default: {
+			switch (TAG_type(ps)) {
+			case type_top_tag:
+			case type_bottom_tag: {
+				/* 'void *' to object pointer */
+				conv = (CONV_PTR_VOID | CONV_REVERSE);
+				goto pointer_void_label;
+			}
+			case type_func_tag: {
+				/* Function to object pointer */
+				BITSTREAM *us;
+				bs = enc_special(bs, TOK_from_ptr_void);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				ts = enc_alignment(ts, pt);
+				ts = enc_special(ts, TOK_f_to_pv);
+				us = start_bitstream(NIL(FILE), ts->link);
+				us = enc_exp(us, e);
+				ts = enc_bitstream(ts, us);
+				bs = enc_bitstream(bs, ts);
+				break;
+			}
+			default: {
+				/* Object pointer to object pointer */
+				if (conv & CONV_REVERSE) {
+					/* Force conversion in these cases */
+					/* EMPTY */
+				} else {
+					if (eq_type_rep(ps, pt, 1)) {
+						bs = enc_exp(bs, e);
+						break;
+					}
+				}
+				bs = enc_special(bs, TOK_ptr_to_ptr);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				ts = enc_alignment(ts, ps);
+				ts = enc_alignment(ts, pt);
+				ts = enc_exp(ts, e);
+				bs = enc_bitstream(bs, ts);
+				break;
+			}
+			}
+			break;
+		}
+		}
+		break;
+	}
+	case CONV_INT_PTR: {
+		/* Integer to pointer conversion */
+		TYPE s = DEREF_type(exp_type(e));
+		TYPE pt = DEREF_type(type_ptr_etc_sub(t));
+		switch (TAG_type(pt)) {
+		case type_top_tag:
+		case type_bottom_tag: {
+			/* Integer to 'void *' */
+			bs = enc_special(bs, TOK_i_to_pv);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_variety(ts, s);
+			ts = enc_exp(ts, e);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		case type_func_tag: {
+			/* Integer to function */
+			BITSTREAM *us;
+			bs = enc_special(bs, TOK_pv_to_f);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_special(ts, TOK_i_to_pv);
+			us = start_bitstream(NIL(FILE), ts->link);
+			us = enc_variety(us, s);
+			us = enc_exp(us, e);
+			ts = enc_bitstream(ts, us);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		default: {
+			/* Integer to object pointer */
+			bs = enc_special(bs, TOK_i_to_p);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_variety(ts, s);
+			ts = enc_alignment(ts, pt);
+			ts = enc_exp(ts, e);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		}
+		break;
+	}
+	case CONV_PTR_INT: {
+		/* Pointer to integer conversion */
+		TYPE s = DEREF_type(exp_type(e));
+		TYPE ps = DEREF_type(type_ptr_etc_sub(s));
+		switch (TAG_type(ps)) {
+		case type_top_tag:
+		case type_bottom_tag: {
+			/* 'void *' to integer */
+			bs = enc_special(bs, TOK_pv_to_i);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_variety(ts, t);
+			ts = enc_exp(ts, e);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		case type_func_tag: {
+			/* Function to integer */
+			BITSTREAM *us;
+			bs = enc_special(bs, TOK_pv_to_i);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_variety(ts, t);
+			ts = enc_special(ts, TOK_f_to_pv);
+			us = start_bitstream(NIL(FILE), ts->link);
+			us = enc_exp(us, e);
+			ts = enc_bitstream(ts, us);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		default: {
+			/* Object pointer to integer */
+			bs = enc_special(bs, TOK_p_to_i);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_alignment(ts, ps);
+			ts = enc_variety(ts, t);
+			ts = enc_exp(ts, e);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+		}
+		break;
+	}
+	case CONV_NULL: {
+		/* Null pointer conversion */
+		bs = enc_null_exp(bs, t);
+		break;
+	}
+	case CONV_PTR_MEM_FUNC: {
+		/* Pointer to member function to function conversion */
+		IDENTIFIER fn = is_const_ptr_mem(e, 1);
+		if (!IS_NULL_id(fn)) {
+			/* Constant function */
+			ulong n = unit_no(bs, fn, VAR_tag, 0);
+			ENC_obtain_tag(bs);
+			ENC_make_tag(bs, n);
+		} else {
+			/* Non-constant function */
+			ulong n = LINK_NONE;
+			bs = make_ptr_mem_func(bs, e, &n, 0);
+			bs = enc_special(bs, TOK_pmf_func);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ENC_obtain_tag(ts);
+			ENC_make_tag(ts, n);
+			bs = enc_bitstream(bs, ts);
+		}
+		break;
+	}
-	default : {
+	default: {
-	    /* Other conversions */
+		/* Other conversions */
-	    TYPE s = DEREF_type ( exp_type ( e ) ) ;
+		TYPE s = DEREF_type(exp_type(e));
-	    if ( eq_type_rep ( s, t, 0 ) ) {
+		if (eq_type_rep(s, t, 0)) {
-		bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-	    } else {
+		} else {
-		ENC_component ( bs ) ;
+			ENC_component(bs);
-		bs = enc_shape ( bs, t ) ;
+			bs = enc_shape(bs, t);
-		ENC_make_compound ( bs ) ;
+			ENC_make_compound(bs);
-		ENC_offset_max ( bs ) ;
+			ENC_offset_max(bs);
-		ENC_shape_offset ( bs ) ;
+			ENC_shape_offset(bs);
-		bs = enc_shape ( bs, s ) ;
+			bs = enc_shape(bs, s);
-		ENC_shape_offset ( bs ) ;
+			ENC_shape_offset(bs);
-		bs = enc_shape ( bs, t ) ;
+			bs = enc_shape(bs, t);
-		ENC_LIST_SMALL ( bs, 2 ) ;
+			ENC_LIST_SMALL(bs, 2);
-		ENC_offset_zero ( bs ) ;
+			ENC_offset_zero(bs);
-		bs = enc_alignment ( bs, s ) ;
+			bs = enc_alignment(bs, s);
-		bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-		ENC_offset_zero ( bs ) ;
+			ENC_offset_zero(bs);
-		bs = enc_alignment ( bs, t ) ;
+			bs = enc_alignment(bs, t);
-	    }
+		}
-	    break ;
+		break;
+	}
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A BASE CLASS CONVERSION
     This routine adds the base class conversion of e using the base
     offset off to the bitstream bs.  conv represents the conversion type.
     ENCODE A TDF ERROR TREATMENT
     This routine adds an error treatment corresponding to arithmetic
     operations on the arithmetic type t to the bitstream bs.
 */
-BITSTREAM *enc_error_treatment
+BITSTREAM *
-    PROTO_N ( ( bs, t ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t )
+enc_error_treatment(BITSTREAM *bs, TYPE t)
+{
-    if ( IS_type_floating ( t ) || check_int_type ( t, btype_signed ) ) {
+	if (IS_type_floating(t) || check_int_type(t, btype_signed)) {
-	ENC_impossible ( bs ) ;
+		ENC_impossible(bs);
-    } else {
+	} else {
-	ENC_wrap ( bs ) ;
+		ENC_wrap(bs);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LIST OF VIRTUAL FUNCTION ARGUMENTS
     This routine adds the list of virtual function arguments p to the
     bitstream bs.  m is a tag number giving a pointer into the virtual
     function table and j gives the number of the argument corresponding
     to the object pointer.
 */
-static BITSTREAM *enc_virt_args
+static BITSTREAM *
-    PROTO_N ( ( bs, p, m, j ) )
-    PROTO_T ( BITSTREAM *bs X LIST ( EXP ) p X ulong m X unsigned j )
+enc_virt_args(BITSTREAM *bs, LIST(EXP)p, ulong m, unsigned j)
 {
-    unsigned i ;
+	unsigned i;
-    unsigned n = LENGTH_list ( p ) ;
+	unsigned n = LENGTH_list(p);
-    ENC_LIST ( bs, n ) ;
+	ENC_LIST(bs, n);
-    for ( i = 0 ; i < n ; i++ ) {
+	for (i = 0; i < n; i++) {
-	EXP e = DEREF_exp ( HEAD_list ( p ) ) ;
+		EXP e = DEREF_exp(HEAD_list(p));
-	if ( i == j ) {
+		if (i == j) {
-	    TYPE t ;
+			TYPE t;
-	    BITSTREAM *ts ;
+			BITSTREAM *ts;
-	    ENC_add_to_ptr ( bs ) ;
+			ENC_add_to_ptr(bs);
-	    bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-	    bs = enc_special ( bs, TOK_pmf_delta ) ;
+			bs = enc_special(bs, TOK_pmf_delta);
-	    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+			ts = start_bitstream(NIL(FILE), bs->link);
-	    t = DEREF_type ( exp_type ( e ) ) ;
+			t = DEREF_type(exp_type(e));
-	    if ( IS_type_ptr_etc ( t ) ) {
+			if (IS_type_ptr_etc(t)) {
-		t = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+				t = DEREF_type(type_ptr_etc_sub(t));
-	    }
+			}
-	    ts = enc_alignment ( ts, t ) ;
+			ts = enc_alignment(ts, t);
-	    ENC_obtain_tag ( ts ) ;
+			ENC_obtain_tag(ts);
-	    ENC_make_tag ( ts, m ) ;
+			ENC_make_tag(ts, m);
-	    bs = enc_bitstream ( bs, ts ) ;
+			bs = enc_bitstream(bs, ts);
-	} else {
+		} else {
-	    bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-	}
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A NAMED FUNCTION CALL
     This routine outputs an apply_proc construct for the identifier
     function call given by e to the bitstream bs.  t gives the return
     type.
 */
-static BITSTREAM *enc_func_id_call
+static BITSTREAM *
-    PROTO_N ( ( bs, t, e ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X EXP e )
+enc_func_id_call(BITSTREAM *bs, TYPE t, EXP e)
+{
-    IDENTIFIER id = DEREF_id ( exp_func_id_id ( e ) ) ;
+	IDENTIFIER id = DEREF_id(exp_func_id_id(e));
-    LIST ( EXP ) args = DEREF_list ( exp_func_id_args ( e ) ) ;
+	LIST(EXP)args = DEREF_list(exp_func_id_args(e));
-    EXP virt = DEREF_exp ( exp_func_id_virt ( e ) ) ;
+	EXP virt = DEREF_exp(exp_func_id_virt(e));
-    /* Check for static member functions */
-    unsigned tag = TAG_id ( id ) ;
-    if ( tag == id_stat_mem_func_tag ) {
-	EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
-	if ( !IS_NULL_exp ( a ) ) {
-	    ENC_SEQ_SMALL ( bs, 1 ) ;
-	    bs = enc_exp ( bs, a ) ;
-	}
-	args = TAIL_list ( args ) ;
-    }
-    /* Output the procedure application */
+	/* Check for static member functions */
-    if ( tag == id_token_tag ) {
+	unsigned tag = TAG_id(id);
-	/* Function token */
-	ulong n ;
-	IGNORE enc_tokdef ( id, 0 ) ;
+	if (tag == id_stat_mem_func_tag) {
-	ENC_exp_apply_token ( bs ) ;
-	n = unit_no ( bs, id, VAR_token, 0 ) ;
+		EXP a = DEREF_exp(HEAD_list(args));
-	ENC_make_tok ( bs, n ) ;
-	if ( IS_NULL_list ( args ) ) {
+		if (!IS_NULL_exp(a)) {
-	    ENC_LEN_SMALL ( bs, 0 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-	} else {
-	    BITSTREAM *ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-	    while ( !IS_NULL_list ( args ) ) {
-		EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
-		ts = enc_exp ( ts, a ) ;
+			bs = enc_exp(bs, a);
-		args = TAIL_list ( args ) ;
-	    }
+		}
-	    bs = enc_bitstream ( bs, ts ) ;
+		args = TAIL_list(args);
+	}
+	/* Output the procedure application */
+	if (tag == id_token_tag) {
+		/* Function token */
+		ulong n;
+		IGNORE enc_tokdef(id, 0);
+		ENC_exp_apply_token(bs);
+		n = unit_no(bs, id, VAR_token, 0);
+		ENC_make_tok(bs, n);
+		if (IS_NULL_list(args)) {
+			ENC_LEN_SMALL(bs, 0);
+		} else {
+			BITSTREAM *ts = start_bitstream(NIL(FILE), bs->link);
+			while (!IS_NULL_list(args)) {
+				EXP a = DEREF_exp(HEAD_list(args));
+				ts = enc_exp(ts, a);
+				args = TAIL_list(args);
+			}
+			bs = enc_bitstream(bs, ts);
+		}
-    } else if ( !IS_NULL_exp ( virt ) ) {
+	} else if (!IS_NULL_exp(virt)) {
-	/* Virtual function */
+		/* Virtual function */
-	EXP a ;
+		EXP a;
-	ulong tok ;
+		ulong tok;
-	VIRTUAL vt ;
+		VIRTUAL vt;
-	unsigned i ;
+		unsigned i;
-	OFFSET off ;
+		OFFSET off;
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	ulong n, m, p ;
+		ulong n, m, p;
-	/* Find class information */
+		/* Find class information */
-	CLASS_TYPE ct = parent_class ( id ) ;
+		CLASS_TYPE ct = parent_class(id);
-	IGNORE compile_class ( ct ) ;
+		IGNORE compile_class(ct);
-	vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+		vt = DEREF_virt(ctype_virt(ct));
-	off = DEREF_off ( virt_table_off ( vt ) ) ;
+		off = DEREF_off(virt_table_off(vt));
-	tok = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+		tok = DEREF_ulong(virt_table_tok(vt));
-	m = virtual_no ( id, vt ) ;
+		m = virtual_no(id, vt);
-	/* Introduce variable for argument */
+		/* Introduce variable for argument */
-	a = DEREF_exp ( exp_dummy_value ( virt ) ) ;
+		a = DEREF_exp(exp_dummy_value(virt));
-	bs = make_ptr_mem_func ( bs, a, &n, 0 ) ;
+		bs = make_ptr_mem_func(bs, a, &n, 0);
-	COPY_exp ( exp_dummy_value ( virt ), NULL_exp ) ;
+		COPY_exp(exp_dummy_value(virt), NULL_exp);
-	COPY_ulong ( exp_dummy_no ( virt ), n ) ;
+		COPY_ulong(exp_dummy_no(virt), n);
-	/* Find pointer to member function */
+		/* Find pointer to member function */
-	p = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+		p = unit_no(bs, NULL_id, VAR_tag, 1);
-	ENC_identify ( bs ) ;
+		ENC_identify(bs);
-	bs = enc_access ( bs, dspec_none ) ;
+		bs = enc_access(bs, dspec_none);
-	ENC_make_tag ( bs, p ) ;
+		ENC_make_tag(bs, p);
-	bs = enc_special ( bs, TOK_vtab_func ) ;
+		bs = enc_special(bs, TOK_vtab_func);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	ENC_add_to_ptr ( ts ) ;
+		ENC_add_to_ptr(ts);
-	ts = enc_add_ptr ( ts, virt, LINK_NONE, off, 0 ) ;
+		ts = enc_add_ptr(ts, virt, LINK_NONE, off, 0);
-	tok = link_no ( ts, tok, VAR_token ) ;
+		tok = link_no(ts, tok, VAR_token);
-	ENC_exp_apply_token ( ts ) ;
+		ENC_exp_apply_token(ts);
-	ENC_make_tok ( ts, tok ) ;
+		ENC_make_tok(ts, tok);
-	ENC_LEN_SMALL ( ts, 0 ) ;
+		ENC_LEN_SMALL(ts, 0);
-	ts = enc_make_snat ( ts, ( int ) m ) ;
+		ts = enc_make_snat(ts,(int)m);
-	bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-	/* Encode function call */
+		/* Encode function call */
-	ENC_apply_proc ( bs ) ;
+		ENC_apply_proc(bs);
-	bs = enc_shape ( bs, t ) ;
+		bs = enc_shape(bs, t);
-	bs = enc_special ( bs, TOK_pmf_func ) ;
+		bs = enc_special(bs, TOK_pmf_func);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	ENC_obtain_tag ( ts ) ;
+		ENC_obtain_tag(ts);
-	ENC_make_tag ( ts, p ) ;
+		ENC_make_tag(ts, p);
-	bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-	i = DEREF_unsigned ( exp_func_id_extra ( e ) ) ;
+		i = DEREF_unsigned(exp_func_id_extra(e));
-	bs = enc_virt_args ( bs, args, p, i ) ;
+		bs = enc_virt_args(bs, args, p, i);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	COPY_exp ( exp_dummy_value ( virt ), a ) ;
+		COPY_exp(exp_dummy_value(virt), a);
-    } else {
+	} else {
-	/* Simple function */
+		/* Simple function */
-	ulong n ;
+		ulong n;
-	DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	if ( ( ds & dspec_inline ) && !( ds & dspec_temp ) ) {
+		if ((ds & dspec_inline) && !(ds & dspec_temp)) {
-	    /* Check for function inlining */
+			/* Check for function inlining */
-	    if ( output_inline ) {
+			if (output_inline) {
-		EXP a = check_inline ( id, args, t ) ;
+				EXP a = check_inline(id, args, t);
-		if ( !IS_NULL_exp ( a ) ) {
+				if (!IS_NULL_exp(a)) {
-		    COPY_dspec ( id_storage ( id ), ( ds | dspec_temp ) ) ;
+					COPY_dspec(id_storage(id),
+						   (ds | dspec_temp));
-		    bs = enc_exp ( bs, a ) ;
+					bs = enc_exp(bs, a);
-		    free_exp ( a, 1 ) ;
+					free_exp(a, 1);
-		    COPY_dspec ( id_storage ( id ), ds ) ;
+					COPY_dspec(id_storage(id), ds);
-		    return ( bs ) ;
+					return (bs);
+				}
+			}
+		}
+		ENC_apply_proc(bs);
+		bs = enc_shape(bs, t);
+		IGNORE capsule_id(id, VAR_tag);
+		n = unit_no(bs, id, VAR_tag, 0);
+		ENC_obtain_tag(bs);
+		ENC_make_tag(bs, n);
+		bs = enc_exp_list(bs, args);
-	    }
+		ENC_OFF(bs);
+	}
-	ENC_apply_proc ( bs ) ;
-	bs = enc_shape ( bs, t ) ;
-	IGNORE capsule_id ( id, VAR_tag ) ;
-	n = unit_no ( bs, id, VAR_tag, 0 ) ;
-	ENC_obtain_tag ( bs ) ;
-	ENC_make_tag ( bs, n ) ;
-	bs = enc_exp_list ( bs, args ) ;
-	ENC_OFF ( bs ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A FUNCTION CALL
     This routine outputs an apply_proc construct for the expression
     function call given by e to the bitstream bs.  t gives the return
     type.
 */
-static BITSTREAM *enc_func_call
+static BITSTREAM *
-    PROTO_N ( ( bs, t, e ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X EXP e )
+enc_func_call(BITSTREAM *bs, TYPE t, EXP e)
 {
-    EXP a = DEREF_exp ( exp_func_fn ( e ) ) ;
+	EXP a = DEREF_exp(exp_func_fn(e));
-    LIST ( EXP ) args = DEREF_list ( exp_func_args ( e ) ) ;
+	LIST(EXP)args = DEREF_list(exp_func_args(e));
-    if ( IS_exp_call ( a ) ) {
+	if (IS_exp_call(a)) {
-	/* Pointer to member function call */
+		/* Pointer to member function call */
-	EXP b ;
+		EXP b;
-	EXP b1 ;
+		EXP b1;
-	TYPE s ;
+		TYPE s;
-	ulong n ;
+		ulong n;
-	unsigned i ;
+		unsigned i;
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	CLASS_TYPE ct ;
+		CLASS_TYPE ct;
-	ulong m = LINK_NONE ;
+		ulong m = LINK_NONE;
-	/* Decompose pointer to member */
+		/* Decompose pointer to member */
-	b = DEREF_exp ( exp_call_arg ( a ) ) ;
+		b = DEREF_exp(exp_call_arg(a));
-	b1 = DEREF_exp ( exp_dummy_value ( b ) ) ;
+		b1 = DEREF_exp(exp_dummy_value(b));
-	a = DEREF_exp ( exp_call_ptr ( a ) ) ;
+		a = DEREF_exp(exp_call_ptr(a));
-	s = DEREF_type ( exp_type ( a ) ) ;
+		s = DEREF_type(exp_type(a));
-	ct = DEREF_ctype ( type_ptr_mem_of ( s ) ) ;
+		ct = DEREF_ctype(type_ptr_mem_of(s));
-	/* Introduce variable for argument */
+		/* Introduce variable for argument */
-	bs = make_ptr_mem_func ( bs, b1, &m, 0 ) ;
+		bs = make_ptr_mem_func(bs, b1, &m, 0);
-	COPY_exp ( exp_dummy_value ( b ), NULL_exp ) ;
+		COPY_exp(exp_dummy_value(b), NULL_exp);
-	COPY_ulong ( exp_dummy_no ( b ), m ) ;
+		COPY_ulong(exp_dummy_no(b), m);
-	IGNORE compile_class ( ct ) ;
+		IGNORE compile_class(ct);
-	/* Allow for virtual functions */
+		/* Allow for virtual functions */
-	bs = make_ptr_mem_func ( bs, a, &n, 1 ) ;
+		bs = make_ptr_mem_func(bs, a, &n, 1);
-	ENC_SEQ_SMALL ( bs, 1 ) ;
+		ENC_SEQ_SMALL(bs, 1);
-	bs = enc_special ( bs, TOK_pmf_virt ) ;
+		bs = enc_special(bs, TOK_pmf_virt);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	ENC_obtain_tag ( ts ) ;
+		ENC_obtain_tag(ts);
-	ENC_make_tag ( ts, n ) ;
+		ENC_make_tag(ts, n);
-	ts = enc_exp ( ts, b ) ;
+		ts = enc_exp(ts, b);
-	ts = enc_al_ctype ( ts, ct ) ;
+		ts = enc_al_ctype(ts, ct);
-	bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-	/* Encode call */
+		/* Encode call */
-	ENC_apply_proc ( bs ) ;
+		ENC_apply_proc(bs);
-	bs = enc_shape ( bs, t ) ;
+		bs = enc_shape(bs, t);
-	bs = enc_special ( bs, TOK_pmf_func ) ;
+		bs = enc_special(bs, TOK_pmf_func);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	ENC_obtain_tag ( ts ) ;
+		ENC_obtain_tag(ts);
-	ENC_make_tag ( ts, n ) ;
+		ENC_make_tag(ts, n);
-	bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-	i = DEREF_unsigned ( exp_func_extra ( e ) ) ;
+		i = DEREF_unsigned(exp_func_extra(e));
-	bs = enc_virt_args ( bs, args, n, i ) ;
+		bs = enc_virt_args(bs, args, n, i);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	COPY_exp ( exp_dummy_value ( b ), b1 ) ;
+		COPY_exp(exp_dummy_value(b), b1);
-    } else {
+	} else {
-	/* Simple function call */
+		/* Simple function call */
-	ENC_apply_proc ( bs ) ;
+		ENC_apply_proc(bs);
-	bs = enc_shape ( bs, t ) ;
+		bs = enc_shape(bs, t);
-	bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
-	bs = enc_exp_list ( bs, args ) ;
+		bs = enc_exp_list(bs, args);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A DUMMY EXPRESSION
     This routine adds the dummy expression given by the tag n plus the
     offset off to the bitstream bs.  cnt gives the expression type.
 */
-BITSTREAM *enc_dummy_exp
+BITSTREAM *
-    PROTO_N ( ( bs, t, n, off, cnt, virt ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X ulong n X OFFSET off X
+enc_dummy_exp(BITSTREAM *bs, TYPE t, ulong n, OFFSET off, int cnt, int virt)
-	      int cnt X int virt )
 {
-    int bf = 0 ;
+	int bf = 0;
-    OFFSET off1 = NULL_off ;
+	OFFSET off1 = NULL_off;
-    if ( cnt > 2 ) {
+	if (cnt > 2) {
-	/* Special tag */
+		/* Special tag */
-	n = last_params [ cnt ] ;
+		n = last_params[cnt];
-	cnt = last_conts [ cnt ] ;
+		cnt = last_conts[cnt];
-    }
+	}
-    if ( n == LINK_NONE ) {
+	if (n == LINK_NONE) {
-	/* This shouldn't happen */
+		/* This shouldn't happen */
-	n = capsule_no ( NULL_string, VAR_tag ) ;
+		n = capsule_no(NULL_string, VAR_tag);
-    }
+	}
-    if ( n & LINK_EXTERN ) {
+	if (n & LINK_EXTERN) {
-	/* Allow for global tags */
+		/* Allow for global tags */
-	n = link_no ( bs, n, VAR_tag ) ;
+		n = link_no(bs, n, VAR_tag);
-    }
-    if ( cnt == 1 ) {
-	/* Contents */
-	bs = enc_cont_op ( bs, t, &bf ) ;
-	if ( bf ) {
-	    off1 = decons_bitf_off ( &off ) ;
-	    bs = enc_bfvar ( bs, t ) ;
-	} else {
-	    bs = enc_shape ( bs, t ) ;
+	}
-    } else if ( cnt == 2 ) {
+	if (cnt == 1) {
-	/* Contents of pointer */
+		/* Contents */
-	ENC_contents ( bs ) ;
-	ENC_pointer ( bs ) ;
-	bs = enc_alignment ( bs, t ) ;
+		bs = enc_cont_op(bs, t, &bf);
-    }
+		if (bf) {
-    if ( is_zero_offset ( off ) ) {
+			off1 = decons_bitf_off(&off);
-	/* Zero offset */
-	ENC_obtain_tag ( bs ) ;
-	ENC_make_tag ( bs, n ) ;
+			bs = enc_bfvar(bs, t);
-    } else if ( virt ) {
-	/* Virtual base offset */
-	EXP e ;
-	MAKE_exp_dummy ( t, NULL_exp, n, NULL_off, 0, e ) ;
-	bs = enc_add_ptr ( bs, e, LINK_NONE, off, 1 ) ;
-	free_exp ( e, 1 ) ;
-    } else {
+		} else {
-	/* Non-virtual base offset */
-	ENC_add_to_ptr ( bs ) ;
-	ENC_obtain_tag ( bs ) ;
-	ENC_make_tag ( bs, n ) ;
-	bs = enc_offset ( bs, off ) ;
+			bs = enc_shape(bs, t);
-    }
+		}
-    if ( bf ) {
+	} else if (cnt == 2) {
-	/* End of bitfield contents */
+		/* Contents of pointer */
-	bs = enc_offset ( bs, off1 ) ;
+		ENC_contents(bs);
-    }
-    return ( bs ) ;
+		ENC_pointer(bs);
-}
-/*
-    ENCODE AN ASSIGNMENT EXPRESSION
-    This routine adds the assignment or initialisation expression 'a = b'
-    to the bitstream bs.
-*/
-static BITSTREAM *enc_assign_exp
-    PROTO_N ( ( bs, a, b ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X EXP b )
-{
-    TYPE s = DEREF_type ( exp_type ( a ) ) ;
-    if ( IS_exp_dummy ( a ) ) {
-	/* Check for dummy expressions */
-	EXP c = DEREF_exp ( exp_dummy_value ( a ) ) ;
-	if ( IS_NULL_exp ( c ) ) {
-	    ulong n = DEREF_ulong ( exp_dummy_no ( a ) ) ;
-	    OFFSET off = DEREF_off ( exp_dummy_off ( a ) ) ;
-	    int cnt = DEREF_int ( exp_dummy_cont ( a ) ) ;
-	    bs = enc_init_tag ( bs, n, off, cnt, s, b, NULL_exp, 0 ) ;
-	    return ( bs ) ;
+		bs = enc_alignment(bs, t);
+	}
-    }
-    if ( is_init_complex ( b ) ) {
+	if (is_zero_offset(off)) {
-	/* Introduce identity for complex assignment */
+		/* Zero offset */
-	ulong n ;
+		ENC_obtain_tag(bs);
-	bs = make_identity ( bs, a, &n, 0, 0 ) ;
+		ENC_make_tag(bs, n);
-	bs = enc_init_tag ( bs, n, NULL_off, 0, s, b, NULL_exp, 0 ) ;
-    } else {
+	} else if (virt) {
-	/* Simple assignment */
+		/* Virtual base offset */
-	int bf = 0 ;
+		EXP e;
-	bs = enc_assign_op ( bs, s, &bf ) ;
+		MAKE_exp_dummy(t, NULL_exp, n, NULL_off, 0, e);
-	if ( bf ) {
-	    /* Bitfield assignment */
-	    OFFSET off = decons_bitf_exp ( &a ) ;
-	    bs = enc_addr_exp ( bs, s, a ) ;
+		bs = enc_add_ptr(bs, e, LINK_NONE, off, 1);
-	    bs = enc_offset ( bs, off ) ;
+		free_exp(e, 1);
 	} else {
+		/* Non-virtual base offset */
+		ENC_add_to_ptr(bs);
+		ENC_obtain_tag(bs);
+		ENC_make_tag(bs, n);
+		bs = enc_offset(bs, off);
+	}
+	if (bf) {
-	    /* Non-bitfield assignment */
+		/* End of bitfield contents */
-	    bs = enc_addr_exp ( bs, s, a ) ;
+		bs = enc_offset(bs, off1);
+	}
-	bs = enc_exp ( bs, b ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
-    ENCODE A TDF EXP
+    ENCODE AN ASSIGNMENT EXPRESSION
-    This routine adds the expression e to the bitstream bs as a TDF EXP.
+    This routine adds the assignment or initialisation expression 'a = b'
+    to the bitstream bs.
 */
-BITSTREAM *enc_exp
+static BITSTREAM *
-    PROTO_N ( ( bs, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP e )
+enc_assign_exp(BITSTREAM *bs, EXP a, EXP b)
+{
-    TYPE t ;
-    if ( IS_NULL_exp ( e ) ) {
-	/* Deal with null expressions */
-	ENC_make_top ( bs ) ;
-	return ( bs ) ;
-    }
-    /* Examine expression cases */
-    t = DEREF_type ( exp_type ( e ) ) ;
+	TYPE s = DEREF_type(exp_type(a));
-    ASSERT ( ORDER_exp == 88 ) ;
-    switch ( TAG_exp ( e ) ) {
-	case exp_identifier_tag : {
-	    /* Identifier lvalue expressions */
-	    bs = enc_addr_exp ( bs, t, e ) ;
-	    break ;
-	}
-	case exp_int_lit_tag : {
-	    /* Integer literals */
-	    NAT n = DEREF_nat ( exp_int_lit_nat ( e ) ) ;
-	    unsigned etag = DEREF_unsigned ( exp_int_lit_etag ( e ) ) ;
-	    bs = enc_int_lit ( bs, n, t, etag ) ;
-	    break ;
-	}
-	case exp_float_lit_tag : {
-	    /* Floating literals */
-	    FLOAT f = DEREF_flt ( exp_float_lit_flt ( e ) ) ;
-	    bs = enc_float ( bs, f, t ) ;
-	    break ;
-	}
-	case exp_char_lit_tag : {
-	    /* Character literals */
-	    STRING s = DEREF_str ( exp_char_lit_str ( e ) ) ;
-	    bs = enc_char ( bs, s, t, t ) ;
-	    break ;
-	}
-	case exp_string_lit_tag : {
-	    /* String literals */
-	    STRING s = DEREF_str ( exp_string_lit_str ( e ) ) ;
-	    bs = enc_string ( bs, s, t ) ;
-	    break ;
-	}
-	case exp_value_tag : {
-	    /* Undefined values */
-	    if ( IS_type_top ( t ) ) {
-		ENC_make_top ( bs ) ;
-	    } else {
-		ENC_make_value ( bs ) ;
-		bs = enc_shape ( bs, t ) ;
-	    }
-	    break ;
-	}
-	case exp_null_tag :
-	case exp_zero_tag : {
-	    /* Null expressions */
-	    bs = enc_null_exp ( bs, t ) ;
-	    break ;
-	}
-	case exp_paren_tag :
-	case exp_copy_tag : {
-	    /* Parenthesised expressions */
-	    EXP a = DEREF_exp ( exp_paren_etc_arg ( e ) ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    break ;
-	}
-	case exp_assign_tag : {
-	    /* Assignment expressions */
-	    EXP a = DEREF_exp ( exp_assign_ref ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_assign_arg ( e ) ) ;
-	    bs = enc_assign_exp ( bs, a, b ) ;
-	    break ;
-	}
-	case exp_init_tag : {
-	    /* Initialisation expressions */
-	    ulong n ;
-	    int context = 1 ;
-	    IDENTIFIER id = DEREF_id ( exp_init_id ( e ) ) ;
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-	    EXP a = DEREF_exp ( exp_init_arg ( e ) ) ;
-	    EXP d = DEREF_exp ( id_variable_etc_term ( id ) ) ;
-	    if ( !IS_NULL_exp ( d ) ) {
-		while ( IS_exp_nof ( d ) ) {
+	if (IS_exp_dummy(a)) {
-		    d = DEREF_exp ( exp_nof_pad ( d ) ) ;
-		}
-		ENC_SEQ_SMALL ( bs, 1 ) ;
-	    }
-	    if ( !( ds & dspec_auto ) ) {
-		/* Allow for external variables */
-		if ( capsule_id ( id, VAR_tag ) ) {
-		    make_term_global ( t, &d ) ;
-		}
-		context = 2 ;
-	    }
-	    n = unit_no ( bs, id, VAR_tag, 0 ) ;
-	    bs = enc_init_tag ( bs, n, NULL_off, 0, t, a, d, context ) ;
-	    break ;
-	}
-	case exp_preinc_tag : {
-	    /* Pre-increment expressions */
+		/* Check for dummy expressions */
-	    int bf = 0 ;
-	    ulong n = LINK_NONE ;
-	    EXP a = DEREF_exp ( exp_preinc_ref ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_preinc_op ( e ) ) ;
-	    EXP a1 = DEREF_exp ( exp_dummy_value ( a ) ) ;
+		EXP c = DEREF_exp(exp_dummy_value(a));
-	    TYPE s = DEREF_type ( exp_type ( a ) ) ;
-	    int op = DEREF_int ( exp_preinc_becomes ( e ) ) ;
-	    /* Declare identity for complex operations */
-	    if ( op != lex_assign ) {
-		COPY_exp ( exp_dummy_value ( a ), NULL_exp ) ;
-		bs = make_identity ( bs, a1, &n, 0, 0 ) ;
-		COPY_ulong ( exp_dummy_no ( a ), n ) ;
-	    }
-	    /* Encode the result */
-	    bs = enc_assign_op ( bs, s, &bf ) ;
-	    if ( n == LINK_NONE ) {
-		bs = enc_exp ( bs, a1 ) ;
-	    } else {
-		ENC_obtain_tag ( bs ) ;
-		ENC_make_tag ( bs, n ) ;
-	    }
-	    if ( bf ) {
-		OFFSET off = DEREF_off ( exp_dummy_off ( a ) ) ;
-		bs = enc_offset ( bs, off ) ;
-	    }
-	    bs = enc_exp ( bs, b ) ;
-	    COPY_exp ( exp_dummy_value ( a ), a1 ) ;
-	    break ;
-	}
-	case exp_postinc_tag : {
-	    /* Post-increment expressions */
-	    ulong n ;
-	    int bf = 0 ;
-	    EXP a = DEREF_exp ( exp_postinc_ref ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_postinc_value ( e ) ) ;
-	    EXP c = DEREF_exp ( exp_postinc_op ( e ) ) ;
-	    EXP a1 = DEREF_exp ( exp_dummy_value ( a ) ) ;
-	    EXP b1 = NULL_exp ;
-	    TYPE s = DEREF_type ( exp_type ( a ) ) ;
-	    /* Declare outer identity */
-	    COPY_exp ( exp_dummy_value ( a ), NULL_exp ) ;
-	    bs = make_identity ( bs, a1, &n, 0, 0 ) ;
-	    COPY_ulong ( exp_dummy_no ( a ), n ) ;
-	    /* Declare inner identity if necessary */
-	    if ( !IS_NULL_exp ( b ) ) {
+		if (IS_NULL_exp(c)) {
-		ulong m ;
-		b1 = DEREF_exp ( exp_dummy_value ( b ) ) ;
+			ulong n = DEREF_ulong(exp_dummy_no(a));
-		COPY_exp ( exp_dummy_value ( b ), NULL_exp ) ;
-		bs = make_identity ( bs, b1, &m, 1, 1 ) ;
-		COPY_ulong ( exp_dummy_no ( b ), m ) ;
-	    }
-	    /* Encode the result */
-	    bs = enc_assign_op ( bs, s, &bf ) ;
-	    ENC_obtain_tag ( bs ) ;
-	    ENC_make_tag ( bs, n ) ;
-	    if ( bf ) {
-		OFFSET off = DEREF_off ( exp_dummy_off ( a ) ) ;
+			OFFSET off = DEREF_off(exp_dummy_off(a));
-		bs = enc_offset ( bs, off ) ;
-	    }
-	    bs = enc_exp ( bs, c ) ;
-	    if ( !IS_NULL_exp ( b ) ) {
-		bs = enc_exp ( bs, b ) ;
-		COPY_exp ( exp_dummy_value ( b ), b1 ) ;
-	    }
-	    COPY_exp ( exp_dummy_value ( a ), a1 ) ;
-	    break ;
-	}
-	case exp_indir_tag : {
-	    /* Indirection expressions */
-	    EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
+			int cnt = DEREF_int(exp_dummy_cont(a));
-	    bs = enc_exp ( bs, a ) ;
-	    break ;
-	}
-	case exp_contents_tag : {
-	    /* Contents expressions */
-	    EXP a = DEREF_exp ( exp_contents_ptr ( e ) ) ;
-	    bs = enc_cont_exp ( bs, t, a ) ;
-	    break ;
-	}
-	case exp_address_tag : {
-	    /* Address expressions */
-	    EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
-	    bs = enc_addr_exp ( bs, t, a ) ;
-	    break ;
-	}
-	case exp_address_mem_tag : {
-	    /* Member address expressions */
-	    EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
-	    IDENTIFIER id = DEREF_id ( exp_member_id ( a ) ) ;
-	    bs = enc_ptr_mem ( bs, t, id, NULL_graph ) ;
+			bs = enc_init_tag(bs, n, off, cnt, s, b, NULL_exp, 0);
-	    break ;
-	}
-	case exp_func_tag : {
-	    /* Function applications */
-	    bs = enc_func_call ( bs, t, e ) ;
-	    break ;
-	}
-	case exp_func_id_tag : {
-	    /* Function identifier applications */
-	    bs = enc_func_id_call ( bs, t, e ) ;
-	    break ;
-	}
-	case exp_negate_tag : {
-	    /* Negation expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_negate ( bs ) ;
-	    } else {
-		ENC_negate ( bs ) ;
-	    }
-	    goto unary_err_label ;
-	}
-	case exp_compl_tag : {
-	    /* Complement expressions */
-	    ENC_not ( bs ) ;
-	    goto unary_label ;
-	}
-	case exp_abs_tag : {
-	    /* Absolute expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_abs ( bs ) ;
-	    } else {
-		ENC_abs ( bs ) ;
+			return (bs);
-	    }
-	    goto unary_err_label ;
-	}
+		}
-	unary_err_label : {
-	    /* Unary operands with error treatment */
-	    bs = enc_error_treatment ( bs, t ) ;
-	    goto unary_label ;
+	}
+	if (is_init_complex(b)) {
+		/* Introduce identity for complex assignment */
+		ulong n;
+		bs = make_identity(bs, a, &n, 0, 0);
+		bs = enc_init_tag(bs, n, NULL_off, 0, s, b, NULL_exp, 0);
+	} else {
+		/* Simple assignment */
+		int bf = 0;
+		bs = enc_assign_op(bs, s, &bf);
+		if (bf) {
+			/* Bitfield assignment */
+			OFFSET off = decons_bitf_exp(&a);
+			bs = enc_addr_exp(bs, s, a);
+			bs = enc_offset(bs, off);
+		} else {
+			/* Non-bitfield assignment */
+			bs = enc_addr_exp(bs, s, a);
+		}
+		bs = enc_exp(bs, b);
+	}
+	return (bs);
+}
+/*
+    ENCODE A TDF EXP
+    This routine adds the expression e to the bitstream bs as a TDF EXP.
+*/
-	unary_label : {
-	    /* Unary operands */
-	    EXP a = DEREF_exp ( exp_negate_etc_arg ( e ) ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    break ;
+BITSTREAM *
-	}
-	case exp_plus_tag : {
-	    /* Addition expressions */
-	    unsigned tag = TAG_type ( t ) ;
-	    if ( tag == type_floating_tag ) {
-		ENC_floating_plus ( bs ) ;
-		ENC_impossible ( bs ) ;
-		ENC_LIST_SMALL ( bs, 2 ) ;
+enc_exp(BITSTREAM *bs, EXP e)
-	    } else {
-		if ( tag == type_enumerate_tag ) {
-		    /* Special case for enumerators */
-		    t = promote_type ( t ) ;
-		}
-		ENC_plus ( bs ) ;
-		bs = enc_error_treatment ( bs, t ) ;
-	    }
-	    goto binary_label ;
-	}
-	case exp_minus_tag : {
-	    /* Subtraction expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_minus ( bs ) ;
-	    } else {
-		ENC_minus ( bs ) ;
-	    }
-	    goto binary_err_label ;
-	}
+{
-	case exp_mult_tag : {
-	    /* Multiplication expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_mult ( bs ) ;
-		ENC_impossible ( bs ) ;
-		ENC_LIST_SMALL ( bs, 2 ) ;
-	    } else {
-		ENC_mult ( bs ) ;
-		bs = enc_error_treatment ( bs, t ) ;
-	    }
+	TYPE t;
-	    goto binary_label ;
-	}
-	case exp_div_tag : {
-	    /* Division expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_div ( bs ) ;
-	    } else {
-		int div_mode = division_mode ;
-		if ( div_mode == 3 ) {
+	if (IS_NULL_exp(e)) {
-		    /* Tokenised division */
-		    bs = enc_special ( bs, TOK_div ) ;
-		    goto division_label ;
-		}
-		switch ( div_mode ) {
-		    case 0 : ENC_div0 ( bs ) ; break ;
-		    case 1 : ENC_div1 ( bs ) ; break ;
-		    case 2 : ENC_div2 ( bs ) ; break ;
-		}
-		ENC_impossible ( bs ) ;
-	    }
-	    goto binary_err_label ;
-	}
-	case exp_rem_tag : {
-	    /* Remainder expressions */
-	    int div_mode = division_mode ;
-	    if ( div_mode == 3 ) {
-		/* Tokenised division */
-		bs = enc_special ( bs, TOK_rem ) ;
-		goto division_label ;
-	    }
-	    switch ( div_mode ) {
-		case 0 : ENC_rem0 ( bs ) ; break ;
-		case 1 : ENC_rem1 ( bs ) ; break ;
-		case 2 : ENC_rem2 ( bs ) ; break ;
-	    }
-	    ENC_impossible ( bs ) ;
-	    goto binary_err_label ;
-	}
-	division_label : {
-	    /* Division operands */
-	    EXP a = DEREF_exp ( exp_plus_etc_arg1 ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_plus_etc_arg2 ( e ) ) ;
-	    BITSTREAM *ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-	    ts = enc_exp ( ts, a ) ;
-	    ts = enc_exp ( ts, b ) ;
-	    bs = enc_bitstream ( bs, ts ) ;
-	    break ;
-	}
-	case exp_and_tag : {
-	    /* Bitwise and expressions */
-	    ENC_and ( bs ) ;
-	    goto binary_label ; ;
-	}
-	case exp_or_tag : {
-	    /* Bitwise or expressions */
-	    ENC_or ( bs ) ;
-	    goto binary_label ; ;
-	}
-	case exp_xor_tag : {
-	    /* Bitwise xor expressions */
-	    ENC_xor ( bs ) ;
-	    goto binary_label ; ;
-	}
-	case exp_lshift_tag : {
-	    /* Left shift expressions */
-	    ENC_shift_left ( bs ) ;
-	    goto binary_err_label ; ;
-	}
-	case exp_rshift_tag : {
-	    /* Right shift expressions */
+		/* Deal with null expressions */
-	    ENC_shift_right ( bs ) ;
-	    goto binary_label ;
-	}
-	case exp_max_tag : {
-	    /* Maximum expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_maximum ( bs ) ;
-#if ( TDF_major >= 4 )
-		ENC_impossible ( bs ) ;
-#endif
-	    } else {
-		ENC_maximum ( bs ) ;
+		ENC_make_top(bs);
-	    }
-	    goto binary_label ;
-	}
-	case exp_min_tag : {
-	    /* Minimum expressions */
-	    if ( IS_type_floating ( t ) ) {
-		ENC_floating_minimum ( bs ) ;
-#if ( TDF_major >= 4 )
-		ENC_impossible ( bs ) ;
-#endif
-	    } else {
-		ENC_minimum ( bs ) ;
+		return (bs);
-	    }
-	    goto binary_label ;
-	}
-	binary_err_label : {
-	    /* Binary operands with error treatment */
-	    bs = enc_error_treatment ( bs, t ) ;
-	    goto binary_label ;
-	}
-	binary_label : {
-	    /* Binary operands */
-	    EXP a = DEREF_exp ( exp_plus_etc_arg1 ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_plus_etc_arg2 ( e ) ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    bs = enc_exp ( bs, b ) ;
-	    break ;
-	}
-	case exp_cast_tag : {
-	    /* Cast expressions */
-	    EXP a = DEREF_exp ( exp_cast_arg ( e ) ) ;
-	    unsigned conv = DEREF_unsigned ( exp_cast_conv ( e ) ) ;
-	    bs = enc_cast_exp ( bs, t, a, conv ) ;
-	    break ;
-	}
-	case exp_base_cast_tag : {
-	    /* Base class cast expressions */
-	    EXP a = DEREF_exp ( exp_base_cast_arg ( e ) ) ;
-	    OFFSET off = DEREF_off ( exp_base_cast_off ( e ) ) ;
-	    unsigned conv = DEREF_unsigned ( exp_base_cast_conv ( e ) ) ;
-	    if ( conv == CONV_PTR_MEM_BASE ) {
-		/* Check for constant pointer to members */
-		IDENTIFIER fn = is_const_ptr_mem ( a, 0 ) ;
-		if ( !IS_NULL_id ( fn ) ) {
-		    CLASS_TYPE cs = parent_class ( fn ) ;
-		    CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
-		    GRAPH gr = find_base_class ( ct, cs, 0 ) ;
-		    bs = enc_ptr_mem ( bs, t, fn, gr ) ;
-		    break ;
-		}
-	    }
-	    bs = enc_base_cast_exp ( bs, a, off, conv ) ;
-	    break ;
-	}
-	case exp_add_ptr_tag : {
-	    /* Pointer additions */
-	    EXP a = DEREF_exp ( exp_add_ptr_ptr ( e ) ) ;
-	    OFFSET off = DEREF_off ( exp_add_ptr_off ( e ) ) ;
-	    int virt = DEREF_int ( exp_add_ptr_virt ( e ) ) ;
-	    bs = enc_add_ptr ( bs, a, LINK_NONE, off, virt ) ;
-	    break ;
-	}
-	case exp_offset_size_tag : {
-	    /* Size of offset */
-	    OFFSET off = DEREF_off ( exp_offset_size_off ( e ) ) ;
-	    TYPE s = DEREF_type ( exp_offset_size_step ( e ) ) ;
-	    ENC_offset_div ( bs ) ;
-	    bs = enc_variety ( bs, t ) ;
-	    bs = enc_offset ( bs, off ) ;
-	    bs = enc_shape_offset ( bs, s ) ;
-	    break ;
-	}
-	case exp_constr_tag : {
-	    /* Constructor calls */
-	    EXP a = DEREF_exp ( exp_constr_call ( e ) ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    break ;
-	}
-	case exp_destr_tag : {
-	    /* Destructor calls */
-	    EXP a = DEREF_exp ( exp_destr_call ( e ) ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    break ;
-	}
-	case exp_rtti_no_tag : {
-	    /* Link-time type information */
-	    TYPE s = DEREF_type ( exp_rtti_no_arg ( e ) ) ;
-	    ENC_make_int ( bs ) ;
-	    bs = enc_variety ( bs, t ) ;
-	    bs = enc_arith ( bs, s, 0 ) ;
-	    break ;
+	}
+	/* Examine expression cases */
+	t = DEREF_type(exp_type(e));
+	ASSERT(ORDER_exp == 88);
+	switch (TAG_exp(e)) {
+	case exp_identifier_tag: {
+		/* Identifier lvalue expressions */
+		bs = enc_addr_exp(bs, t, e);
+		break;
+	}
+	case exp_int_lit_tag: {
+		/* Integer literals */
+		NAT n = DEREF_nat(exp_int_lit_nat(e));
+		unsigned etag = DEREF_unsigned(exp_int_lit_etag(e));
+		bs = enc_int_lit(bs, n, t, etag);
+		break;
+	}
+	case exp_float_lit_tag: {
+		/* Floating literals */
+		FLOAT f = DEREF_flt(exp_float_lit_flt(e));
+		bs = enc_float(bs, f, t);
+		break;
+	}
+	case exp_char_lit_tag: {
+		/* Character literals */
+		STRING s = DEREF_str(exp_char_lit_str(e));
+		bs = enc_char(bs, s, t, t);
+		break;
+	}
+	case exp_string_lit_tag: {
+		/* String literals */
+		STRING s = DEREF_str(exp_string_lit_str(e));
+		bs = enc_string(bs, s, t);
+		break;
+	}
+	case exp_value_tag: {
+		/* Undefined values */
+		if (IS_type_top(t)) {
+			ENC_make_top(bs);
+		} else {
+			ENC_make_value(bs);
+			bs = enc_shape(bs, t);
+		}
+		break;
+	}
+	case exp_null_tag:
+	case exp_zero_tag: {
+		/* Null expressions */
+		bs = enc_null_exp(bs, t);
+		break;
+	}
+	case exp_paren_tag:
+	case exp_copy_tag: {
+		/* Parenthesised expressions */
+		EXP a = DEREF_exp(exp_paren_etc_arg(e));
+		bs = enc_exp(bs, a);
+		break;
+	}
+	case exp_assign_tag: {
+		/* Assignment expressions */
+		EXP a = DEREF_exp(exp_assign_ref(e));
+		EXP b = DEREF_exp(exp_assign_arg(e));
+		bs = enc_assign_exp(bs, a, b);
+		break;
+	}
+	case exp_init_tag: {
+		/* Initialisation expressions */
+		ulong n;
+		int context = 1;
+		IDENTIFIER id = DEREF_id(exp_init_id(e));
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		EXP a = DEREF_exp(exp_init_arg(e));
+		EXP d = DEREF_exp(id_variable_etc_term(id));
+		if (!IS_NULL_exp(d)) {
+			while (IS_exp_nof(d)) {
+				d = DEREF_exp(exp_nof_pad(d));
+			}
+			ENC_SEQ_SMALL(bs, 1);
+		}
+		if (!(ds & dspec_auto)) {
+			/* Allow for external variables */
+			if (capsule_id(id, VAR_tag)) {
+				make_term_global(t, &d);
+			}
+			context = 2;
+		}
+		n = unit_no(bs, id, VAR_tag, 0);
+		bs = enc_init_tag(bs, n, NULL_off, 0, t, a, d, context);
+		break;
+	}
+	case exp_preinc_tag: {
+		/* Pre-increment expressions */
+		int bf = 0;
+		ulong n = LINK_NONE;
+		EXP a = DEREF_exp(exp_preinc_ref(e));
+		EXP b = DEREF_exp(exp_preinc_op(e));
+		EXP a1 = DEREF_exp(exp_dummy_value(a));
+		TYPE s = DEREF_type(exp_type(a));
+		int op = DEREF_int(exp_preinc_becomes(e));
+		/* Declare identity for complex operations */
+		if (op != lex_assign) {
+			COPY_exp(exp_dummy_value(a), NULL_exp);
+			bs = make_identity(bs, a1, &n, 0, 0);
+			COPY_ulong(exp_dummy_no(a), n);
+		}
+		/* Encode the result */
+		bs = enc_assign_op(bs, s, &bf);
+		if (n == LINK_NONE) {
+			bs = enc_exp(bs, a1);
+		} else {
+			ENC_obtain_tag(bs);
+			ENC_make_tag(bs, n);
+		}
+		if (bf) {
+			OFFSET off = DEREF_off(exp_dummy_off(a));
+			bs = enc_offset(bs, off);
+		}
+		bs = enc_exp(bs, b);
+		COPY_exp(exp_dummy_value(a), a1);
+		break;
+	}
+	case exp_postinc_tag: {
+		/* Post-increment expressions */
+		ulong n;
+		int bf = 0;
+		EXP a = DEREF_exp(exp_postinc_ref(e));
+		EXP b = DEREF_exp(exp_postinc_value(e));
+		EXP c = DEREF_exp(exp_postinc_op(e));
+		EXP a1 = DEREF_exp(exp_dummy_value(a));
+		EXP b1 = NULL_exp;
+		TYPE s = DEREF_type(exp_type(a));
+		/* Declare outer identity */
+		COPY_exp(exp_dummy_value(a), NULL_exp);
+		bs = make_identity(bs, a1, &n, 0, 0);
+		COPY_ulong(exp_dummy_no(a), n);
+		/* Declare inner identity if necessary */
+		if (!IS_NULL_exp(b)) {
+			ulong m;
+			b1 = DEREF_exp(exp_dummy_value(b));
+			COPY_exp(exp_dummy_value(b), NULL_exp);
+			bs = make_identity(bs, b1, &m, 1, 1);
+			COPY_ulong(exp_dummy_no(b), m);
+		}
+		/* Encode the result */
+		bs = enc_assign_op(bs, s, &bf);
+		ENC_obtain_tag(bs);
+		ENC_make_tag(bs, n);
+		if (bf) {
+			OFFSET off = DEREF_off(exp_dummy_off(a));
+			bs = enc_offset(bs, off);
+		}
+		bs = enc_exp(bs, c);
+		if (!IS_NULL_exp(b)) {
+			bs = enc_exp(bs, b);
+			COPY_exp(exp_dummy_value(b), b1);
+		}
+		COPY_exp(exp_dummy_value(a), a1);
+		break;
+	}
+	case exp_indir_tag: {
+		/* Indirection expressions */
+		EXP a = DEREF_exp(exp_indir_ptr(e));
+		bs = enc_exp(bs, a);
+		break;
+	}
+	case exp_contents_tag: {
+		/* Contents expressions */
+		EXP a = DEREF_exp(exp_contents_ptr(e));
+		bs = enc_cont_exp(bs, t, a);
+		break;
+	}
+	case exp_address_tag: {
+		/* Address expressions */
+		EXP a = DEREF_exp(exp_address_arg(e));
+		bs = enc_addr_exp(bs, t, a);
+		break;
+	}
+	case exp_address_mem_tag: {
+		/* Member address expressions */
+		EXP a = DEREF_exp(exp_address_mem_arg(e));
+		IDENTIFIER id = DEREF_id(exp_member_id(a));
+		bs = enc_ptr_mem(bs, t, id, NULL_graph);
+		break;
+	}
+	case exp_func_tag: {
+		/* Function applications */
+		bs = enc_func_call(bs, t, e);
+		break;
+	}
+	case exp_func_id_tag: {
+		/* Function identifier applications */
+		bs = enc_func_id_call(bs, t, e);
+		break;
+	}
+	case exp_negate_tag: {
+		/* Negation expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_negate(bs);
+		} else {
+			ENC_negate(bs);
+		}
+		goto unary_err_label;
+	}
+	case exp_compl_tag: {
+		/* Complement expressions */
+		ENC_not(bs);
+		goto unary_label;
+	}
+	case exp_abs_tag: {
+		/* Absolute expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_abs(bs);
+		} else {
+			ENC_abs(bs);
+		}
+		goto unary_err_label;
+	}
+unary_err_label: {
+			 /* Unary operands with error treatment */
+			 bs = enc_error_treatment(bs, t);
+			 goto unary_label;
+		 }
+unary_label: {
+		     /* Unary operands */
+		     EXP a = DEREF_exp(exp_negate_etc_arg(e));
+		     bs = enc_exp(bs, a);
+		     break;
+	     }
+	case exp_plus_tag: {
+		/* Addition expressions */
+		unsigned tag = TAG_type(t);
+		if (tag == type_floating_tag) {
+			ENC_floating_plus(bs);
+			ENC_impossible(bs);
+			ENC_LIST_SMALL(bs, 2);
+		} else {
+			if (tag == type_enumerate_tag) {
+				/* Special case for enumerators */
+				t = promote_type(t);
+			}
+			ENC_plus(bs);
+			bs = enc_error_treatment(bs, t);
+		}
+		goto binary_label;
+	}
+	case exp_minus_tag: {
+		/* Subtraction expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_minus(bs);
+		} else {
+			ENC_minus(bs);
+		}
+		goto binary_err_label;
+	}
+	case exp_mult_tag: {
+		/* Multiplication expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_mult(bs);
+			ENC_impossible(bs);
+			ENC_LIST_SMALL(bs, 2);
+		} else {
+			ENC_mult(bs);
+			bs = enc_error_treatment(bs, t);
+		}
+		goto binary_label;
+	}
+	case exp_div_tag: {
+		/* Division expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_div(bs);
+		} else {
+			int div_mode = division_mode;
+			if (div_mode == 3) {
+				/* Tokenised division */
+				bs = enc_special(bs, TOK_div);
+				goto division_label;
+			}
+			switch (div_mode) {
+			case 0:
+				ENC_div0(bs);
+				break;
+			case 1:
+				ENC_div1(bs);
+				break;
+			case 2:
+				ENC_div2(bs);
+				break;
+			}
+			ENC_impossible(bs);
+		}
+		goto binary_err_label;
+	}
+	case exp_rem_tag: {
+		/* Remainder expressions */
+		int div_mode = division_mode;
+		if (div_mode == 3) {
+			/* Tokenised division */
+			bs = enc_special(bs, TOK_rem);
+			goto division_label;
+		}
+		switch (div_mode) {
+		case 0:
+			ENC_rem0(bs);
+			break;
+		case 1:
+			ENC_rem1(bs);
+			break;
+		case 2:
+			ENC_rem2(bs);
+			break;
+		}
+		ENC_impossible(bs);
+		goto binary_err_label;
+	}
+division_label: {
+			/* Division operands */
+			EXP a = DEREF_exp(exp_plus_etc_arg1(e));
+			EXP b = DEREF_exp(exp_plus_etc_arg2(e));
+			BITSTREAM *ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_exp(ts, a);
+			ts = enc_exp(ts, b);
+			bs = enc_bitstream(bs, ts);
+			break;
+		}
+	case exp_and_tag: {
+		/* Bitwise and expressions */
+		ENC_and(bs);
+		goto binary_label;
+	}
+	case exp_or_tag: {
+		/* Bitwise or expressions */
+		ENC_or(bs);
+		goto binary_label;
+	}
+	case exp_xor_tag: {
+		/* Bitwise xor expressions */
+		ENC_xor(bs);
+		goto binary_label;
+	}
+	case exp_lshift_tag: {
+		/* Left shift expressions */
+		ENC_shift_left(bs);
+		goto binary_err_label;
+	}
+	case exp_rshift_tag: {
+		/* Right shift expressions */
+		ENC_shift_right(bs);
+		goto binary_label;
+	}
+	case exp_max_tag: {
+		/* Maximum expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_maximum(bs);
+#if (TDF_major >= 4)
+			ENC_impossible(bs);
+#endif
+		} else {
+			ENC_maximum(bs);
+		}
+		goto binary_label;
+	}
+	case exp_min_tag: {
+		/* Minimum expressions */
+		if (IS_type_floating(t)) {
+			ENC_floating_minimum(bs);
+#if (TDF_major >= 4)
+			ENC_impossible(bs);
+#endif
+		} else {
+			ENC_minimum(bs);
+		}
+		goto binary_label;
+	}
+binary_err_label: {
+			  /* Binary operands with error treatment */
+			  bs = enc_error_treatment(bs, t);
+			  goto binary_label;
+		  }
+binary_label: {
+		      /* Binary operands */
+		      EXP a = DEREF_exp(exp_plus_etc_arg1(e));
+		      EXP b = DEREF_exp(exp_plus_etc_arg2(e));
+		      bs = enc_exp(bs, a);
+		      bs = enc_exp(bs, b);
+		      break;
+	      }
+	case exp_cast_tag: {
+		/* Cast expressions */
+		EXP a = DEREF_exp(exp_cast_arg(e));
+		unsigned conv = DEREF_unsigned(exp_cast_conv(e));
+		bs = enc_cast_exp(bs, t, a, conv);
+		break;
+	}
+	case exp_base_cast_tag: {
+		/* Base class cast expressions */
+		EXP a = DEREF_exp(exp_base_cast_arg(e));
+		OFFSET off = DEREF_off(exp_base_cast_off(e));
+		unsigned conv = DEREF_unsigned(exp_base_cast_conv(e));
+		if (conv == CONV_PTR_MEM_BASE) {
+			/* Check for constant pointer to members */
+			IDENTIFIER fn = is_const_ptr_mem(a, 0);
+			if (!IS_NULL_id(fn)) {
+				CLASS_TYPE cs = parent_class(fn);
+				CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
+				GRAPH gr = find_base_class(ct, cs, 0);
+				bs = enc_ptr_mem(bs, t, fn, gr);
+				break;
+			}
+		}
+		bs = enc_base_cast_exp(bs, a, off, conv);
+		break;
+	}
+	case exp_add_ptr_tag: {
+		/* Pointer additions */
+		EXP a = DEREF_exp(exp_add_ptr_ptr(e));
+		OFFSET off = DEREF_off(exp_add_ptr_off(e));
+		int virt = DEREF_int(exp_add_ptr_virt(e));
+		bs = enc_add_ptr(bs, a, LINK_NONE, off, virt);
+		break;
+	}
+	case exp_offset_size_tag: {
+		/* Size of offset */
+		OFFSET off = DEREF_off(exp_offset_size_off(e));
+		TYPE s = DEREF_type(exp_offset_size_step(e));
+		ENC_offset_div(bs);
+		bs = enc_variety(bs, t);
+		bs = enc_offset(bs, off);
+		bs = enc_shape_offset(bs, s);
+		break;
+	}
+	case exp_constr_tag: {
+		/* Constructor calls */
+		EXP a = DEREF_exp(exp_constr_call(e));
+		bs = enc_exp(bs, a);
+		break;
+	}
+	case exp_destr_tag: {
+		/* Destructor calls */
+		EXP a = DEREF_exp(exp_destr_call(e));
+		bs = enc_exp(bs, a);
+		break;
+	}
+	case exp_rtti_no_tag: {
+		/* Link-time type information */
+		TYPE s = DEREF_type(exp_rtti_no_arg(e));
+		ENC_make_int(bs);
+		bs = enc_variety(bs, t);
+		bs = enc_arith(bs, s, 0);
+		break;
+	}
-	case exp_dynamic_tag : {
+	case exp_dynamic_tag: {
-	    /* Dynamic initialisers */
+		/* Dynamic initialisers */
-	    EXP a = DEREF_exp ( exp_dynamic_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_dynamic_arg(e));
-	    bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
+		break;
+	}
+	case exp_aggregate_tag: {
+		/* Aggregate initialisers */
+		unsigned tt = TAG_type(t);
+		if (tt == type_array_tag) {
+			bs = enc_init_array(bs, e, NULL_nat, t);
+		} else if (tt == type_compound_tag) {
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			bs = enc_init_class(bs, e, ct);
+		}
+		break;
+	}
+	case exp_nof_tag: {
+		/* Array initialisers */
+		int pad = 1;
+		EXP a = DEREF_exp(exp_nof_start(e));
+		NAT n = DEREF_nat(exp_nof_size(e));
+		EXP b = DEREF_exp(exp_nof_pad(e));
+		EXP c = DEREF_exp(exp_nof_end(e));
+		if (!IS_NULL_exp(c))ENC_concat_nof(bs);
+		if (!IS_NULL_exp(a)) {
+			/* Encode initial component */
+			if (IS_exp_aggregate(a) && is_zero_exp(b)) {
+				/* Deal with integral arrays */
+				bs = enc_init_array(bs, a, n, t);
-	    break ;
+				break;
+			}
+			if (is_zero_nat(n)) {
+				pad = 0;
+			} else {
+				ENC_concat_nof(bs);
+			}
+			bs = enc_exp(bs, a);
+		}
+		if (pad) {
+			ENC_n_copies(bs);
+			bs = enc_nat(bs, n, 1);
+			if (IS_NULL_exp(b)) {
+				TYPE s = DEREF_type(type_array_sub(t));
+				bs = enc_null_exp(bs, s);
+			} else {
+				bs = enc_exp(bs, b);
+			}
+		}
+		if (!IS_NULL_exp(c)) {
+			bs = enc_exp(bs, c);
+		}
+		break;
+	}
+	case exp_call_tag: {
+		/* Shouldn't happen */
+		EXP a = DEREF_exp(exp_call_ptr(e));
+		EXP b = DEREF_exp(exp_call_arg(e));
+		ENC_SEQ_SMALL(bs, 1);
+		bs = enc_exp(bs, a);
+		bs = enc_exp(bs, b);
+		break;
+	}
+	case exp_not_tag:
+	case exp_log_and_tag:
+	case exp_log_or_tag:
+	case exp_test_tag:
+	case exp_compare_tag: {
+		/* Logical expressions */
+		bs = enc_logical(bs, e, t);
+		break;
+	}
+	case exp_assembler_tag: {
+		/* Assembler expression */
+		bs = enc_asm(bs, e);
+		break;
+	}
+	case exp_fail_tag: {
+		/* Install-time failure expression */
+		string s = DEREF_string(exp_fail_msg(e));
+		ENC_fail_installer(bs);
+		ENC_make_string(bs);
+		bs = enc_ustring(bs, s);
+		break;
+	}
+	case exp_token_tag: {
+		/* Token applications */
+		IDENTIFIER tok = DEREF_id(exp_token_tok(e));
+		LIST(TOKEN)args = DEREF_list(exp_token_args(e));
+		bs = enc_token(bs, tok, args);
+		break;
+	}
+	case exp_dummy_tag: {
+		/* Dummy identifier tag */
+		EXP a = DEREF_exp(exp_dummy_value(e));
+		if (IS_NULL_exp(a)) {
+			ulong n = DEREF_ulong(exp_dummy_no(e));
+			OFFSET off = DEREF_off(exp_dummy_off(e));
+			int cnt = DEREF_int(exp_dummy_cont(e));
+			int virt = DEREF_int(exp_dummy_virt(e));
+			bs = enc_dummy_exp(bs, t, n, off, cnt, virt);
+		} else {
+			bs = enc_exp(bs, a);
+		}
+		break;
+	}
+#if LANGUAGE_CPP
+	case exp_alloc_tag: {
+		/* Allocator calls */
+		bs = enc_alloc(bs, e);
+		break;
+	}
+	case exp_dealloc_tag: {
+		/* Deallocator calls */
+		bs = enc_dealloc(bs, e, LINK_NONE);
+		break;
+	}
+	case exp_rtti_tag: {
+		/* Run-time type information */
+		if (IS_type_compound(t)) {
+			/* Make sure that 'type_info' is completed */
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			IGNORE compile_class(ct);
+		}
+		bs = enc_rtti_exp(bs, e);
+		break;
+	}
+	case exp_rtti_type_tag: {
+		/* Run-time type information */
+		TYPE s = DEREF_type(exp_rtti_type_arg(e));
+		int op = DEREF_int(exp_rtti_type_op(e));
+		if (IS_type_compound(t)) {
+			/* Make sure that 'type_info' is completed */
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			IGNORE compile_class(ct);
+		}
+		bs = enc_rtti_type(bs, s, op);
+		break;
+	}
+	case exp_dyn_cast_tag: {
+		/* Dynamic cast expressions */
+		bs = enc_dyn_cast(bs, e);
+		break;
+	}
+	case exp_initialiser_tag: {
+		/* Constructor initialisers */
+		bs = enc_ctor_init(bs, e);
+		break;
+	}
+	case exp_exception_tag: {
+		/* Throw expression */
+		EXP a = DEREF_exp(exp_exception_arg(e));
+		EXP b = DEREF_exp(exp_exception_size(e));
+		EXP d = DEREF_exp(exp_exception_destr(e));
+		bs = enc_throw(bs, a, b, d);
+		break;
+	}
-	case exp_aggregate_tag : {
-	    /* Aggregate initialisers */
-	    unsigned tt = TAG_type ( t ) ;
-	    if ( tt == type_array_tag ) {
-		bs = enc_init_array ( bs, e, NULL_nat, t ) ;
-	    } else if ( tt == type_compound_tag ) {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		bs = enc_init_class ( bs, e, ct ) ;
-	    }
-	    break ;
-	}
-	case exp_nof_tag : {
+	case exp_thrown_tag: {
-	    /* Array initialisers */
+		/* Thrown expression */
-	    int pad = 1 ;
-	    EXP a = DEREF_exp ( exp_nof_start ( e ) ) ;
-	    NAT n = DEREF_nat ( exp_nof_size ( e ) ) ;
+		int done = DEREF_int(exp_thrown_done(e));
-	    EXP b = DEREF_exp ( exp_nof_pad ( e ) ) ;
-	    EXP c = DEREF_exp ( exp_nof_end ( e ) ) ;
-	    if ( !IS_NULL_exp ( c ) ) ENC_concat_nof ( bs ) ;
-	    if ( !IS_NULL_exp ( a ) ) {
-		/* Encode initial component */
-		if ( IS_exp_aggregate ( a ) && is_zero_exp ( b ) ) {
-		    /* Deal with integral arrays */
-		    bs = enc_init_array ( bs, a, n, t ) ;
-		    break ;
+		if (done) {
-		}
-		if ( is_zero_nat ( n ) ) {
+			bs = enc_special(bs, TOK_except_caught);
-		    pad = 0 ;
 		} else {
-		    ENC_concat_nof ( bs ) ;
+			bs = enc_thrown(bs, t);
+		}
-		bs = enc_exp ( bs, a ) ;
-	    }
-	    if ( pad ) {
-		ENC_n_copies ( bs ) ;
-		bs = enc_nat ( bs, n, 1 ) ;
-		if ( IS_NULL_exp ( b ) ) {
-		    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-		    bs = enc_null_exp ( bs, s ) ;
-		} else {
-		    bs = enc_exp ( bs, b ) ;
-		}
-	    }
-	    if ( !IS_NULL_exp ( c ) ) bs = enc_exp ( bs, c ) ;
-	    break ;
-	}
-	case exp_call_tag : {
-	    /* Shouldn't happen */
-	    EXP a = DEREF_exp ( exp_call_ptr ( e ) ) ;
-	    EXP b = DEREF_exp ( exp_call_arg ( e ) ) ;
-	    ENC_SEQ_SMALL ( bs, 1 ) ;
-	    bs = enc_exp ( bs, a ) ;
-	    bs = enc_exp ( bs, b ) ;
-	    break ;
-	}
-	case exp_not_tag :
-	case exp_log_and_tag :
-	case exp_log_or_tag :
-	case exp_test_tag :
-	case exp_compare_tag : {
-	    /* Logical expressions */
-	    bs = enc_logical ( bs, e, t ) ;
-	    break ;
-	}
-	case exp_assembler_tag : {
-	    /* Assembler expression */
-	    bs = enc_asm ( bs, e ) ;
-	    break ;
-	}
-	case exp_fail_tag : {
-	    /* Install-time failure expression */
-	    string s = DEREF_string ( exp_fail_msg ( e ) ) ;
-	    ENC_fail_installer ( bs ) ;
-	    ENC_make_string ( bs ) ;
-	    bs = enc_ustring ( bs, s ) ;
-	    break ;
-	}
-	case exp_token_tag : {
-	    /* Token applications */
-	    IDENTIFIER tok = DEREF_id ( exp_token_tok ( e ) ) ;
-	    LIST ( TOKEN ) args = DEREF_list ( exp_token_args ( e ) ) ;
-	    bs = enc_token ( bs, tok, args ) ;
-	    break ;
-	}
-	case exp_dummy_tag : {
-	    /* Dummy identifier tag */
-	    EXP a = DEREF_exp ( exp_dummy_value ( e ) ) ;
-	    if ( IS_NULL_exp ( a ) ) {
-		ulong n = DEREF_ulong ( exp_dummy_no ( e ) ) ;
-		OFFSET off = DEREF_off ( exp_dummy_off ( e ) ) ;
-		int cnt = DEREF_int ( exp_dummy_cont ( e ) ) ;
-		int virt = DEREF_int ( exp_dummy_virt ( e ) ) ;
-		bs = enc_dummy_exp ( bs, t, n, off, cnt, virt ) ;
-	    } else {
-		bs = enc_exp ( bs, a ) ;
-	    }
-	    break ;
-	}
-#if LANGUAGE_CPP
-	case exp_alloc_tag : {
-	    /* Allocator calls */
-	    bs = enc_alloc ( bs, e ) ;
-	    break ;
-	}
-	case exp_dealloc_tag : {
-	    /* Deallocator calls */
-	    bs = enc_dealloc ( bs, e, LINK_NONE ) ;
-	    break ;
-	}
-	case exp_rtti_tag : {
-	    /* Run-time type information */
-	    if ( IS_type_compound ( t ) ) {
-		/* Make sure that 'type_info' is completed */
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		IGNORE compile_class ( ct ) ;
-	    }
-	    bs = enc_rtti_exp ( bs, e ) ;
-	    break ;
-	}
-	case exp_rtti_type_tag : {
-	    /* Run-time type information */
-	    TYPE s = DEREF_type ( exp_rtti_type_arg ( e ) ) ;
-	    int op = DEREF_int ( exp_rtti_type_op ( e ) ) ;
-	    if ( IS_type_compound ( t ) ) {
-		/* Make sure that 'type_info' is completed */
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		IGNORE compile_class ( ct ) ;
-	    }
-	    bs = enc_rtti_type ( bs, s, op ) ;
-	    break ;
+		break;
+	}
+#endif
+	case exp_comma_tag:
+	case exp_if_stmt_tag:
+	case exp_hash_if_tag:
-	case exp_dyn_cast_tag : {
+	case exp_location_tag: {
-	    /* Dynamic cast expressions */
+		/* Statement-like expressions */
-	    bs = enc_dyn_cast ( bs, e ) ;
+		bs = enc_stmt_exp(bs, e, t, 1);
-	    break ;
+		break;
+	}
+	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_return_stmt_tag:
+	case exp_goto_stmt_tag:
+	case exp_label_stmt_tag:
+	case exp_try_block_tag:
-	case exp_initialiser_tag : {
+	case exp_handler_tag: {
-	    /* Constructor initialisers */
+		/* Statements */
-	    bs = enc_ctor_init ( bs, e ) ;
+		bs = enc_stmt(bs, e);
-	    break ;
+		break;
+	}
-	case exp_exception_tag : {
+	case exp_member_tag:
-	    /* Throw expression */
+	case exp_ambiguous_tag:
-	    EXP a = DEREF_exp ( exp_exception_arg ( e ) ) ;
+	case exp_undeclared_tag:
+	case exp_set_tag:
+	case exp_unused_tag:
+	case exp_op_tag:
+	case exp_opn_tag:
-	    EXP b = DEREF_exp ( exp_exception_size ( e ) ) ;
+	case exp_uncompiled_tag:
+	default: {
-	    EXP d = DEREF_exp ( exp_exception_destr ( e ) ) ;
+		/* Illegal expressions */
-	    bs = enc_throw ( bs, a, b, d ) ;
+		ENC_make_top(bs);
-	    break ;
+		break;
+	}
-	case exp_thrown_tag : {
-	    /* Thrown expression */
-	    int done = DEREF_int ( exp_thrown_done ( e ) ) ;
-	    if ( done ) {
-		bs = enc_special ( bs, TOK_except_caught ) ;
-	    } else {
-		bs = enc_thrown ( bs, t ) ;
-	    }
-	    break ;
-	}
-#endif
-	case exp_comma_tag :
-	case exp_if_stmt_tag :
-	case exp_hash_if_tag :
-	case exp_location_tag : {
-	    /* Statement-like expressions */
-	    bs = enc_stmt_exp ( bs, e, t, 1 ) ;
-	    break ;
-	}
-	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_return_stmt_tag :
-	case exp_goto_stmt_tag :
-	case exp_label_stmt_tag :
-	case exp_try_block_tag :
-	case exp_handler_tag : {
-	    /* Statements */
-	    bs = enc_stmt ( bs, e ) ;
-	    break ;
-	}
-	case exp_member_tag :
-	case exp_ambiguous_tag :
-	case exp_undeclared_tag :
-	case exp_set_tag :
-	case exp_unused_tag :
-	case exp_op_tag :
-	case exp_opn_tag :
-	case exp_uncompiled_tag :
-	default : {
-	    /* Illegal expressions */
-	    ENC_make_top ( bs ) ;
-	    break ;
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 #endif /* TDF_OUTPUT */

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/producers/common/output/exp.c – Rev 5 → 6