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

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #if TDF_OUTPUT
 /*
     INITIALISER FLAGS
     The flag in_static_init is set to true when encoding a static
     initialiser.  The flag in_dynamic_init is set to true when encoding
     a dynamic initialiser.
 */
-int in_static_init = 0 ;
+int in_static_init = 0;
-int in_dynamic_init = 0 ;
+int in_dynamic_init = 0;
 /*
     ENCODE AN AGGREGATE ARRAY INITIALISER
     This routine adds the aggregate initialiser for an array of type t,
     given by the aggregate expression e followed by n zeros, to the
     bitstream bs.  n may be null to indicate the absence of padding.
 */
-BITSTREAM *enc_init_array
+BITSTREAM *
-    PROTO_N ( ( bs, e, n, t ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X NAT n X TYPE t )
+enc_init_array(BITSTREAM *bs, EXP e, NAT n, TYPE t)
 {
-    LIST ( EXP ) p = DEREF_list ( exp_aggregate_args ( e ) ) ;
+	LIST(EXP)p = DEREF_list(exp_aggregate_args(e));
-    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+	TYPE s = DEREF_type(type_array_sub(t));
-    unsigned tag = TAG_type ( s ) ;
+	unsigned tag = TAG_type(s);
-    if ( tag == type_integer_tag || tag == type_enumerate_tag ) {
+	if (tag == type_integer_tag || tag == type_enumerate_tag) {
-	unsigned mask = 0 ;
+		unsigned mask = 0;
-	unsigned long len = 0 ;
+		unsigned long len = 0;
-	LIST ( EXP ) q = p ;
+		LIST(EXP)q = p;
-	LIST ( unsigned ) vs = NULL_list ( unsigned ) ;
+		LIST(unsigned)vs = NULL_list(unsigned);
-	while ( !IS_NULL_list ( q ) ) {
+		while (!IS_NULL_list(q)) {
-	    /* Check for arrays of integers */
+			/* Check for arrays of integers */
-	    unsigned v = 0 ;
+			unsigned v = 0;
-	    EXP a = DEREF_exp ( HEAD_list ( q ) ) ;
+			EXP a = DEREF_exp(HEAD_list(q));
-	    if ( !IS_NULL_exp ( a ) ) {
+			if (!IS_NULL_exp(a)) {
-		NAT m ;
+				NAT m;
-		unsigned tm ;
+				unsigned tm;
-		if ( !IS_exp_int_lit ( a ) ) break ;
+				if (!IS_exp_int_lit(a)) {
+					break;
+				}
-		m = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+				m = DEREF_nat(exp_int_lit_nat(a));
-		tm = TAG_nat ( m ) ;
+				tm = TAG_nat(m);
-		if ( tm == nat_calc_tag ) {
+				if (tm == nat_calc_tag) {
-		    /* Allow for character literals */
+					/* Allow for character literals */
-		    a = eval_exp ( a, 1 ) ;
+					a = eval_exp(a, 1);
-		    if ( !IS_exp_int_lit ( a ) ) break ;
+					if (!IS_exp_int_lit(a)) {
+						break;
+					}
-		    m = DEREF_nat ( exp_int_lit_nat ( a ) ) ;
+					m = DEREF_nat(exp_int_lit_nat(a));
-		    tm = TAG_nat ( m ) ;
+					tm = TAG_nat(m);
-		}
+				}
-		if ( tm != nat_small_tag ) break ;
+				if (tm != nat_small_tag) {
+					break;
+				}
-		v = DEREF_unsigned ( nat_small_value ( m ) ) ;
+				v = DEREF_unsigned(nat_small_value(m));
-	    }
+			}
-	    CONS_unsigned ( v, vs, vs ) ;
+			CONS_unsigned(v, vs, vs);
-	    mask |= v ;
+			mask |= v;
-	    len++ ;
+			len++;
-	    q = TAIL_list ( q ) ;
+			q = TAIL_list(q);
-	}
+		}
-	if ( IS_NULL_list ( q ) ) {
+		if (IS_NULL_list(q)) {
-	    /* Array of small integers */
+			/* Array of small integers */
-	    if ( mask == 0 ) {
+			if (mask == 0) {
-		/* All zeros */
+				/* All zeros */
-		bs = enc_null_exp ( bs, t ) ;
+				bs = enc_null_exp(bs, t);
-	    } else {
+			} else {
-		/* Encode as a string */
+				/* Encode as a string */
-		LIST ( unsigned ) us ;
+				LIST(unsigned)us;
-		unsigned bits = no_bits ( mask ) ;
+				unsigned bits = no_bits(mask);
-		if ( !IS_NULL_nat ( n ) ) {
+				if (!IS_NULL_nat(n)) {
-		    /* Check for padding */
+					/* Check for padding */
-		    unsigned long pad = get_nat_value ( n ) ;
+					unsigned long pad = get_nat_value(n);
-		    if ( pad <= STRING_PADDING ) {
+					if (pad <= STRING_PADDING) {
-			len += pad ;
+						len += pad;
-			n = NULL_nat ;
+						n = NULL_nat;
-		    } else {
+					} else {
-			ENC_concat_nof ( bs ) ;
+						ENC_concat_nof(bs);
-		    }
+					}
-		}
+				}
-		ENC_make_nof_int ( bs ) ;
+				ENC_make_nof_int(bs);
-		bs = enc_variety ( bs, s ) ;
+				bs = enc_variety(bs, s);
-		ENC_make_string ( bs ) ;
+				ENC_make_string(bs);
-		ENC_INT ( bs, bits ) ;
+				ENC_INT(bs, bits);
-		ENC_INT ( bs, len ) ;
+				ENC_INT(bs, len);
-		vs = REVERSE_list ( vs ) ;
+				vs = REVERSE_list(vs);
-		us = vs ;
+				us = vs;
-		while ( !IS_NULL_list ( us ) ) {
+				while (!IS_NULL_list(us)) {
-		    /* Encode each element */
+					/* Encode each element */
+					unsigned v =
-		    unsigned v = DEREF_unsigned ( HEAD_list ( us ) ) ;
+					    DEREF_unsigned(HEAD_list(us));
-		    ENC_BITS ( bs, bits, v ) ;
+					ENC_BITS(bs, bits, v);
-		    len-- ;
+					len--;
-		    us = TAIL_list ( us ) ;
+					us = TAIL_list(us);
-		}
+				}
-		while ( len ) {
+				while (len) {
-		    /* Encode explicit padding */
+					/* Encode explicit padding */
-		    ENC_BITS ( bs, bits, 0 ) ;
+					ENC_BITS(bs, bits, 0);
-		    len-- ;
+					len--;
-		}
+				}
-		if ( !IS_NULL_nat ( n ) ) {
+				if (!IS_NULL_nat(n)) {
-		    /* Encode remaining padding */
+					/* Encode remaining padding */
-		    ENC_n_copies ( bs ) ;
+					ENC_n_copies(bs);
-		    bs = enc_nat ( bs, n, 1 ) ;
+					bs = enc_nat(bs, n, 1);
-		    bs = enc_null_exp ( bs, s ) ;
+					bs = enc_null_exp(bs, s);
-		}
+				}
-	    }
+			}
-	    DESTROY_list ( vs, SIZE_unsigned ) ;
+			DESTROY_list(vs, SIZE_unsigned);
-	    return ( bs ) ;
+			return (bs);
-	}
+		}
-	DESTROY_list ( vs, SIZE_unsigned ) ;
+		DESTROY_list(vs, SIZE_unsigned);
-    }
+	}
-    /* Simple list */
+	/* Simple list */
-    if ( !IS_NULL_nat ( n ) ) {
+	if (!IS_NULL_nat(n)) {
-	ENC_concat_nof ( bs ) ;
+		ENC_concat_nof(bs);
-    }
+	}
-    ENC_make_nof ( bs ) ;
+	ENC_make_nof(bs);
-    bs = enc_exp_list ( bs, p ) ;
+	bs = enc_exp_list(bs, p);
-    if ( !IS_NULL_nat ( n ) ) {
+	if (!IS_NULL_nat(n)) {
-	ENC_n_copies ( bs ) ;
+		ENC_n_copies(bs);
-	bs = enc_nat ( bs, n, 1 ) ;
+		bs = enc_nat(bs, n, 1);
-	bs = enc_null_exp ( bs, s ) ;
+		bs = enc_null_exp(bs, s);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE AN AGGREGATE CLASS INITIALISER
     This routine adds the aggregate initialiser for an object of class
     type t given by the aggregate expression p to the bitstream bs.  Note
     that t cannot have any base classes.
 */
-BITSTREAM *enc_init_class
+BITSTREAM *
-    PROTO_N ( ( bs, e, ct ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X CLASS_TYPE ct )
+enc_init_class(BITSTREAM *bs, EXP e, CLASS_TYPE ct)
 {
-    LIST ( EXP ) p = DEREF_list ( exp_aggregate_args ( e ) ) ;
+	LIST(EXP)p = DEREF_list(exp_aggregate_args(e));
-    LIST ( OFFSET ) q = DEREF_list ( exp_aggregate_offs ( e ) ) ;
+	LIST(OFFSET)q = DEREF_list(exp_aggregate_offs(e));
-    unsigned m = LENGTH_list ( p ) ;
+	unsigned m = LENGTH_list(p);
-    IGNORE compile_class ( ct ) ;
+	IGNORE compile_class(ct);
-    if ( m == 0 ) {
+	if (m == 0) {
-	/* Deal with empty classes */
+		/* Deal with empty classes */
-	ENC_make_value ( bs ) ;
+		ENC_make_value(bs);
-	bs = enc_ctype ( bs, ct ) ;
+		bs = enc_ctype(bs, ct);
-    } else {
+	} else {
-	ENC_make_compound ( bs ) ;
+		ENC_make_compound(bs);
-	ENC_shape_offset ( bs ) ;
+		ENC_shape_offset(bs);
-	bs = enc_ctype ( bs, ct ) ;
+		bs = enc_ctype(bs, ct);
-	ENC_LIST ( bs, m + m ) ;
+		ENC_LIST(bs, m + m);
-	while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-	    /* Scan aggregate initialiser */
+			/* Scan aggregate initialiser */
-	    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+			EXP a = DEREF_exp(HEAD_list(p));
-	    OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
+			OFFSET off = DEREF_off(HEAD_list(q));
-	    bs = enc_offset ( bs, off ) ;
+			bs = enc_offset(bs, off);
-	    bs = enc_exp ( bs, a ) ;
+			bs = enc_exp(bs, a);
-	    q = TAIL_list ( q ) ;
+			q = TAIL_list(q);
-	    p = TAIL_list ( p ) ;
+			p = TAIL_list(p);
-	}
+		}
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ALLOCATION LOOP COUNTER
     This variable is used to hold the tag of the loop counter variable
     which is used in new-initialiser expressions.
 */
-static ulong alloc_counter = LINK_NONE ;
+static ulong alloc_counter = LINK_NONE;
 /*
     DECLARE A LOOP COUNTER
     This routine declares the pointer to s variable n to be the pointer
     variable m plus the offset off and the offset of the type t.
 */
-static BITSTREAM *enc_loop_decl
+static BITSTREAM *
-    PROTO_N ( ( bs, n, m, s, cnt, off, t ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X ulong m X TYPE s X
+enc_loop_decl(BITSTREAM *bs, ulong n, ulong m, TYPE s, int cnt, OFFSET off,
-	      int cnt X OFFSET off X TYPE t )
+	      TYPE t)
+{
-    DECL_SPEC ds = dspec_none ;
+	DECL_SPEC ds = dspec_none;
-    if ( n == alloc_counter ) ds = dspec_mutable ;
+	if (n == alloc_counter) {
+		ds = dspec_mutable;
+	}
-    if ( cnt ) cnt = 2 ;
+	if (cnt) {
+		cnt = 2;
+	}
-    ENC_variable ( bs ) ;
+	ENC_variable(bs);
-    bs = enc_access ( bs, ds ) ;
+	bs = enc_access(bs, ds);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    if ( IS_NULL_type ( t ) ) {
+	if (IS_NULL_type(t)) {
-	bs = enc_dummy_exp ( bs, s, m, off, cnt, 0 ) ;
+		bs = enc_dummy_exp(bs, s, m, off, cnt, 0);
-    } else {
+	} else {
-	ENC_add_to_ptr ( bs ) ;
+		ENC_add_to_ptr(bs);
-	bs = enc_dummy_exp ( bs, s, m, off, cnt, 0 ) ;
+		bs = enc_dummy_exp(bs, s, m, off, cnt, 0);
-	bs = enc_shape_offset ( bs, t ) ;
+		bs = enc_shape_offset(bs, t);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     TEST A LOOP COUNTER
     This routine compares the pointer to t variables n and m using test
     tst, jumping to label lab if appropriate.
 */
-static BITSTREAM *enc_loop_test
+static BITSTREAM *
-    PROTO_N ( ( bs, n, m, t, lab, tst ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X ulong m X TYPE t X
+enc_loop_test(BITSTREAM *bs, ulong n, ulong m, TYPE t, ulong lab, NTEST tst)
-	      ulong lab X NTEST tst )
+{
-    ENC_pointer_test ( bs ) ;
+	ENC_pointer_test(bs);
-    ENC_OFF ( bs ) ;
+	ENC_OFF(bs);
-    bs = enc_ntest ( bs, tst ) ;
+	bs = enc_ntest(bs, tst);
-    ENC_make_label ( bs, lab ) ;
+	ENC_make_label(bs, lab);
-    ENC_contents ( bs ) ;
+	ENC_contents(bs);
-    ENC_pointer ( bs ) ;
+	ENC_pointer(bs);
-    bs = enc_alignment ( bs, t ) ;
+	bs = enc_alignment(bs, t);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    if ( m == LINK_NONE ) {
+	if (m == LINK_NONE) {
-	ENC_make_null_ptr ( bs ) ;
+		ENC_make_null_ptr(bs);
-	bs = enc_alignment ( bs, t ) ;
+		bs = enc_alignment(bs, t);
-    } else {
+	} else {
-	ENC_contents ( bs ) ;
+		ENC_contents(bs);
-	ENC_pointer ( bs ) ;
+		ENC_pointer(bs);
-	bs = enc_alignment ( bs, t ) ;
+		bs = enc_alignment(bs, t);
-	ENC_obtain_tag ( bs ) ;
+		ENC_obtain_tag(bs);
-	ENC_make_tag ( bs, m ) ;
+		ENC_make_tag(bs, m);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     TEST A BOOLEAN FLAG
     This routine tests the flag given by the tag n, and-ed with a if this
     is not zero, against zero.  A further s expressions to be evaluated
     if tst is true must be added together with the terminating expression
     of the conditional.
 */
-BITSTREAM *enc_flag_test
+BITSTREAM *
-    PROTO_N ( ( bs, n, s, a, tst ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X unsigned s X int a X NTEST tst )
+enc_flag_test(BITSTREAM *bs, ulong n, unsigned s, int a, NTEST tst)
 {
-    ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+	ulong lab = unit_no(bs, NULL_id, VAR_label, 1);
-    ENC_conditional ( bs ) ;
+	ENC_conditional(bs);
-    ENC_make_label ( bs, lab ) ;
+	ENC_make_label(bs, lab);
+	if (s) {
-    if ( s ) ENC_SEQUENCE ( bs, s ) ;
+		ENC_SEQUENCE(bs, s);
+	}
-    ENC_integer_test ( bs ) ;
+	ENC_integer_test(bs);
-    ENC_OFF ( bs ) ;
+	ENC_OFF(bs);
-    bs = enc_ntest ( bs, tst ) ;
+	bs = enc_ntest(bs, tst);
-    ENC_make_label ( bs, lab ) ;
+	ENC_make_label(bs, lab);
+	if (a) {
-    if ( a ) ENC_and ( bs ) ;
+		ENC_and(bs);
+	}
-    ENC_contents ( bs ) ;
+	ENC_contents(bs);
-    bs = enc_shape ( bs, type_sint ) ;
+	bs = enc_shape(bs, type_sint);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
+	if (a) {
-    if ( a ) bs = enc_make_int ( bs, type_sint, a ) ;
+		bs = enc_make_int(bs, type_sint, a);
+	}
-    bs = enc_make_int ( bs, type_sint, 0 ) ;
+	bs = enc_make_int(bs, type_sint, 0);
-    return ( bs ) ;
+	return (bs);
 }
 /*
     INCREMENT A LOOP COUNTER
     This routine increments (or decrements if neg is true) the pointer
     variable n by the offset of the type t.
 */
-static BITSTREAM *enc_loop_incr
+static BITSTREAM *
-    PROTO_N ( ( bs, n, t, neg ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X TYPE t X int neg )
+enc_loop_incr(BITSTREAM *bs, ulong n, TYPE t, int neg)
+{
-    ENC_assign ( bs ) ;
+	ENC_assign(bs);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    ENC_add_to_ptr ( bs ) ;
+	ENC_add_to_ptr(bs);
-    ENC_contents ( bs ) ;
+	ENC_contents(bs);
-    ENC_pointer ( bs ) ;
+	ENC_pointer(bs);
-    bs = enc_alignment ( bs, t ) ;
+	bs = enc_alignment(bs, t);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
+	if (neg) {
-    if ( neg ) ENC_offset_negate ( bs ) ;
+		ENC_offset_negate(bs);
+	}
-    bs = enc_shape_offset ( bs, t ) ;
+	bs = enc_shape_offset(bs, t);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     FIND A TERMINATOR TYPE
     This routine returns the type for a terminator for a value of type t.
 */
-static TYPE find_count_type
+static TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+find_count_type(TYPE t)
 {
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	if ( IS_type_array ( t ) ) {
+		if (IS_type_array(t)) {
-	    /* Handle arrays */
+			/* Handle arrays */
-	    NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+			NAT n = DEREF_nat(type_array_size(t));
-	    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_array_sub(t));
-	    s = find_count_type ( s ) ;
+			s = find_count_type(s);
-	    MAKE_type_array ( cv_none, s, n, t ) ;
+			MAKE_type_array(cv_none, s, n, t);
-	} else {
+		} else {
-	    t = dummy_count ;
+			t = dummy_count;
-	}
+		}
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     DECLARE A TERMINATOR COUNT VARIABLE
     This routine introduces a local variable for the terminator count
     variable given by d.
 */
-static BITSTREAM *enc_count_decl
+static BITSTREAM *
-    PROTO_N ( ( bs, d, s, pm ) )
-    PROTO_T ( BITSTREAM *bs X EXP d X TYPE s X ulong *pm )
+enc_count_decl(BITSTREAM *bs, EXP d, TYPE s, ulong *pm)
+{
-    if ( IS_exp_destr ( d ) ) {
+	if (IS_exp_destr(d)) {
-	EXP c = DEREF_exp ( exp_destr_count ( d ) ) ;
+		EXP c = DEREF_exp(exp_destr_count(d));
-	if ( !IS_NULL_exp ( c ) ) {
+		if (!IS_NULL_exp(c)) {
-	    int cnt = DEREF_int ( exp_dummy_cont ( c ) ) ;
+			int cnt = DEREF_int(exp_dummy_cont(c));
-	    if ( cnt == 0 ) {
+			if (cnt == 0) {
-		/* Variable not yet introduced */
+				/* Variable not yet introduced */
-		TYPE t = dummy_count ;
+				TYPE t = dummy_count;
-		ulong n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+				ulong n = unit_no(bs, NULL_id, VAR_tag, 1);
-		ulong m = DEREF_ulong ( exp_dummy_no ( c ) ) ;
+				ulong m = DEREF_ulong(exp_dummy_no(c));
-		s = find_count_type ( s ) ;
+				s = find_count_type(s);
-		bs = enc_loop_decl ( bs, n, m, t, 0, NULL_off, s ) ;
+				bs = enc_loop_decl(bs, n, m, t, 0, NULL_off, s);
-		COPY_int ( exp_dummy_cont ( c ), 2 ) ;
+				COPY_int(exp_dummy_cont(c), 2);
-		COPY_ulong ( exp_dummy_no ( c ), n ) ;
+				COPY_ulong(exp_dummy_no(c), n);
-		*pm = m ;
+				*pm = m;
-	    }
+			}
+		}
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     END A TERMINATOR COUNT VARIABLE
     This routine ends the terminator count given by d.
 */
-static void enc_count_end
+static void
-    PROTO_N ( ( d, m ) )
-    PROTO_T ( EXP d X ulong m )
+enc_count_end(EXP d, ulong m)
 {
-    if ( IS_exp_destr ( d ) ) {
+	if (IS_exp_destr(d)) {
-	EXP c = DEREF_exp ( exp_destr_count ( d ) ) ;
+		EXP c = DEREF_exp(exp_destr_count(d));
-	if ( !IS_NULL_exp ( c ) && m != LINK_NONE ) {
+		if (!IS_NULL_exp(c) && m != LINK_NONE) {
-	    COPY_int ( exp_dummy_cont ( c ), 0 ) ;
+			COPY_int(exp_dummy_cont(c), 0);
-	    COPY_ulong ( exp_dummy_no ( c ), m ) ;
+			COPY_ulong(exp_dummy_no(c), m);
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     INCREMENT A TERMINATOR COUNT VARIABLE
     This routine increments the terminator count variable given by d.
     Note that this is only done at the innermost level, i.e. when the
     associated type t is not an array.
 */
-static BITSTREAM *enc_count_incr
+static BITSTREAM *
-    PROTO_N ( ( bs, d, neg, t ) )
-    PROTO_T ( BITSTREAM *bs X EXP d X int neg X TYPE t )
+enc_count_incr(BITSTREAM *bs, EXP d, int neg, TYPE t)
+{
-    if ( IS_exp_destr ( d ) && !IS_type_array ( t ) ) {
+	if (IS_exp_destr(d) && !IS_type_array(t)) {
-	EXP c = DEREF_exp ( exp_destr_count ( d ) ) ;
+		EXP c = DEREF_exp(exp_destr_count(d));
-	if ( !IS_NULL_exp ( c ) ) {
+		if (!IS_NULL_exp(c)) {
-	    ulong n = DEREF_ulong ( exp_dummy_no ( c ) ) ;
+			ulong n = DEREF_ulong(exp_dummy_no(c));
-	    bs = enc_loop_incr ( bs, n, dummy_count, neg ) ;
+			bs = enc_loop_incr(bs, n, dummy_count, neg);
-	    return ( bs ) ;
+			return (bs);
+		}
+	}
-    }
-    ENC_make_top ( bs ) ;
+	ENC_make_top(bs);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A TERMINATOR TYPE
     This routine adds the type of the terminator object corresponding to
     type t to the bitstream bs.
 */
-BITSTREAM *enc_term_type
+BITSTREAM *
-    PROTO_N ( ( bs, t ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t )
+enc_term_type(BITSTREAM *bs, TYPE t)
 {
-    while ( IS_type_array ( t ) ) {
+	while (IS_type_array(t)) {
-	/* Allow for arrays */
+		/* Allow for arrays */
-	NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+		NAT n = DEREF_nat(type_array_size(t));
-	ENC_nof ( bs ) ;
+		ENC_nof(bs);
-	bs = enc_nat ( bs, n, 1 ) ;
+		bs = enc_nat(bs, n, 1);
-	t = DEREF_type ( type_array_sub ( t ) ) ;
+		t = DEREF_type(type_array_sub(t));
-    }
+	}
-    bs = enc_special ( bs, TOK_destr_type ) ;
+	bs = enc_special(bs, TOK_destr_type);
-    return ( bs ) ;
+	return (bs);
 }
 /*
     DEFINE A GLOBAL TERMINATOR OBJECT
     This routine defines a global terminator object corresponding to an
     object of type t and destructor pd.
 */
-void make_term_global
+void
-    PROTO_N ( ( t, pd ) )
-    PROTO_T ( TYPE t X EXP *pd )
+make_term_global(TYPE t, EXP *pd)
+{
-    EXP d = *pd ;
+	EXP d = *pd;
-    if ( !IS_NULL_exp ( d ) ) {
+	if (!IS_NULL_exp(d)) {
-	EXP a ;
+		EXP a;
-	while ( IS_exp_nof ( d ) ) {
+		while (IS_exp_nof(d)) {
-	    d = DEREF_exp ( exp_nof_pad ( d ) ) ;
+			d = DEREF_exp(exp_nof_pad(d));
-	}
+		}
-	a = DEREF_exp ( exp_destr_count ( d ) ) ;
+		a = DEREF_exp(exp_destr_count(d));
-	if ( IS_NULL_exp ( a ) ) {
+		if (IS_NULL_exp(a)) {
-	    /* Not already defined */
+			/* Not already defined */
-	    TYPE s = dummy_count ;
+			TYPE s = dummy_count;
-	    ulong n = capsule_no ( NULL_string, VAR_tag ) ;
+			ulong n = capsule_no(NULL_string, VAR_tag);
-	    BITSTREAM *bs = enc_tagdec_start ( NULL_id, n, t, 1 ) ;
+			BITSTREAM *bs = enc_tagdec_start(NULL_id, n, t, 1);
-	    bs = enc_term_type ( bs, t ) ;
+			bs = enc_term_type(bs, t);
-	    enc_tagdec_end ( bs ) ;
+			enc_tagdec_end(bs);
-	    bs = enc_tagdef_start ( NULL_id, n, t, 1 ) ;
+			bs = enc_tagdef_start(NULL_id, n, t, 1);
-	    while ( IS_type_array ( t ) ) {
+			while (IS_type_array(t)) {
-		NAT m = DEREF_nat ( type_array_size ( t ) ) ;
+				NAT m = DEREF_nat(type_array_size(t));
-		ENC_n_copies ( bs ) ;
+				ENC_n_copies(bs);
-		bs = enc_nat ( bs, m, 1 ) ;
+				bs = enc_nat(bs, m, 1);
-		t = DEREF_type ( type_array_sub ( t ) ) ;
+				t = DEREF_type(type_array_sub(t));
-	    }
+			}
-	    bs = enc_special ( bs, TOK_destr_null ) ;
+			bs = enc_special(bs, TOK_destr_null);
-	    enc_tagdef_end ( bs ) ;
+			enc_tagdef_end(bs);
-	    MAKE_exp_dummy ( s, NULL_exp, n, NULL_off, 0, a ) ;
+			MAKE_exp_dummy(s, NULL_exp, n, NULL_off, 0, a);
-	    COPY_exp ( exp_destr_count ( d ), a ) ;
+			COPY_exp(exp_destr_count(d), a);
+		}
+		*pd = d;
+	}
-	*pd = d ;
-    }
-    return ;
+	return;
+}
 /*
     DEFINE A LOCAL TERMINATOR OBJECT
     This routine defines a local terminator object corresponding to an
     object of type t and destructor pd.
 */
-BITSTREAM *make_term_local
+BITSTREAM *
-    PROTO_N ( ( bs, t, pd, var ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X EXP *pd X int var )
+make_term_local(BITSTREAM *bs, TYPE t, EXP *pd, int var)
+{
-    EXP d = *pd ;
+	EXP d = *pd;
-    if ( !IS_NULL_exp ( d ) ) {
+	if (!IS_NULL_exp(d)) {
-	EXP a ;
+		EXP a;
-	TYPE s = dummy_count ;
+		TYPE s = dummy_count;
-	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, dspec_none ) ;
+		bs = enc_access(bs, dspec_none);
-	ENC_make_tag ( bs, n ) ;
+		ENC_make_tag(bs, n);
-	if ( var == 4 ) {
+		if (var == 4) {
-	    /* Initialise to zero for temporaries */
+			/* Initialise to zero for temporaries */
-	    while ( IS_type_array ( t ) ) {
+			while (IS_type_array(t)) {
-		NAT m = DEREF_nat ( type_array_size ( t ) ) ;
+				NAT m = DEREF_nat(type_array_size(t));
-		ENC_n_copies ( bs ) ;
+				ENC_n_copies(bs);
-		bs = enc_nat ( bs, m, 1 ) ;
+				bs = enc_nat(bs, m, 1);
-		t = DEREF_type ( type_array_sub ( t ) ) ;
+				t = DEREF_type(type_array_sub(t));
-	    }
+			}
-	    bs = enc_special ( bs, TOK_destr_null ) ;
+			bs = enc_special(bs, TOK_destr_null);
-	} else {
+		} else {
-	    ENC_make_value ( bs ) ;
+			ENC_make_value(bs);
-	    bs = enc_term_type ( bs, t ) ;
+			bs = enc_term_type(bs, t);
+		}
+		while (IS_exp_nof(d)) {
+			d = DEREF_exp(exp_nof_pad(d));
+		}
+		MAKE_exp_dummy(s, NULL_exp, n, NULL_off, 0, a);
+		COPY_exp(exp_destr_count(d), a);
+		*pd = d;
+	}
-	while ( IS_exp_nof ( d ) ) {
-	    d = DEREF_exp ( exp_nof_pad ( d ) ) ;
-	}
-	MAKE_exp_dummy ( s, NULL_exp, n, NULL_off, 0, a ) ;
-	COPY_exp ( exp_destr_count ( d ), a ) ;
-	*pd = d ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     DECREASE A PARTIAL DESTRUCTOR COUNT
     This routine decreases the partial destructor count by the value given
     in t and n.
 */
-BITSTREAM *enc_destr_count
+BITSTREAM *
-    PROTO_N ( ( bs, t, n ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int n )
+enc_destr_count(BITSTREAM *bs, TYPE t, int n)
 {
-    TYPE s = type_sint ;
+	TYPE s = type_sint;
-    ulong m = last_params [ DUMMY_count ] ;
+	ulong m = last_params[DUMMY_count];
-    ENC_assign ( bs ) ;
+	ENC_assign(bs);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, m ) ;
+	ENC_make_tag(bs, m);
-    ENC_minus ( bs ) ;
+	ENC_minus(bs);
-    bs = enc_error_treatment ( bs, s ) ;
+	bs = enc_error_treatment(bs, s);
-    ENC_contents ( bs ) ;
+	ENC_contents(bs);
-    bs = enc_shape ( bs, s ) ;
+	bs = enc_shape(bs, s);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, m ) ;
+	ENC_make_tag(bs, m);
-    if ( !IS_NULL_type ( t ) && IS_type_array ( t ) ) {
+	if (!IS_NULL_type(t) && IS_type_array(t)) {
-	EXP a = sizeof_array ( &t, s ) ;
+		EXP a = sizeof_array(&t, s);
-	bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
-	free_exp ( a, 1 ) ;
+		free_exp(a, 1);
-    } else {
+	} else {
-	bs = enc_make_int ( bs, s, n ) ;
+		bs = enc_make_int(bs, s, n);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE THE TERMINATOR FOR A TAG
     This routine adds a terminator expression for the destructor d to the
     bitstream bs.  The other arguments are as in enc_init_tag.  The effect
     of the terminator expression is to add the destructor call to a list
     of destructors to be called at a later stage.
 */
-static BITSTREAM *enc_term_start
+static BITSTREAM *
-    PROTO_N ( ( bs, n, off, cnt, t, d, context ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X OFFSET off X int cnt X
+enc_term_start(BITSTREAM *bs, ulong n, OFFSET off, int cnt, TYPE t, EXP d,
-	      TYPE t X EXP d X int context )
+	       int context)
 {
-    int tok = TOK_destr_local ;
+	int tok = TOK_destr_local;
-    switch ( context ) {
+	switch (context) {
-	case 1 :
+	case 1:
-	destr_lab : {
+destr_lab: {
-	    /* Destroy local variable */
+		   /* Destroy local variable */
-	    BITSTREAM *ts, *us ;
+		   BITSTREAM *ts, *us;
-	    EXP c = DEREF_exp ( exp_destr_count ( d ) ) ;
+		   EXP c = DEREF_exp(exp_destr_count(d));
-	    ASSERT ( !IS_NULL_exp ( c ) ) ;
+		   ASSERT(!IS_NULL_exp(c));
-	    bs = enc_special ( bs, tok ) ;
+		   bs = enc_special(bs, tok);
-	    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		   ts = start_bitstream(NIL(FILE), bs->link);
-	    ts = enc_exp ( ts, c ) ;
+		   ts = enc_exp(ts, c);
-	    ts = enc_special ( ts, TOK_destr_cast ) ;
+		   ts = enc_special(ts, TOK_destr_cast);
-	    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
+		   us = start_bitstream(NIL(FILE), ts->link);
-	    us = enc_alignment ( us, t ) ;
+		   us = enc_alignment(us, t);
-	    us = enc_dummy_exp ( us, t, n, off, 2 * cnt, 0 ) ;
+		   us = enc_dummy_exp(us, t, n, off, 2 * cnt, 0);
-	    ts = enc_bitstream ( ts, us ) ;
+		   ts = enc_bitstream(ts, us);
-	    ts = enc_destr_func ( ts, d ) ;
+		   ts = enc_destr_func(ts, d);
-	    bs = enc_bitstream ( bs, ts ) ;
+		   bs = enc_bitstream(bs, ts);
-	    break ;
+		   break;
+	   }
+	case 2: {
+		/* Destroy global variable */
+		tok = TOK_destr_global;
+		goto destr_lab;
+	}
-	case 2 : {
+	case 5: {
-	    /* Destroy global variable */
+		/* Partial constructor count */
-	    tok = TOK_destr_global ;
+		bs = enc_destr_count(bs, t, 1);
-	    goto destr_lab ;
+		break;
+	}
-	case 5 : {
+	default: {
-	    /* Partial constructor count */
-	    bs = enc_destr_count ( bs, t, 1 ) ;
+		ENC_make_top(bs);
-	    break ;
+		break;
+	}
-	default : {
-	    ENC_make_top ( bs ) ;
-	    break ;
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE AN ASSIGNMENT TO A TAG
     This routine adds an assignment of the value e to the tag n plus offset
     off of type t (or the contents of tag n plus offset off if cnt is true)
     to the bitstream bs.  context is 2 for the initialisation of a global
     variable, 1 for the initialisation of a local variable and 0 otherwise.
     If the destructor expression d is not null then the terminator
     expressions for tag n are also initialised.  In this the case the
     output comprises two TDF expressions, otherwise it is a single
     expression.
+	}
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     CREATE A DUMMY INITIALISER EXPRESSION
     This routine creates a dummy initialiser expression of type t.
 */
-EXP make_dummy_init
+EXP
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+make_dummy_init(TYPE t)
+{
-    EXP a ;
+	EXP a;
-    if ( IS_type_array ( t ) ) {
+	if (IS_type_array(t)) {
-	NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+		NAT n = DEREF_nat(type_array_size(t));
-	TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_array_sub(t));
-	EXP b = make_dummy_init ( s ) ;
+		EXP b = make_dummy_init(s);
-	MAKE_exp_nof ( t, NULL_exp, n, b, NULL_exp, a ) ;
+		MAKE_exp_nof(t, NULL_exp, n, b, NULL_exp, a);
-	return ( a ) ;
+		return (a);
-    }
+	}
-    MAKE_exp_value ( t, a ) ;
+	MAKE_exp_value(t, a);
-    return ( a ) ;
+	return (a);
+}
 /*
     ENCODE A GLOBAL INITIALISER EXPRESSION
     This routine adds the initialiser expression e for the global variable
     with capsule tag number n and type t to the bitstream bs.  If d is
     not the null expression then the terminator expressions for tag n
     are also initialised.
 */
-BITSTREAM *enc_init_global
+BITSTREAM *
-    PROTO_N ( ( bs, e, d, n, t ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X EXP d X ulong n X TYPE t )
+enc_init_global(BITSTREAM *bs, EXP e, EXP d, ulong n, TYPE t)
 {
-    int i = in_static_init ;
+	int i = in_static_init;
-    int j = in_dynamic_init ;
+	int j = in_dynamic_init;
-    int uc = unreached_code ;
+	int uc = unreached_code;
-    unreached_code = 0 ;
+	unreached_code = 0;
-    in_static_init = 1 ;
+	in_static_init = 1;
-    if ( IS_exp_dynamic ( e ) && n != LINK_NONE ) {
+	if (IS_exp_dynamic(e) && n != LINK_NONE) {
-	/* Dynamic initialisers */
+		/* Dynamic initialisers */
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	EXP a = DEREF_exp ( exp_dynamic_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_dynamic_arg(e));
-	bs = enc_null_exp ( bs, t ) ;
+		bs = enc_null_exp(bs, t);
-	in_static_init = 0 ;
+		in_static_init = 0;
-	in_dynamic_init = 1 ;
+		in_dynamic_init = 1;
-	ts = start_bitstream ( NIL ( FILE ), init_func->link ) ;
+		ts = start_bitstream(NIL(FILE), init_func->link);
-	n = link_no ( ts, n, VAR_tag ) ;
+		n = link_no(ts, n, VAR_tag);
-	ts = enc_init_tag ( ts, n, NULL_off, 0, t, a, d, 2 ) ;
+		ts = enc_init_tag(ts, n, NULL_off, 0, t, a, d, 2);
-	init_func = join_bitstreams ( init_func, ts ) ;
+		init_func = join_bitstreams(init_func, ts);
-	if ( !IS_NULL_exp ( d ) ) init_no++ ;
+		if (!IS_NULL_exp(d)) {
+			init_no++;
+		}
-	init_no++ ;
+		init_no++;
-    } else {
+	} else {
-	/* Static initialisers */
+		/* Static initialisers */
-	bs = enc_exp ( bs, e ) ;
+		bs = enc_exp(bs, e);
-	if ( !IS_NULL_exp ( d ) && n != LINK_NONE ) {
+		if (!IS_NULL_exp(d) && n != LINK_NONE) {
-	    /* Dynamic destructors */
+			/* Dynamic destructors */
-	    BITSTREAM *ts ;
+			BITSTREAM *ts;
-	    EXP a = make_dummy_init ( t ) ;
+			EXP a = make_dummy_init(t);
-	    in_static_init = 0 ;
+			in_static_init = 0;
-	    in_dynamic_init = 1 ;
+			in_dynamic_init = 1;
-	    ts = start_bitstream ( NIL ( FILE ), init_func->link ) ;
+			ts = start_bitstream(NIL(FILE), init_func->link);
-	    n = link_no ( ts, n, VAR_tag ) ;
+			n = link_no(ts, n, VAR_tag);
-	    ts = enc_init_tag ( ts, n, NULL_off, 0, t, a, d, 2 ) ;
+			ts = enc_init_tag(ts, n, NULL_off, 0, t, a, d, 2);
-	    init_func = join_bitstreams ( init_func, ts ) ;
+			init_func = join_bitstreams(init_func, ts);
-	    init_no += 2 ;
+			init_no += 2;
-	    free_exp ( a, 1 ) ;
+			free_exp(a, 1);
+		}
+	}
-    }
-    unreached_code = uc ;
+	unreached_code = uc;
-    in_dynamic_init = j ;
+	in_dynamic_init = j;
-    in_static_init = i ;
+	in_static_init = i;
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LOCAL ASSIGNMENT EXPRESSION
     This routine is similar to enc_init_local, but handles assignment
     rather than initialisation.
 */
-BITSTREAM *enc_assign_local
+BITSTREAM *
-    PROTO_N ( ( bs, a, d, n, t, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X EXP d X ulong n X TYPE t X EXP e )
+enc_assign_local(BITSTREAM *bs, EXP a, EXP d, ulong n, TYPE t, EXP e)
 {
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	ENC_SEQ_SMALL ( bs, 1 ) ;
+		ENC_SEQ_SMALL(bs, 1);
-	ts = enc_diag_begin ( &bs ) ;
+		ts = enc_diag_begin(&bs);
+		if (!IS_NULL_exp(d)) {
-	if ( !IS_NULL_exp ( d ) ) ENC_SEQ_SMALL ( ts, 1 ) ;
+			ENC_SEQ_SMALL(ts, 1);
+		}
-	ts = enc_init_tag ( ts, n, NULL_off, 0, t, a, d, 1 ) ;
+		ts = enc_init_tag(ts, n, NULL_off, 0, t, a, d, 1);
-	bs = enc_diag_end ( bs, ts, e, 1 ) ;
+		bs = enc_diag_end(bs, ts, e, 1);
-    } else {
+	} else {
-	unsigned seq = 1 ;
+		unsigned seq = 1;
-	if ( !IS_NULL_exp ( d ) ) seq++ ;
+		if (!IS_NULL_exp(d)) {
+			seq++;
+		}
-	ENC_SEQ_SMALL ( bs, seq ) ;
+		ENC_SEQ_SMALL(bs, seq);
-	bs = enc_init_tag ( bs, n, NULL_off, 0, t, a, d, 1 ) ;
+		bs = enc_init_tag(bs, n, NULL_off, 0, t, a, d, 1);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A LOCAL INITIALISER EXPRESSION
     This routine adds the initialiser expression a for the local
     variable with tag number n (in the current unit) and type t to the
     bitstream bs.  e gives the corresponding declaration statement for
     use with diagnostics.
 */
-BITSTREAM *enc_init_local
+BITSTREAM *
-    PROTO_N ( ( bs, a, d, n, t, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X EXP d X ulong n X TYPE t X EXP e )
+enc_init_local(BITSTREAM *bs, EXP a, EXP d, ulong n, TYPE t, EXP e)
+{
-    if ( n != LINK_NONE ) {
+	if (n != LINK_NONE) {
-	switch ( TAG_exp ( a ) ) {
+		switch (TAG_exp(a)) {
-	    case exp_constr_tag :
+		case exp_constr_tag:
-	    case exp_dynamic_tag :
+		case exp_dynamic_tag:
-	    dynamic_label : {
+dynamic_label: {
-		/* Explicit initialisation */
+		       /* Explicit initialisation */
-		ENC_make_value ( bs ) ;
+		       ENC_make_value(bs);
-		bs = enc_shape ( bs, t ) ;
+		       bs = enc_shape(bs, t);
-		bs = enc_assign_local ( bs, a, d, n, t, e ) ;
+		       bs = enc_assign_local(bs, a, d, n, t, e);
-		return ( bs ) ;
+		       return (bs);
-	    }
+	       }
-	    case exp_aggregate_tag :
+		case exp_aggregate_tag:
-	    case exp_nof_tag : {
+		case exp_nof_tag: {
-		/* Explicitly initialise in non-constant cases */
+			/* Explicitly initialise in non-constant cases */
-		if ( !is_const_exp ( a, -1 ) ) goto dynamic_label ;
+			if (!is_const_exp(a, -1)) {
+				goto dynamic_label;
+			}
-		break ;
+			break;
-	    }
+		}
-	    case exp_paren_tag :
+		case exp_paren_tag:
-	    case exp_copy_tag : {
+		case exp_copy_tag: {
-		/* Parenthesised expressions */
+			/* Parenthesised expressions */
-		a = DEREF_exp ( exp_paren_etc_arg ( a ) ) ;
+			a = DEREF_exp(exp_paren_etc_arg(a));
-		bs = enc_init_local ( bs, a, d, n, t, e ) ;
+			bs = enc_init_local(bs, a, d, n, t, e);
-		return ( bs ) ;
+			return (bs);
-	    }
+		}
-	    default : {
+		default : {
-		if ( !IS_NULL_exp ( d ) ) goto dynamic_label ;
+			if (!IS_NULL_exp(d)) {
+				goto dynamic_label;
+			}
-		break ;
+			break;
+		}
-	    }
+		}
+	}
+	if (!IS_NULL_exp(e)) {
+		BITSTREAM *ts = enc_diag_begin(&bs);
+		ts = enc_exp(ts, a);
+		bs = enc_diag_end(bs, ts, e, 1);
+	} else {
+		bs = enc_exp(bs, a);
+	}
-    }
-    if ( !IS_NULL_exp ( e ) ) {
-	BITSTREAM *ts = enc_diag_begin ( &bs ) ;
-	ts = enc_exp ( ts, a ) ;
-	bs = enc_diag_end ( bs, ts, e, 1 ) ;
-    } else {
-	bs = enc_exp ( bs, a ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     IS AN EXPRESSION A COMPLEX ASSIGNEE?
     This routine checks whether the expression a, which forms the right hand
     side of an assignment, requires the use of enc_init_tag rather than a
     simple assignment operation.
 */
-int is_init_complex
+int
-    PROTO_N ( ( a ) )
-    PROTO_T ( EXP a )
+is_init_complex(EXP a)
 {
-    switch ( TAG_exp ( a ) ) {
+	switch (TAG_exp(a)) {
-	case exp_constr_tag :
+	case exp_constr_tag:
-	case exp_dynamic_tag :
+	case exp_dynamic_tag:
-	case exp_aggregate_tag :
+	case exp_aggregate_tag:
-	case exp_string_lit_tag :
+	case exp_string_lit_tag:
-	case exp_nof_tag : {
+	case exp_nof_tag: {
-	    /* These are the complex cases */
+		/* These are the complex cases */
-	    return ( 1 ) ;
+		return (1);
 	}
-	case exp_paren_tag :
+	case exp_paren_tag:
-	case exp_copy_tag : {
+	case exp_copy_tag: {
-	    a = DEREF_exp ( exp_paren_etc_arg ( a ) ) ;
+		a = DEREF_exp(exp_paren_etc_arg(a));
-	    return ( is_init_complex ( a ) ) ;
+		return (is_init_complex(a));
 	}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     ENCODE A GLOBAL TERMINATOR EXPRESSION
     capsule tag number n and type t to the termination function ts.  If m
     is not LINK_NONE then it is the capsule tag number of a flag which
     needs to be checked before the termination expression is called.
     Note that the terminations are done in the reverse order to the
     initialisations.
 */
-BITSTREAM *enc_term_global
+BITSTREAM *
-    PROTO_N ( ( ts, n, t, e, m ) )
-    PROTO_T ( BITSTREAM *ts X ulong n X TYPE t X EXP e X ulong m )
+enc_term_global(BITSTREAM *ts, ulong n, TYPE t, EXP e, ulong m)
 {
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	BITSTREAM *bs ;
+		BITSTREAM *bs;
-	int uc = unreached_code ;
+		int uc = unreached_code;
-	unreached_code = 0 ;
+		unreached_code = 0;
-	bs = start_bitstream ( NIL ( FILE ), ts->link ) ;
+		bs = start_bitstream(NIL(FILE), ts->link);
-	n = link_no ( bs, n, VAR_tag ) ;
+		n = link_no(bs, n, VAR_tag);
-	if ( m == LINK_NONE ) {
+		if (m == LINK_NONE) {
-	    /* Simple case */
+			/* Simple case */
-	    bs = enc_term_local ( bs, n, NULL_off, 0, t, e, 2 ) ;
+			bs = enc_term_local(bs, n, NULL_off, 0, t, e, 2);
-	} else {
+		} else {
-	    /* Check flag before call */
+			/* Check flag before call */
-	    m = link_no ( bs, m, VAR_tag ) ;
+			m = link_no(bs, m, VAR_tag);
-	    bs = enc_flag_test ( bs, m, ( unsigned ) 1, 0, ntest_not_eq ) ;
+			bs = enc_flag_test(bs, m,(unsigned)1, 0, ntest_not_eq);
-	    bs = enc_term_local ( bs, n, NULL_off, 0, t, e, 2 ) ;
+			bs = enc_term_local(bs, n, NULL_off, 0, t, e, 2);
-	    ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
+		}
+		ts = join_bitstreams(bs, ts);
+		unreached_code = uc;
+	}
-	ts = join_bitstreams ( bs, ts ) ;
-	unreached_code = uc ;
-    }
-    return ( ts ) ;
+	return (ts);
+}
 /*
     ENCODE A LOCAL TERMINATOR EXPRESSION
     tag number n and type t to the bitstream bs.  context is 2 for global
     variables, 1, 3 or 4 for local variables, and 0 in destructors and
     deallocation expressions.  For local variables the result consists
     of two TDF expressions (including terminator variable adjustment).
     Otherwise the result is a single expression.
 */
-BITSTREAM *enc_term_local
+BITSTREAM *
-    PROTO_N ( ( bs, n, off, cnt, t, e, context ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X OFFSET off X int cnt X
+enc_term_local(BITSTREAM *bs, ulong n, OFFSET off, int cnt, TYPE t, EXP e,
-	      TYPE t X EXP e X int context )
+	       int context)
 {
-    /* Allow for parenthesised expressions */
+	/* Allow for parenthesised expressions */
-    EXP a = NULL_exp ;
+	EXP a = NULL_exp;
-    EXP c = NULL_exp ;
+	EXP c = NULL_exp;
-    unsigned tops = 0 ;
+	unsigned tops = 0;
-    while ( IS_exp_paren_etc ( e ) ) {
+	while (IS_exp_paren_etc(e)) {
-	e = DEREF_exp ( exp_paren_etc_arg ( e ) ) ;
+		e = DEREF_exp(exp_paren_etc_arg(e));
+	}
+	/* Check for array destructors */
+	if (IS_type_array(t)) {
+		TYPE r = t;
+		EXP d = sizeof_array(&r, type_sint);
+		switch (context) {
+		case 1:
+		case 3:
+		case 4: {
+			/* Local variables */
+			tops = 1;
+			break;
+		}
+		}
+		if (IS_NULL_exp(d) || is_zero_exp(d)) {
+			/* Zero sized arrays */
+			tops++;
+		} else {
+			/* Non-trivial arrays */
+			int calc = 1;
+			ulong dn = LINK_NONE;
+			unsigned seq = tops + 2;
+			ulong ptr = unit_no(bs, NULL_id, VAR_tag, 1);
+			ulong end = unit_no(bs, NULL_id, VAR_tag, 1);
+			ulong lab = unit_no(bs, NULL_id, VAR_label, 1);
+			bs = enc_loop_decl(bs, ptr, n, r, cnt, off, t);
+			bs = enc_loop_decl(bs, end, n, r, cnt, off, NULL_type);
+			while (IS_exp_nof(e)) {
+				/* Step over array destructors */
+				e = DEREF_exp(exp_nof_pad(e));
+			}
+			if (context != 2) {
+				/* Declare counter */
+				bs = enc_count_decl(bs, e, t, &dn);
+				seq++;
+			}
+			if (IS_exp_int_lit(d)) {
+				/* Check whether dimensions are constant */
+				NAT m = DEREF_nat(exp_int_lit_nat(d));
+				if (!IS_nat_calc(m)) {
+					calc = 0;
-    }
+				}
+			}
+			if (calc) {
+				/* Check for calculated bounds */
+				ulong lab2 = unit_no(bs, NULL_id, VAR_label, 1);
+				ENC_conditional(bs);
+				ENC_make_label(bs, lab2);
+				ENC_SEQ_SMALL(bs, 1);
+				bs = enc_loop_test(bs, ptr, end, r, lab2,
+						   ntest_greater);
+				tops++;
+			}
+			ENC_repeat(bs);
+			ENC_make_label(bs, lab);
+			ENC_make_top(bs);
+			ENC_SEQ_SMALL(bs, seq);
+			bs = enc_loop_incr(bs, ptr, r, 1);
+			if (context != 2) {
+				/* Decrease counter */
+				bs = enc_count_incr(bs, e, 1, r);
+			}
+			bs = enc_term_local(bs, ptr, NULL_off, 1, r, e,
+					    context);
+			bs = enc_loop_test(bs, ptr, end, r, lab, ntest_eq);
+			enc_count_end(e, dn);
+		}
+		while (tops) {
+			ENC_make_top(bs);
+			tops--;
+		}
+		return (bs);
+	}
-    /* Check for array destructors */
-    if ( IS_type_array ( t ) ) {
-	TYPE r = t ;
-	EXP d = sizeof_array ( &r, type_sint ) ;
-	switch ( context ) {
-	    case 1 : case 3 : case 4 : {
-		/* Local variables */
-		tops = 1 ;
-		break ;
-	    }
-	}
-	if ( IS_NULL_exp ( d ) || is_zero_exp ( d ) ) {
-	    /* Zero sized arrays */
+	/* Simple destructor calls */
-	    tops++ ;
-	} else {
-	    /* Non-trivial arrays */
-	    int calc = 1 ;
-	    ulong dn = LINK_NONE ;
-	    unsigned seq = tops + 2 ;
-	    ulong ptr = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-	    ulong end = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-	    ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
-	    bs = enc_loop_decl ( bs, ptr, n, r, cnt, off, t ) ;
-	    bs = enc_loop_decl ( bs, end, n, r, cnt, off, NULL_type ) ;
-	    while ( IS_exp_nof ( e ) ) {
+	if (IS_exp_destr(e)) {
-		/* Step over array destructors */
-		e = DEREF_exp ( exp_nof_pad ( e ) ) ;
+		a = DEREF_exp(exp_destr_obj(e));
-	    }
-	    if ( context != 2 ) {
-		/* Declare counter */
-		bs = enc_count_decl ( bs, e, t, &dn ) ;
+		COPY_ulong(exp_dummy_no(a), n);
-		seq++ ;
-	    }
-	    if ( IS_exp_int_lit ( d ) ) {
+		COPY_off(exp_dummy_off(a), off);
-		/* Check whether dimensions are constant */
+		COPY_int(exp_dummy_cont(a), 2 * cnt);
-		NAT m = DEREF_nat ( exp_int_lit_nat ( d ) ) ;
+		c = DEREF_exp(exp_destr_count(e));
-		if ( !IS_nat_calc ( m ) ) calc = 0 ;
-	    }
-	    if ( calc ) {
-		/* Check for calculated bounds */
-		ulong lab2 = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
-		ENC_conditional ( bs ) ;
-		ENC_make_label ( bs, lab2 ) ;
-		ENC_SEQ_SMALL ( bs, 1 ) ;
-		bs = enc_loop_test ( bs, ptr, end, r, lab2, ntest_greater ) ;
-		tops++ ;
-	    }
-	    ENC_repeat ( bs ) ;
-	    ENC_make_label ( bs, lab ) ;
+		e = DEREF_exp(exp_destr_call(e));
-	    ENC_make_top ( bs ) ;
-	    ENC_SEQ_SMALL ( bs, seq ) ;
-	    bs = enc_loop_incr ( bs, ptr, r, 1 ) ;
-	    if ( context != 2 ) {
-		/* Decrease counter */
-		bs = enc_count_incr ( bs, e, 1, r ) ;
-	    }
-	    bs = enc_term_local ( bs, ptr, NULL_off, 1, r, e, context ) ;
-	    bs = enc_loop_test ( bs, ptr, end, r, lab, ntest_eq ) ;
-	    enc_count_end ( e, dn ) ;
+	}
-	while ( tops ) {
+	switch (context) {
+	case 1:
+	case 3: {
+		/* Local variable */
+		if (!IS_NULL_exp(c)) {
+			BITSTREAM *ts;
+			bs = enc_special(bs, TOK_destr_end);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_exp(ts, c);
+			bs = enc_bitstream(bs, ts);
+		} else {
+			tops = 1;
+		}
+		break;
+	}
+	case 4: {
+		/* Explicitly initialised local variable */
+		if (!IS_NULL_exp(c)) {
+			/* Check for initialisation */
+			BITSTREAM *ts;
+			ulong lab = unit_no(bs, NULL_id, VAR_label, 1);
+			ENC_conditional(bs);
-	    ENC_make_top ( bs ) ;
+			ENC_make_label(bs, lab);
+			ENC_SEQ_SMALL(bs, 2);
+			bs = enc_special(bs, TOK_destr_test);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_exp(ts, c);
+			ENC_make_label(ts, lab);
+			bs = enc_bitstream(bs, ts);
+			bs = enc_special(bs, TOK_destr_end);
+			ts = start_bitstream(NIL(FILE), bs->link);
+			ts = enc_exp(ts, c);
+			bs = enc_bitstream(bs, ts);
+			tops = 2;
+		} else {
-	    tops-- ;
+			tops = 1;
+		}
+		break;
+	}
+	case 5: {
+		/* Partial destructor count */
+		ulong m = last_params[DUMMY_count];
+		bs = enc_flag_test(bs, m,(unsigned)1, 0, ntest_not_eq);
+		bs = enc_destr_count(bs, t, 1);
+		break;
+	}
-	return ( bs ) ;
-    }
-    /* Simple destructor calls */
-    if ( IS_exp_destr ( e ) ) {
-	a = DEREF_exp ( exp_destr_obj ( e ) ) ;
-	COPY_ulong ( exp_dummy_no ( a ), n ) ;
-	COPY_off ( exp_dummy_off ( a ), off ) ;
-	COPY_int ( exp_dummy_cont ( a ), 2 * cnt ) ;
-	c = DEREF_exp ( exp_destr_count ( e ) ) ;
-	e = DEREF_exp ( exp_destr_call ( e ) ) ;
-    }
-    switch ( context ) {
-	case 1 :
-	case 3 : {
-	    /* Local variable */
-	    if ( !IS_NULL_exp ( c ) ) {
-		BITSTREAM *ts ;
-		bs = enc_special ( bs, TOK_destr_end ) ;
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		ts = enc_exp ( ts, c ) ;
-		bs = enc_bitstream ( bs, ts ) ;
-	    } else {
-		tops = 1 ;
-	    }
-	    break ;
+	}
-	case 4 : {
+	bs = enc_exp(bs, e);
-	    /* Explicitly initialised local variable */
-	    if ( !IS_NULL_exp ( c ) ) {
+	if (!IS_NULL_exp(a)) {
-		/* Check for initialisation */
+		/* Reset dummy expression */
-		BITSTREAM *ts ;
-		ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
-		ENC_conditional ( bs ) ;
-		ENC_make_label ( bs, lab ) ;
-		ENC_SEQ_SMALL ( bs, 2 ) ;
-		bs = enc_special ( bs, TOK_destr_test ) ;
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		ts = enc_exp ( ts, c ) ;
-		ENC_make_label ( ts, lab ) ;
+		COPY_off(exp_dummy_off(a), NULL_off);
-		bs = enc_bitstream ( bs, ts ) ;
-		bs = enc_special ( bs, TOK_destr_end ) ;
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		ts = enc_exp ( ts, c ) ;
-		bs = enc_bitstream ( bs, ts ) ;
-		tops = 2 ;
-	    } else {
-		tops = 1 ;
-	    }
-	    break ;
+	}
-	case 5 : {
+	while (tops) {
-	    /* Partial destructor count */
+		/* End any conditionals */
-	    ulong m = last_params [ DUMMY_count ] ;
-	    bs = enc_flag_test ( bs, m, ( unsigned ) 1, 0, ntest_not_eq ) ;
-	    bs = enc_destr_count ( bs, t, 1 ) ;
+		ENC_make_top(bs);
-	    break ;
+		tops--;
+	}
-    }
-    bs = enc_exp ( bs, e ) ;
-    if ( !IS_NULL_exp ( a ) ) {
-	/* Reset dummy expression */
-	COPY_off ( exp_dummy_off ( a ), NULL_off ) ;
-    }
-    while ( tops ) {
-	/* End any conditionals */
-	ENC_make_top ( bs ) ;
-	tops-- ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ALLOCATION ROUTINES
 #if LANGUAGE_CPP
 /*
     ENCODE A NEW-INITIALISER EXPRESSION
     This routine adds the initialisation of the tag n, obtained from a
     call to an allocation function, with the expression a to the bitstream
     bs.  If d is not the null expression then any exceptions thrown by a
     must be caught and the allocated memory freed using d.
 */
-static BITSTREAM *enc_init_new
+static BITSTREAM *
-    PROTO_N ( ( bs, n, a, d ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X EXP a X EXP d )
+enc_init_new(BITSTREAM *bs, ulong n, EXP a, EXP d)
 {
-    EXP a0 = new_try_body ( a ) ;
+	EXP a0 = new_try_body(a);
-    EXP a1 = DEREF_exp ( exp_assign_ref ( a0 ) ) ;
+	EXP a1 = DEREF_exp(exp_assign_ref(a0));
-    EXP a2 = DEREF_exp ( exp_assign_arg ( a0 ) ) ;
+	EXP a2 = DEREF_exp(exp_assign_arg(a0));
-    COPY_ulong ( exp_dummy_no ( a1 ), n ) ;
+	COPY_ulong(exp_dummy_no(a1), n);
-    if ( IS_NULL_exp ( d ) ) {
+	if (IS_NULL_exp(d)) {
-	/* Simple initialisation */
+		/* Simple initialisation */
-	a = DEREF_exp ( exp_try_block_body ( a ) ) ;
-	bs = enc_stmt ( bs, a ) ;
-    } else {
-	/* Initialisation with deletion */
-	int uc ;
-	ulong ex ;
-	TYPE s = NULL_type ;
-	ulong ptr = LINK_NONE ;
-	ulong prev = alloc_counter ;
-	TYPE t = DEREF_type ( exp_type ( a2 ) ) ;
-	EXP b = DEREF_exp ( exp_dealloc_term ( d ) ) ;
-	if ( IS_exp_nof ( a2 ) && !IS_NULL_exp ( b ) ) {
-	    /* Declare array initialisation counter */
-	    s = DEREF_type ( type_array_sub ( t ) ) ;
-	    ptr = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-	    alloc_counter = ptr ;
-	    bs = enc_loop_decl ( bs, ptr, n, s, 1, NULL_off, NULL_type ) ;
-	} else {
-	    alloc_counter = LINK_NONE ;
-	}
-	bs = enc_try_start ( bs, &ex, ( unsigned ) 2 ) ;
-	COPY_ulong ( exp_try_block_no ( a ), ex ) ;
-	a = DEREF_exp ( exp_try_block_body ( a ) ) ;
+		a = DEREF_exp(exp_try_block_body(a));
-	bs = enc_stmt ( bs, a ) ;
+		bs = enc_stmt(bs, a);
-	bs = enc_try_end ( bs, ex ) ;
-	uc = unreached_code ;
-	if ( ptr == LINK_NONE ) {
-	    ENC_SEQ_SMALL ( bs, 1 ) ;
 	} else {
+		/* Initialisation with deletion */
+		int uc;
+		ulong ex;
+		TYPE s = NULL_type;
+		ulong ptr = LINK_NONE;
+		ulong prev = alloc_counter;
+		TYPE t = DEREF_type(exp_type(a2));
+		EXP b = DEREF_exp(exp_dealloc_term(d));
+		if (IS_exp_nof(a2) && !IS_NULL_exp(b)) {
+			/* Declare array initialisation counter */
+			s = DEREF_type(type_array_sub(t));
+			ptr = unit_no(bs, NULL_id, VAR_tag, 1);
+			alloc_counter = ptr;
+			bs = enc_loop_decl(bs, ptr, n, s, 1, NULL_off,
+					   NULL_type);
+		} else {
+			alloc_counter = LINK_NONE;
+		}
+		bs = enc_try_start(bs, &ex,(unsigned)2);
+		COPY_ulong(exp_try_block_no(a), ex);
+		a = DEREF_exp(exp_try_block_body(a));
+		bs = enc_stmt(bs, a);
+		bs = enc_try_end(bs, ex);
+		uc = unreached_code;
+		if (ptr == LINK_NONE) {
+			ENC_SEQ_SMALL(bs, 1);
+		} else {
-	    /* Destroy a partially constructed array */
+			/* Destroy a partially constructed array */
-	    EXP b1 = b ;
+			EXP b1 = b;
-	    ulong lab1 = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+			ulong lab1 = unit_no(bs, NULL_id, VAR_label, 1);
-	    ulong lab2 = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+			ulong lab2 = unit_no(bs, NULL_id, VAR_label, 1);
-	    ENC_SEQ_SMALL ( bs, 2 ) ;
+			ENC_SEQ_SMALL(bs, 2);
-	    ENC_conditional ( bs ) ;
+			ENC_conditional(bs);
-	    ENC_make_label ( bs, lab1 ) ;
+			ENC_make_label(bs, lab1);
-	    ENC_SEQ_SMALL ( bs, 1 ) ;
+			ENC_SEQ_SMALL(bs, 1);
-	    bs = enc_loop_test ( bs, ptr, n, s, lab1, ntest_not_eq ) ;
+			bs = enc_loop_test(bs, ptr, n, s, lab1, ntest_not_eq);
-	    ENC_repeat ( bs ) ;
+			ENC_repeat(bs);
-	    ENC_make_label ( bs, lab2 ) ;
+			ENC_make_label(bs, lab2);
-	    ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
-	    ENC_SEQ_SMALL ( bs, 2 ) ;
+			ENC_SEQ_SMALL(bs, 2);
-	    bs = enc_loop_incr ( bs, ptr, s, 1 ) ;
+			bs = enc_loop_incr(bs, ptr, s, 1);
+			if (IS_exp_nof(b1)) {
-	    if ( IS_exp_nof ( b1 ) ) b1 = DEREF_exp ( exp_nof_pad ( b1 ) ) ;
+				b1 = DEREF_exp(exp_nof_pad(b1));
+			}
-	    bs = enc_term_local ( bs, ptr, NULL_off, 1, s, b1, 0 ) ;
+			bs = enc_term_local(bs, ptr, NULL_off, 1, s, b1, 0);
-	    bs = enc_loop_test ( bs, ptr, n, s, lab2, ntest_eq ) ;
+			bs = enc_loop_test(bs, ptr, n, s, lab2, ntest_eq);
-	    ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
+		}
+		COPY_exp(exp_dealloc_term(d), NULL_exp);
+		bs = enc_dealloc(bs, d, n);
+		COPY_exp(exp_dealloc_term(d), b);
+		bs = enc_rethrow(bs);
+		alloc_counter = prev;
+		unreached_code = uc;
+	}
-	COPY_exp ( exp_dealloc_term ( d ), NULL_exp ) ;
-	bs = enc_dealloc ( bs, d, n ) ;
-	COPY_exp ( exp_dealloc_term ( d ), b ) ;
-	bs = enc_rethrow ( bs ) ;
-	alloc_counter = prev ;
-	unreached_code = uc ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE AN ALLOCATION EXPRESSION
     This routine adds the allocation expression e to the bitstream bs.
 /*
     ENCODE A DEALLOCATION EXPRESSION
     This routine adds the deallocation expression e to the bitstream bs.
     If the argument is already stored in a tag then this is given by n.
 */
-BITSTREAM *enc_dealloc
+BITSTREAM *
-    PROTO_N ( ( bs, e, n ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X ulong n )
+enc_dealloc(BITSTREAM *bs, EXP e, ulong n)
+{
-    EXP a = DEREF_exp ( exp_dealloc_call ( e ) ) ;
+	EXP a = DEREF_exp(exp_dealloc_call(e));
-    EXP b = DEREF_exp ( exp_dealloc_term ( e ) ) ;
+	EXP b = DEREF_exp(exp_dealloc_term(e));
-    EXP c = DEREF_exp ( exp_dealloc_size ( e ) ) ;
+	EXP c = DEREF_exp(exp_dealloc_size(e));
-    EXP d = DEREF_exp ( exp_dealloc_arg ( e ) ) ;
+	EXP d = DEREF_exp(exp_dealloc_arg(e));
-    EXP d1 = DEREF_exp ( exp_dummy_value ( d ) ) ;
+	EXP d1 = DEREF_exp(exp_dummy_value(d));
-    /* Use given tag if necessary */
+	/* Use given tag if necessary */
-    int var = 1 ;
+	int var = 1;
-    if ( n != LINK_NONE ) {
+	if (n != LINK_NONE) {
-	COPY_exp ( exp_dummy_value ( d ), NULL_exp ) ;
+		COPY_exp(exp_dummy_value(d), NULL_exp);
-	COPY_ulong ( exp_dummy_no ( d ), n ) ;
+		COPY_ulong(exp_dummy_no(d), n);
-	var = 0 ;
+		var = 0;
-    }
-    if ( IS_NULL_exp ( b ) && IS_NULL_exp ( c ) ) {
-	/* Simple case */
-	bs = enc_exp ( bs, a ) ;
-    } else {
-	/* Complex case */
-	NAT i ;
-	TYPE t = DEREF_type ( exp_type ( d ) ) ;
-	TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
-	/* Check for virtual deallocators (see make_delete_exp) */
-	if ( !IS_NULL_exp ( a ) && IS_exp_paren ( a ) ) {
-	    if ( !IS_NULL_exp ( b ) ) a = NULL_exp ;
-	}
-	/* Introduce variable for deallocation argument */
-	if ( var ) {
-	    unsigned seq = 2 ;
-	    ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
-	    n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-	    COPY_exp ( exp_dummy_value ( d ), NULL_exp ) ;
-	    COPY_ulong ( exp_dummy_no ( d ), n ) ;
-	    ENC_variable ( bs ) ;
-	    bs = enc_access ( bs, dspec_none ) ;
-	    ENC_make_tag ( bs, n ) ;
-	    bs = enc_exp ( bs, d1 ) ;
-	    /* Check for null pointers */
-	    if ( !IS_NULL_exp ( c ) ) seq = 1 ;
-	    ENC_conditional ( bs ) ;
-	    ENC_make_label ( bs, lab ) ;
-	    ENC_SEQ_SMALL ( bs, seq ) ;
-	    bs = enc_loop_test ( bs, n, LINK_NONE, s, lab, ntest_not_eq ) ;
-	} else {
-	    if ( IS_NULL_exp ( c ) ) ENC_SEQ_SMALL ( bs, 1 ) ;
+	}
+	if (IS_NULL_exp(b) && IS_NULL_exp(c)) {
+		/* Simple case */
+		bs = enc_exp(bs, a);
+	} else {
+		/* Complex case */
+		NAT i;
+		TYPE t = DEREF_type(exp_type(d));
+		TYPE s = DEREF_type(type_ptr_sub(t));
+		/* Check for virtual deallocators (see make_delete_exp) */
+		if (!IS_NULL_exp(a) && IS_exp_paren(a)) {
+			if (!IS_NULL_exp(b)) {
+				a = NULL_exp;
+			}
+		}
+		/* Introduce variable for deallocation argument */
+		if (var) {
+			unsigned seq = 2;
+			ulong lab = unit_no(bs, NULL_id, VAR_label, 1);
+			n = unit_no(bs, NULL_id, VAR_tag, 1);
+			COPY_exp(exp_dummy_value(d), NULL_exp);
+			COPY_ulong(exp_dummy_no(d), n);
+			ENC_variable(bs);
+			bs = enc_access(bs, dspec_none);
+			ENC_make_tag(bs, n);
+			bs = enc_exp(bs, d1);
+			/* Check for null pointers */
+			if (!IS_NULL_exp(c)) {
+				seq = 1;
+			}
+			ENC_conditional(bs);
+			ENC_make_label(bs, lab);
+			ENC_SEQ_SMALL(bs, seq);
+			bs = enc_loop_test(bs, n, LINK_NONE, s, lab,
+					   ntest_not_eq);
+		} else {
+			if (IS_NULL_exp(c))ENC_SEQ_SMALL(bs, 1);
+		}
-	/* Introduce identity for array size */
+		/* Introduce identity for array size */
-	if ( !IS_NULL_exp ( c ) ) {
+		if (!IS_NULL_exp(c)) {
-	    if ( IS_exp_dummy ( c ) ) {
+			if (IS_exp_dummy(c)) {
-		int bf = 0 ;
+				int bf = 0;
-		BITSTREAM *ts ;
+				BITSTREAM *ts;
-		TYPE tz = type_size_t ;
+				TYPE tz = type_size_t;
-		ulong m = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+				ulong m = unit_no(bs, NULL_id, VAR_tag, 1);
-		COPY_ulong ( exp_dummy_no ( c ), m ) ;
+				COPY_ulong(exp_dummy_no(c), m);
-		/* Find array size */
+				/* Find array size */
-		ENC_identify ( bs ) ;
+				ENC_identify(bs);
-		bs = enc_access ( bs, dspec_none ) ;
+				bs = enc_access(bs, dspec_none);
-		ENC_make_tag ( bs, m ) ;
+				ENC_make_tag(bs, m);
-		ENC_contents ( bs ) ;
+				ENC_contents(bs);
-		bs = enc_shape ( bs, tz ) ;
+				bs = enc_shape(bs, tz);
-		bs = enc_special ( bs, TOK_ptr_to_ptr ) ;
+				bs = enc_special(bs, TOK_ptr_to_ptr);
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+				ts = start_bitstream(NIL(FILE), bs->link);
-		ts = enc_alignment ( ts, s ) ;
+				ts = enc_alignment(ts, s);
-		ts = enc_alignment ( ts, tz ) ;
+				ts = enc_alignment(ts, tz);
-		ENC_add_to_ptr ( ts ) ;
+				ENC_add_to_ptr(ts);
-		ts = enc_cont_op ( ts, t, &bf ) ;
+				ts = enc_cont_op(ts, t, &bf);
-		ts = enc_shape ( ts, t ) ;
+				ts = enc_shape(ts, t);
-		ENC_obtain_tag ( ts ) ;
+				ENC_obtain_tag(ts);
-		ENC_make_tag ( ts, n ) ;
+				ENC_make_tag(ts, n);
-		ts = enc_extra_offset ( ts, s, off_size_t, -1 ) ;
+				ts = enc_extra_offset(ts, s, off_size_t, -1);
-		bs = enc_bitstream ( bs, ts ) ;
+				bs = enc_bitstream(bs, ts);
-		ASSERT ( bf == 0 ) ;
+				ASSERT(bf == 0);
+			}
+			/* Construct dummy array type */
+			if (!IS_NULL_exp(b)) {
+				MAKE_nat_calc(c, i);
+				MAKE_type_array(cv_none, s, i, s);
+				ENC_SEQ_SMALL(bs, 1);
+			}
+		}
+		/* Encode destructors */
+		if (!IS_NULL_exp(b)) {
+			bs = enc_term_local(bs, n, NULL_off, 1, s, b, 0);
+			if (!IS_NULL_exp(c)) {
+				/* Destroy dummy array type */
+				ulong tok;
+				CV_SPEC cv;
+				IDENTIFIER tid;
+				DESTROY_type_array(destroy, cv, tid, s, i, s);
+				DESTROY_nat_calc(destroy, c, tok, i);
+				UNUSED(tok);
+				UNUSED(tid);
+				UNUSED(cv);
+				UNUSED(c);
+				UNUSED(s);
-	    }
+			}
+		}
-	    /* Construct dummy array type */
-	    if ( !IS_NULL_exp ( b ) ) {
-		MAKE_nat_calc ( c, i ) ;
-		MAKE_type_array ( cv_none, s, i, s ) ;
-		ENC_SEQ_SMALL ( bs, 1 ) ;
-	    }
-	}
-	/* Encode destructors */
-	if ( !IS_NULL_exp ( b ) ) {
-	    bs = enc_term_local ( bs, n, NULL_off, 1, s, b, 0 ) ;
-	    if ( !IS_NULL_exp ( c ) ) {
-		/* Destroy dummy array type */
-		ulong tok ;
-		CV_SPEC cv ;
-		IDENTIFIER tid ;
-		DESTROY_type_array ( destroy, cv, tid, s, i, s ) ;
-		DESTROY_nat_calc ( destroy, c, tok, i ) ;
-		UNUSED ( tok ) ;
-		UNUSED ( tid ) ;
-		UNUSED ( cv ) ;
-		UNUSED ( c ) ;
-		UNUSED ( s ) ;
-	    }
-	}
-	/* Encode deallocation function call */
+		/* Encode deallocation function call */
-	bs = enc_exp ( bs, a ) ;
+		bs = enc_exp(bs, a);
-	if ( var ) {
+		if (var) {
-	    /* End conditional */
+			/* End conditional */
-	    ENC_make_top ( bs ) ;
+			ENC_make_top(bs);
+		}
+	}
-    }
-    COPY_exp ( exp_dummy_value ( d ), d1 ) ;
+	COPY_exp(exp_dummy_value(d), d1);
-    return ( bs ) ;
+	return (bs);
+}
 #endif /* LANGUAGE_CPP */
 #endif /* TDF_OUTPUT */

Subversion Repositories tendra.SVN

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