WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/output/struct.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.
 */
     the top node of a graph, a virtual base class, or a non-virtual base
     class.  These macros give mnemonic values for these uses.  Names are
     also given to the various class type token numbers.
 */
-#define ctype_shape( A )	ctype_tok1 ( ( A ) )
+#define ctype_shape(A)		ctype_tok1((A))
-#define ctype_null_exp( A )	ctype_tok2 ( ( A ) )
+#define ctype_null_exp(A)	ctype_tok2((A))
-#define graph_al_tag( A )	graph_tok1 ( ( A ) )
+#define graph_al_tag(A)		graph_tok1((A))
-#define graph_core_off( A )	graph_tok2 ( ( A ) )
+#define graph_core_off(A)	graph_tok2((A))
-#define graph_base_off( A )	graph_tok1 ( ( A ) )
+#define graph_base_off(A)	graph_tok1((A))
-#define graph_real_off( A )	graph_tok2 ( ( A ) )
+#define graph_real_off(A)	graph_tok2((A))
 /*
     DUMMY CLASS TYPE
     These types are dummies used in the class layout routines.
 */
-TYPE dummy_class = NULL_type ;
+TYPE dummy_class = NULL_type;
-TYPE dummy_vtab = NULL_type ;
+TYPE dummy_vtab = NULL_type;
-TYPE dummy_count = NULL_type ;
+TYPE dummy_count = NULL_type;
-TYPE ptr_dummy_class = NULL_type ;
+TYPE ptr_dummy_class = NULL_type;
-TYPE ptr_dummy_vtab = NULL_type ;
+TYPE ptr_dummy_vtab = NULL_type;
-TYPE dummy_func = NULL_type ;
+TYPE dummy_func = NULL_type;
-ulong size_dummy_vtab = 0 ;
+ulong size_dummy_vtab = 0;
-OFFSET off_size_t = NULL_off ;
+OFFSET off_size_t = NULL_off;
-IDENTIFIER dummy_type_name = NULL_id ;
+IDENTIFIER dummy_type_name = NULL_id;
 /*
     ENCODE AN EXPRESSION TOKEN APPLICATION
     This routine adds an application of the simple expression token n to
     the bitstream bs.
 */
-static BITSTREAM *enc_exp_token
+static BITSTREAM *
-    PROTO_N ( ( bs, n ) )
-    PROTO_T ( BITSTREAM *bs X ulong n )
+enc_exp_token(BITSTREAM *bs, ulong n)
+{
-    ulong m = link_no ( bs, n, VAR_token ) ;
+	ulong m = link_no(bs, n, VAR_token);
-    ENC_exp_apply_token ( bs ) ;
+	ENC_exp_apply_token(bs);
-    ENC_make_tok ( bs, m ) ;
+	ENC_make_tok(bs, m);
-    ENC_LEN_SMALL ( bs, 0 ) ;
+	ENC_LEN_SMALL(bs, 0);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A SHAPE TOKEN APPLICATION
     This routine adds an application of the simple shape token n to the
     bitstream bs.
 */
-static BITSTREAM *enc_shape_token
+static BITSTREAM *
-    PROTO_N ( ( bs, n ) )
-    PROTO_T ( BITSTREAM *bs X ulong n )
+enc_shape_token(BITSTREAM *bs, ulong n)
+{
-    ulong m = link_no ( bs, n, VAR_token ) ;
+	ulong m = link_no(bs, n, VAR_token);
-    ENC_shape_apply_token ( bs ) ;
+	ENC_shape_apply_token(bs);
-    ENC_make_tok ( bs, m ) ;
+	ENC_make_tok(bs, m);
-    ENC_LEN_SMALL ( bs, 0 ) ;
+	ENC_LEN_SMALL(bs, 0);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     VIRTUAL FUNCTION TABLE ROUTINES
 /*
     ENCODE A BUFFER AS A STRING LITERAL
     This routine adds the contents of the buffer bf to the bitstream bs
     as a string literal.
 */
-static BITSTREAM *enc_buffer
+static BITSTREAM *
-    PROTO_N ( ( bs, bf ) )
-    PROTO_T ( BITSTREAM *bs X BUFFER *bf )
+enc_buffer(BITSTREAM *bs, BUFFER *bf)
+{
-    string s = bf->start ;
+	string s = bf->start;
-    unsigned long n = ( unsigned long ) ( bf->posn - s ) ;
+	unsigned long n = (unsigned long)(bf->posn - s);
-    /* Declare the string literal */
+	/* Declare the string literal */
-    ulong m = capsule_no ( NULL_string, VAR_tag ) ;
+	ulong m = capsule_no(NULL_string, VAR_tag);
-    BITSTREAM *ts = enc_tagdec_start ( NULL_id, m, NULL_type, 1 ) ;
+	BITSTREAM *ts = enc_tagdec_start(NULL_id, m, NULL_type, 1);
-    ENC_nof ( ts ) ;
+	ENC_nof(ts);
-    ENC_make_nat ( ts ) ;
+	ENC_make_nat(ts);
-    ENC_INT ( ts, n ) ;
+	ENC_INT(ts, n);
-    ts = enc_shape ( ts, type_char ) ;
+	ts = enc_shape(ts, type_char);
-    enc_tagdec_end ( ts ) ;
+	enc_tagdec_end(ts);
-    /* Define the string literal */
+	/* Define the string literal */
-    ts = enc_tagdef_start ( NULL_id, m, NULL_type, 1 ) ;
+	ts = enc_tagdef_start(NULL_id, m, NULL_type, 1);
-    ENC_make_nof_int ( ts ) ;
+	ENC_make_nof_int(ts);
-    ts = enc_variety ( ts, type_char ) ;
+	ts = enc_variety(ts, type_char);
-    ENC_make_string ( ts ) ;
+	ENC_make_string(ts);
-    ts = enc_tdfstring ( ts, n, s ) ;
+	ts = enc_tdfstring(ts, n, s);
-    enc_tagdef_end ( ts ) ;
+	enc_tagdef_end(ts);
-    /* Encode the result */
+	/* Encode the result */
-    m = link_no ( bs, m, VAR_tag ) ;
+	m = link_no(bs, m, VAR_tag);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, m ) ;
+	ENC_make_tag(bs, m);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE RUN-TIME BASE CLASS INFORMATION
     This routine defines the run-time base class information for the base
     classes br or the sub-types pt and adds the address of the first base
     to bs.
 */
-static BITSTREAM *enc_rtti_bases
+static BITSTREAM *
-    PROTO_N ( ( bs, br, pt, sz ) )
-    PROTO_T ( BITSTREAM *bs X LIST ( GRAPH ) br X LIST ( TYPE ) pt X NAT sz )
+enc_rtti_bases(BITSTREAM *bs, LIST(GRAPH)br, LIST(TYPE)pt, NAT sz)
 {
-    TYPE t ;
+	TYPE t;
-    ulong n, m ;
+	ulong n, m;
-    BITSTREAM *ts, *us ;
+	BITSTREAM *ts, *us;
-    int a = INFO_public ;
+	int a = INFO_public;
-    if ( !IS_NULL_list ( br ) ) {
+	if (!IS_NULL_list(br)) {
-	/* Get base class information */
+		/* Get base class information */
-	VIRTUAL vt ;
+		VIRTUAL vt;
-	CLASS_TYPE ct ;
+		CLASS_TYPE ct;
-	GRAPH gr = DEREF_graph ( HEAD_list ( br ) ) ;
+		GRAPH gr = DEREF_graph(HEAD_list(br));
-	DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+		DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-	br = TAIL_list ( br ) ;
+		br = TAIL_list(br);
-	/* Find base class information */
+		/* Find base class information */
-	ct = DEREF_ctype ( graph_head ( gr ) ) ;
+		ct = DEREF_ctype(graph_head(gr));
-	t = make_class_type ( ct ) ;
+		t = make_class_type(ct);
-	vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+		vt = DEREF_virt(ctype_virt(ct));
-	if ( !IS_NULL_virt ( vt ) ) {
+		if (!IS_NULL_virt(vt)) {
-	    /* Make sure base class is declared */
+			/* Make sure base class is declared */
-	    int used = DEREF_int ( virt_table_rtti_used ( vt ) ) ;
+			int used = DEREF_int(virt_table_rtti_used(vt));
-	    if ( !used ) {
+			if (!used) {
-		IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+				IDENTIFIER cid = DEREF_id(ctype_name(ct));
-		COPY_int ( virt_table_rtti_used ( vt ), 1 ) ;
+				COPY_int(virt_table_rtti_used(vt), 1);
-		compile_virtual ( ct, !has_linkage ( cid ) ) ;
+				compile_virtual(ct, !has_linkage(cid));
-	    }
+			}
-	}
+		}
-	if ( acc & dspec_virtual ) sz = small_nat [1] ;
+		if (acc & dspec_virtual) {
+			sz = small_nat[1];
+		}
-	acc &= dspec_access ;
+		acc &= dspec_access;
-	if ( acc == dspec_protected ) {
+		if (acc == dspec_protected) {
-	    a = INFO_protected ;
+			a = INFO_protected;
-	} else if ( acc == dspec_private ) {
+		} else if (acc == dspec_private) {
-	    a = INFO_private ;
+			a = INFO_private;
-	}
+		}
-	m = DEREF_ulong ( graph_base_off ( gr ) ) ;
+		m = DEREF_ulong(graph_base_off(gr));
-    } else if ( !IS_NULL_list ( pt ) ) {
+	} else if (!IS_NULL_list(pt)) {
-	/* Get sub-type information */
+		/* Get sub-type information */
-	t = DEREF_type ( HEAD_list ( pt ) ) ;
+		t = DEREF_type(HEAD_list(pt));
-	pt = TAIL_list ( pt ) ;
+		pt = TAIL_list(pt);
-	if ( !IS_NULL_type ( t ) ) {
+		if (!IS_NULL_type(t)) {
-	    CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
+			CV_SPEC cv = DEREF_cv(type_qual(t));
-	    if ( IS_type_func ( t ) ) {
+			if (IS_type_func(t)) {
-		/* Allow for function qualifiers */
+				/* Allow for function qualifiers */
-		cv = DEREF_cv ( type_func_mqual ( t ) ) ;
+				cv = DEREF_cv(type_func_mqual(t));
-	    }
+			}
-	    if ( cv ) {
+			if (cv) {
-		if ( cv & cv_const ) a |= INFO_const ;
+				if (cv & cv_const) {
+					a |= INFO_const;
+				}
-		if ( cv & cv_volatile ) a |= INFO_volatile ;
+				if (cv & cv_volatile) {
+					a |= INFO_volatile;
+				}
-		t = qualify_type ( t, cv_none, 0 ) ;
+				t = qualify_type(t, cv_none, 0);
-	    }
+			}
-	}
+		}
-	m = LINK_NONE ;
+		m = LINK_NONE;
-    } else {
+	} else {
-	/* Output end of list */
+		/* Output end of list */
-	ENC_make_null_ptr ( bs ) ;
+		ENC_make_null_ptr(bs);
-	ENC_alignment ( bs ) ;
+		ENC_alignment(bs);
-	bs = enc_special ( bs, TOK_baseid_type ) ;
+		bs = enc_special(bs, TOK_baseid_type);
-	return ( bs ) ;
+		return (bs);
-    }
+	}
-    /* Declare base structure */
-    n = capsule_no ( NULL_string, VAR_tag ) ;
-    ts = enc_tagdec_start ( NULL_id, n, NULL_type, 1 ) ;
-    ts = enc_special ( ts, TOK_baseid_type ) ;
-    enc_tagdec_end ( ts ) ;
+	/* Declare base structure */
+	n = capsule_no(NULL_string, VAR_tag);
+	ts = enc_tagdec_start(NULL_id, n, NULL_type, 1);
+	ts = enc_special(ts, TOK_baseid_type);
+	enc_tagdec_end(ts);
-    /* Define base structure */
+	/* Define base structure */
-    ts = enc_tagdef_start ( NULL_id, n, NULL_type, 1 ) ;
+	ts = enc_tagdef_start(NULL_id, n, NULL_type, 1);
-    ts = enc_special ( ts, TOK_baseid_make ) ;
+	ts = enc_special(ts, TOK_baseid_make);
-    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
+	us = start_bitstream(NIL(FILE), ts->link);
-    us = enc_rtti_type ( us, t, lex_typeid ) ;
+	us = enc_rtti_type(us, t, lex_typeid);
-    if ( m == LINK_NONE ) {
+	if (m == LINK_NONE) {
-	ENC_offset_zero ( us ) ;
+		ENC_offset_zero(us);
-	us = enc_alignment ( us, type_sint ) ;
+		us = enc_alignment(us, type_sint);
-    } else {
+	} else {
-	us = enc_exp_token ( us, m ) ;
+		us = enc_exp_token(us, m);
-    }
+	}
-    us = enc_rtti_bases ( us, br, pt, NULL_nat ) ;
+	us = enc_rtti_bases(us, br, pt, NULL_nat);
-    us = enc_make_snat ( us, a ) ;
+	us = enc_make_snat(us, a);
-    us = enc_snat ( us, sz, 0, 0 ) ;
+	us = enc_snat(us, sz, 0, 0);
-    ts = enc_bitstream ( ts, us ) ;
+	ts = enc_bitstream(ts, us);
-    enc_tagdef_end ( ts ) ;
+	enc_tagdef_end(ts);
-    /* Encode the result */
+	/* Encode the result */
-    n = link_no ( bs, n, VAR_tag ) ;
+	n = link_no(bs, n, VAR_tag);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A RUN-TIME TYPE INFORMATION STRUCTURE
     This routine defines the tag n to be the run-time type information
     structure for the type t.  If def is false then only the declaration
     is output.
 */
-static void enc_rtti_struct
+static void
-    PROTO_N ( ( t, n, def ) )
-    PROTO_T ( TYPE t X ulong n X int def )
+enc_rtti_struct(TYPE t, ulong n, int def)
+{
-    unsigned acc = find_usage ( n, VAR_tag ) ;
+	unsigned acc = find_usage(n, VAR_tag);
-    if ( !( acc & USAGE_DECL ) ) {
+	if (!(acc & USAGE_DECL)) {
-	BITSTREAM *bs = enc_tagdec_start ( NULL_id, n, NULL_type, 1 ) ;
+		BITSTREAM *bs = enc_tagdec_start(NULL_id, n, NULL_type, 1);
-	bs = enc_special ( bs, TOK_typeid_type ) ;
+		bs = enc_special(bs, TOK_typeid_type);
-	enc_tagdec_end ( bs ) ;
+		enc_tagdec_end(bs);
-    }
+	}
-    if ( def && !( acc & USAGE_DEFN ) ) {
+	if (def && !(acc & USAGE_DEFN)) {
-	int c = RTTI_void ;
+		int c = RTTI_void;
-	NAT sz = NULL_nat ;
+		NAT sz = NULL_nat;
-	BITSTREAM *bs, *ts ;
+		BITSTREAM *bs, *ts;
-	LIST ( TYPE ) p = NULL_list ( TYPE ) ;
+		LIST(TYPE)p = NULL_list(TYPE);
-	LIST ( GRAPH ) br = NULL_list ( GRAPH ) ;
+		LIST(GRAPH)br = NULL_list(GRAPH);
-	BUFFER *bf = clear_buffer ( &print_buff, NIL ( FILE ) ) ;
+		BUFFER *bf = clear_buffer(&print_buff, NIL(FILE));
-	print_uniq_anon++ ;
+		print_uniq_anon++;
-	IGNORE print_type ( t, bf, 0 ) ;
+		IGNORE print_type(t, bf, 0);
-	print_uniq_anon-- ;
+		print_uniq_anon--;
-	bfputc ( bf, 0 ) ;
+		bfputc(bf, 0);
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_integer_tag : {
+		case type_integer_tag: {
-		/* Integral types */
+			/* Integral types */
-		c = RTTI_integer ;
+			c = RTTI_integer;
-		break ;
+			break;
-	    }
+		}
-	    case type_floating_tag : {
+		case type_floating_tag: {
-		/* Floating-point types */
+			/* Floating-point types */
-		c = RTTI_float ;
+			c = RTTI_float;
-		break ;
+			break;
-	    }
+		}
-	    case type_ptr_tag : {
+		case type_ptr_tag: {
-		/* Pointer types */
+			/* Pointer types */
-		TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_sub(t));
-		CONS_type ( s, p, p ) ;
+			CONS_type(s, p, p);
-		c = RTTI_ptr ;
+			c = RTTI_ptr;
-		break ;
+			break;
-	    }
+		}
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		/* Reference types */
+			/* Reference types */
-		TYPE s = DEREF_type ( type_ref_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ref_sub(t));
-		CONS_type ( s, p, p ) ;
+			CONS_type(s, p, p);
-		c = RTTI_ref ;
+			c = RTTI_ref;
-		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));
-		CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(type_ptr_mem_of(t));
-		CONS_type ( s, p, p ) ;
+			CONS_type(s, p, p);
-		s = make_class_type ( cs ) ;
+			s = make_class_type(cs);
-		CONS_type ( s, p, p ) ;
+			CONS_type(s, p, p);
-		c = RTTI_ptr_mem ;
+			c = RTTI_ptr_mem;
-		break ;
+			break;
-	    }
+		}
-	    case type_func_tag : {
+		case type_func_tag: {
-		/* Function types */
+			/* Function types */
-		TYPE s = DEREF_type ( type_func_ret ( t ) ) ;
+			TYPE s = DEREF_type(type_func_ret(t));
-		CV_SPEC mq = DEREF_cv ( type_func_mqual ( t ) ) ;
+			CV_SPEC mq = DEREF_cv(type_func_mqual(t));
-		int ell = DEREF_int ( type_func_ellipsis ( t ) ) ;
+			int ell = DEREF_int(type_func_ellipsis(t));
-		LIST ( TYPE ) q = DEREF_list ( type_func_ptypes ( t ) ) ;
+			LIST(TYPE)q = DEREF_list(type_func_ptypes(t));
-		CONS_type ( s, p, p ) ;
+			CONS_type(s, p, p);
-		while ( !IS_NULL_list ( q ) ) {
+			while (!IS_NULL_list(q)) {
-		    s = DEREF_type ( HEAD_list ( q ) ) ;
+				s = DEREF_type(HEAD_list(q));
-		    CONS_type ( s, p, p ) ;
+				CONS_type(s, p, p);
-		    q = TAIL_list ( q ) ;
+				q = TAIL_list(q);
-		}
+			}
-		if ( ell & FUNC_ELLIPSIS ) {
+			if (ell & FUNC_ELLIPSIS) {
-		    CONS_type ( type_any, p, p ) ;
+				CONS_type(type_any, p, p);
+			}
+			p = REVERSE_list(p);
+			if (mq & cv_c) {
+				c = RTTI_c_func;
+			} else {
+				c = RTTI_func;
+			}
+			break;
+		}
+		case type_array_tag: {
+			/* Array types */
+			TYPE s = DEREF_type(type_array_sub(t));
+			CONS_type(s, p, p);
+			sz = DEREF_nat(type_array_size(t));
+			c = RTTI_array;
+			break;
+		}
+		case type_bitfield_tag: {
+			/* Bitfield types */
+			INT_TYPE it = DEREF_itype(type_bitfield_defn(t));
+			TYPE s = DEREF_type(itype_bitfield_sub(it));
+			CONS_type(s, p, p);
+			sz = DEREF_nat(itype_bitfield_size(it));
+			c = RTTI_bitfield;
+			break;
+		}
+		case type_compound_tag: {
+			/* Class types */
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
+			GRAPH gr = DEREF_graph(ctype_base(ct));
+			br = DEREF_list(graph_tails(gr));
+			if (ci & cinfo_union) {
+				c = RTTI_union;
+			} else {
+				c = RTTI_class;
+			}
+			break;
+		}
-		p = REVERSE_list ( p ) ;
+		case type_enumerate_tag: {
-		if ( mq & cv_c ) {
+			/* Enumeration types */
-		    c = RTTI_c_func ;
+			c = RTTI_enum;
-		} else {
+			break;
-		    c = RTTI_func ;
+		}
-		break ;
-	    }
-	    case type_array_tag : {
-		/* Array types */
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-		CONS_type ( s, p, p ) ;
-		sz = DEREF_nat ( type_array_size ( t ) ) ;
-		c = RTTI_array ;
-		break ;
-	    }
-	    case type_bitfield_tag : {
-		/* Bitfield types */
-		INT_TYPE it = DEREF_itype ( type_bitfield_defn ( t ) ) ;
-		TYPE s = DEREF_type ( itype_bitfield_sub ( it ) ) ;
-		CONS_type ( s, p, p ) ;
-		sz = DEREF_nat ( itype_bitfield_size ( it ) ) ;
-		c = RTTI_bitfield ;
-		break ;
-	    }
-	    case type_compound_tag : {
-		/* Class types */
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
-		GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
-		br = DEREF_list ( graph_tails ( gr ) ) ;
-		if ( ci & cinfo_union ) {
-		    c = RTTI_union ;
-		} else {
-		    c = RTTI_class ;
+		}
+		bs = enc_tagdef_start(NULL_id, n, NULL_type, 1);
+		bs = enc_special(bs, TOK_typeid_make);
+		ts = start_bitstream(NIL(FILE), bs->link);
-		break ;
+		ts = enc_make_snat(ts, c);
-	    }
+		ts = enc_buffer(ts, bf);
-	    case type_enumerate_tag : {
+		ts = enc_rtti_bases(ts, br, p, sz);
-		/* Enumeration types */
+		DESTROY_list(p, SIZE_type);
-		c = RTTI_enum ;
+		bs = enc_bitstream(bs, ts);
-		break ;
+		enc_tagdef_end(bs);
-	    }
+	}
-	bs = enc_tagdef_start ( NULL_id, n, NULL_type, 1 ) ;
-	bs = enc_special ( bs, TOK_typeid_make ) ;
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-	ts = enc_make_snat ( ts, c ) ;
-	ts = enc_buffer ( ts, bf ) ;
-	ts = enc_rtti_bases ( ts, br, p, sz ) ;
-	DESTROY_list ( p, SIZE_type ) ;
-	bs = enc_bitstream ( bs, ts ) ;
-	enc_tagdef_end ( bs ) ;
-    }
-    return ;
+	return;
+}
 /*
     LIST OF RUN-TIME TYPE INFORMATION STRUCTURES
     These lists gives the tag numbers for the various type information
     structures output.  Polymorphic classes, which form the most common
     such types, are dealt with separately as part of the virtual function
     table.
 */
-static LIST ( TYPE ) rtti_types = NULL_list ( TYPE ) ;
+static LIST(TYPE)rtti_types = NULL_list(TYPE);
-static LIST ( ulong ) rtti_tags = NULL_list ( ulong ) ;
+static LIST(ulong)rtti_tags = NULL_list(ulong);
 /*
     ENCODE THE RUN-TIME TYPE INFORMATION FOR A TYPE
     This routine adds a reference to the run-time type information
     structure for the type t to the bitstream bs, defining this if
     necessary.
 */
-BITSTREAM *enc_rtti_type
+BITSTREAM *
-    PROTO_N ( ( bs, t, op ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int op )
+enc_rtti_type(BITSTREAM *bs, TYPE t, int op)
 {
-    ulong n = LINK_NONE ;
+	ulong n = LINK_NONE;
-    if ( IS_NULL_type ( t ) ) {
+	if (IS_NULL_type(t)) {
-	/* Map null type to null pointer */
+		/* Map null type to null pointer */
-	ENC_make_null_ptr ( bs ) ;
+		ENC_make_null_ptr(bs);
-	ENC_alignment ( bs ) ;
+		ENC_alignment(bs);
-	bs = enc_special ( bs, TOK_typeid_type ) ;
+		bs = enc_special(bs, TOK_typeid_type);
-	return ( bs ) ;
+		return (bs);
-    }
+	}
-    if ( op == lex_typeid && !output_rtti ) {
+	if (op == lex_typeid && !output_rtti) {
-	/* Use dummy type if RTTI suppressed */
+		/* Use dummy type if RTTI suppressed */
-	t = type_error ;
+		t = type_error;
-    }
+	}
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_top_tag :
+	case type_top_tag:
-	case type_bottom_tag :
+	case type_bottom_tag:
-	case type_integer_tag :
+	case type_integer_tag:
-	case type_floating_tag :
+	case type_floating_tag:
-	case type_pre_tag :
+	case type_pre_tag:
-	case type_error_tag : {
+	case type_error_tag: {
-	    /* Built-in types */
+		/* Built-in types */
-	    BITSTREAM *ts ;
+		BITSTREAM *ts;
-	    bs = enc_special ( bs, TOK_typeid_basic ) ;
+		bs = enc_special(bs, TOK_typeid_basic);
-	    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	    ts = enc_arith ( ts, t, 1 ) ;
+		ts = enc_arith(ts, t, 1);
-	    bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-	    return ( bs ) ;
+		return (bs);
 	}
-	case type_compound_tag : {
+	case type_compound_tag: {
-	    /* Class types */
+		/* Class types */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+		CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-	    if ( ci & cinfo_polymorphic ) {
+		if (ci & cinfo_polymorphic) {
-		/* Polymorphic class types */
+			/* Polymorphic class types */
-		int used ;
+			int used;
-		VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+			VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-		n = DEREF_ulong ( virt_table_rtti ( vt ) ) ;
+			n = DEREF_ulong(virt_table_rtti(vt));
-		if ( n == LINK_NONE ) {
+			if (n == LINK_NONE) {
-		    IGNORE compile_class ( ct ) ;
+				IGNORE compile_class(ct);
-		    n = DEREF_ulong ( virt_table_rtti ( vt ) ) ;
+				n = DEREF_ulong(virt_table_rtti(vt));
-		}
+			}
-		used = DEREF_int ( virt_table_rtti_used ( vt ) ) ;
+			used = DEREF_int(virt_table_rtti_used(vt));
-		if ( !used ) {
+			if (!used) {
-		    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+				IDENTIFIER cid = DEREF_id(ctype_name(ct));
-		    COPY_int ( virt_table_rtti_used ( vt ), 1 ) ;
+				COPY_int(virt_table_rtti_used(vt), 1);
-		    compile_virtual ( ct, !has_linkage ( cid ) ) ;
+				compile_virtual(ct, !has_linkage(cid));
+			}
+			if (op == lex_vtable) {
+				/* Deal with virtual function tables */
+				/* NOT YET IMPLEMENTED */
+				n = DEREF_ulong(virt_table_tbl(vt));
+				n = link_no(bs, n, VAR_tag);
+				ENC_obtain_tag(bs);
+				ENC_make_tag(bs, n);
+				return (bs);
+			}
+		} else {
+			IGNORE compile_class(ct);
+		}
+		break;
+	}
+	}
+	if (n == LINK_NONE) {
+		/* Check for previous definition */
+		LIST(TYPE)p = rtti_types;
+		LIST(ulong)q = rtti_tags;
+		while (!IS_NULL_list(p)) {
+			TYPE s = DEREF_type(HEAD_list(p));
+			if (eq_type(s, t)) {
+				n = DEREF_ulong(HEAD_list(q));
+				break;
+			}
+			q = TAIL_list(q);
+			p = TAIL_list(p);
+		}
+		if (n == LINK_NONE) {
+			/* Define a new structure */
+			string s = NULL;
+			if (output_all) {
+				s = mangle_tname("__ti__", t);
+			}
+			n = capsule_no(s, VAR_tag);
+			CONS_type(t, rtti_types, rtti_types);
+			CONS_ulong(n, rtti_tags, rtti_tags);
+			enc_rtti_struct(t, n, 1);
+		}
-		if ( op == lex_vtable ) {
-		    /* Deal with virtual function tables */
-		    /* NOT YET IMPLEMENTED */
-		    n = DEREF_ulong ( virt_table_tbl ( vt ) ) ;
-		    n = link_no ( bs, n, VAR_tag ) ;
-		    ENC_obtain_tag ( bs ) ;
-		    ENC_make_tag ( bs, n ) ;
-		    return ( bs ) ;
-		}
-	    } else {
-		IGNORE compile_class ( ct ) ;
-	    }
-	    break ;
-	}
-    }
-    if ( n == LINK_NONE ) {
-	/* Check for previous definition */
-	LIST ( TYPE ) p = rtti_types ;
-	LIST ( ulong ) q = rtti_tags ;
-	while ( !IS_NULL_list ( p ) ) {
-	    TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
-	    if ( eq_type ( s, t ) ) {
-		n = DEREF_ulong ( HEAD_list ( q ) ) ;
-		break ;
-	    }
-	    q = TAIL_list ( q ) ;
-	    p = TAIL_list ( p ) ;
-	}
-	if ( n == LINK_NONE ) {
-	    /* Define a new structure */
-	    string s = NULL ;
-	    if ( output_all ) s = mangle_tname ( "__ti__", t ) ;
-	    n = capsule_no ( s, VAR_tag ) ;
-	    CONS_type ( t, rtti_types, rtti_types ) ;
-	    CONS_ulong ( n, rtti_tags, rtti_tags ) ;
-	    enc_rtti_struct ( t, n, 1 ) ;
+	}
-    }
-    n = link_no ( bs, n, VAR_tag ) ;
+	n = link_no(bs, n, VAR_tag);
-    ENC_obtain_tag ( bs ) ;
+	ENC_obtain_tag(bs);
-    ENC_make_tag ( bs, n ) ;
+	ENC_make_tag(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE THE RUN-TIME TYPE INFORMATION FOR AN EXPRESSION
     This routine adds the run-time type information expression e to
     the bitstream bs.
 */
-BITSTREAM *enc_rtti_exp
+BITSTREAM *
-    PROTO_N ( ( bs, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP e )
+enc_rtti_exp(BITSTREAM *bs, EXP e)
 {
-    EXP a = DEREF_exp ( exp_rtti_arg ( e ) ) ;
+	EXP a = DEREF_exp(exp_rtti_arg(e));
-    EXP b = DEREF_exp ( exp_rtti_except ( e ) ) ;
+	EXP b = DEREF_exp(exp_rtti_except(e));
-    int op = DEREF_int ( exp_rtti_op ( e ) ) ;
+	int op = DEREF_int(exp_rtti_op(e));
-    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+	TYPE t = DEREF_type(exp_type(a));
-    if ( IS_type_ptr_etc ( t ) ) {
+	if (IS_type_ptr_etc(t)) {
-	TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_etc_sub(t));
-	if ( IS_type_compound ( s ) ) {
+		if (IS_type_compound(s)) {
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( s ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(s));
-	    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+			VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-	    if ( !IS_NULL_virt ( vt ) ) {
+			if (!IS_NULL_virt(vt)) {
-		/* Pointer to polymorphic class */
+				/* Pointer to polymorphic class */
-		EXP a1 ;
+				EXP a1;
-		int used ;
+				int used;
-		OFFSET off ;
+				OFFSET off;
-		ulong n, m ;
+				ulong n, m;
-		BITSTREAM *ts ;
+				BITSTREAM *ts;
-		IGNORE compile_class ( ct ) ;
+				IGNORE compile_class(ct);
-		off = DEREF_off ( virt_table_off ( vt ) ) ;
+				off = DEREF_off(virt_table_off(vt));
-		n = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+				n = DEREF_ulong(virt_table_tok(vt));
-		/* Introduce variable for pointer */
+				/* Introduce variable for pointer */
-		a1 = DEREF_exp ( exp_dummy_value ( a ) ) ;
+				a1 = DEREF_exp(exp_dummy_value(a));
-		m = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+				m = 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, m ) ;
+				ENC_make_tag(bs, m);
-		bs = enc_exp ( bs, a ) ;
+				bs = enc_exp(bs, a);
-		COPY_ulong ( exp_dummy_no ( a ), m ) ;
+				COPY_ulong(exp_dummy_no(a), m);
-		COPY_exp ( exp_dummy_value ( a ), NULL_exp ) ;
+				COPY_exp(exp_dummy_value(a), NULL_exp);
-		/* Check for null pointers */
+				/* Check for null pointers */
-		if ( !IS_NULL_exp ( b ) ) {
+				if (!IS_NULL_exp(b)) {
-		    ulong lab = unit_no ( bs, NULL_id, VAR_label, 1 ) ;
+					ulong lab = unit_no(bs, NULL_id,
+							    VAR_label, 1);
-		    ENC_SEQ_SMALL ( bs, 1 ) ;
+					ENC_SEQ_SMALL(bs, 1);
-		    ENC_conditional ( bs ) ;
+					ENC_conditional(bs);
-		    ENC_make_label ( bs, lab ) ;
+					ENC_make_label(bs, lab);
-		    ENC_SEQ_SMALL ( bs, 1 ) ;
+					ENC_SEQ_SMALL(bs, 1);
-		    ENC_pointer_test ( bs ) ;
+					ENC_pointer_test(bs);
-		    ENC_OFF ( bs ) ;
+					ENC_OFF(bs);
-		    ENC_equal ( bs ) ;
+					ENC_equal(bs);
-		    ENC_make_label ( bs, lab ) ;
+					ENC_make_label(bs, lab);
-		    bs = enc_exp ( bs, a ) ;
+					bs = enc_exp(bs, a);
-		    bs = enc_null_exp ( bs, t ) ;
+					bs = enc_null_exp(bs, t);
-		    bs = enc_exp ( bs, b ) ;
+					bs = enc_exp(bs, b);
-		    ENC_make_top ( bs ) ;
+					ENC_make_top(bs);
-		}
+				}
-		/* Find the run-time type information */
+				/* Find the run-time type information */
-		ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+				ts = start_bitstream(NIL(FILE), bs->link);
-		if ( op == lex_typeid ) {
+				if (op == lex_typeid) {
-		    bs = enc_special ( bs, TOK_typeid_ref ) ;
+					bs = enc_special(bs, TOK_typeid_ref);
-		} else {
+				} else {
-		    bs = enc_special ( bs, TOK_vtab_func ) ;
+					bs = enc_special(bs, TOK_vtab_func);
-		}
+				}
-		ENC_add_to_ptr ( ts ) ;
+				ENC_add_to_ptr(ts);
-		ts = enc_add_ptr ( ts, a, LINK_NONE, off, 0 ) ;
+				ts = enc_add_ptr(ts, a, LINK_NONE, off, 0);
-		ts = enc_exp_token ( ts, n ) ;
+				ts = enc_exp_token(ts, n);
-		if ( op != lex_typeid ) {
+				if (op != lex_typeid) {
-		    ENC_make_signed_nat ( ts ) ;
+					ENC_make_signed_nat(ts);
-		    ENC_OFF ( ts ) ;
+					ENC_OFF(ts);
-		    ENC_INT_SMALL ( ts, 0 ) ;
+					ENC_INT_SMALL(ts, 0);
-		}
+				}
-		bs = enc_bitstream ( bs, ts ) ;
+				bs = enc_bitstream(bs, ts);
-		used = DEREF_int ( virt_table_rtti_used ( vt ) ) ;
+				used = DEREF_int(virt_table_rtti_used(vt));
-		if ( !used ) {
+				if (!used) {
-		    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+					IDENTIFIER cid = DEREF_id(ctype_name(ct));
-		    COPY_int ( virt_table_rtti_used ( vt ), 1 ) ;
+					COPY_int(virt_table_rtti_used(vt), 1);
-		    compile_virtual ( ct, !has_linkage ( cid ) ) ;
+					compile_virtual(ct, !has_linkage(cid));
+				}
+				COPY_exp(exp_dummy_value(a), a1);
+				return (bs);
+			}
+		}
-		COPY_exp ( exp_dummy_value ( a ), a1 ) ;
-		return ( bs ) ;
-	    }
+	}
-    }
-    bs = enc_rtti_type ( bs, t, op ) ;
+	bs = enc_rtti_type(bs, t, op);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DYNAMIC CAST EXPRESSION
     This routine adds the dynamic cast expression e to the bitstream bs.
 */
-BITSTREAM *enc_dyn_cast
+BITSTREAM *
-    PROTO_N ( ( bs, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP e )
+enc_dyn_cast(BITSTREAM *bs, EXP e)
 {
-    ulong m ;
+	ulong m;
-    int used ;
+	int used;
-    OFFSET off ;
+	OFFSET off;
-    VIRTUAL vt ;
+	VIRTUAL vt;
-    CLASS_TYPE ct ;
+	CLASS_TYPE ct;
-    BITSTREAM *ts, *us ;
+	BITSTREAM *ts, *us;
-    ulong r = LINK_NONE ;
+	ulong r = LINK_NONE;
-    TYPE t = DEREF_type ( exp_type ( e ) ) ;
+	TYPE t = DEREF_type(exp_type(e));
-    EXP a = DEREF_exp ( exp_dyn_cast_arg ( e ) ) ;
+	EXP a = DEREF_exp(exp_dyn_cast_arg(e));
-    TYPE s = DEREF_type ( exp_type ( a ) ) ;
+	TYPE s = DEREF_type(exp_type(a));
-    EXP a1 = DEREF_exp ( exp_dummy_value ( a ) ) ;
+	EXP a1 = DEREF_exp(exp_dummy_value(a));
-    EXP b = DEREF_exp ( exp_dyn_cast_except ( e ) ) ;
+	EXP b = DEREF_exp(exp_dyn_cast_except(e));
-    /* Introduce identity for argument */
+	/* Introduce identity for argument */
-    ulong n = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
+	ulong n = 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, n ) ;
+	ENC_make_tag(bs, n);
-    bs = enc_exp ( bs, a1 ) ;
+	bs = enc_exp(bs, a1);
-    COPY_exp ( exp_dummy_value ( a ), NULL_exp ) ;
+	COPY_exp(exp_dummy_value(a), NULL_exp);
-    COPY_ulong ( exp_dummy_no ( a ), n ) ;
+	COPY_ulong(exp_dummy_no(a), n);
-    /* Convert to result type */
+	/* Convert to result type */
-    bs = enc_special ( bs, TOK_from_ptr_void ) ;
+	bs = enc_special(bs, TOK_from_ptr_void);
-    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+	ts = start_bitstream(NIL(FILE), bs->link);
-    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);
-    /* Introduce variable in exception case */
+	/* Introduce variable in exception case */
-    if ( !IS_NULL_exp ( b ) ) {
+	if (!IS_NULL_exp(b)) {
-	r = unit_no ( ts, NULL_id, VAR_tag, 1 ) ;
+		r = unit_no(ts, NULL_id, VAR_tag, 1);
-	ENC_variable ( ts ) ;
+		ENC_variable(ts);
-	ts = enc_access ( ts, crt_func_access ) ;
+		ts = enc_access(ts, crt_func_access);
-	ENC_make_tag ( ts, r ) ;
+		ENC_make_tag(ts, r);
-    }
+	}
-    /* Encode main token */
+	/* Encode main token */
-    ts = enc_special ( ts, TOK_dynam_cast ) ;
+	ts = enc_special(ts, TOK_dynam_cast);
-    us = start_bitstream ( NIL ( FILE ), ts->link ) ;
+	us = start_bitstream(NIL(FILE), ts->link);
-    /* Encode address of virtual function table */
+	/* Encode address of virtual function table */
-    s = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
+	s = DEREF_type(type_ptr_etc_sub(s));
-    ct = DEREF_ctype ( type_compound_defn ( s ) ) ;
+	ct = DEREF_ctype(type_compound_defn(s));
-    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));
-    m = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+	m = DEREF_ulong(virt_table_tok(vt));
-    ENC_add_to_ptr ( us ) ;
+	ENC_add_to_ptr(us);
-    us = enc_add_ptr ( us, a, LINK_NONE, off, 0 ) ;
+	us = enc_add_ptr(us, a, LINK_NONE, off, 0);
-    us = enc_exp_token ( us, m ) ;
+	us = enc_exp_token(us, m);
-    used = DEREF_int ( virt_table_rtti_used ( vt ) ) ;
+	used = DEREF_int(virt_table_rtti_used(vt));
-    if ( !used ) {
+	if (!used) {
-	IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+		IDENTIFIER cid = DEREF_id(ctype_name(ct));
-	COPY_int ( virt_table_rtti_used ( vt ), 1 ) ;
+		COPY_int(virt_table_rtti_used(vt), 1);
-	compile_virtual ( ct, !has_linkage ( cid ) ) ;
+		compile_virtual(ct, !has_linkage(cid));
-    }
+	}
-    /* Output run-time type information */
+	/* Output run-time type information */
-    us = enc_rtti_type ( us, t, lex_typeid ) ;
+	us = enc_rtti_type(us, t, lex_typeid);
-    ts = enc_bitstream ( ts, us ) ;
+	ts = enc_bitstream(ts, us);
-    /* Check for exceptions */
+	/* Check for exceptions */
-    if ( !IS_NULL_exp ( b ) ) {
+	if (!IS_NULL_exp(b)) {
-	ulong lab = unit_no ( ts, NULL_id, VAR_label, 1 ) ;
+		ulong lab = unit_no(ts, NULL_id, VAR_label, 1);
-	ENC_SEQ_SMALL ( ts, 1 ) ;
+		ENC_SEQ_SMALL(ts, 1);
-	ENC_conditional ( ts ) ;
+		ENC_conditional(ts);
-	ENC_make_label ( ts, lab ) ;
+		ENC_make_label(ts, lab);
-	ENC_SEQ_SMALL ( ts, 1 ) ;
+		ENC_SEQ_SMALL(ts, 1);
-	ts = enc_special ( ts, TOK_pv_test ) ;
+		ts = enc_special(ts, TOK_pv_test);
-	us = start_bitstream ( NIL ( FILE ), ts->link ) ;
+		us = start_bitstream(NIL(FILE), ts->link);
-	ENC_contents ( us ) ;
+		ENC_contents(us);
-	us = enc_special ( us, TOK_ptr_void ) ;
+		us = enc_special(us, TOK_ptr_void);
-	ENC_obtain_tag ( us ) ;
+		ENC_obtain_tag(us);
-	ENC_make_tag ( us, r ) ;
+		ENC_make_tag(us, r);
-	ENC_make_label ( us, lab ) ;
+		ENC_make_label(us, lab);
-	ENC_equal ( us ) ;
+		ENC_equal(us);
-	ts = enc_bitstream ( ts, us ) ;
+		ts = enc_bitstream(ts, us);
-	ts = enc_exp ( ts, b ) ;
+		ts = enc_exp(ts, b);
-	ENC_make_top ( ts ) ;
+		ENC_make_top(ts);
-	ENC_contents ( ts ) ;
+		ENC_contents(ts);
-	ts = enc_special ( ts, TOK_ptr_void ) ;
+		ts = enc_special(ts, TOK_ptr_void);
-	ENC_obtain_tag ( ts ) ;
+		ENC_obtain_tag(ts);
-	ENC_make_tag ( ts, r ) ;
+		ENC_make_tag(ts, r);
-    }
+	}
-    /* End conversion expression */
+	/* End conversion expression */
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    COPY_exp ( exp_dummy_value ( a ), a1 ) ;
+	COPY_exp(exp_dummy_value(a), a1);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     LIST OF PREVIOUSLY DEFINED THUNKS
     A list of all previously defined thunks is maintained to avoid
     unnecessary duplication.
 */
-static VIRTUAL all_thunks = NULL_virt ;
+static VIRTUAL all_thunks = NULL_virt;
 /*
     CREATE A THUNK FUNCTION
     This routine creates a dummy function of type f which calls fid with
     its given arguments and returns its result with the base class conversion
     given by ret applied.  The tag number of the dummy function is returned.
     This is used for overriding virtual functions in which the return
     type differs.
 /*
     ENCODE THE SHAPE OF A VIRTUAL FUNCTION TABLE
     This routine adds the shape of a virtual function table containing
     n functions to the bitstream bs.
 */
-BITSTREAM *enc_vtable_shape
+BITSTREAM *
-    PROTO_N ( ( bs, n ) )
-    PROTO_T ( BITSTREAM *bs X ulong n )
+enc_vtable_shape(BITSTREAM *bs, ulong n)
 {
-    BITSTREAM *ts ;
+	BITSTREAM *ts;
-    bs = enc_special ( bs, TOK_vtab_type ) ;
+	bs = enc_special(bs, TOK_vtab_type);
-    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+	ts = start_bitstream(NIL(FILE), bs->link);
-    ENC_make_nat ( ts ) ;
+	ENC_make_nat(ts);
-    ENC_INT ( ts, n + VIRTUAL_EXTRA ) ;
+	ENC_INT(ts, n + VIRTUAL_EXTRA);
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE THE DEFINITION OF A VIRTUAL FUNCTION TABLE
     This routine encodes the definition of the virtual function table vt.
     n gives the tag number for the table, gr is the table offset and the
     flag inherited is true for secondary tables.  rtti gives the tag
     number for the run-time type information.
 */
-static void enc_vtable_defn
+static void
-    PROTO_N ( ( vt, n, ct, gr, inherited, rtti ) )
-    PROTO_T ( VIRTUAL vt X ulong n X CLASS_TYPE ct X GRAPH gr X
+enc_vtable_defn(VIRTUAL vt, ulong n, CLASS_TYPE ct, GRAPH gr, int inherited,
-	      int inherited X ulong rtti )
+		ulong rtti)
 {
-    ulong r ;
+	ulong r;
-    BITSTREAM *bs, *ts, *us ;
+	BITSTREAM *bs, *ts, *us;
-    ulong m = DEREF_ulong ( virt_no ( vt ) ) ;
+	ulong m = DEREF_ulong(virt_no(vt));
-    ulong p = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+	ulong p = DEREF_ulong(virt_table_tok(vt));
-    OFFSET off = DEREF_off ( virt_table_off ( vt ) ) ;
+	OFFSET off = DEREF_off(virt_table_off(vt));
-    LIST ( VIRTUAL ) pt = DEREF_list ( virt_table_entries ( vt ) ) ;
+	LIST(VIRTUAL)pt = DEREF_list(virt_table_entries(vt));
-    /* Output start of table */
+	/* Output start of table */
-    bs = enc_tagdef_start ( NULL_id, n, NULL_type, 1 ) ;
+	bs = enc_tagdef_start(NULL_id, n, NULL_type, 1);
-    bs = enc_special ( bs, TOK_vtab_make ) ;
+	bs = enc_special(bs, TOK_vtab_make);
-    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+	ts = start_bitstream(NIL(FILE), bs->link);
-    ENC_obtain_tag ( ts ) ;
+	ENC_obtain_tag(ts);
-    r = link_no ( ts, rtti, VAR_tag ) ;
+	r = link_no(ts, rtti, VAR_tag);
-    ENC_make_tag ( ts, r ) ;
+	ENC_make_tag(ts, r);
-    if ( inherited ) {
+	if (inherited) {
-	/* Add base class offset */
+		/* Add base class offset */
-	OFFSET off2 = DEREF_off ( graph_off ( gr ) ) ;
+		OFFSET off2 = DEREF_off(graph_off(gr));
-	if ( !is_zero_offset ( off2 ) ) {
+		if (!is_zero_offset(off2)) {
-	    ENC_offset_add ( ts ) ;
+			ENC_offset_add(ts);
-	    ts = enc_offset ( ts, off2 ) ;
+			ts = enc_offset(ts, off2);
-	}
+		}
-    }
+	}
-    if ( !is_zero_offset ( off ) ) {
+	if (!is_zero_offset(off)) {
-	/* Add inherited table offset */
+		/* Add inherited table offset */
-	ENC_offset_add ( ts ) ;
+		ENC_offset_add(ts);
-	ts = enc_offset ( ts, off ) ;
+		ts = enc_offset(ts, off);
-    }
+	}
-    ts = enc_exp_token ( ts, p ) ;
+	ts = enc_exp_token(ts, p);
-    ENC_make_nat ( ts ) ;
+	ENC_make_nat(ts);
-    ENC_INT ( ts, m + VIRTUAL_EXTRA ) ;
+	ENC_INT(ts, m + VIRTUAL_EXTRA);
-    /* Output virtual functions */
+	/* Output virtual functions */
-    ENC_make_nof ( ts ) ;
+	ENC_make_nof(ts);
-    ENC_LIST ( ts, m ) ;
+	ENC_LIST(ts, m);
-    while ( !IS_NULL_list ( pt ) ) {
+	while (!IS_NULL_list(pt)) {
-	GRAPH gs ;
+		GRAPH gs;
-	DECL_SPEC ds ;
+		DECL_SPEC ds;
-	IDENTIFIER fid ;
+		IDENTIFIER fid;
-	GRAPH ret = NULL_graph ;
+		GRAPH ret = NULL_graph;
-	IDENTIFIER pid = NULL_id ;
+		IDENTIFIER pid = NULL_id;
-	VIRTUAL at = DEREF_virt ( HEAD_list ( pt ) ) ;
+		VIRTUAL at = DEREF_virt(HEAD_list(pt));
-	while ( IS_virt_link ( at ) ) {
+		while (IS_virt_link(at)) {
-	    /* Allow for symbolic links */
+			/* Allow for symbolic links */
-	    at = DEREF_virt ( DEREF_ptr ( virt_link_to ( at ) ) ) ;
+			at = DEREF_virt(DEREF_ptr(virt_link_to(at)));
-	}
+		}
-	if ( inherited ) {
+		if (inherited) {
-	    /* Allow for inherited function tables */
+			/* Allow for inherited function tables */
-	    VIRTUAL as ;
+			VIRTUAL as;
-	    pid = DEREF_id ( virt_func ( at ) ) ;
+			pid = DEREF_id(virt_func(at));
-	    as = find_overrider ( ct, pid, gr, &ret ) ;
+			as = find_overrider(ct, pid, gr, &ret);
-	    if ( !IS_NULL_virt ( as ) ) at = as ;
+			if (!IS_NULL_virt(as)) {
+				at = as;
+			}
-	}
+		}
-	fid = DEREF_id ( virt_func ( at ) ) ;
+		fid = DEREF_id(virt_func(at));
-	ds = DEREF_dspec ( id_storage ( fid ) ) ;
+		ds = DEREF_dspec(id_storage(fid));
-	gs = DEREF_graph ( virt_base ( at ) ) ;
+		gs = DEREF_graph(virt_base(at));
-	/* Output pointer to member function */
+		/* Output pointer to member function */
-	ts = enc_special ( ts, TOK_pmf_make ) ;
+		ts = enc_special(ts, TOK_pmf_make);
-	us = start_bitstream ( NIL ( FILE ), ts->link ) ;
+		us = start_bitstream(NIL(FILE), ts->link);
-	if ( ds & dspec_pure ) {
+		if (ds & dspec_pure) {
-	    /* Pure virtual function */
+			/* Pure virtual function */
-	    us = enc_special ( us, TOK_vtab_pure ) ;
+			us = enc_special(us, TOK_vtab_pure);
-	} else {
+		} else {
-	    if ( IS_NULL_graph ( ret ) ) {
+			if (IS_NULL_graph(ret)) {
-		IGNORE capsule_id ( fid, VAR_tag ) ;
+				IGNORE capsule_id(fid, VAR_tag);
-		r = unit_no ( us, fid, VAR_tag, 0 ) ;
+				r = unit_no(us, fid, VAR_tag, 0);
-	    } else {
+			} else {
-		TYPE f = DEREF_type ( id_function_etc_type ( pid ) ) ;
+				TYPE f = DEREF_type(id_function_etc_type(pid));
-		r = make_thunk ( f, fid, ret ) ;
+				r = make_thunk(f, fid, ret);
-		r = link_no ( us, r, VAR_tag ) ;
+				r = link_no(us, r, VAR_tag);
-	    }
+			}
-	    ENC_obtain_tag ( us ) ;
+			ENC_obtain_tag(us);
-	    ENC_make_tag ( us, r ) ;
+			ENC_make_tag(us, r);
-	}
+		}
-	us = enc_base ( us, gs, 0 ) ;
+		us = enc_base(us, gs, 0);
-	us = enc_base ( us, gr, 0 ) ;
+		us = enc_base(us, gr, 0);
-	ts = enc_bitstream ( ts, us ) ;
+		ts = enc_bitstream(ts, us);
-	pt = TAIL_list ( pt ) ;
+		pt = TAIL_list(pt);
-    }
+	}
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    enc_tagdef_end ( bs ) ;
+	enc_tagdef_end(bs);
-    return ;
+	return;
 }
 /*
     DEFINE VIRTUAL FUNCTION TABLES
     This routine defines or declares the virtual function tables for
     the class ct depending on the value of def.  The tables are given
     external names only if ext is true.
 */
-void define_vtable
+void
-    PROTO_N ( ( ct, def, ext ) )
-    PROTO_T ( CLASS_TYPE ct X int def X int ext )
+define_vtable(CLASS_TYPE ct, int def, int ext)
 {
-    ulong r ;
+	ulong r;
-    int used ;
+	int used;
-    int have_main_table = 0 ;
+	int have_main_table = 0;
-    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+	VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-    if ( IS_NULL_virt ( vt ) ) return ;
+	if (IS_NULL_virt(vt)) {
-    if ( output_all ) ext = 1 ;
-    if ( def == 2 ) {
-	/* Force definition in this case */
-	IGNORE compile_class ( ct ) ;
-    } else {
-	ulong n = DEREF_ulong ( ctype_shape ( ct ) ) ;
-	if ( n == LINK_NONE ) return ;
-    }
-    /* Output run-time type information */
-    r = DEREF_ulong ( virt_table_rtti ( vt ) ) ;
-    used = DEREF_int ( virt_table_rtti_used ( vt ) ) ;
-    if ( used || def ) {
-	TYPE t = dummy_class ;
-	if ( ext ) {
+		return;
-	    /* Make up external name */
-	    string s = mangle_typeid ( "__ti__", ct ) ;
-	    r = capsule_name ( r, &s, VAR_tag ) ;
 	}
-	record_usage ( r, VAR_tag, USAGE_USE ) ;
-	COPY_int ( virt_table_rtti_used ( vt ), 1 ) ;
-	COPY_ctype ( type_compound_defn ( t ), ct ) ;
-	enc_rtti_struct ( t, r, def ) ;
-    }
-    /* Output virtual function tables */
-    while ( !IS_NULL_virt ( vt ) ) {
-	ulong n ;
-	VIRTUAL vs ;
-	unsigned acc ;
-	CLASS_TYPE cs ;
-	int inherited = 1 ;
+	if (output_all) {
-	GRAPH gr = DEREF_graph ( virt_base ( vt ) ) ;
-	DECL_SPEC gacc = DEREF_dspec ( graph_access ( gr ) ) ;
-	if ( ( gacc & dspec_ignore ) && !have_main_table ) {
-	    /* Main virtual function table */
-	    gr = DEREF_graph ( graph_top ( gr ) ) ;
-	    have_main_table = 1 ;
-	    inherited = 0 ;
+		ext = 1;
 	}
-	cs = DEREF_ctype ( graph_head ( gr ) ) ;
-	vs = DEREF_virt ( ctype_virt ( cs ) ) ;
-	n = DEREF_ulong ( virt_table_tbl ( vt ) ) ;
-	record_usage ( n, VAR_tag, USAGE_USE ) ;
-	acc = find_usage ( n, VAR_tag ) ;
-	if ( ext ) {
+	if (def == 2) {
-	    /* Make up external name */
+		/* Force definition in this case */
-	    string s = mangle_vtable ( "__vt__", gr ) ;
-	    n = capsule_name ( n, &s, VAR_tag ) ;
+		IGNORE compile_class(ct);
-	}
+	} else {
-	if ( !( acc & USAGE_DECL ) ) {
-	    /* Output table declaration */
-	    ulong m = DEREF_ulong ( virt_no ( vs ) ) ;
+		ulong n = DEREF_ulong(ctype_shape(ct));
-	    BITSTREAM *ts = enc_tagdec_start ( NULL_id, n, NULL_type, 1 ) ;
-	    ts = enc_vtable_shape ( ts, m ) ;
+		if (n == LINK_NONE) {
-	    enc_tagdec_end ( ts ) ;
+			return;
-	}
+		}
-	if ( def && !( acc & USAGE_DEFN ) ) {
-	    /* Output table definition */
-	    enc_vtable_defn ( vs, n, ct, gr, inherited, r ) ;
+	}
-	vt = DEREF_virt ( virt_next ( vt ) ) ;
-    }
-    return ;
-}
+	/* Output run-time type information */
+	r = DEREF_ulong(virt_table_rtti(vt));
+	used = DEREF_int(virt_table_rtti_used(vt));
+	if (used || def) {
+		TYPE t = dummy_class;
+		if (ext) {
+			/* Make up external name */
+			string s = mangle_typeid("__ti__", ct);
+			r = capsule_name(r, &s, VAR_tag);
+		}
+		record_usage(r, VAR_tag, USAGE_USE);
+		COPY_int(virt_table_rtti_used(vt), 1);
+		COPY_ctype(type_compound_defn(t), ct);
+		enc_rtti_struct(t, r, def);
+	}
+	/* Output virtual function tables */
+	while (!IS_NULL_virt(vt)) {
+		ulong n;
+		VIRTUAL vs;
+		unsigned acc;
+		CLASS_TYPE cs;
+		int inherited = 1;
+		GRAPH gr = DEREF_graph(virt_base(vt));
+		DECL_SPEC gacc = DEREF_dspec(graph_access(gr));
+		if ((gacc & dspec_ignore) && !have_main_table) {
+			/* Main virtual function table */
+			gr = DEREF_graph(graph_top(gr));
+			have_main_table = 1;
+			inherited = 0;
+		}
+		cs = DEREF_ctype(graph_head(gr));
+		vs = DEREF_virt(ctype_virt(cs));
+		n = DEREF_ulong(virt_table_tbl(vt));
+		record_usage(n, VAR_tag, USAGE_USE);
+		acc = find_usage(n, VAR_tag);
+		if (ext) {
+			/* Make up external name */
+			string s = mangle_vtable("__vt__", gr);
+			n = capsule_name(n, &s, VAR_tag);
+		}
+		if (!(acc & USAGE_DECL)) {
+			/* Output table declaration */
+			ulong m = DEREF_ulong(virt_no(vs));
+			BITSTREAM *ts = enc_tagdec_start(NULL_id, n, NULL_type,
+);
+			ts = enc_vtable_shape(ts, m);
+			enc_tagdec_end(ts);
+		}
+		if (def && !(acc & USAGE_DEFN)) {
+			/* Output table definition */
+			enc_vtable_defn(vs, n, ct, gr, inherited, r);
+		}
+		vt = DEREF_virt(virt_next(vt));
+	}
+	return;
+}
 /*
     ALLOCATE TAG NUMBERS FOR VIRTUAL FUNCTION TABLES
     This routine allocates tag and token numbers for the virtual function
     tables of the polymorphic class ct and its base classes.
 */
-static ulong declare_vtable
+static ulong
-    PROTO_N ( ( ct ) )
-    PROTO_T ( CLASS_TYPE ct )
+declare_vtable(CLASS_TYPE ct)
 {
-    ulong n = LINK_NONE ;
+	ulong n = LINK_NONE;
-    ulong r = LINK_NONE ;
+	ulong r = LINK_NONE;
-    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+	VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-    while ( !IS_NULL_virt ( vt ) ) {
+	while (!IS_NULL_virt(vt)) {
-	ulong t ;
+		ulong t;
-	OFFSET off ;
+		OFFSET off;
-	ulong m = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+		ulong m = DEREF_ulong(virt_table_tok(vt));
-	if ( m != LINK_NONE ) {
+		if (m != LINK_NONE) {
-	    /* Already declared */
+			/* Already declared */
-	    return ( m ) ;
+			return (m);
-	}
+		}
-	off = DEREF_off ( virt_table_off ( vt ) ) ;
+		off = DEREF_off(virt_table_off(vt));
-	if ( IS_NULL_off ( off ) ) {
+		if (IS_NULL_off(off)) {
-	    /* New virtual function table required */
+			/* New virtual function table required */
-	    m = capsule_no ( NULL_string, VAR_token ) ;
+			m = capsule_no(NULL_string, VAR_token);
-	} else if ( IS_off_base ( off ) ) {
+		} else if (IS_off_base(off)) {
-	    /* Use existing virtual function table */
+			/* Use existing virtual function table */
-	    GRAPH gs = DEREF_graph ( off_base_graph ( off ) ) ;
+			GRAPH gs = DEREF_graph(off_base_graph(off));
-	    CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
-	    m = declare_vtable ( cs ) ;
+			m = declare_vtable(cs);
-	} else {
+		} else {
-	    /* Use existing virtual function table */
+			/* Use existing virtual function table */
-	    GRAPH gs = DEREF_graph ( off_deriv_graph ( off ) ) ;
+			GRAPH gs = DEREF_graph(off_deriv_graph(off));
-	    CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
+			CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
-	    m = declare_vtable ( cs ) ;
+			m = declare_vtable(cs);
-	}
+		}
-	if ( n == LINK_NONE ) n = m ;
+		if (n == LINK_NONE) {
+			n = m;
+		}
-	/* Allocate (but not define) virtual table tags */
+		/* Allocate (but not define) virtual table tags */
-	t = capsule_no ( NULL_string, VAR_tag ) ;
+		t = capsule_no(NULL_string, VAR_tag);
-	clear_usage ( t, VAR_tag ) ;
+		clear_usage(t, VAR_tag);
-	if ( r == LINK_NONE ) {
+		if (r == LINK_NONE) {
-	    r = capsule_no ( NULL_string, VAR_tag ) ;
+			r = capsule_no(NULL_string, VAR_tag);
-	    clear_usage ( r, VAR_tag ) ;
+			clear_usage(r, VAR_tag);
+		}
+		COPY_ulong(virt_table_tbl(vt), t);
+		COPY_ulong(virt_table_rtti(vt), r);
+		COPY_ulong(virt_table_tok(vt), m);
+		vt = DEREF_virt(virt_next(vt));
+	}
-	COPY_ulong ( virt_table_tbl ( vt ), t ) ;
-	COPY_ulong ( virt_table_rtti ( vt ), r ) ;
-	COPY_ulong ( virt_table_tok ( vt ), m ) ;
-	vt = DEREF_virt ( virt_next ( vt ) ) ;
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     END OF RUN-TIME TYPE INFORMATION ROUTINES
     The remaining routines are common to both the C and C++ producers.
 */
 #endif /* LANGUAGE_CPP */
 /*
     FIND THE TABLE OFFSET OF A VIRTUAL FUNCTION
     This routine finds the position of the virtual function id in the
     virtual function table vt.
 */
-ulong virtual_no
+ulong
-    PROTO_N ( ( id, vt ) )
-    PROTO_T ( IDENTIFIER id X VIRTUAL vt )
+virtual_no(IDENTIFIER id, VIRTUAL vt)
+{
-    LIST ( VIRTUAL ) pv = DEREF_list ( virt_table_entries ( vt ) ) ;
+	LIST(VIRTUAL)pv = DEREF_list(virt_table_entries(vt));
-    while ( !IS_NULL_list ( pv ) ) {
+	while (!IS_NULL_list(pv)) {
-	VIRTUAL vs = DEREF_virt ( HEAD_list ( pv ) ) ;
+		VIRTUAL vs = DEREF_virt(HEAD_list(pv));
-	IDENTIFIER vid = DEREF_id ( virt_func ( vs ) ) ;
+		IDENTIFIER vid = DEREF_id(virt_func(vs));
-	if ( EQ_id ( vid, id ) ) {
+		if (EQ_id(vid, id)) {
-	    ulong m = DEREF_ulong ( virt_no ( vs ) ) ;
+			ulong m = DEREF_ulong(virt_no(vs));
-	    return ( m + VIRTUAL_EXTRA ) ;
+			return (m + VIRTUAL_EXTRA);
+		}
+		pv = TAIL_list(pv);
+	}
-	pv = TAIL_list ( pv ) ;
-    }
-    return ( VIRTUAL_EXTRA ) ;
+	return (VIRTUAL_EXTRA);
+}
 /*
     IS A TYPE A ZERO SIZED BITFIELD?
     This routine checks whether the type t represents a zero sized
     bitfield.  These force an alignment in a class rather than being
     a proper class member.
 */
-static int is_zero_bitfield
+static int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+is_zero_bitfield(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) && IS_type_bitfield ( t ) ) {
+	if (!IS_NULL_type(t) && IS_type_bitfield(t)) {
-	INT_TYPE bf = DEREF_itype ( type_bitfield_defn ( t ) ) ;
+		INT_TYPE bf = DEREF_itype(type_bitfield_defn(t));
-	DECL_SPEC ds = DEREF_dspec ( itype_bitfield_info ( bf ) ) ;
+		DECL_SPEC ds = DEREF_dspec(itype_bitfield_info(bf));
-	if ( ds & dspec_pure ) return ( 1 ) ;
+		if (ds & dspec_pure) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
+}
 /*
     ENCODE A SHAPE OFFSET EXPRESSION
     This routine adds the offset of the type t to the bitstream bs,
     unless t is dummy_class, when the offset of the type excluding the
     virtual bases is added.
 */
-static BITSTREAM *enc_offset_add
+static BITSTREAM *
-    PROTO_N ( ( bs, t ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t )
+enc_offset_add(BITSTREAM *bs, TYPE t)
 {
-    if ( EQ_type ( t, dummy_class ) ) {
+	if (EQ_type(t, dummy_class)) {
-	/* Class offset */
+		/* Class offset */
-	CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
+		GRAPH gr = DEREF_graph(ctype_base(ct));
-	ulong m = DEREF_ulong ( graph_core_off ( gr ) ) ;
+		ulong m = DEREF_ulong(graph_core_off(gr));
-	if ( m != LINK_NONE ) {
+		if (m != LINK_NONE) {
-	    bs = enc_exp_token ( bs, m ) ;
+			bs = enc_exp_token(bs, m);
-	    return ( bs ) ;
+			return (bs);
-	}
+		}
-    }
+	}
-    ENC_shape_offset ( bs ) ;
+	ENC_shape_offset(bs);
-    bs = enc_shape ( bs, t ) ;
+	bs = enc_shape(bs, t);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE AN OFFSET PAD EXPRESSION
     This routine adds the offset of a structure member of type s
     which follows a member of type t with offset given by the token n
     to the bitstream bs.  Note that bitfield types are awkward.
 */
-static BITSTREAM *enc_offset_pad
+static BITSTREAM *
-    PROTO_N ( ( bs, n, t, s ) )
-    PROTO_T ( BITSTREAM *bs X ulong n X TYPE t X TYPE s )
+enc_offset_pad(BITSTREAM *bs, ulong n, TYPE t, TYPE s)
 {
-    BITSTREAM *ts ;
+	BITSTREAM *ts;
-    unsigned tag = null_tag ;
+	unsigned tag = null_tag;
-    int z = is_zero_bitfield ( t ) ;
+	int z = is_zero_bitfield(t);
-    if ( !IS_NULL_type ( s ) ) {
+	if (!IS_NULL_type(s)) {
-	if ( is_zero_bitfield ( s ) ) {
+		if (is_zero_bitfield(s)) {
-	    /* Force an alignment */
+			/* Force an alignment */
-	    s = find_bitfield_type ( s ) ;
+			s = find_bitfield_type(s);
-	}
+		}
-	ENC_offset_pad ( bs ) ;
+		ENC_offset_pad(bs);
-	bs = enc_alignment ( bs, s ) ;
+		bs = enc_alignment(bs, s);
-	tag = TAG_type ( s ) ;
+		tag = TAG_type(s);
-    }
+	}
-    if ( tag == type_bitfield_tag ) {
+	if (tag == type_bitfield_tag) {
-	/* Use token for bitfields */
+		/* Use token for bitfields */
-	bs = enc_special ( bs, TOK_pad ) ;
+		bs = enc_special(bs, TOK_pad);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-    } else {
+	} else {
-	ts = bs ;
+		ts = bs;
-    }
+	}
-    /* Add offset (except for zero sized bitfields) */
+	/* Add offset (except for zero sized bitfields) */
+	if (!z) {
-    if ( !z ) ENC_offset_add ( ts ) ;
+		ENC_offset_add(ts);
+	}
-    ts = enc_exp_token ( ts, n ) ;
+	ts = enc_exp_token(ts, n);
+	if (!z) {
-    if ( !z ) ts = enc_offset_add ( ts, t ) ;
+		ts = enc_offset_add(ts, t);
+	}
-    /* Encode extra bitfield arguments */
+	/* Encode extra bitfield arguments */
-    if ( tag == type_bitfield_tag ) {
+	if (tag == type_bitfield_tag) {
-	TYPE r = find_bitfield_type ( s ) ;
+		TYPE r = find_bitfield_type(s);
-	ts = enc_shape ( ts, r ) ;
+		ts = enc_shape(ts, r);
-	ts = enc_shape ( ts, s ) ;
+		ts = enc_shape(ts, s);
-	bs = enc_bitstream ( bs, ts ) ;
+		bs = enc_bitstream(bs, ts);
-    } else {
+	} else {
-	bs = ts ;
+		bs = ts;
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     DEFINE AN ALIGNMENT TAG
     This routine defines the alignment tag m to be the token n.  The value
     LINK_NONE for n is used to indicate an incomplete structure.
 */
-static void enc_al_tagdef
+static void
-    PROTO_N ( ( m, n ) )
-    PROTO_T ( ulong m X ulong n )
+enc_al_tagdef(ulong m, ulong n)
+{
-    unsigned acc = find_usage ( m, VAR_alignment ) ;
+	unsigned acc = find_usage(m, VAR_alignment);
-    if ( !( acc & USAGE_DEFN ) ) {
+	if (!(acc & USAGE_DEFN)) {
-	BITSTREAM *bs = aldef_unit ;
+		BITSTREAM *bs = aldef_unit;
-	ulong r = link_no ( bs, m, VAR_alignment ) ;
+		ulong r = link_no(bs, m, VAR_alignment);
-	ENC_make_al_tagdef ( bs ) ;
+		ENC_make_al_tagdef(bs);
-	ENC_INT ( bs, r ) ;
+		ENC_INT(bs, r);
-	if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-	    bs = enc_special ( bs, TOK_empty_align ) ;
+			bs = enc_special(bs, TOK_empty_align);
-	} else {
+		} else {
-	    ENC_alignment ( bs ) ;
+			ENC_alignment(bs);
-	    bs = enc_shape_token ( bs, n ) ;
+			bs = enc_shape_token(bs, n);
+		}
+		record_usage(m, VAR_alignment, USAGE_DEFN);
+		count_item(bs);
+		aldef_unit = bs;
+	}
-	record_usage ( m, VAR_alignment, USAGE_DEFN ) ;
-	count_item ( bs ) ;
-	aldef_unit = bs ;
-    }
-    return ;
+	return;
+}
 /*
     ENCODE A TDF COMPOUND SHAPE
     This routine defines all the shape and offset tokens associated with
     the compound type ct.  It returns the external (capsule) number of
     a token giving the overall shape of the result.
+		} else {
-	    /* Record offset of non-virtual components */
+			/* Empty structure definition */
+			clear_usage(n, VAR_token);
+			n = special_no(TOK_empty_shape);
-	    if ( vo == LINK_NONE ) vo = m ;
+			COPY_ulong(ctype_shape(ct), n);
+			vo = special_no(TOK_empty_offset);
-	    COPY_ulong ( graph_core_off ( gr ), vo ) ;
+			COPY_ulong(graph_core_off(gr), vo);
+			ci |= cinfo_empty;
+		}
+		COPY_cinfo(ctype_info(ct), ci);
-	    /* Non-empty structure shape definition */
+		/* Define associated alignment tag */
-	    if ( ext ) {
-		string s = mangle_typeid ( "~cpp.sh.", ct ) ;
-		n = capsule_name ( n, &s, VAR_token ) ;
+		m = DEREF_ulong(graph_al_tag(gr));
-	    }
-	    bs = enc_tokdef_start ( n, "S", NIL ( ulong ), 1 ) ;
-	    ENC_compound ( bs ) ;
+		if (m != LINK_NONE) {
-	    bs = enc_exp_token ( bs, m ) ;
-	    enc_tokdef_end ( n, bs ) ;
+			enc_al_tagdef(m, n);
-	    ci &= ~cinfo_empty ;
+		}
-	} else {
-	    /* Empty structure definition */
-	    clear_usage ( n, VAR_token ) ;
-	    n = special_no ( TOK_empty_shape ) ;
-	    COPY_ulong ( ctype_shape ( ct ), n ) ;
+		COPY_ctype(type_compound_defn(dummy_class), cd);
-	    vo = special_no ( TOK_empty_offset ) ;
-	    COPY_ulong ( graph_core_off ( gr ), vo ) ;
-	    ci |= cinfo_empty ;
+	}
-	COPY_cinfo ( ctype_info ( ct ), ci ) ;
-	/* Define associated alignment tag */
-	m = DEREF_ulong ( graph_al_tag ( gr ) ) ;
-	if ( m != LINK_NONE ) enc_al_tagdef ( m, n ) ;
-	COPY_ctype ( type_compound_defn ( dummy_class ), cd ) ;
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     ENCODE THE SHAPE OF A CLASS TYPE
     This routine adds the class type ct to the bitstream bs as a TDF SHAPE.
 */
-BITSTREAM *enc_ctype
+BITSTREAM *
-    PROTO_N ( ( bs, ct ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct )
+enc_ctype(BITSTREAM *bs, CLASS_TYPE ct)
+{
-    ulong n = compile_class ( ct ) ;
+	ulong n = compile_class(ct);
-    bs = enc_shape_token ( bs, n ) ;
+	bs = enc_shape_token(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     LIST OF INCOMPLETE CLASSES
     This list is used to hold all the classes which are used while they
     are incomplete.  An alignment tag is introduced for each such class
     which may be defined later if the class is completed.
 */
-static LIST ( CLASS_TYPE ) incompl_classes = NULL_list ( CLASS_TYPE ) ;
+static LIST(CLASS_TYPE)incompl_classes = NULL_list(CLASS_TYPE);
 /*
     DEFINE INCOMPLETE CLASSES
     This routine defines the alignment tags for the incomplete classes
     in this list above.  Note that the class is not compiled if it has
     not already been so.
 */
+void
-void compile_incompl
+compile_incompl(void)
-    PROTO_Z ()
+{
-    LIST ( CLASS_TYPE ) p = incompl_classes ;
+	LIST(CLASS_TYPE)p = incompl_classes;
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	CLASS_TYPE ct = DEREF_ctype ( HEAD_list ( p ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(HEAD_list(p));
-	ulong n = DEREF_ulong ( ctype_shape ( ct ) ) ;
+		ulong n = DEREF_ulong(ctype_shape(ct));
-	if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-	    /* Uncompiled or incomplete class */
+			/* Uncompiled or incomplete class */
-	    GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
+			GRAPH gr = DEREF_graph(ctype_base(ct));
-	    ulong m = DEREF_ulong ( graph_al_tag ( gr ) ) ;
+			ulong m = DEREF_ulong(graph_al_tag(gr));
-	    enc_al_tagdef ( m, n ) ;
+			enc_al_tagdef(m, n);
+		}
+		p = TAIL_list(p);
+	}
-	p = TAIL_list ( p ) ;
-    }
-    DESTROY_list ( incompl_classes, SIZE_ctype ) ;
+	DESTROY_list(incompl_classes, SIZE_ctype);
-    incompl_classes = NULL_list ( CLASS_TYPE ) ;
+	incompl_classes = NULL_list(CLASS_TYPE);
-    return ;
+	return;
+}
 /*
     ENCODE THE ALIGNMENT OF A CLASS TYPE
     This routine adds the alignment of the class type ct to the bitstream
     bs.  Note that ct is not compiled by this routine.
 */
-BITSTREAM *enc_al_ctype
+BITSTREAM *
-    PROTO_N ( ( bs, ct ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct )
+enc_al_ctype(BITSTREAM *bs, CLASS_TYPE ct)
+{
-    GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
+	GRAPH gr = DEREF_graph(ctype_base(ct));
-    ulong m = DEREF_ulong ( graph_al_tag ( gr ) ) ;
+	ulong m = DEREF_ulong(graph_al_tag(gr));
-    if ( m == LINK_NONE ) {
+	if (m == LINK_NONE) {
-	string s = NULL ;
+		string s = NULL;
-	ulong n = DEREF_ulong ( ctype_shape ( ct ) ) ;
+		ulong n = DEREF_ulong(ctype_shape(ct));
-	if ( n != LINK_NONE ) {
+		if (n != LINK_NONE) {
-	    /* Class already compiled */
+			/* Class already compiled */
-	    ENC_alignment ( bs ) ;
+			ENC_alignment(bs);
-	    bs = enc_shape_token ( bs, n ) ;
+			bs = enc_shape_token(bs, n);
-	    return ( bs ) ;
+			return (bs);
+		}
+		if (output_all) {
+			s = mangle_typeid("~cpp.al.", ct);
+		}
+		m = capsule_no(s, VAR_alignment);
+		COPY_ulong(graph_al_tag(gr), m);
+		CONS_ctype(ct, incompl_classes, incompl_classes);
+	}
-	if ( output_all ) s = mangle_typeid ( "~cpp.al.", ct ) ;
-	m = capsule_no ( s, VAR_alignment ) ;
-	COPY_ulong ( graph_al_tag ( gr ), m ) ;
-	CONS_ctype ( ct, incompl_classes, incompl_classes ) ;
-    }
-    m = link_no ( bs, m, VAR_alignment ) ;
+	m = link_no(bs, m, VAR_alignment);
-    ENC_obtain_al_tag ( bs ) ;
+	ENC_obtain_al_tag(bs);
-    ENC_make_al_tag ( bs, m ) ;
+	ENC_make_al_tag(bs, m);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     COMPILE A BASE CLASS
     number representing the base class offset.  If gr is a virtual base
     and ptr is true then this is the offset of the pointer to the base,
     otherwise it is the actual base.
 */
-static ulong compile_base
+static ulong
-    PROTO_N ( ( gr, ptr ) )
-    PROTO_T ( GRAPH gr X int ptr )
+compile_base(GRAPH gr, int ptr)
+{
-    ulong n, m ;
+	ulong n, m;
-    GRAPH g1, g2 ;
+	GRAPH g1, g2;
-    BITSTREAM *bs ;
+	BITSTREAM *bs;
-    string s = NULL ;
+	string s = NULL;
-    OFFSET off = DEREF_off ( graph_off ( gr ) ) ;
+	OFFSET off = DEREF_off(graph_off(gr));
-    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+	DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-    if ( ( acc & dspec_virtual ) && !ptr ) {
+	if ((acc & dspec_virtual) && !ptr) {
-	/* Virtual base class */
+		/* Virtual base class */
-	n = DEREF_ulong ( graph_real_off ( gr ) ) ;
+		n = DEREF_ulong(graph_real_off(gr));
-	return ( n ) ;
+		return (n);
-    }
+	}
-    if ( IS_off_base ( off ) ) {
+	if (IS_off_base(off)) {
-	/* Direct base class */
+		/* Direct base class */
-	n = DEREF_ulong ( graph_base_off ( gr ) ) ;
+		n = DEREF_ulong(graph_base_off(gr));
-	return ( n ) ;
+		return (n);
-    }
+	}
-    /* Check for recorded values */
-    if ( ptr ) {
-	n = DEREF_ulong ( graph_base_off ( gr ) ) ;
-    } else {
-	n = DEREF_ulong ( graph_real_off ( gr ) ) ;
-    }
-    if ( n != LINK_NONE ) return ( n ) ;
-    if ( output_all ) {
-	CONST char *pre = "~cpp.base." ;
-	if ( ( acc & dspec_mutable ) && !ptr ) pre = "~cpp.virt." ;
-	s = mangle_vtable ( pre, gr ) ;
-    }
-    n = capsule_no ( s, VAR_token ) ;
-    /* Decompose base offset */
+	/* Check for recorded values */
-    if ( acc & dspec_mutable ) {
+	if (ptr) {
-	/* Base of virtual base */
+		n = DEREF_ulong(graph_base_off(gr));
-	CLASS_TYPE cs ;
+	} else {
-	g1 = DEREF_graph ( graph_up ( gr ) ) ;
+		n = DEREF_ulong(graph_real_off(gr));
+	}
-	cs = DEREF_ctype ( graph_head ( g1 ) ) ;
+	if (n != LINK_NONE) {
+		return (n);
+	}
-	g2 = DEREF_graph ( ctype_base ( cs ) ) ;
+	if (output_all) {
-	g2 = find_subgraph ( g2, g1, gr ) ;
+		CONST char *pre = "~cpp.base.";
-	if ( ptr ) {
+		if ((acc & dspec_mutable) && !ptr) {
-	    COPY_ulong ( graph_base_off ( gr ), n ) ;
+			pre = "~cpp.virt.";
-	} else {
+		}
-	    COPY_ulong ( graph_real_off ( gr ), n ) ;
+		s = mangle_vtable(pre, gr);
+	}
+	n = capsule_no(s, VAR_token);
+	/* Decompose base offset */
-    } else {
+	if (acc & dspec_mutable) {
-	/* Indirect base */
+		/* Base of virtual base */
+		CLASS_TYPE cs;
-	OFFSET off1 = DEREF_off ( off_deriv_direct ( off ) ) ;
+		g1 = DEREF_graph(graph_up(gr));
-	OFFSET off2 = DEREF_off ( off_deriv_indirect ( off ) ) ;
+		cs = DEREF_ctype(graph_head(g1));
-	g1 = DEREF_graph ( off_base_graph ( off1 ) ) ;
+		g2 = DEREF_graph(ctype_base(cs));
-	if ( IS_off_base ( off2 ) ) {
+		g2 = find_subgraph(g2, g1, gr);
+		if (ptr) {
-	    g2 = DEREF_graph ( off_base_graph ( off2 ) ) ;
+			COPY_ulong(graph_base_off(gr), n);
+		} else {
+			COPY_ulong(graph_real_off(gr), n);
+		}
 	} else {
+		/* Indirect base */
+		OFFSET off1 = DEREF_off(off_deriv_direct(off));
+		OFFSET off2 = DEREF_off(off_deriv_indirect(off));
+		g1 = DEREF_graph(off_base_graph(off1));
+		if (IS_off_base(off2)) {
+			g2 = DEREF_graph(off_base_graph(off2));
+		} else {
-	    g2 = DEREF_graph ( off_deriv_graph ( off2 ) ) ;
+			g2 = DEREF_graph(off_deriv_graph(off2));
+		}
+		COPY_ulong(graph_base_off(gr), n);
+		COPY_ulong(graph_real_off(gr), n);
+	}
-	COPY_ulong ( graph_base_off ( gr ), n ) ;
-	COPY_ulong ( graph_real_off ( gr ), n ) ;
-    }
-    /* Define the token */
+	/* Define the token */
-    bs = enc_tokdef_start ( n, "E", NIL ( ulong ), 1 ) ;
+	bs = enc_tokdef_start(n, "E", NIL(ulong), 1);
-    ENC_offset_add ( bs ) ;
+	ENC_offset_add(bs);
-    m = compile_base ( g1, 0 ) ;
+	m = compile_base(g1, 0);
-    bs = enc_exp_token ( bs, m ) ;
+	bs = enc_exp_token(bs, m);
-    m = compile_base ( g2, ptr ) ;
+	m = compile_base(g2, ptr);
-    bs = enc_exp_token ( bs, m ) ;
+	bs = enc_exp_token(bs, m);
-    enc_tokdef_end ( n, bs ) ;
+	enc_tokdef_end(n, bs);
-    return ( n ) ;
+	return (n);
+}
 /*
     ENCODE A BASE CLASS OFFSET
     This routine adds an offset representing the base class graph gr
     to the bitstream bs.  For virtual bases this is the offset of the
     pointer to the base if ptr is true and the offset of the actual base
     otherwise.
 */
-BITSTREAM *enc_base
+BITSTREAM *
-    PROTO_N ( ( bs, gr, ptr ) )
-    PROTO_T ( BITSTREAM *bs X GRAPH gr X int ptr )
+enc_base(BITSTREAM *bs, GRAPH gr, int ptr)
+{
-    GRAPH gt = DEREF_graph ( graph_top ( gr ) ) ;
+	GRAPH gt = DEREF_graph(graph_top(gr));
-    CLASS_TYPE ct = DEREF_ctype ( graph_head ( gt ) ) ;
+	CLASS_TYPE ct = DEREF_ctype(graph_head(gt));
-    if ( EQ_graph ( gr, gt ) ) {
+	if (EQ_graph(gr, gt)) {
-	ENC_offset_zero ( bs ) ;
+		ENC_offset_zero(bs);
-	bs = enc_al_ctype ( bs, ct ) ;
+		bs = enc_al_ctype(bs, ct);
-    } else {
+	} else {
-	ulong n ;
+		ulong n;
-	IGNORE compile_class ( ct ) ;
+		IGNORE compile_class(ct);
-	n = compile_base ( gr, ptr ) ;
+		n = compile_base(gr, ptr);
-	bs = enc_exp_token ( bs, n ) ;
+		bs = enc_exp_token(bs, n);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE THE START OF A VIRTUAL BASE CLASS POINTER EXPRESSION
     This routine adds the start of a virtual base class pointer expression
     to the bitstream bs.  off1 gives the direct component of the offset
     and off2 gives the indirect component.
 */
-BITSTREAM *enc_add_base
+BITSTREAM *
-    PROTO_N ( ( bs, off1, off2 ) )
-    PROTO_T ( BITSTREAM *bs X OFFSET off1 X OFFSET off2 )
+enc_add_base(BITSTREAM *bs, OFFSET off1, OFFSET off2)
+{
-    GRAPH gr = DEREF_graph ( off_base_graph ( off1 ) ) ;
+	GRAPH gr = DEREF_graph(off_base_graph(off1));
-    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+	DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-    if ( !IS_NULL_off ( off2 ) ) {
+	if (!IS_NULL_off(off2)) {
-	if ( IS_off_deriv ( off2 ) ) {
+		if (IS_off_deriv(off2)) {
-	    OFFSET off3 = DEREF_off ( off_deriv_direct ( off2 ) ) ;
+			OFFSET off3 = DEREF_off(off_deriv_direct(off2));
-	    OFFSET off4 = DEREF_off ( off_deriv_indirect ( off2 ) ) ;
+			OFFSET off4 = DEREF_off(off_deriv_indirect(off2));
-	    bs = enc_add_base ( bs, off3, off4 ) ;
+			bs = enc_add_base(bs, off3, off4);
-	} else {
+		} else {
-	    bs = enc_add_base ( bs, off2, NULL_off ) ;
+			bs = enc_add_base(bs, off2, NULL_off);
+		}
+	}
+	if (acc & dspec_virtual) {
+		/* Indirection for virtual bases */
+		CLASS_TYPE ct = DEREF_ctype(graph_head(gr));
+		ENC_contents(bs);
+		ENC_pointer(bs);
+		bs = enc_al_ctype(bs, ct);
+	}
+	if (!(acc & dspec_ignore)) {
+		/* Add base class offset */
+		ENC_add_to_ptr(bs);
+	}
-    }
-    if ( acc & dspec_virtual ) {
-	/* Indirection for virtual bases */
-	CLASS_TYPE ct = DEREF_ctype ( graph_head ( gr ) ) ;
-	ENC_contents ( bs ) ;
-	ENC_pointer ( bs ) ;
-	bs = enc_al_ctype ( bs, ct ) ;
-    }
-    if ( !( acc & dspec_ignore ) ) {
-	/* Add base class offset */
-	ENC_add_to_ptr ( bs ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE THE END OF A VIRTUAL BASE CLASS POINTER EXPRESSION
     This routine adds the end of a virtual base class pointer expression
     to the bitstream bs.  off1 gives the direct component of the offset
     and off2 gives the indirect component.
 */
-BITSTREAM *enc_end_base
+BITSTREAM *
-    PROTO_N ( ( bs, off1, off2 ) )
-    PROTO_T ( BITSTREAM *bs X OFFSET off1 X OFFSET off2 )
+enc_end_base(BITSTREAM *bs, OFFSET off1, OFFSET off2)
 {
-    GRAPH gr = DEREF_graph ( off_base_graph ( off1 ) ) ;
+	GRAPH gr = DEREF_graph(off_base_graph(off1));
-    DECL_SPEC acc = DEREF_dspec ( graph_access ( gr ) ) ;
+	DECL_SPEC acc = DEREF_dspec(graph_access(gr));
-    if ( !( acc & dspec_ignore ) ) {
+	if (!(acc & dspec_ignore)) {
-	/* Output base class offset */
+		/* Output base class offset */
-	ulong n = DEREF_ulong ( graph_base_off ( gr ) ) ;
+		ulong n = DEREF_ulong(graph_base_off(gr));
-	if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-	    /* Compile class if necessary */
+			/* Compile class if necessary */
-	    GRAPH gt = DEREF_graph ( graph_top ( gr ) ) ;
+			GRAPH gt = DEREF_graph(graph_top(gr));
-	    CLASS_TYPE ct = DEREF_ctype ( graph_head ( gt ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(graph_head(gt));
-	    IGNORE compile_class ( ct ) ;
+			IGNORE compile_class(ct);
-	    n = DEREF_ulong ( graph_base_off ( gr ) ) ;
+			n = DEREF_ulong(graph_base_off(gr));
-	}
+		}
-	bs = enc_exp_token ( bs, n ) ;
+		bs = enc_exp_token(bs, n);
-    }
+	}
-    if ( !IS_NULL_off ( off2 ) ) {
+	if (!IS_NULL_off(off2)) {
-	if ( IS_off_deriv ( off2 ) ) {
+		if (IS_off_deriv(off2)) {
-	    OFFSET off3 = DEREF_off ( off_deriv_direct ( off2 ) ) ;
+			OFFSET off3 = DEREF_off(off_deriv_direct(off2));
-	    OFFSET off4 = DEREF_off ( off_deriv_indirect ( off2 ) ) ;
+			OFFSET off4 = DEREF_off(off_deriv_indirect(off2));
-	    bs = enc_end_base ( bs, off3, off4 ) ;
+			bs = enc_end_base(bs, off3, off4);
-	} else {
+		} else {
-	    bs = enc_end_base ( bs, off2, NULL_off ) ;
+			bs = enc_end_base(bs, off2, NULL_off);
-	}
+		}
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A MEMBER OFFSET
     This routine adds the offset of the member id to the bitstream bs.
     If id is a data member this is the offset of the member from the start
     of the structure.
 */
-BITSTREAM *enc_member
+BITSTREAM *
-    PROTO_N ( ( bs, id ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER id )
+enc_member(BITSTREAM *bs, IDENTIFIER id)
 {
-    ulong tok ;
+	ulong tok;
-    unsigned tag = TAG_id ( id ) ;
+	unsigned tag = TAG_id(id);
-    if ( tag == id_member_tag ) {
+	if (tag == id_member_tag) {
-	/* Simple data member */
+		/* Simple data member */
-	OFFSET off = DEREF_off ( id_member_off ( id ) ) ;
+		OFFSET off = DEREF_off(id_member_off(id));
-	if ( IS_off_member ( off ) ) {
+		if (IS_off_member(off)) {
-	    tok = DEREF_ulong ( id_no ( id ) ) ;
+			tok = DEREF_ulong(id_no(id));
-	    if ( tok == LINK_NONE ) {
+			if (tok == LINK_NONE) {
-		CLASS_TYPE ct = parent_class ( id ) ;
+				CLASS_TYPE ct = parent_class(id);
-		IGNORE compile_class ( ct ) ;
+				IGNORE compile_class(ct);
-		tok = DEREF_ulong ( id_no ( id ) ) ;
+				tok = DEREF_ulong(id_no(id));
-	    }
+			}
-	    if ( tok == LINK_ZERO ) {
+			if (tok == LINK_ZERO) {
-		/* Union member */
+				/* Union member */
-		TYPE t = DEREF_type ( id_member_type ( id ) ) ;
+				TYPE t = DEREF_type(id_member_type(id));
-		ENC_offset_zero ( bs ) ;
+				ENC_offset_zero(bs);
-		bs = enc_alignment ( bs, t ) ;
+				bs = enc_alignment(bs, t);
-	    } else {
+			} else {
-		/* Structure member */
+				/* Structure member */
-		bs = enc_exp_token ( bs, tok ) ;
+				bs = enc_exp_token(bs, tok);
-	    }
+			}
-	} else {
+		} else {
-	    bs = enc_offset ( bs, off ) ;
+			bs = enc_offset(bs, off);
-	}
+		}
-    } else {
+	} else {
-	/* Static data members and member functions */
+		/* Static data members and member functions */
-	IGNORE capsule_id ( id, VAR_tag ) ;
+		IGNORE capsule_id(id, VAR_tag);
-	tok = unit_no ( bs, id, VAR_tag, 0 ) ;
+		tok = unit_no(bs, id, VAR_tag, 0);
-	ENC_obtain_tag ( bs ) ;
+		ENC_obtain_tag(bs);
-	ENC_make_tag ( bs, tok ) ;
+		ENC_make_tag(bs, tok);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A NULL CLASS OBJECT DEFINITION
     This routine adds an expression representing a null value of type
     ct to the bitstream bs.  The virtual base components are only
     included if virt is true.  Note that the order of the components
     is not necessarily the same as that in compile_class, but the
     installers always sort make_compound expressions into the correct
     order.
 */
-static BITSTREAM *enc_null_class_aux
+static BITSTREAM *
-    PROTO_N ( ( bs, ct, virt ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct X int virt )
+enc_null_class_aux(BITSTREAM *bs, CLASS_TYPE ct, int virt)
 {
-    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+	CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-    if ( ci & ( cinfo_empty | cinfo_token ) ) {
+	if (ci & (cinfo_empty | cinfo_token)) {
-	/* Tokenised and empty classes */
+		/* Tokenised and empty classes */
-	ENC_make_value ( bs ) ;
+		ENC_make_value(bs);
-	bs = enc_ctype ( bs, ct ) ;
+		bs = enc_ctype(bs, ct);
-    } else {
-	/* Non-empty classes */
-	MEMBER mem ;
-	unsigned no_mems = 0 ;
-	GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
-	LIST ( GRAPH ) br = DEREF_list ( graph_tails ( gr ) ) ;
-	LIST ( GRAPH ) bv = DEREF_list ( ctype_vbase ( ct ) ) ;
-	NAMESPACE ns = DEREF_nspace ( ctype_member ( ct ) ) ;
-	BITSTREAM *ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-	/* Scan through direct base classes */
-	while ( !IS_NULL_list ( br ) ) {
-	    GRAPH gs = DEREF_graph ( HEAD_list ( br ) ) ;
-	    DECL_SPEC acc = DEREF_dspec ( graph_access ( gs ) ) ;
-	    CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
-	    ulong m = DEREF_ulong ( graph_base_off ( gs ) ) ;
-	    if ( acc & dspec_virtual ) {
-		ts = enc_exp_token ( ts, m ) ;
-		ENC_make_null_ptr ( ts ) ;
-		ts = enc_al_ctype ( ts, cs ) ;
-		no_mems++ ;
-	    } else {
-		CLASS_INFO cj = DEREF_cinfo ( ctype_info ( cs ) ) ;
-		if ( !( cj & cinfo_empty ) ) {
-		    ts = enc_exp_token ( ts, m ) ;
-		    ts = enc_null_class_aux ( ts, cs, 0 ) ;
-		    no_mems++ ;
-		}
-	    }
-	    br = TAIL_list ( br ) ;
-	}
-	/* Scan through data members */
-	mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
-	mem = next_data_member ( mem, 0 ) ;
-	while ( !IS_NULL_member ( mem ) ) {
-	    IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
-	    TYPE s = DEREF_type ( id_member_type ( mid ) ) ;
-	    ts = enc_member ( ts, mid ) ;
-	    ts = enc_null_exp ( ts, s ) ;
-	    no_mems++ ;
-	    if ( ci & cinfo_union ) break ;
-	    mem = DEREF_member ( member_next ( mem ) ) ;
-	    mem = next_data_member ( mem, 0 ) ;
-	}
-	/* Scan through virtual function tables */
-#if LANGUAGE_CPP
-	if ( ci & cinfo_polymorphic ) {
-	    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
-	    while ( !IS_NULL_virt ( vt ) ) {
-		OFFSET off = DEREF_off ( virt_table_off ( vt ) ) ;
-		if ( IS_NULL_off ( off ) ) {
-		    ulong m = DEREF_ulong ( virt_table_tok ( vt ) ) ;
-		    ts = enc_exp_token ( ts, m ) ;
-		    size_dummy_vtab = DEREF_ulong ( virt_no ( vt ) ) ;
-		    ts = enc_null_exp ( ts, ptr_dummy_vtab ) ;
-		    no_mems++ ;
-		}
-		vt = DEREF_virt ( virt_next ( vt ) ) ;
-	    }
-	}
-#endif
-	/* Scan through virtual bases */
-	if ( virt ) {
-	    while ( !IS_NULL_list ( bv ) ) {
-		GRAPH gs = DEREF_graph ( HEAD_list ( bv ) ) ;
-		CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
-		CLASS_INFO cj = DEREF_cinfo ( ctype_info ( cs ) ) ;
-		if ( !( cj & cinfo_empty ) ) {
-		    ulong m = DEREF_ulong ( graph_real_off ( gs ) ) ;
-		    ts = enc_exp_token ( ts, m ) ;
-		    ts = enc_null_class_aux ( ts, cs, 0 ) ;
-		    no_mems++ ;
-		}
-		bv = TAIL_list ( bv ) ;
-	    }
 	} else {
+		/* Non-empty classes */
+		MEMBER mem;
+		unsigned no_mems = 0;
+		GRAPH gr = DEREF_graph(ctype_base(ct));
+		LIST(GRAPH)br = DEREF_list(graph_tails(gr));
+		LIST(GRAPH)bv = DEREF_list(ctype_vbase(ct));
+		NAMESPACE ns = DEREF_nspace(ctype_member(ct));
+		BITSTREAM *ts = start_bitstream(NIL(FILE), bs->link);
+		/* Scan through direct base classes */
-	    if ( IS_NULL_list ( bv ) ) virt = 1 ;
+		while (!IS_NULL_list(br)) {
+			GRAPH gs = DEREF_graph(HEAD_list(br));
+			DECL_SPEC acc = DEREF_dspec(graph_access(gs));
+			CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
+			ulong m = DEREF_ulong(graph_base_off(gs));
+			if (acc & dspec_virtual) {
+				ts = enc_exp_token(ts, m);
+				ENC_make_null_ptr(ts);
+				ts = enc_al_ctype(ts, cs);
+				no_mems++;
+			} else {
+				CLASS_INFO cj = DEREF_cinfo(ctype_info(cs));
+				if (!(cj & cinfo_empty)) {
+					ts = enc_exp_token(ts, m);
+					ts = enc_null_class_aux(ts, cs, 0);
+					no_mems++;
+				}
+			}
+			br = TAIL_list(br);
-	}
+		}
-	/* Encode complete construct */
+		/* Scan through data members */
+		mem = DEREF_member(nspace_ctype_first(ns));
+		mem = next_data_member(mem, 0);
+		while (!IS_NULL_member(mem)) {
+			IDENTIFIER mid = DEREF_id(member_id(mem));
+			TYPE s = DEREF_type(id_member_type(mid));
+			ts = enc_member(ts, mid);
+			ts = enc_null_exp(ts, s);
-	if ( no_mems ) {
+			no_mems++;
+			if (ci & cinfo_union) {
+				break;
+			}
+			mem = DEREF_member(member_next(mem));
+			mem = next_data_member(mem, 0);
+		}
+		/* Scan through virtual function tables */
+#if LANGUAGE_CPP
-	    ENC_make_compound ( bs ) ;
+		if (ci & cinfo_polymorphic) {
+			VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-	    if ( virt ) {
+			while (!IS_NULL_virt(vt)) {
+				OFFSET off = DEREF_off(virt_table_off(vt));
-		ENC_shape_offset ( bs ) ;
+				if (IS_NULL_off(off)) {
+					ulong m =
+					    DEREF_ulong(virt_table_tok(vt));
-		bs = enc_ctype ( bs, ct ) ;
+					ts = enc_exp_token(ts, m);
+					size_dummy_vtab =
+					    DEREF_ulong(virt_no(vt));
+					ts = enc_null_exp(ts, ptr_dummy_vtab);
+					no_mems++;
+				}
+				vt = DEREF_virt(virt_next(vt));
+			}
+		}
+#endif
+		/* Scan through virtual bases */
-	    } else {
+		if (virt) {
+			while (!IS_NULL_list(bv)) {
-		ulong m = DEREF_ulong ( graph_core_off ( gr ) ) ;
+				GRAPH gs = DEREF_graph(HEAD_list(bv));
+				CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
+				CLASS_INFO cj = DEREF_cinfo(ctype_info(cs));
-		if ( m == LINK_NONE ) {
+				if (!(cj & cinfo_empty)) {
+					ulong m =
-		    ENC_shape_offset ( bs ) ;
+					    DEREF_ulong(graph_real_off(gs));
-		    bs = enc_ctype ( bs, ct ) ;
+					ts = enc_exp_token(ts, m);
+					ts = enc_null_class_aux(ts, cs, 0);
+					no_mems++;
+				}
+				bv = TAIL_list(bv);
+			}
 		} else {
-		    bs = enc_exp_token ( bs, m ) ;
+			if (IS_NULL_list(bv)) {
+				virt = 1;
+			}
+		}
+		/* Encode complete construct */
+		if (no_mems) {
+			ENC_make_compound(bs);
+			if (virt) {
+				ENC_shape_offset(bs);
+				bs = enc_ctype(bs, ct);
+			} else {
+				ulong m = DEREF_ulong(graph_core_off(gr));
+				if (m == LINK_NONE) {
+					ENC_shape_offset(bs);
+					bs = enc_ctype(bs, ct);
+				} else {
+					bs = enc_exp_token(bs, m);
-	    }
+				}
+			}
-	    ENC_LIST ( bs, no_mems + no_mems ) ;
+			ENC_LIST(bs, no_mems + no_mems);
-	    bs = join_bitstreams ( bs, ts ) ;
+			bs = join_bitstreams(bs, ts);
-	} else {
+		} else {
-	    ENC_make_value ( bs ) ;
+			ENC_make_value(bs);
-	    bs = enc_ctype ( bs, ct ) ;
+			bs = enc_ctype(bs, ct);
-	    end_bitstream ( ts, 0 ) ;
+			end_bitstream(ts, 0);
-	}
+		}
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A NULL CLASS OBJECT
     This routine adds the default null value for the class type ct to the
     bitstream bs.  This is represented by a token which is defined the
     first time the routine is called.
 */
-BITSTREAM *enc_null_class
+BITSTREAM *
-    PROTO_N ( ( bs, ct ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct )
+enc_null_class(BITSTREAM *bs, CLASS_TYPE ct)
+{
-    ulong n = DEREF_ulong ( ctype_null_exp ( ct ) ) ;
+	ulong n = DEREF_ulong(ctype_null_exp(ct));
-    if ( n == LINK_NONE ) {
+	if (n == LINK_NONE) {
-	/* Define token for null value */
+		/* Define token for null value */
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	string s = NULL ;
+		string s = NULL;
-	IGNORE compile_class ( ct ) ;
+		IGNORE compile_class(ct);
+		if (output_all) {
-	if ( output_all ) s = mangle_typeid ( "~cpp.null.", ct ) ;
+			s = mangle_typeid("~cpp.null.", ct);
+		}
-	n = capsule_no ( s, VAR_token ) ;
+		n = capsule_no(s, VAR_token);
-	COPY_ulong ( ctype_null_exp ( ct ), n ) ;
+		COPY_ulong(ctype_null_exp(ct), n);
-	ts = enc_tokdef_start ( n, "E", NIL ( ulong ), 1 ) ;
+		ts = enc_tokdef_start(n, "E", NIL(ulong), 1);
-	ts = enc_null_class_aux ( ts, ct, 1 ) ;
+		ts = enc_null_class_aux(ts, ct, 1);
-	enc_tokdef_end ( n, ts ) ;
+		enc_tokdef_end(n, ts);
-    }
+	}
-    bs = enc_exp_token ( bs, n ) ;
+	bs = enc_exp_token(bs, n);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     CONSTRUCTOR INITIALISER ROUTINES
     The constructor initialiser routines are only included in the C++
     producer.
 */
 #if LANGUAGE_CPP
 /*
     ENCODE A CONSTRUCTOR INITIALISER
     This routine performs a construct initialisation using a at offset
     off from the tag m.  virt controls how m is accessed.  Note that a
     may be a dummy expression to indicate that m is initialised from
     the corresponding offset from the second argument in a copy
     constructor or assignment operator (see init_empty_base).
 */
-static BITSTREAM *enc_ctor_exp
+static BITSTREAM *
-    PROTO_N ( ( bs, a, off, m, virt, seq ) )
-    PROTO_T ( BITSTREAM *bs X EXP a X OFFSET off X ulong m X
+enc_ctor_exp(BITSTREAM *bs, EXP a, OFFSET off, ulong m, int virt, unsigned seq)
-	      int virt X unsigned seq )
 {
-    if ( !IS_NULL_exp ( a ) ) {
+	if (!IS_NULL_exp(a)) {
-	int context = 0 ;
+		int context = 0;
-	EXP d = NULL_exp ;
+		EXP d = NULL_exp;
-	TYPE s = DEREF_type ( exp_type ( a ) ) ;
+		TYPE s = DEREF_type(exp_type(a));
-	if ( IS_exp_paren ( a ) ) {
+		if (IS_exp_paren(a)) {
-	    /* Used to mark destructors - see destr_init */
+			/* Used to mark destructors - see destr_init */
-	    if ( seq > 1 ) {
+			if (seq > 1) {
-		context = 5 ;
+				context = 5;
-		d = a ;
+				d = a;
-	    }
+			}
-	    a = DEREF_exp ( exp_paren_arg ( a ) ) ;
+			a = DEREF_exp(exp_paren_arg(a));
-	}
+		}
-	if ( IS_NULL_exp ( a ) ) {
+		if (IS_NULL_exp(a)) {
-	    /* EMPTY */
+			/* EMPTY */
-	} else if ( IS_exp_value ( a ) ) {
+		} else if (IS_exp_value(a)) {
-	    /* Copy assignment */
+			/* Copy assignment */
-	    int bf = 0 ;
+			int bf = 0;
-	    TYPE t = DEREF_type ( exp_type ( a ) ) ;
+			TYPE t = DEREF_type(exp_type(a));
-	    bs = enc_assign_op ( bs, t, &bf ) ;
+			bs = enc_assign_op(bs, t, &bf);
-	    if ( bf ) {
+			if (bf) {
-		/* Bitfield assignment */
+				/* Bitfield assignment */
-		OFFSET off1 = off ;
+				OFFSET off1 = off;
-		OFFSET off2 = decons_bitf_off ( &off1 ) ;
+				OFFSET off2 = decons_bitf_off(&off1);
-		bs = enc_dummy_exp ( bs, t, m, off1, 0, virt ) ;
+				bs = enc_dummy_exp(bs, t, m, off1, 0, virt);
-		bs = enc_offset ( bs, off2 ) ;
+				bs = enc_offset(bs, off2);
-	    } else {
+			} else {
-		/* Non-bitfield assignment */
+				/* Non-bitfield assignment */
-		bs = enc_dummy_exp ( bs, t, m, off, 0, virt ) ;
+				bs = enc_dummy_exp(bs, t, m, off, 0, virt);
-	    }
+			}
-	    last_conts [ DUMMY_copy ] = 1 ;
+			last_conts[DUMMY_copy] = 1;
-	    bs = enc_dummy_exp ( bs, t, LINK_NONE, off, DUMMY_copy, 1 ) ;
+			bs = enc_dummy_exp(bs, t, LINK_NONE, off, DUMMY_copy, 1);
-	    last_conts [ DUMMY_copy ] = 0 ;
+			last_conts[DUMMY_copy] = 0;
-	    seq-- ;
+			seq--;
-	} else {
+		} else {
-	    /* Constructor initialiser */
+			/* Constructor initialiser */
-	    bs = enc_init_tag ( bs, m, off, 0, s, a, d, context ) ;
+			bs = enc_init_tag(bs, m, off, 0, s, a, d, context);
-	    if ( !IS_NULL_exp ( d ) ) {
+			if (!IS_NULL_exp(d)) {
-		d = NULL_exp ;
+				d = NULL_exp;
-		seq-- ;
+				seq--;
-	    }
+			}
-	    seq-- ;
+			seq--;
-	}
+		}
-	if ( !IS_NULL_exp ( d ) ) {
+		if (!IS_NULL_exp(d)) {
-	    /* Increase constructor count */
+			/* Increase constructor count */
-	    bs = enc_destr_count ( bs, s, 1 ) ;
+			bs = enc_destr_count(bs, s, 1);
-	    seq-- ;
+			seq--;
+		}
+	}
-    }
-    while ( seq ) {
+	while (seq) {
-	ENC_make_top ( bs ) ;
+		ENC_make_top(bs);
-	seq-- ;
+		seq--;
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     INITIALISE VIRTUAL BASE POINTERS
     This routine adds a list of virtual base pointer initialisations
     for an object with tag number m and class ct to the bitstream bs.
 */
-static BITSTREAM *enc_virt_init
+static BITSTREAM *
-    PROTO_N ( ( bs, ct, m ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct X ulong m )
+enc_virt_init(BITSTREAM *bs, CLASS_TYPE ct, ulong m)
+{
-    LIST ( GRAPH ) bv = DEREF_list ( ctype_vbase ( ct ) ) ;
+	LIST(GRAPH)bv = DEREF_list(ctype_vbase(ct));
-    while ( !IS_NULL_list ( bv ) ) {
+	while (!IS_NULL_list(bv)) {
-	GRAPH gr = DEREF_graph ( HEAD_list ( bv ) ) ;
+		GRAPH gr = DEREF_graph(HEAD_list(bv));
-	ulong tv = DEREF_ulong ( graph_real_off ( gr ) ) ;
+		ulong tv = DEREF_ulong(graph_real_off(gr));
-	while ( !IS_NULL_graph ( gr ) ) {
+		while (!IS_NULL_graph(gr)) {
-	    ulong tp = compile_base ( gr, 1 ) ;
+			ulong tp = compile_base(gr, 1);
-	    ENC_assign ( bs ) ;
+			ENC_assign(bs);
-	    ENC_add_to_ptr ( bs ) ;
+			ENC_add_to_ptr(bs);
-	    ENC_obtain_tag ( bs ) ;
+			ENC_obtain_tag(bs);
-	    ENC_make_tag ( bs, m ) ;
+			ENC_make_tag(bs, m);
-	    bs = enc_exp_token ( bs, tp ) ;
+			bs = enc_exp_token(bs, tp);
-	    ENC_add_to_ptr ( bs ) ;
+			ENC_add_to_ptr(bs);
-	    ENC_obtain_tag ( bs ) ;
+			ENC_obtain_tag(bs);
-	    ENC_make_tag ( bs, m ) ;
+			ENC_make_tag(bs, m);
-	    bs = enc_exp_token ( bs, tv ) ;
+			bs = enc_exp_token(bs, tv);
-	    gr = DEREF_graph ( graph_equal ( gr ) ) ;
+			gr = DEREF_graph(graph_equal(gr));
+		}
+		bv = TAIL_list(bv);
+	}
-	bv = TAIL_list ( bv ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     INITIALISE VIRTUAL FUNCTION TABLES
     This routine adds a list of virtual function table initialisations
     for an object with tag number m and class ct to the bitstream bs.
 */
-static BITSTREAM *enc_vtab_init
+static BITSTREAM *
-    PROTO_N ( ( bs, ct, m, virt ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct X ulong m X int virt )
+enc_vtab_init(BITSTREAM *bs, CLASS_TYPE ct, ulong m, int virt)
+{
-    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
+	VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-    while ( !IS_NULL_virt ( vt ) ) {
+	while (!IS_NULL_virt(vt)) {
-	OFFSET off = DEREF_off ( virt_table_off ( vt ) ) ;
+		OFFSET off = DEREF_off(virt_table_off(vt));
-	ulong tv = DEREF_ulong ( virt_table_tok ( vt ) ) ;
+		ulong tv = DEREF_ulong(virt_table_tok(vt));
-	ulong tt = DEREF_ulong ( virt_table_tbl ( vt ) ) ;
+		ulong tt = DEREF_ulong(virt_table_tbl(vt));
-	record_usage ( tt, VAR_tag, USAGE_USE ) ;
+		record_usage(tt, VAR_tag, USAGE_USE);
-	ENC_assign ( bs ) ;
+		ENC_assign(bs);
-	ENC_add_to_ptr ( bs ) ;
+		ENC_add_to_ptr(bs);
-	if ( is_zero_offset ( off ) ) {
+		if (is_zero_offset(off)) {
-	    ENC_obtain_tag ( bs ) ;
+			ENC_obtain_tag(bs);
-	    ENC_make_tag ( bs, m ) ;
+			ENC_make_tag(bs, m);
-	} else {
+		} else {
-	    TYPE t = ptr_dummy_class ;
+			TYPE t = ptr_dummy_class;
-	    bs = enc_dummy_exp ( bs, t, m, off, 0, virt ) ;
+			bs = enc_dummy_exp(bs, t, m, off, 0, virt);
+		}
+		bs = enc_exp_token(bs, tv);
+		tt = link_no(bs, tt, VAR_tag);
+		ENC_obtain_tag(bs);
+		ENC_make_tag(bs, tt);
+		vt = DEREF_virt(virt_next(vt));
+	}
-	bs = enc_exp_token ( bs, tv ) ;
-	tt = link_no ( bs, tt, VAR_tag ) ;
-	ENC_obtain_tag ( bs ) ;
-	ENC_make_tag ( bs, tt ) ;
-	vt = DEREF_virt ( virt_next ( vt ) ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     DELETE AN OBJECT
     This routine adds the conditional deletion for an object with tag
     number m and class ct to the bitstream bs.
 */
-static BITSTREAM *enc_delete_obj
+static BITSTREAM *
-    PROTO_N ( ( bs, ct, m ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct X ulong m )
+enc_delete_obj(BITSTREAM *bs, CLASS_TYPE ct, ulong m)
+{
-    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+	IDENTIFIER cid = DEREF_id(ctype_name(ct));
-    TYPE t = DEREF_type ( id_class_name_etc_defn ( cid ) ) ;
+	TYPE t = DEREF_type(id_class_name_etc_defn(cid));
-    IDENTIFIER fid = find_allocator ( t, lex_delete, 0, NULL_id ) ;
+	IDENTIFIER fid = find_allocator(t, lex_delete, 0, NULL_id);
-    if ( IS_NULL_id ( fid ) ) {
+	if (IS_NULL_id(fid)) {
-	/* This shouldn't happen */
+		/* This shouldn't happen */
-	ENC_make_top ( bs ) ;
+		ENC_make_top(bs);
-    } else {
+	} else {
-	ulong d ;
+		ulong d;
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	TYPE fn = DEREF_type ( id_function_etc_type ( fid ) ) ;
+		TYPE fn = DEREF_type(id_function_etc_type(fid));
-	LIST ( TYPE ) ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
+		LIST(TYPE)ptypes = DEREF_list(type_func_ptypes(fn));
-	unsigned npids = LENGTH_list ( ptypes ) ;
+		unsigned npids = LENGTH_list(ptypes);
-	/* Mark the function as to be compiled */
+		/* Mark the function as to be compiled */
-	IGNORE capsule_id ( fid, VAR_tag ) ;
+		IGNORE capsule_id(fid, VAR_tag);
-	CONS_id ( fid, pending_funcs, pending_funcs ) ;
+		CONS_id(fid, pending_funcs, pending_funcs);
-	/* Encode the function call */
+		/* Encode the function call */
-	ENC_apply_proc ( bs ) ;
+		ENC_apply_proc(bs);
-	ENC_top ( bs ) ;
+		ENC_top(bs);
-	ENC_obtain_tag ( bs ) ;
+		ENC_obtain_tag(bs);
-	d = unit_no ( bs, fid, VAR_tag, 0 ) ;
+		d = unit_no(bs, fid, VAR_tag, 0);
-	ENC_make_tag ( bs, d ) ;
+		ENC_make_tag(bs, d);
-	if ( npids > 2 ) npids = 2 ;
+		if (npids > 2) {
+			npids = 2;
+		}
-	ENC_LIST_SMALL ( bs, npids ) ;
+		ENC_LIST_SMALL(bs, npids);
-	bs = enc_special ( bs, TOK_to_ptr_void ) ;
+		bs = enc_special(bs, TOK_to_ptr_void);
-	ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+		ts = start_bitstream(NIL(FILE), bs->link);
-	ts = enc_al_ctype ( ts, ct ) ;
+		ts = enc_al_ctype(ts, ct);
-	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);
-	if ( npids == 2 ) {
+		if (npids == 2) {
-	    /* Allow for second argument */
+			/* Allow for second argument */
-	    TYPE s ;
+			TYPE s;
-	    TYPE c = type_char ;
+			TYPE c = type_char;
-	    ptypes = TAIL_list ( ptypes ) ;
+			ptypes = TAIL_list(ptypes);
-	    s = DEREF_type ( HEAD_list ( ptypes ) ) ;
+			s = DEREF_type(HEAD_list(ptypes));
-	    if ( !IS_type_integer ( s ) ) s = type_size_t ;
+			if (!IS_type_integer(s)) {
+				s = type_size_t;
+			}
-	    ENC_offset_div ( bs ) ;
+			ENC_offset_div(bs);
-	    bs = enc_variety ( bs, s ) ;
+			bs = enc_variety(bs, s);
-	    bs = enc_shape_offset ( bs, t ) ;
+			bs = enc_shape_offset(bs, t);
-	    bs = enc_shape_offset ( bs, c ) ;
+			bs = enc_shape_offset(bs, c);
+		}
+		ENC_OFF(bs);
+	}
-	ENC_OFF ( bs ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LIST OF CONSTRUCTOR INITIALISERS
     This routine adds the list of constructor initialisers given by e
     to the bitstream bs.
 */
-BITSTREAM *enc_ctor_init
+BITSTREAM *
-    PROTO_N ( ( bs, e ) )
-    PROTO_T ( BITSTREAM *bs X EXP e )
+enc_ctor_init(BITSTREAM *bs, EXP e)
+{
-    ulong n, m ;
+	ulong n, m;
-    CLASS_TYPE ct = last_class ;
+	CLASS_TYPE ct = last_class;
-    int kind = DEREF_int ( exp_initialiser_kind ( e ) ) ;
+	int kind = DEREF_int(exp_initialiser_kind(e));
-    LIST ( EXP ) p = DEREF_list ( exp_initialiser_args ( e ) ) ;
+	LIST(EXP)p = DEREF_list(exp_initialiser_args(e));
-    LIST ( OFFSET ) q = DEREF_list ( exp_initialiser_offs ( e ) ) ;
+	LIST(OFFSET)q = DEREF_list(exp_initialiser_offs(e));
-    /* Find number of items */
-    unsigned np = LENGTH_list ( p ) ;
-    unsigned nv = DEREF_unsigned ( exp_initialiser_virt ( e ) ) ;
-    unsigned nb = DEREF_unsigned ( exp_initialiser_base ( e ) ) ;
-    unsigned no = np - nv ;
+	/* Find number of items */
+	unsigned np = LENGTH_list(p);
+	unsigned nv = DEREF_unsigned(exp_initialiser_virt(e));
+	unsigned nb = DEREF_unsigned(exp_initialiser_base(e));
+	unsigned no = np - nv;
-    /* Compile the class */
+	/* Compile the class */
-    IGNORE compile_class ( ct ) ;
+	IGNORE compile_class(ct);
+	/* Find the 'this' pointer */
+	n = last_params[DUMMY_this];
+	m = unit_no(bs, NULL_id, VAR_tag, 1);
+	ENC_identify(bs);
+	bs = enc_access(bs, crt_func_access);
+	ENC_make_tag(bs, m);
+	ENC_contents(bs);
+	ENC_pointer(bs);
+	bs = enc_al_ctype(bs, ct);
+	ENC_obtain_tag(bs);
+	ENC_make_tag(bs, n);
+	if (kind == DEFAULT_DESTR) {
+		/* Deal with destructors */
+		int context = 0;
+		unsigned ns = no + 1;
+		ulong m2 = last_params[DUMMY_extra];
+		if (last_params[DUMMY_count] != LINK_NONE) {
+			context = 5;
+			ns--;
+		}
+		if (nv) {
+			ns++;
+		}
+		if (ns > 1) {
+			ENC_SEQUENCE(bs, ns - 1);
+		} else {
+			if (ns == 0) {
+				ENC_make_top(bs);
+			}
+		}
+		/* Destroy members and direct bases */
+		while (no) {
+			EXP a = DEREF_exp(HEAD_list(p));
+			if (IS_NULL_exp(a)) {
+				ENC_make_top(bs);
+			} else {
+				TYPE s = DEREF_type(exp_type(a));
+				OFFSET off = DEREF_off(HEAD_list(q));
+				bs = enc_term_local(bs, m, off, 0, s, a,
+						    context);
+			}
+			q = TAIL_list(q);
+			p = TAIL_list(p);
+			no--;
+		}
+		/* Conditionally destroy virtual bases */
+		if (nv) {
+			int mask = 0;
+			if (context == 0) {
+				mask = EXTRA_DESTR;
+			}
+			bs = enc_flag_test(bs, m2, nv, mask, ntest_not_eq);
+			while (!IS_NULL_list(p)) {
+				EXP a = DEREF_exp(HEAD_list(p));
+				if (IS_NULL_exp(a)) {
+					ENC_make_top(bs);
+				} else {
+					TYPE s = DEREF_type(exp_type(a));
+					OFFSET off = DEREF_off(HEAD_list(q));
+					bs = enc_term_local(bs, m, off, 0, s,
+							    a, context);
+				}
+				q = TAIL_list(q);
+				p = TAIL_list(p);
+			}
+			ENC_make_top(bs);
+		}
+		/* Conditionally call 'operator delete' */
+		if (context == 0) {
+			ns = 1;
+			bs = enc_flag_test(bs, m2, ns, EXTRA_DELETE,
+					   ntest_not_eq);
+			bs = enc_delete_obj(bs, ct, m);
+			ENC_make_top(bs);
+		}
-    /* Find the 'this' pointer */
-    n = last_params [ DUMMY_this ] ;
-    m = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-    ENC_identify ( bs ) ;
-    bs = enc_access ( bs, crt_func_access ) ;
-    ENC_make_tag ( bs, m ) ;
-    ENC_contents ( bs ) ;
-    ENC_pointer ( bs ) ;
-    bs = enc_al_ctype ( bs, ct ) ;
-    ENC_obtain_tag ( bs ) ;
-    ENC_make_tag ( bs, n ) ;
-    if ( kind == DEFAULT_DESTR ) {
-	/* Deal with destructors */
-	int context = 0 ;
-	unsigned ns = no + 1 ;
-	ulong m2 = last_params [ DUMMY_extra ] ;
-	if ( last_params [ DUMMY_count ] != LINK_NONE ) {
-	    context = 5 ;
-	    ns-- ;
-	}
-	if ( nv ) ns++ ;
-	if ( ns > 1 ) {
-	    ENC_SEQUENCE ( bs, ns - 1 ) ;
 	} else {
-	    if ( ns == 0 ) ENC_make_top ( bs ) ;
+		/* Deal with constructors */
-	}
+		int virt = 1;
+		unsigned ns, nu;
+		unsigned ni = 0;
+		unsigned nt = 0;
+		unsigned ne = 1;
-	/* Destroy members and direct bases */
+		/* Allow for copy constructors */
-	while ( no ) {
+		if (kind == DEFAULT_COPY || kind == DEFAULT_ASSIGN) {
-	    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+			ulong n1 = last_params[DUMMY_second];
-	    if ( IS_NULL_exp ( a ) ) {
+			ulong m1 = unit_no(bs, NULL_id, VAR_tag, 1);
-		ENC_make_top ( bs ) ;
+			ENC_identify(bs);
+			bs = enc_access(bs, crt_func_access);
-	    } else {
+			ENC_make_tag(bs, m1);
-		TYPE s = DEREF_type ( exp_type ( a ) ) ;
+			ENC_contents(bs);
-		OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
+			ENC_pointer(bs);
-		bs = enc_term_local ( bs, m, off, 0, s, a, context ) ;
+			bs = enc_al_ctype(bs, ct);
-	    }
-	    q = TAIL_list ( q ) ;
+			ENC_obtain_tag(bs);
-	    p = TAIL_list ( p ) ;
+			ENC_make_tag(bs, n1);
-	    no-- ;
+			last_params[DUMMY_copy] = m1;
-	}
+		}
-	/* Conditionally destroy virtual bases */
+		/* Count number of items */
-	if ( nv ) {
+		if (kind != DEFAULT_ASSIGN) {
-	    int mask = 0 ;
+			VIRTUAL vt = DEREF_virt(ctype_virt(ct));
-	    if ( context == 0 ) mask = EXTRA_DESTR ;
+			if (kind != DEFAULT_PRELUDE) {
-	    bs = enc_flag_test ( bs, m2, nv, mask, ntest_not_eq ) ;
+				LIST(GRAPH)bv = DEREF_list(ctype_vbase(ct));
-	    while ( !IS_NULL_list ( p ) ) {
+				while (!IS_NULL_list(bv)) {
+					/* Virtual base pointers */
-		EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+					GRAPH gr = DEREF_graph(HEAD_list(bv));
+					while (!IS_NULL_graph(gr)) {
+						ni++;
+						gr = DEREF_graph(graph_equal(gr));
+					}
+					bv = TAIL_list(bv);
+				}
+			}
-		if ( IS_NULL_exp ( a ) ) {
+			if (!IS_NULL_virt(vt)) {
+				/* Virtual function tables */
+				IDENTIFIER cid = DEREF_id(ctype_name(ct));
+				compile_virtual(ct, !has_linkage(cid));
+				while (!IS_NULL_virt(vt)) {
+					nt++;
+					vt = DEREF_virt(virt_next(vt));
+				}
+			}
+			virt = 0;
+		}
+		if (last_params[DUMMY_count] != LINK_NONE) {
+			ne = 2;
+		}
+		ns = ne * no + nt;
+		nu = ne * nv + ni;
+		if (nu) {
+			ns++;
+		}
+		if (ns > 1) {
-		    ENC_make_top ( bs ) ;
+			ENC_SEQUENCE(bs, ns - 1);
 		} else {
-		    TYPE s = DEREF_type ( exp_type ( a ) ) ;
-		    OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
-		    bs = enc_term_local ( bs, m, off, 0, s, a, context ) ;
-		}
-		q = TAIL_list ( q ) ;
+			if (ns == 0) {
-		p = TAIL_list ( p ) ;
-	    }
-	    ENC_make_top ( bs ) ;
+				ENC_make_top(bs);
-	}
+			}
-	/* Conditionally call 'operator delete' */
-	if ( context == 0 ) {
-	    ns = 1 ;
-	    bs = enc_flag_test ( bs, m2, ns, EXTRA_DELETE, ntest_not_eq ) ;
-	    bs = enc_delete_obj ( bs, ct, m ) ;
-	    ENC_make_top ( bs ) ;
-	}
+		}
+		/* Conditionally initialise virtual bases */
+		if (nu) {
+			int dv = 0;
+			ulong m2 = last_params[DUMMY_extra];
+			bs = enc_flag_test(bs, m2, nu, 0, ntest_not_eq);
-    } else {
+			if (ni) {
-	/* Deal with constructors */
+				/* Initialise virtual base pointers */
+				bs = enc_virt_init(bs, ct, m);
+			}
-	int virt = 1 ;
+			while (nv) {
+				/* Virtual base initialisers */
+				EXP a = DEREF_exp(HEAD_list(p));
+				OFFSET off = DEREF_off(HEAD_list(q));
+				bs = enc_ctor_exp(bs, a, off, m, virt, ne);
+				if (!IS_NULL_exp(a) && IS_exp_paren(a)) {
+					dv++;
+				}
-	unsigned ns, nu ;
+				q = TAIL_list(q);
-	unsigned ni = 0 ;
+				p = TAIL_list(p);
+				nv--;
+			}
-	unsigned nt = 0 ;
+			if (ne == 1 || dv == 0) {
-	unsigned ne = 1 ;
+				ENC_make_top(bs);
+			} else {
+				bs = enc_destr_count(bs, NULL_type, dv);
+			}
+		}
-	/* Allow for copy constructors */
+		/* Initialise direct bases */
-	if ( kind == DEFAULT_COPY || kind == DEFAULT_ASSIGN ) {
-	    ulong n1 = last_params [ DUMMY_second ] ;
-	    ulong m1 = unit_no ( bs, NULL_id, VAR_tag, 1 ) ;
-	    ENC_identify ( bs ) ;
+		while (nb) {
-	    bs = enc_access ( bs, crt_func_access ) ;
+			EXP a = DEREF_exp(HEAD_list(p));
-	    ENC_make_tag ( bs, m1 ) ;
+			OFFSET off = DEREF_off(HEAD_list(q));
-	    ENC_contents ( bs ) ;
+			bs = enc_ctor_exp(bs, a, off, m, virt, ne);
-	    ENC_pointer ( bs ) ;
+			q = TAIL_list(q);
-	    bs = enc_al_ctype ( bs, ct ) ;
+			p = TAIL_list(p);
-	    ENC_obtain_tag ( bs ) ;
+			nb--;
-	    ENC_make_tag ( bs, n1 ) ;
-	    last_params [ DUMMY_copy ] = m1 ;
-	}
+		}
-	/* Count number of items */
-	if ( kind != DEFAULT_ASSIGN ) {
-	    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
-	    if ( kind != DEFAULT_PRELUDE ) {
-		LIST ( GRAPH ) bv = DEREF_list ( ctype_vbase ( ct ) ) ;
-		while ( !IS_NULL_list ( bv ) ) {
-		    /* Virtual base pointers */
+		/* Initialise virtual function tables */
-		    GRAPH gr = DEREF_graph ( HEAD_list ( bv ) ) ;
-		    while ( !IS_NULL_graph ( gr ) ) {
-			ni++ ;
-			gr = DEREF_graph ( graph_equal ( gr ) ) ;
-		    }
+		if (nt) {
-		    bv = TAIL_list ( bv ) ;
+			bs = enc_vtab_init(bs, ct, m, 1);
+		}
-	    }
-	    if ( !IS_NULL_virt ( vt ) ) {
+		/* Initialise members */
-		/* Virtual function tables */
+		while (!IS_NULL_list(p)) {
-		IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+			EXP a = DEREF_exp(HEAD_list(p));
-		compile_virtual ( ct, !has_linkage ( cid ) ) ;
+			OFFSET off = DEREF_off(HEAD_list(q));
-		while ( !IS_NULL_virt ( vt ) ) {
+			bs = enc_ctor_exp(bs, a, off, m, virt, ne);
-		    nt++ ;
+			q = TAIL_list(q);
-		    vt = DEREF_virt ( virt_next ( vt ) ) ;
+			p = TAIL_list(p);
+		}
-	    }
-	    virt = 0 ;
-	}
-	if ( last_params [ DUMMY_count ] != LINK_NONE ) ne = 2 ;
+		last_params[DUMMY_copy] = LINK_NONE;
-	ns = ne * no + nt ;
-	nu = ne * nv + ni ;
-	if ( nu ) ns++ ;
-	if ( ns > 1 ) {
-	    ENC_SEQUENCE ( bs, ns - 1 ) ;
-	} else {
-	    if ( ns == 0 ) ENC_make_top ( bs ) ;
-	}
-	/* Conditionally initialise virtual bases */
-	if ( nu ) {
-	    int dv = 0 ;
-	    ulong m2 = last_params [ DUMMY_extra ] ;
-	    bs = enc_flag_test ( bs, m2, nu, 0, ntest_not_eq ) ;
-	    if ( ni ) {
-		/* Initialise virtual base pointers */
-		bs = enc_virt_init ( bs, ct, m ) ;
-	    }
-	    while ( nv ) {
-		/* Virtual base initialisers */
-		EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
-		OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
-		bs = enc_ctor_exp ( bs, a, off, m, virt, ne ) ;
-		if ( !IS_NULL_exp ( a ) && IS_exp_paren ( a ) ) dv++ ;
-		q = TAIL_list ( q ) ;
-		p = TAIL_list ( p ) ;
-		nv-- ;
-	    }
-	    if ( ne == 1 || dv == 0 ) {
-		ENC_make_top ( bs ) ;
-	    } else {
-		bs = enc_destr_count ( bs, NULL_type, dv ) ;
-	    }
-	}
-	/* Initialise direct bases */
-	while ( nb ) {
-	    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
-	    OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
-	    bs = enc_ctor_exp ( bs, a, off, m, virt, ne ) ;
-	    q = TAIL_list ( q ) ;
-	    p = TAIL_list ( p ) ;
-	    nb-- ;
-	}
-	/* Initialise virtual function tables */
-	if ( nt ) bs = enc_vtab_init ( bs, ct, m, 1 ) ;
-	/* Initialise members */
-	while ( !IS_NULL_list ( p ) ) {
-	    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
-	    OFFSET off = DEREF_off ( HEAD_list ( q ) ) ;
-	    bs = enc_ctor_exp ( bs, a, off, m, virt, ne ) ;
-	    q = TAIL_list ( q ) ;
-	    p = TAIL_list ( p ) ;
+	}
-	last_params [ DUMMY_copy ] = LINK_NONE ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 #endif /* LANGUAGE_CPP */
 #endif /* TDF_OUTPUT */

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/output/struct.c – Rev 2 → 7