WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/output/diag2.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997, 1998
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "throw.h"
 #include "tok.h"
 #include "typeid.h"
 #include "ustring.h"
 #include "virtual.h"
-#if ( TDF_OUTPUT && TDF_NEW_DIAG )
+#if (TDF_OUTPUT && TDF_NEW_DIAG)
 /*
     DWARF TAG VALUES
     Certain values used within the diagnostic format are actually DWARF
     tag values.  These macros give the values used.
 */
 #define DWARF_LANG_TRAD_C		1
 #define DWARF_LANG_ANSI_C		2
 #define DWARF_LANG_CPP			4
 #define DWARF_NO_CALL			2
 #define DWARF_RUN_TIME			3
 #define DWARF_CASE_SENSITIVE		0
 /*
     ENCODE A DIAGNOSTIC FILE NAME
     This routine adds the diagnostic file name given by posn to the
     bitstream bs.
 */
-static BITSTREAM *enc_dg_filename
+static BITSTREAM *
-    PROTO_N ( ( bs, posn ) )
-    PROTO_T ( BITSTREAM *bs X PTR ( POSITION ) posn )
+enc_dg_filename(BITSTREAM *bs, PTR(POSITION)posn)
 {
-    ulong n = DEREF_ulong ( posn_tok ( posn ) ) ;
+	ulong n = DEREF_ulong(posn_tok(posn));
-    if ( n == LINK_NONE ) {
+	if (n == LINK_NONE) {
-	BITSTREAM *ts ;
+		BITSTREAM *ts;
-	string bn = DEREF_string ( posn_base ( posn ) ) ;
+		string bn = DEREF_string(posn_base(posn));
-	string mn = ustrlit ( find_machine () ) ;
+		string mn = ustrlit(find_machine());
-	ulong date = DEREF_ulong ( posn_datestamp ( posn ) ) ;
+		ulong date = DEREF_ulong(posn_datestamp(posn));
-	n = capsule_no ( NULL_string, VAR_token ) ;
+		n = capsule_no(NULL_string, VAR_token);
-	COPY_ulong ( posn_tok ( posn ), n ) ;
+		COPY_ulong(posn_tok(posn), n);
-	if ( !output_date ) date = 0 ;
+		if (!output_date) {
+			date = 0;
+		}
-	ts = enc_tokdef_start ( n, "Q", NIL ( ulong ), 0 ) ;
+		ts = enc_tokdef_start(n, "Q", NIL(ulong), 0);
-	ENC_make_dg_filename ( ts ) ;
+		ENC_make_dg_filename(ts);
-	ENC_make_nat ( ts ) ;
+		ENC_make_nat(ts);
-	ENC_INT ( ts, date ) ;
+		ENC_INT(ts, date);
-	ENC_make_string ( ts ) ;
+		ENC_make_string(ts);
-	ts = enc_ustring ( ts, mn ) ;
+		ts = enc_ustring(ts, mn);
-	ENC_make_string ( ts ) ;
+		ENC_make_string(ts);
-	if ( is_full_pathname ( bn ) ) {
+		if (is_full_pathname(bn)) {
-	    ts = enc_ustring ( ts, ustrlit ( "" ) ) ;
+			ts = enc_ustring(ts, ustrlit(""));
-	} else {
+		} else {
-	    string dn = DEREF_string ( posn_dir ( posn ) ) ;
+			string dn = DEREF_string(posn_dir(posn));
-	    if ( dn == NULL ) {
+			if (dn == NULL) {
-		string en = ustrlit ( find_cwd () ) ;
+				string en = ustrlit(find_cwd());
-		ts = enc_ustring ( ts, en ) ;
+				ts = enc_ustring(ts, en);
-	    } else if ( is_full_pathname ( dn ) ) {
+			} else if (is_full_pathname(dn)) {
-		ts = enc_ustring ( ts, dn ) ;
+				ts = enc_ustring(ts, dn);
-	    } else {
+			} else {
-		string en = ustrlit ( find_cwd () ) ;
+				string en = ustrlit(find_cwd());
-		BUFFER *bf = clear_buffer ( &incl_buff, NIL ( FILE ) ) ;
+				BUFFER *bf = clear_buffer(&incl_buff, NIL(FILE));
-		bfprintf ( bf, "%s/%s", en, dn ) ;
+				bfprintf(bf, "%s/%s", en, dn);
-		ts = enc_ustring ( ts, bf->start ) ;
+				ts = enc_ustring(ts, bf->start);
-	    }
+			}
+		}
+		ENC_make_string(ts);
+		ts = enc_ustring(ts, bn);
+		enc_tokdef_end(n, ts);
+	}
-	ENC_make_string ( ts ) ;
-	ts = enc_ustring ( ts, bn ) ;
-	enc_tokdef_end ( n, ts ) ;
-    }
-    /* Encode token application */
+	/* Encode token application */
-    ENC_dg_filename_apply_token ( bs ) ;
+	ENC_dg_filename_apply_token(bs);
-    n = link_no ( bs, n, VAR_token ) ;
+	n = link_no(bs, n, VAR_token);
-    ENC_make_tok ( bs, n ) ;
+	ENC_make_tok(bs, n);
-    ENC_LEN_SMALL ( bs, 0 ) ;
+	ENC_LEN_SMALL(bs, 0);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC SOURCE POSITION
     This routine adds the source position given by the span from p to q
     to the bitstream bs.
 */
-static BITSTREAM *enc_dg_loc
+static BITSTREAM *
-    PROTO_N ( ( bs, p, q ) )
-    PROTO_T ( BITSTREAM *bs X PTR ( LOCATION ) p X PTR ( LOCATION ) q )
+enc_dg_loc(BITSTREAM *bs, PTR(LOCATION)p, PTR(LOCATION)q)
+{
-    if ( IS_NULL_ptr ( p ) || IS_NULL_ptr ( q ) ) {
+	if (IS_NULL_ptr(p) || IS_NULL_ptr(q)) {
-	ENC_dg_null_sourcepos ( bs ) ;
+		ENC_dg_null_sourcepos(bs);
-    } else {
-	ulong lp = DEREF_ulong ( loc_line ( p ) ) ;
-	ulong lq = DEREF_ulong ( loc_line ( q ) ) ;
-	ulong cp = DEREF_ulong ( loc_column ( p ) ) ;
-	ulong cq = DEREF_ulong ( loc_column ( q ) ) ;
-	PTR ( POSITION ) fp = DEREF_ptr ( loc_posn ( p ) ) ;
-	PTR ( POSITION ) fq = DEREF_ptr ( loc_posn ( q ) ) ;
-	if ( EQ_ptr ( p, q ) ) {
-	    ENC_dg_mark_sourcepos ( bs ) ;
-	} else if ( lp == lq && cp == cq && EQ_ptr ( fp, fq ) ) {
-	    ENC_dg_mark_sourcepos ( bs ) ;
-	    q = p ;
 	} else {
+		ulong lp = DEREF_ulong(loc_line(p));
+		ulong lq = DEREF_ulong(loc_line(q));
+		ulong cp = DEREF_ulong(loc_column(p));
+		ulong cq = DEREF_ulong(loc_column(q));
+		PTR(POSITION)fp = DEREF_ptr(loc_posn(p));
+		PTR(POSITION)fq = DEREF_ptr(loc_posn(q));
+		if (EQ_ptr(p, q)) {
+			ENC_dg_mark_sourcepos(bs);
+		} else if (lp == lq && cp == cq && EQ_ptr(fp, fq)) {
+			ENC_dg_mark_sourcepos(bs);
+			q = p;
+		} else {
-	    ENC_dg_span_sourcepos ( bs ) ;
+			ENC_dg_span_sourcepos(bs);
+		}
+		bs = enc_dg_filename(bs, fp);
+		ENC_make_nat(bs);
+		ENC_INT(bs, lp);
+		ENC_make_nat(bs);
+		ENC_INT(bs, cp);
+		if (!EQ_ptr(p, q)) {
+			if (EQ_ptr(fp, fq)) {
+				ENC_OFF(bs);
+			} else {
+				ENC_ON(bs);
+				bs = enc_dg_filename(bs, fq);
+			}
+			ENC_make_nat(bs);
+			ENC_INT(bs, lq);
+			ENC_make_nat(bs);
+			ENC_INT(bs, cq);
+		}
+	}
-	bs = enc_dg_filename ( bs, fp ) ;
-	ENC_make_nat ( bs ) ;
-	ENC_INT ( bs, lp ) ;
-	ENC_make_nat ( bs ) ;
-	ENC_INT ( bs, cp ) ;
-	if ( !EQ_ptr ( p, q ) ) {
-	    if ( EQ_ptr ( fp, fq ) ) {
-		ENC_OFF ( bs ) ;
-	    } else {
-		ENC_ON ( bs ) ;
-		bs = enc_dg_filename ( bs, fq ) ;
-	    }
-	    ENC_make_nat ( bs ) ;
-	    ENC_INT ( bs, lq ) ;
-	    ENC_make_nat ( bs ) ;
-	    ENC_INT ( bs, cq ) ;
-	}
-    }
-    return ( bs ) ;
+	return (bs);
 }
 /*
     FIND THE START OR END OF A BLOCK
     This routine returns the location of the start or end of the block e.
 */
-static PTR ( LOCATION ) block_loc
+static
-    PROTO_N ( ( e, end ) )
-    PROTO_T ( EXP e X int end )
+PTR(LOCATION)block_loc(EXP e, int end)
+{
-    PTR ( LOCATION ) loc = NULL_ptr ( LOCATION ) ;
+	PTR(LOCATION)loc = NULL_ptr(LOCATION);
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	if ( IS_exp_solve_stmt ( e ) ) {
+		if (IS_exp_solve_stmt(e)) {
-	    e = DEREF_exp ( exp_solve_stmt_body ( e ) ) ;
+			e = DEREF_exp(exp_solve_stmt_body(e));
+		}
+		if (IS_exp_sequence(e)) {
+			EXP a;
+			LIST(EXP)p;
+			if (end) {
+				p = DEREF_list(exp_sequence_last(e));
+			} else {
+				p = DEREF_list(exp_sequence_first(e));
+			}
+			a = DEREF_exp(HEAD_list(p));
+			if (!IS_NULL_exp(a) && IS_exp_location(a)) {
+				loc = exp_location_end(a);
+			}
+		}
+	}
-	if ( IS_exp_sequence ( e ) ) {
-	    EXP a ;
-	    LIST ( EXP ) p ;
-	    if ( end ) {
-		p = DEREF_list ( exp_sequence_last ( e ) ) ;
-	    } else {
-		p = DEREF_list ( exp_sequence_first ( e ) ) ;
-	    }
-	    a = DEREF_exp ( HEAD_list ( p ) ) ;
-	    if ( !IS_NULL_exp ( a ) && IS_exp_location ( a ) ) {
-		loc = exp_location_end ( a ) ;
-	    }
-	}
-    }
-    return ( loc ) ;
+	return (loc);
+}
 /*
     ENCODE THE START OF A NAMESPACE
     This routine adds the start of a list of names derived from the
     namespace ns to the bitstream bs.
 */
-static BITSTREAM *enc_dg_namelist
+static BITSTREAM *
-    PROTO_N ( ( bs, ns ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns )
+enc_dg_namelist(BITSTREAM *bs, NAMESPACE ns)
+{
-    ulong n = capsule_no ( NULL_string, VAR_dgtag ) ;
+	ulong n = capsule_no(NULL_string, VAR_dgtag);
-    IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
+	IDENTIFIER id = DEREF_id(nspace_name(ns));
+	if (!IS_NULL_id(id)) {
-    if ( !IS_NULL_id ( id ) ) COPY_ulong ( id_no ( id ), n ) ;
+		COPY_ulong(id_no(id), n);
+	}
-    record_usage ( n, VAR_dgtag, USAGE_DEFN ) ;
+	record_usage(n, VAR_dgtag, USAGE_DEFN);
-    ENC_dg_tag_namelist ( bs ) ;
+	ENC_dg_tag_namelist(bs);
-    n = link_no ( bs, n, VAR_dgtag ) ;
+	n = link_no(bs, n, VAR_dgtag);
-    ENC_make_dg_tag ( bs, n ) ;
+	ENC_make_dg_tag(bs, n);
-    ENC_make_dg_namelist ( bs ) ;
+	ENC_make_dg_namelist(bs);
-    ENC_LIST_SMALL ( bs, 0 ) ;
+	ENC_LIST_SMALL(bs, 0);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE COMMAND-LINE OPTIONS
     This routine adds the revelant command-line options as a list of
     strings to the bitstream bs.
 */
-static BITSTREAM *enc_dg_options
+static BITSTREAM *
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+enc_dg_options(BITSTREAM *bs)
 {
-    unsigned n = 0 ;
+	unsigned n = 0;
-    INCL_DIR *d = dir_path ;
+	INCL_DIR *d = dir_path;
-    while ( d != NULL ) {
+	while (d != NULL) {
-	n++ ;
+		n++;
-	d = d->next ;
+		d = d->next;
-    }
+	}
-    ENC_LIST ( bs, n ) ;
+	ENC_LIST(bs, n);
-    d = dir_path ;
+	d = dir_path;
-    while ( d != NULL ) {
+	while (d != NULL) {
-	BUFFER *bf = clear_buffer ( &incl_buff, NIL ( FILE ) ) ;
+		BUFFER *bf = clear_buffer(&incl_buff, NIL(FILE));
-	ENC_make_string ( bs ) ;
+		ENC_make_string(bs);
-	bfprintf ( bf, "-I%s", d->path ) ;
+		bfprintf(bf, "-I%s", d->path);
-	bs = enc_ustring ( bs, bf->start ) ;
+		bs = enc_ustring(bs, bf->start);
-	d = d->next ;
+		d = d->next;
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A COMPILATION UNIT
     This routine adds the top-level compilation unit information to the
     bitstream bs.  The current location gives information about the
     primary source file.
 */
-BITSTREAM *enc_dg_compilation
+BITSTREAM *
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+enc_dg_compilation(BITSTREAM *bs)
 {
-    LOCATION loc ;
+	LOCATION loc;
-    ulong date = crt_time ;
+	ulong date = crt_time;
-    string vers = report_version ( 0 ) ;
+	string vers = report_version(0);
-    ENC_make_dg_compilation ( bs ) ;
+	ENC_make_dg_compilation(bs);
-    bs = enc_dg_filename ( bs, crt_loc.posn ) ;
+	bs = enc_dg_filename(bs, crt_loc.posn);
-    ENC_LIST_SMALL ( bs, 0 ) ;
+	ENC_LIST_SMALL(bs, 0);
-    ENC_LIST_SMALL ( bs, 0 ) ;
+	ENC_LIST_SMALL(bs, 0);
-    loc = crt_loc ;
+	loc = crt_loc;
-    IGNORE set_crt_loc ( ustrlit ( "" ), 0 ) ;
+	IGNORE set_crt_loc(ustrlit(""), 0);
-    bs = enc_dg_filename ( bs, crt_loc.posn ) ;
+	bs = enc_dg_filename(bs, crt_loc.posn);
-    crt_loc = loc ;
+	crt_loc = loc;
-    if ( !output_date ) date = 0 ;
-    ENC_make_nat ( bs ) ;
-    ENC_INT ( bs, date ) ;
-    ENC_make_nat ( bs ) ;
-    ENC_INT ( bs, DWARF_LANG ) ;
-    ENC_make_nat ( bs ) ;
-    ENC_INT ( bs, DWARF_CASE_SENSITIVE ) ;
-    ENC_make_string ( bs ) ;
-    bs = enc_ustring ( bs, vers ) ;
-    bs = enc_dg_options ( bs ) ;
-    bs = enc_dg_namelist ( bs, global_namespace ) ;
-    /* Output basic type definitions */
-    if ( output_builtin ) {
+	if (!output_date) {
-	CV_SPEC cv ;
-	BUILTIN_TYPE n ;
-	for ( n = ntype_char ; n < ntype_ellipsis ; n++ ) {
-	    TYPE t = type_builtin [n] ;
-	    switch ( TAG_type ( t ) ) {
-		case type_integer_tag :
-		case type_floating_tag : {
-		    IGNORE enc_dg_basetype ( t, 1 ) ;
-		    break ;
+		date = 0;
-		}
-	    }
-	}
-	for ( cv = cv_none ; cv <= cv_qual ; cv++ ) {
-	    TYPE t = qualify_type ( type_void, cv, 0 ) ;
-	    MAKE_type_ptr ( cv_none, t, t ) ;
-	    IGNORE enc_dg_basetype ( t, 1 ) ;
+	}
+	ENC_make_nat(bs);
+	ENC_INT(bs, date);
+	ENC_make_nat(bs);
+	ENC_INT(bs, DWARF_LANG);
+	ENC_make_nat(bs);
+	ENC_INT(bs, DWARF_CASE_SENSITIVE);
+	ENC_make_string(bs);
+	bs = enc_ustring(bs, vers);
+	bs = enc_dg_options(bs);
+	bs = enc_dg_namelist(bs, global_namespace);
+	/* Output basic type definitions */
+	if (output_builtin) {
+		CV_SPEC cv;
+		BUILTIN_TYPE n;
+		for (n = ntype_char; n < ntype_ellipsis; n++) {
+			TYPE t = type_builtin[n];
+			switch (TAG_type(t)) {
+			case type_integer_tag:
+			case type_floating_tag: {
+				IGNORE enc_dg_basetype(t, 1);
+				break;
-    }
+			}
+			}
+		}
+		for (cv = cv_none; cv <= cv_qual; cv++) {
+			TYPE t = qualify_type(type_void, cv, 0);
+			MAKE_type_ptr(cv_none, t, t);
+			IGNORE enc_dg_basetype(t, 1);
+		}
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC ACCESS SPECIFIER
     This routine adds the access specifier component of ds to the bitstream
     bs.  All access specifiers are optional, the default being public.
 */
-static BITSTREAM *enc_dg_access
+static BITSTREAM *
-    PROTO_N ( ( bs, ds ) )
-    PROTO_T ( BITSTREAM *bs X DECL_SPEC ds )
+enc_dg_access(BITSTREAM *bs, DECL_SPEC ds)
 {
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    if ( acc == dspec_private ) {
+	if (acc == dspec_private) {
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	ENC_dg_private_accessibility ( bs ) ;
+		ENC_dg_private_accessibility(bs);
-    } else if ( acc == dspec_protected ) {
+	} else if (acc == dspec_protected) {
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	ENC_dg_protected_accessibility ( bs ) ;
+		ENC_dg_protected_accessibility(bs);
-    } else {
+	} else {
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A DIAGNOSTIC VIRTUAL SPECIFIER
     This routine adds the virtual specifier component of ds to the bitstream
     bs.  All virtual specifiers are optional, the default being non-virtual.
 */
-static BITSTREAM *enc_dg_virtual
+static BITSTREAM *
-    PROTO_N ( ( bs, ds ) )
-    PROTO_T ( BITSTREAM *bs X DECL_SPEC ds )
+enc_dg_virtual(BITSTREAM *bs, DECL_SPEC ds)
 {
-    if ( ds & dspec_virtual ) {
+	if (ds & dspec_virtual) {
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	if ( ds & dspec_pure ) {
+		if (ds & dspec_pure) {
-	    ENC_dg_abstract_virtuality ( bs ) ;
+			ENC_dg_abstract_virtuality(bs);
-	} else {
+		} else {
-	    ENC_dg_virtual_virtuality ( bs ) ;
+			ENC_dg_virtual_virtuality(bs);
-	}
+		}
-    } else {
+	} else {
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-    }
+	}
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A TEMPLATE ARGUMENT
     Template arguments are encoded as dummy object or type names.
 */
-static BITSTREAM *enc_dg_token_arg
+static BITSTREAM *
-    PROTO_N ( ( bs, tok ) )
-    PROTO_T ( BITSTREAM *bs X TOKEN tok )
+enc_dg_token_arg(BITSTREAM *bs, TOKEN tok)
+{
-    int is_type = 0 ;
+	int is_type = 0;
-    EXP e = NULL_exp ;
+	EXP e = NULL_exp;
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    if ( !IS_NULL_tok ( tok ) ) {
+	if (!IS_NULL_tok(tok)) {
-	switch ( TAG_tok ( tok ) ) {
+		switch (TAG_tok(tok)) {
-	    case tok_exp_tag : {
+		case tok_exp_tag: {
-		int c = DEREF_int ( tok_exp_constant ( tok ) ) ;
+			int c = DEREF_int(tok_exp_constant(tok));
+			if (c) {
-		if ( c ) e = DEREF_exp ( tok_exp_value ( tok ) ) ;
+				e = DEREF_exp(tok_exp_value(tok));
+			}
-		break ;
+			break;
-	    }
+		}
-	    case tok_nat_tag :
+		case tok_nat_tag:
-	    case tok_snat_tag : {
+		case tok_snat_tag: {
-		NAT n = DEREF_nat ( tok_nat_etc_value ( tok ) ) ;
+			NAT n = DEREF_nat(tok_nat_etc_value(tok));
-		e = calc_nat_value ( n, type_sint ) ;
+			e = calc_nat_value(n, type_sint);
-		break ;
+			break;
-	    }
+		}
-	    case tok_type_tag : {
+		case tok_type_tag: {
-		t = DEREF_type ( tok_type_value ( tok ) ) ;
+			t = DEREF_type(tok_type_value(tok));
-		is_type = 1 ;
+			is_type = 1;
-		break ;
+			break;
-	    }
+		}
-	    case tok_class_tag : {
+		case tok_class_tag: {
-		is_type = 1 ;
+			is_type = 1;
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    if ( is_type ) {
+	if (is_type) {
-	/* Type name */
+		/* Type name */
-	ENC_dg_type_name ( bs ) ;
+		ENC_dg_type_name(bs);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	ENC_dg_null_sourcepos ( bs ) ;
+		ENC_dg_null_sourcepos(bs);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	if ( !IS_NULL_type ( t ) ) {
+		if (!IS_NULL_type(t)) {
-	    ENC_ON ( bs ) ;
+			ENC_ON(bs);
-	    bs = enc_dg_type ( bs, t, 0 ) ;
+			bs = enc_dg_type(bs, t, 0);
+		} else {
+			ENC_OFF(bs);
+		}
+		ENC_false(bs);
+		ENC_OFFS(bs, 2);
 	} else {
-	    ENC_OFF ( bs ) ;
-	}
-	ENC_false ( bs ) ;
-	ENC_OFFS ( bs, 2 ) ;
-    } else {
-	/* Object name */
+		/* Object name */
-	ENC_dg_object_name ( bs ) ;
+		ENC_dg_object_name(bs);
-	bs = enc_dg_name ( bs, NULL_id, NULL_type ) ;
+		bs = enc_dg_name(bs, NULL_id, NULL_type);
-	ENC_dg_null_sourcepos ( bs ) ;
+		ENC_dg_null_sourcepos(bs);
-	if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-	    t = DEREF_type ( exp_type ( e ) ) ;
+			t = DEREF_type(exp_type(e));
-	    bs = enc_dg_type ( bs, t, 0 ) ;
+			bs = enc_dg_type(bs, t, 0);
-	    ENC_ON ( bs ) ;
+			ENC_ON(bs);
-	    bs = enc_exp ( bs, e ) ;
+			bs = enc_exp(bs, e);
-	} else {
+		} else {
-	    bs = enc_dg_type ( bs, t, 0 ) ;
+			bs = enc_dg_type(bs, t, 0);
-	    ENC_OFF ( bs ) ;
+			ENC_OFF(bs);
+		}
+		ENC_OFF(bs);
+	}
-	ENC_OFF ( bs ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE AN ARTIFICIAL IDENTIFIER NAME
     This routine adds the artificial identifier name s to the bitstream bs.
 */
-static BITSTREAM *enc_dg_artificial
+static BITSTREAM *
-    PROTO_N ( ( bs, s ) )
-    PROTO_T ( BITSTREAM *bs X CONST char *s )
+enc_dg_artificial(BITSTREAM *bs, CONST char *s)
+{
-    ENC_dg_artificial_idname ( bs ) ;
+	ENC_dg_artificial_idname(bs);
-    ENC_ON ( bs ) ;
+	ENC_ON(bs);
-    ENC_make_string ( bs ) ;
+	ENC_make_string(bs);
-    bs = enc_ustring ( bs, ustrlit ( s ) ) ;
+	bs = enc_ustring(bs, ustrlit(s));
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC IDENTIFIER NAME
     This routine adds the name of the identifier id to the bitstream bs.
 */
-BITSTREAM *enc_dg_name
+BITSTREAM *
-    PROTO_N ( ( bs, id, form ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER id X TYPE form )
+enc_dg_name(BITSTREAM *bs, IDENTIFIER id, TYPE form)
+{
-    if ( !IS_NULL_type ( form ) && IS_type_token ( form ) ) {
+	if (!IS_NULL_type(form) && IS_type_token(form)) {
-	/* Template instance name */
+		/* Template instance name */
-	IDENTIFIER tid = DEREF_id ( type_token_tok ( form ) ) ;
+		IDENTIFIER tid = DEREF_id(type_token_tok(form));
-	LIST ( TOKEN ) args = DEREF_list ( type_token_args ( form ) ) ;
+		LIST(TOKEN)args = DEREF_list(type_token_args(form));
-	if ( !IS_id_token ( tid ) ) {
+		if (!IS_id_token(tid)) {
-	    ENC_dg_instance_idname ( bs ) ;
+			ENC_dg_instance_idname(bs);
-	    ENC_OFF ( bs ) ;
+			ENC_OFF(bs);
-	    bs = enc_dg_name ( bs, tid, NULL_type ) ;
+			bs = enc_dg_name(bs, tid, NULL_type);
-	    bs = enc_dg_loc ( bs, id_loc ( tid ), id_loc ( tid ) ) ;
+			bs = enc_dg_loc(bs, id_loc(tid), id_loc(tid));
-	    ENC_LIST ( bs, LENGTH_list ( args ) ) ;
+			ENC_LIST(bs, LENGTH_list(args));
-	    while ( !IS_NULL_list ( args ) ) {
+			while (!IS_NULL_list(args)) {
-		TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
+				TOKEN arg = DEREF_tok(HEAD_list(args));
-		bs = enc_dg_token_arg ( bs, arg ) ;
+				bs = enc_dg_token_arg(bs, arg);
-		args = TAIL_list ( args ) ;
+				args = TAIL_list(args);
-	    }
+			}
-	    return ( bs ) ;
+			return (bs);
-	}
+		}
-    }
+	}
-    if ( !IS_NULL_id ( id ) ) {
+	if (!IS_NULL_id(id)) {
-	string s ;
+		string s;
-	HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		HASHID nm = DEREF_hashid(id_name(id));
-	switch ( TAG_hashid ( nm ) ) {
+		switch (TAG_hashid(nm)) {
-	    case hashid_name_tag : {
+		case hashid_name_tag: {
-		/* Simple case */
+			/* Simple case */
-		s = DEREF_string ( hashid_name_text ( nm ) ) ;
+			s = DEREF_string(hashid_name_text(nm));
-		break ;
+			break;
-	    }
+		}
-	    case hashid_ename_tag : {
+		case hashid_ename_tag: {
-		/* Extended case */
+			/* Extended case */
-		if ( EQ_KEYWORD ( nm, lex_this_Hname ) ) {
+			if (EQ_KEYWORD(nm, lex_this_Hname)) {
-		    bs = enc_dg_artificial ( bs, "this" ) ;
+				bs = enc_dg_artificial(bs, "this");
-		    return ( bs ) ;
+				return (bs);
+			}
+			s = DEREF_string(hashid_ename_text(nm));
+			break;
+		}
+		case hashid_anon_tag: {
+			/* Anonymous case */
+			ENC_dg_anonymous_idname(bs);
+			ENC_OFF(bs);
+			return (bs);
+		}
+		default : {
+			/* Other cases */
+			BUFFER *bf;
+			bf = clear_buffer(&mangle_buff, NIL(FILE));
+			IGNORE print_hashid(nm, 0, 0, bf, 0);
+			s = bf->start;
+			break;
+		}
+		}
+		if (has_linkage(id)) {
+			ENC_dg_external_idname(bs);
+		} else {
+			ENC_dg_sourcestring_idname(bs);
+		}
-		s = DEREF_string ( hashid_ename_text ( nm ) ) ;
+		ENC_make_string(bs);
-		break ;
+		bs = enc_ustring(bs, s);
-	    }
+	} else {
-	    case hashid_anon_tag : {
-		/* Anonymous case */
-		ENC_dg_anonymous_idname ( bs ) ;
+		ENC_dg_anonymous_idname(bs);
-		ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-		return ( bs ) ;
-	    }
-	    default : {
-		/* Other cases */
-		BUFFER *bf ;
-		bf = clear_buffer ( &mangle_buff, NIL ( FILE ) ) ;
-		IGNORE print_hashid ( nm, 0, 0, bf, 0 ) ;
-		s = bf->start ;
-		break ;
-	    }
+	}
-	if ( has_linkage ( id ) ) {
-	    ENC_dg_external_idname ( bs ) ;
-	} else {
-	    ENC_dg_sourcestring_idname ( bs ) ;
-	}
-	ENC_make_string ( bs ) ;
-	bs = enc_ustring ( bs, s ) ;
-    } else {
-	ENC_dg_anonymous_idname ( bs ) ;
-	ENC_OFF ( bs ) ;
-    }
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A DIAGNOSTIC IDENTIFIER
     This routine adds the diagnostics for the identifier id to the
     bitstream bs.  use indicates whether a declaration or a definition
     should be output.
+	}
-	case id_class_name_tag :
+	case id_class_name_tag:
-	case id_enum_name_tag :
+	case id_enum_name_tag:
-	case id_class_alias_tag :
+	case id_class_alias_tag:
-	case id_enum_alias_tag :
+	case id_enum_alias_tag:
-	case id_type_alias_tag : {
+	case id_type_alias_tag: {
-	    /* Type names */
+		/* Type names */
-	    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+		TYPE t = DEREF_type(id_class_name_etc_defn(id));
-	    ENC_dg_type_name ( bs ) ;
+		ENC_dg_type_name(bs);
-	    if ( tagged ) {
+		if (tagged) {
-		ENC_OFF ( bs ) ;
+			ENC_OFF(bs);
-	    } else {
-		TYPE form = NULL_type ;
-		if ( IS_type_compound ( t ) ) {
-		    CLASS_TYPE ct ;
-		    ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		    form = DEREF_type ( ctype_form ( ct ) ) ;
-		}
-		ENC_ON ( bs ) ;
-		bs = enc_dg_name ( bs, id, form ) ;
-	    }
-	    bs = enc_dg_loc ( bs, id_loc ( id ), id_loc ( id ) ) ;
-	    bs = enc_dg_access ( bs, ds ) ;
-	    ENC_ON ( bs ) ;
-	    if ( tagged ) {
-		ulong m = link_no ( bs, n, VAR_dgtag ) ;
-		if ( use & USAGE_USE ) {
-		    ENC_dg_spec_ref_type ( bs ) ;
 		} else {
+			TYPE form = NULL_type;
+			if (IS_type_compound(t)) {
+				CLASS_TYPE ct;
+				ct = DEREF_ctype(type_compound_defn(t));
+				form = DEREF_type(ctype_form(ct));
+			}
+			ENC_ON(bs);
-		    ENC_dg_tag_type ( bs ) ;
+			bs = enc_dg_name(bs, id, form);
+		}
+		bs = enc_dg_loc(bs, id_loc(id), id_loc(id));
+		bs = enc_dg_access(bs, ds);
+		ENC_ON(bs);
+		if (tagged) {
+			ulong m = link_no(bs, n, VAR_dgtag);
+			if (use & USAGE_USE) {
+				ENC_dg_spec_ref_type(bs);
+			} else {
+				ENC_dg_tag_type(bs);
+			}
-		ENC_make_dg_tag ( bs, m ) ;
+			ENC_make_dg_tag(bs, m);
-		if ( use & USAGE_DEFN ) {
+			if (use & USAGE_DEFN) {
-		    record_usage ( n, VAR_dgtag, USAGE_DEFN ) ;
+				record_usage(n, VAR_dgtag, USAGE_DEFN);
-		} else {
+			} else {
-		    record_usage ( n, VAR_dgtag, USAGE_DECL ) ;
+				record_usage(n, VAR_dgtag, USAGE_DECL);
+			}
+		}
+		bs = enc_dg_type(bs, t, force);
+		ENC_false(bs);
+		ENC_OFFS(bs, 2);
+		break;
+	}
+	case id_nspace_name_tag: {
+		/* Namespace names */
+		IDENTIFIER nid = id;
+		NAMESPACE ns = DEREF_nspace(id_nspace_name_defn(id));
+		if (IS_nspace_unnamed(ns)) {
+			nid = NULL_id;
+		}
-	    }
+		ENC_dg_namespace_name(bs);
-	    bs = enc_dg_type ( bs, t, force ) ;
+		bs = enc_dg_name(bs, nid, NULL_type);
-	    ENC_false ( bs ) ;
+		bs = enc_dg_loc(bs, id_loc(id), id_loc(id));
-	    ENC_OFFS ( bs, 2 ) ;
+		bs = enc_dg_namelist(bs, ns);
-	    break ;
+		break;
+	}
+	}
+	if (spec) {
+		ENC_OFF(bs);
+	}
+	return (bs);
+}
-	case id_nspace_name_tag : {
-	    /* Namespace names */
-	    IDENTIFIER nid = id ;
-	    NAMESPACE ns = DEREF_nspace ( id_nspace_name_defn ( id ) ) ;
-	    if ( IS_nspace_unnamed ( ns ) ) nid = NULL_id ;
-	    ENC_dg_namespace_name ( bs ) ;
-	    bs = enc_dg_name ( bs, nid, NULL_type ) ;
-	    bs = enc_dg_loc ( bs, id_loc ( id ), id_loc ( id ) ) ;
-	    bs = enc_dg_namelist ( bs, ns ) ;
-	    break ;
-	}
-    }
-    if ( spec ) ENC_OFF ( bs ) ;
-    return ( bs ) ;
-}
 /*
     ENCODE DIAGNOSTICS FOR A TOKEN DEFINITION
     This routine outputs any diagnostic information for the token id
     to the appropriate diagnostic units.  It is only called if id is
     defined.  The type t may be used to override the type of id.
 */
-void enc_dg_token
+void
-    PROTO_N ( ( id, t ) )
-    PROTO_T ( IDENTIFIER id X TYPE t )
+enc_dg_token(IDENTIFIER id, TYPE t)
 {
-    UNUSED ( id ) ;
+	UNUSED(id);
-    UNUSED ( t ) ;
+	UNUSED(t);
-    return ;
+	return;
 }
 /*
     LIST OF INCOMPLETE CLASSES
     This list is used to hold all the classes which are used while they
     are incomplete.  A diagnostic tag is introduced for each such class
     which may be defined later if the class is completed.
 */
-static LIST ( IDENTIFIER ) dg_classes = NULL_list ( IDENTIFIER ) ;
+static LIST(IDENTIFIER)dg_classes = NULL_list(IDENTIFIER);
 /*
     DEFINE INCOMPLETE CLASSES
     This routine defines the diagnostic tags for the incomplete classes
     in the list above.
 */
+int
-int enc_dg_pending
+enc_dg_pending(void)
-    PROTO_Z ()
 {
-    int changed = 0 ;
+	int changed = 0;
-    LIST ( IDENTIFIER ) p ;
+	LIST(IDENTIFIER)p;
-    while ( p = dg_classes, !IS_NULL_list ( p ) ) {
+	while (p = dg_classes, !IS_NULL_list(p)) {
-	dg_classes = NULL_list ( IDENTIFIER ) ;
+		dg_classes = NULL_list(IDENTIFIER);
-	while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-	    IDENTIFIER id ;
+			IDENTIFIER id;
-	    DESTROY_CONS_id ( destroy, id, p, p ) ;
+			DESTROY_CONS_id(destroy, id, p, p);
-	    enc_dg_id ( id, 2 ) ;
+			enc_dg_id(id, 2);
-	    changed = 1 ;
+			changed = 1;
-	}
+		}
-    }
+	}
-    return ( changed ) ;
+	return (changed);
 }
 /*
     FIND A DIAGNOSTIC TAG USAGE
     This routine determines the usage for the diagnostic tag associated
     with the identifier id in the context given by def (true for
     definitions, false for declarations).  The value returned indicates
     whether the diagnostic tag should be declared or defined.
 */
-static unsigned find_dg_usage
+static unsigned
-    PROTO_N ( ( id, pn, def ) )
-    PROTO_T ( IDENTIFIER id X ulong *pn X int def )
+find_dg_usage(IDENTIFIER id, ulong *pn, int def)
 {
-    unsigned use = USAGE_NONE ;
+	unsigned use = USAGE_NONE;
-    switch ( TAG_id ( id ) ) {
+	switch (TAG_id(id)) {
-	case id_class_name_tag :
+	case id_class_name_tag:
-	case id_enum_name_tag :
+	case id_enum_name_tag:
-	case id_class_alias_tag :
+	case id_class_alias_tag:
-	case id_enum_alias_tag :
+	case id_enum_alias_tag:
-	case id_type_alias_tag : {
+	case id_type_alias_tag: {
-	    /* Type names */
+		/* Type names */
-	    TYPE t ;
+		TYPE t;
-	    ulong n = DEREF_ulong ( id_no ( id ) ) ;
+		ulong n = DEREF_ulong(id_no(id));
-	    if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-		/* Introduce diagnostic tag for type */
+			/* Introduce diagnostic tag for type */
-		NAMESPACE ns ;
+			NAMESPACE ns;
-		string s = NULL ;
+			string s = NULL;
+			if (def == 0) {
-		if ( def == 0 ) return ( USAGE_NONE ) ;
+				return (USAGE_NONE);
+			}
-		t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+			t = DEREF_type(id_class_name_etc_defn(id));
-		if ( IS_type_top_etc ( t ) ) {
+			if (IS_type_top_etc(t)) {
-		    /* Ignore 'void' types */
+				/* Ignore 'void' types */
+				return (USAGE_NONE);
+			}
+			ns = DEREF_nspace(id_parent(id));
+			if (is_local_nspace(ns) == 2) {
-		    return ( USAGE_NONE ) ;
+				return (USAGE_NONE);
+			}
+			if (output_all) {
+				s = mangle_tname("__dg__", t);
+			}
+			n = capsule_no(s, VAR_dgtag);
+			COPY_ulong(id_no(id), n);
+		} else {
+			use = USAGE_USE;
+		}
+		if (is_defined(id, &t, 0)) {
+			/* Only define each type once */
+			unsigned prev = find_usage(n, VAR_dgtag);
+			if (prev & USAGE_DEFN) {
+				use = USAGE_NONE;
+			} else {
+				use |= (USAGE_DECL | USAGE_DEFN);
+			}
+		} else {
+			/* Only declare each type once */
+			if (use == USAGE_USE) {
+				use = USAGE_NONE;
+			} else {
+				CONS_id(id, dg_classes, dg_classes);
+				use = USAGE_DECL;
+			}
+		}
-		ns = DEREF_nspace ( id_parent ( id ) ) ;
-		if ( is_local_nspace ( ns ) == 2 ) return ( USAGE_NONE ) ;
-		if ( output_all ) s = mangle_tname ( "__dg__", t ) ;
-		n = capsule_no ( s, VAR_dgtag ) ;
-		COPY_ulong ( id_no ( id ), n ) ;
-	    } else {
-		use = USAGE_USE ;
-	    }
-	    if ( is_defined ( id, &t, 0 ) ) {
-		/* Only define each type once */
-		unsigned prev = find_usage ( n, VAR_dgtag ) ;
-		if ( prev & USAGE_DEFN ) {
-		    use = USAGE_NONE ;
-		} else {
-		    use |= ( USAGE_DECL | USAGE_DEFN ) ;
-		}
-	    } else {
-		/* Only declare each type once */
-		if ( use == USAGE_USE ) {
-		    use = USAGE_NONE ;
-		} else {
-		    CONS_id ( id, dg_classes, dg_classes ) ;
-		    use = USAGE_DECL ;
-		}
-	    }
-	    *pn = n ;
+		*pn = n;
-	    break ;
+		break;
+	}
-	case id_variable_tag :
+	case id_variable_tag:
-	case id_stat_member_tag :
+	case id_stat_member_tag:
-	case id_function_tag :
+	case id_function_tag:
-	case id_mem_func_tag :
+	case id_mem_func_tag:
-	case id_stat_mem_func_tag : {
+	case id_stat_mem_func_tag: {
-	    /* Tag names */
+		/* Tag names */
-	    ulong n = get_diag_tag ( id, VAR_tag ) ;
+		ulong n = get_diag_tag(id, VAR_tag);
-	    if ( n == LINK_NONE ) {
+		if (n == LINK_NONE) {
-		/* Introduce diagnostic tag for tag */
+			/* Introduce diagnostic tag for tag */
-		string s = NULL ;
+			string s = NULL;
+			if (output_all) {
-		if ( output_all ) s = mangle_name ( id, VAR_dgtag, 0 ) ;
+				s = mangle_name(id, VAR_dgtag, 0);
+			}
-		n = capsule_no ( s, VAR_dgtag ) ;
+			n = capsule_no(s, VAR_dgtag);
-		set_diag_tag ( id, VAR_tag, n ) ;
+			set_diag_tag(id, VAR_tag, n);
-		use = USAGE_DECL ;
+			use = USAGE_DECL;
+			if (def) {
-		if ( def ) use |= USAGE_DEFN ;
+				use |= USAGE_DEFN;
+			}
-	    } else {
+		} else {
-		/* Only declare each tag once */
+			/* Only declare each tag once */
-		if ( def ) {
+			if (def) {
-		    unsigned prev = find_usage ( n, VAR_dgtag ) ;
+				unsigned prev = find_usage(n, VAR_dgtag);
-		    if ( prev & USAGE_DEFN ) {
+				if (prev & USAGE_DEFN) {
-			use = USAGE_NONE ;
+					use = USAGE_NONE;
-		    } else {
+				} else {
-			use = ( USAGE_USE | USAGE_DECL | USAGE_DEFN ) ;
+					use = (USAGE_USE | USAGE_DECL | USAGE_DEFN);
-		    }
+				}
-		}
+			}
-	    }
+		}
-	    *pn = n ;
+		*pn = n;
+		break;
+	}
+	case id_nspace_name_tag: {
+		/* Namespace names */
+		use = USAGE_DEFN;
-	    break ;
+		break;
+	}
-	case id_nspace_name_tag : {
-	    /* Namespace names */
-	    use = USAGE_DEFN ;
-	    break ;
+	}
-    }
-    return ( use ) ;
+	return (use);
+}
 /*
     ENCODE A GLOBAL DIAGNOSTIC IDENTIFIER
     This routine adds the diagnostic information for the global identifier
     id to the diagnostic definition unit.  def is true for a definition.
 */
-void enc_dg_id
+void
-    PROTO_N ( ( id, def ) )
-    PROTO_T ( IDENTIFIER id X int def )
+enc_dg_id(IDENTIFIER id, int def)
+{
-    ulong n ;
+	ulong n;
-    NAMESPACE ns ;
+	NAMESPACE ns;
-    BITSTREAM *bs ;
+	BITSTREAM *bs;
-    IDENTIFIER pid ;
+	IDENTIFIER pid;
-    /* Check the identifier */
+	/* Check the identifier */
-    ulong m = LINK_NONE ;
+	ulong m = LINK_NONE;
-    unsigned use = find_dg_usage ( id, &m, def ) ;
+	unsigned use = find_dg_usage(id, &m, def);
-    if ( use == USAGE_NONE ) return ;
+	if (use == USAGE_NONE) {
+		return;
+	}
-    /* Find the parent namespace */
+	/* Find the parent namespace */
-    ns = DEREF_nspace ( id_parent ( id ) ) ;
+	ns = DEREF_nspace(id_parent(id));
-    while ( !IS_NULL_nspace ( ns ) && IS_nspace_ctype ( ns ) ) {
+	while (!IS_NULL_nspace(ns) && IS_nspace_ctype(ns)) {
-	pid = DEREF_id ( nspace_name ( ns ) ) ;
+		pid = DEREF_id(nspace_name(ns));
-	enc_dg_id ( pid, 1 ) ;
+		enc_dg_id(pid, 1);
-	if ( m != LINK_NONE ) {
+		if (m != LINK_NONE) {
-	    /* Check for inline definitions */
+			/* Check for inline definitions */
-	    unsigned prev = find_usage ( m, VAR_dgtag ) ;
+			unsigned prev = find_usage(m, VAR_dgtag);
-	    if ( prev & USAGE_DEFN ) return ;
+			if (prev & USAGE_DEFN) {
+				return;
+			}
+		}
+		ns = DEREF_nspace(id_parent(pid));
+	}
+	if (IS_NULL_nspace(ns) || !IS_nspace_named_etc(ns)) {
+		/* Ignore local identifiers */
+		return;
+	}
+	pid = DEREF_id(nspace_name(ns));
+	if (IS_NULL_id(pid)) {
+		return;
+	}
+	n = DEREF_ulong(id_no(pid));
+	if (n == LINK_NONE) {
+		/* Allocate namespace list number */
+		enc_dg_id(pid, 1);
+		n = DEREF_ulong(id_no(pid));
+		if (n == LINK_NONE) {
+			return;
+		}
+	}
-	ns = DEREF_nspace ( id_parent ( pid ) ) ;
-    }
-    if ( IS_NULL_nspace ( ns ) || !IS_nspace_named_etc ( ns ) ) {
-	/* Ignore local identifiers */
-	return ;
-    }
-    pid = DEREF_id ( nspace_name ( ns ) ) ;
-    if ( IS_NULL_id ( pid ) ) return ;
-    n = DEREF_ulong ( id_no ( pid ) ) ;
-    if ( n == LINK_NONE ) {
-	/* Allocate namespace list number */
-	enc_dg_id ( pid, 1 ) ;
-	n = DEREF_ulong ( id_no ( pid ) ) ;
-	if ( n == LINK_NONE ) return ;
-    }
-    /* Add the identifier to the namespace */
+	/* Add the identifier to the namespace */
-    bs = start_bitstream ( NIL ( FILE ), diagcomp_unit->link ) ;
+	bs = start_bitstream(NIL(FILE), diagcomp_unit->link);
-    ENC_dg_name_append ( bs ) ;
+	ENC_dg_name_append(bs);
-    n = link_no ( bs, n, VAR_dgtag ) ;
+	n = link_no(bs, n, VAR_dgtag);
-    ENC_make_dg_tag ( bs, n ) ;
+	ENC_make_dg_tag(bs, n);
-    bs = enc_dg_decl ( bs, id, m, use ) ;
+	bs = enc_dg_decl(bs, id, m, use);
-    count_item ( bs ) ;
+	count_item(bs);
-    diagcomp_unit = join_bitstreams ( diagcomp_unit, bs ) ;
+	diagcomp_unit = join_bitstreams(diagcomp_unit, bs);
-    return ;
+	return;
+}
 /*
     DIAGNOSTICS FOR POINTER TO VOID
     This table gives the diagnostic tag numbers used to represent the types
     'cv void *'  for the various cv-qualifiers, cv.
 */
-static ulong diag_ptr_void [4] = {
+static ulong diag_ptr_void[4] = {
-    LINK_NONE, LINK_NONE, LINK_NONE, LINK_NONE
+	LINK_NONE, LINK_NONE, LINK_NONE, LINK_NONE
-} ;
+};
 /*
     ENCODE A BUILT-IN DIAGNOSTIC TYPE
     This routine adds the diagnostics for the definition of the built-in
     type t to the diagnostic  bs.  This includes 'void *' as well as the
     more obvious integer and floating point types.
 */
-ulong enc_dg_basetype
+ulong
-    PROTO_N ( ( t, def ) )
-    PROTO_T ( TYPE t X int def )
+enc_dg_basetype(TYPE t, int def)
 {
-    BITSTREAM *bs = NULL ;
+	BITSTREAM *bs = NULL;
-    CV_SPEC cv = cv_none ;
+	CV_SPEC cv = cv_none;
-    BASE_TYPE bt = btype_none ;
+	BASE_TYPE bt = btype_none;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    string nm = mangle_tname ( "__dg__", t ) ;
+	string nm = mangle_tname("__dg__", t);
-    ulong n = capsule_no ( nm, VAR_dgtag ) ;
+	ulong n = capsule_no(nm, VAR_dgtag);
-    /* Introduce dummy type name */
+	/* Introduce dummy type name */
-    if ( def ) {
+	if (def) {
-	IDENTIFIER gid = DEREF_id ( nspace_name ( global_namespace ) ) ;
+		IDENTIFIER gid = DEREF_id(nspace_name(global_namespace));
-	ulong m = DEREF_ulong ( id_no ( gid ) ) ;
+		ulong m = DEREF_ulong(id_no(gid));
-	record_usage ( n, VAR_dgtag, USAGE_DEFN ) ;
+		record_usage(n, VAR_dgtag, USAGE_DEFN);
-	bs = start_bitstream ( NIL ( FILE ), diagcomp_unit->link ) ;
+		bs = start_bitstream(NIL(FILE), diagcomp_unit->link);
-	ENC_dg_name_append ( bs ) ;
+		ENC_dg_name_append(bs);
-	m = link_no ( bs, m, VAR_dgtag ) ;
+		m = link_no(bs, m, VAR_dgtag);
-	ENC_make_dg_tag ( bs, m ) ;
+		ENC_make_dg_tag(bs, m);
-	ENC_dg_type_name ( bs ) ;
+		ENC_dg_type_name(bs);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	ENC_dg_global_sourcepos ( bs ) ;
+		ENC_dg_global_sourcepos(bs);
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	ENC_dg_tag_type ( bs ) ;
+		ENC_dg_tag_type(bs);
-	m = link_no ( bs, n, VAR_dgtag ) ;
+		m = link_no(bs, n, VAR_dgtag);
-	ENC_make_dg_tag ( bs, m ) ;
+		ENC_make_dg_tag(bs, m);
-    }
+	}
-    /* Encode type definition */
+	/* Encode type definition */
-    switch ( tag ) {
+	switch (tag) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	    COPY_ulong ( itype_diag ( it ), n ) ;
+		COPY_ulong(itype_diag(it), n);
-	    if ( IS_itype_basic ( it ) ) {
+		if (IS_itype_basic(it)) {
-		bt = DEREF_btype ( itype_basic_rep ( it ) ) ;
+			bt = DEREF_btype(itype_basic_rep(it));
-	    }
+		}
-	    if ( def ) {
+		if (def) {
-		if ( bt & ( btype_char | btype_wchar_t ) ) {
+			if (bt & (btype_char | btype_wchar_t)) {
-		    ENC_dg_char_type ( bs ) ;
+				ENC_dg_char_type(bs);
-		} else if ( bt & btype_bool ) {
+			} else if (bt & btype_bool) {
-		    ENC_dg_boolean_type ( bs ) ;
+				ENC_dg_boolean_type(bs);
+			} else {
+				ENC_dg_integer_type(bs);
+			}
+		}
+		break;
+	}
+	case type_floating_tag: {
+		FLOAT_TYPE ft = DEREF_ftype(type_floating_rep(t));
+		COPY_ulong(ftype_diag(ft), n);
+		if (IS_ftype_basic(ft)) {
+			bt = DEREF_btype(ftype_basic_rep(ft));
+		}
+		if (def) {
+			ENC_dg_float_type(bs);
+		}
+		break;
+	}
+	case type_ptr_tag: {
+		TYPE s = DEREF_type(type_ptr_sub(t));
+		cv = DEREF_cv(type_qual(s));
+		cv &= cv_qual;
+		diag_ptr_void[cv] = n;
+		bt = (btype_void | btype_star);
+		if (def) {
+			ENC_dg_address_type(bs);
+		}
+		break;
+	}
+	}
+	if (def) {
+		if (bt == btype_none) {
+			bs = enc_dg_name(bs, NULL_id, NULL_type);
 		} else {
+			int sp = 0;
+			BUFFER *bf = clear_buffer(&mangle_buff, NIL(FILE));
-		    ENC_dg_integer_type ( bs ) ;
+			ENC_dg_external_idname(bs);
+			ENC_make_string(bs);
+			if (cv) {
+				sp = print_cv(cv, bf, sp);
+			}
+			IGNORE print_btype(bt, bf, sp);
+			bs = enc_ustring(bs, bf->start);
+		}
+		switch (tag) {
+		case type_integer_tag: {
+			bs = enc_variety(bs, t);
+			break;
+		}
+		case type_floating_tag: {
+			bs = enc_flvar(bs, t);
+			break;
+		}
+		case type_ptr_tag: {
+			bs = enc_shape(bs, t);
+			break;
+		}
-	    }
-	    break ;
-	}
+		}
-	case type_floating_tag : {
-	    FLOAT_TYPE ft = DEREF_ftype ( type_floating_rep ( t ) ) ;
-	    COPY_ulong ( ftype_diag ( ft ), n ) ;
-	    if ( IS_ftype_basic ( ft ) ) {
-		bt = DEREF_btype ( ftype_basic_rep ( ft ) ) ;
-	    }
-	    if ( def ) ENC_dg_float_type ( bs ) ;
-	    break ;
+		ENC_true(bs);
-	}
-	case type_ptr_tag : {
-	    TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
-	    cv = DEREF_cv ( type_qual ( s ) ) ;
-	    cv &= cv_qual ;
+		ENC_OFFS(bs, 2);
-	    diag_ptr_void [ cv ] = n ;
-	    bt = ( btype_void | btype_star ) ;
-	    if ( def ) ENC_dg_address_type ( bs ) ;
-	    break ;
-	}
-    }
-    if ( def ) {
-	if ( bt == btype_none ) {
-	    bs = enc_dg_name ( bs, NULL_id, NULL_type ) ;
-	} else {
-	    int sp = 0 ;
+		count_item(bs);
-	    BUFFER *bf = clear_buffer ( &mangle_buff, NIL ( FILE ) ) ;
-	    ENC_dg_external_idname ( bs ) ;
-	    ENC_make_string ( bs ) ;
-	    if ( cv ) sp = print_cv ( cv, bf, sp ) ;
+		diagcomp_unit = join_bitstreams(diagcomp_unit, bs);
-	    IGNORE print_btype ( bt, bf, sp ) ;
-	    bs = enc_ustring ( bs, bf->start ) ;
-	}
-	switch ( tag ) {
-	    case type_integer_tag : {
-		bs = enc_variety ( bs, t ) ;
-		break ;
-	    }
-	    case type_floating_tag : {
-		bs = enc_flvar ( bs, t ) ;
-		break ;
-	    }
-	    case type_ptr_tag : {
-		bs = enc_shape ( bs, t ) ;
-		break ;
-	    }
+	}
-	ENC_true ( bs ) ;
-	ENC_OFFS ( bs, 2 ) ;
-	count_item ( bs ) ;
-	diagcomp_unit = join_bitstreams ( diagcomp_unit, bs ) ;
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     ENCODE A DIAGNOSTIC CLASS TAG
     This routine adds the diagnostic tag corresponding to the class ct
     to the bitstream bs.
 */
-static BITSTREAM *enc_dg_ctype
+static BITSTREAM *
-    PROTO_N ( ( bs, ct ) )
-    PROTO_T ( BITSTREAM *bs X CLASS_TYPE ct )
+enc_dg_ctype(BITSTREAM *bs, CLASS_TYPE ct)
 {
-    ulong n ;
+	ulong n;
-    IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
+	IDENTIFIER cid = DEREF_id(ctype_name(ct));
-    cid = DEREF_id ( id_alias ( cid ) ) ;
+	cid = DEREF_id(id_alias(cid));
-    n = DEREF_ulong ( id_no ( cid ) ) ;
+	n = DEREF_ulong(id_no(cid));
-    if ( n == LINK_NONE ) {
+	if (n == LINK_NONE) {
-	enc_dg_id ( cid, 1 ) ;
+		enc_dg_id(cid, 1);
-	n = DEREF_ulong ( id_no ( cid ) ) ;
+		n = DEREF_ulong(id_no(cid));
-    }
+	}
-    n = link_no ( bs, n, VAR_dgtag ) ;
+	n = link_no(bs, n, VAR_dgtag);
-    ENC_make_dg_tag ( bs, n ) ;
+	ENC_make_dg_tag(bs, n);
-    return ( bs ) ;
+	return (bs);
 }
 /*
     ENCODE A DIAGNOSTIC OFFSET TOKEN
     This routine adds the offset off plus the offset token tok to the
     bitstream bs in the form of a token with one expression parameter
     which returns the parameter plus the offset (allowing for virtual
     indirections etc.).
 */
-static BITSTREAM *enc_dg_offset
+static BITSTREAM *
-    PROTO_N ( ( bs, off, tok, spec ) )
-    PROTO_T ( BITSTREAM *bs X OFFSET off X ulong tok X int spec )
+enc_dg_offset(BITSTREAM *bs, OFFSET off, ulong tok, int spec)
-{
-    BITSTREAM *ts, *us ;
-    ulong m = LINK_NONE ;
-    ulong n = capsule_no ( NULL_string, VAR_token ) ;
-    ts = enc_tokdef_start ( n, "EE", &m, 1 ) ;
-    if ( spec == -1 ) {
-	us = ts ;
-    } else {
-	ts = enc_special ( ts, spec ) ;
-	us = start_bitstream ( NIL ( FILE ), ts->link ) ;
-    }
-    if ( tok == LINK_NONE ) {
-	us = enc_add_ptr ( us, NULL_exp, m, off, 1 ) ;
-    } else {
-	ENC_add_to_ptr ( us ) ;
-	us = enc_add_ptr ( us, NULL_exp, m, off, 1 ) ;
-	tok = link_no ( us, tok, VAR_token ) ;
-	ENC_exp_apply_token ( us ) ;
-	ENC_make_tok ( us, tok ) ;
-	ENC_LEN_SMALL ( us, 0 ) ;
-    }
-    if ( spec == -1 ) {
-	ts = us ;
-    } else {
-	ts = enc_bitstream ( ts, us ) ;
-    }
-    enc_tokdef_end ( n, ts ) ;
-    n = link_no ( bs, n, VAR_token ) ;
-    ENC_make_tok ( bs, n ) ;
-    return ( bs ) ;
-}
-/*
-    ENCODE A LIST OF DIAGNOSTIC BASE CLASSES
-    This routine adds the list of diagnostic base classes given by br
-    to the bitstream bs.
-*/
-static BITSTREAM *enc_dg_bases
-    PROTO_N ( ( bs, br ) )
-    PROTO_T ( BITSTREAM *bs X LIST ( GRAPH ) br )
+{
-    ENC_LIST ( bs, LENGTH_list ( br ) ) ;
+	BITSTREAM *ts, *us;
-    while ( !IS_NULL_list ( br ) ) {
+	ulong m = LINK_NONE;
-	GRAPH gs = DEREF_graph ( HEAD_list ( br ) ) ;
+	ulong n = capsule_no(NULL_string, VAR_token);
-	OFFSET off = DEREF_off ( graph_off ( gs ) ) ;
-	CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
-	DECL_SPEC acc = DEREF_dspec ( graph_access ( gs ) ) ;
-	ENC_make_dg_class_base ( bs ) ;
-	bs = enc_dg_ctype ( bs, cs ) ;
+	ts = enc_tokdef_start(n, "EE", &m, 1);
-	ENC_OFF ( bs ) ;
+	if (spec == -1) {
-	if ( is_zero_offset ( off ) ) {
-	    ENC_OFF ( bs ) ;
+		us = ts;
 	} else {
-	    /* Base class offset */
+		ts = enc_special(ts, spec);
+		us = start_bitstream(NIL(FILE), ts->link);
+	}
-	    ENC_ON ( bs ) ;
+	if (tok == LINK_NONE) {
+		us = enc_add_ptr(us, NULL_exp, m, off, 1);
+	} else {
+		ENC_add_to_ptr(us);
-	    bs = enc_dg_offset ( bs, off, LINK_NONE, -1 ) ;
+		us = enc_add_ptr(us, NULL_exp, m, off, 1);
+		tok = link_no(us, tok, VAR_token);
+		ENC_exp_apply_token(us);
+		ENC_make_tok(us, tok);
+		ENC_LEN_SMALL(us, 0);
+	}
+	if (spec == -1) {
+		ts = us;
+	} else {
+		ts = enc_bitstream(ts, us);
+	}
-	bs = enc_dg_access ( bs, acc ) ;
+	enc_tokdef_end(n, ts);
-	bs = enc_dg_virtual ( bs, acc ) ;
+	n = link_no(bs, n, VAR_token);
-	br = TAIL_list ( br ) ;
+	ENC_make_tok(bs, n);
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
-    ENCODE A DIAGNOSTIC CLASS MEMBER
+    ENCODE A LIST OF DIAGNOSTIC BASE CLASSES
-    This routine adds the class member id to the bitstream bs as a
+    This routine adds the list of diagnostic base classes given by br
-    DG_CLASSMEM if ct is not null, or as a DG_FIELD otherwise.  The
-    number of members is recorded in pm.  The routine is also used to
-    handle type members of blocks when blk is true.
+    to the bitstream bs.
 */
-static BITSTREAM *enc_dg_member
+static BITSTREAM *
-    PROTO_N ( ( bs, id, pm, ct, blk ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER id X unsigned *pm X
+enc_dg_bases(BITSTREAM *bs, LIST(GRAPH)br)
-	      CLASS_TYPE ct X int blk )
+{
-    int def = 0 ;
-    unsigned done = 0 ;
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-    if ( IS_id_function_etc ( id ) ) {
+	ENC_LIST(bs, LENGTH_list(br));
-	/* Allow for overloaded functions */
-	IDENTIFIER fid = DEREF_id ( id_function_etc_over ( id ) ) ;
-	if ( !IS_NULL_id ( fid ) ) {
+	while (!IS_NULL_list(br)) {
-	    bs = enc_dg_member ( bs, fid, pm, ct, blk ) ;
-	}
-    }
-    if ( ds & ( dspec_alias | dspec_inherit | dspec_token ) ) {
-	/* Ignore inherited members */
-	return ( bs ) ;
-    }
-    if ( ds & dspec_defn ) def = 1 ;
-    switch ( TAG_id ( id ) ) {
-	case id_member_tag : {
-	    /* Data members */
-	    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+		GRAPH gs = DEREF_graph(HEAD_list(br));
-	    if ( !IS_hashid_anon ( nm ) ) {
+		OFFSET off = DEREF_off(graph_off(gs));
-		TYPE t = DEREF_type ( id_member_type ( id ) ) ;
+		CLASS_TYPE cs = DEREF_ctype(graph_head(gs));
-		OFFSET off = DEREF_off ( id_member_off ( id ) ) ;
+		DECL_SPEC acc = DEREF_dspec(graph_access(gs));
-		ENC_dg_field_classmem ( bs ) ;
+		ENC_make_dg_class_base(bs);
-		bs = enc_dg_name ( bs, id, NULL_type ) ;
-		bs = enc_dg_loc ( bs, id_loc ( id ), id_loc ( id ) ) ;
-		bs = enc_offset ( bs, off ) ;
-		bs = enc_dg_type ( bs, t, 0 ) ;
+		bs = enc_dg_ctype(bs, cs);
-		bs = enc_dg_access ( bs, ds ) ;
-		ENC_OFFS ( bs, 2 ) ;
+		ENC_OFF(bs);
-		done = 1 ;
-	    }
-	    break ;
-	}
-	case id_stat_member_tag : {
-	    /* Static data members */
-	    if ( !IS_NULL_ctype ( ct ) ) {
-		ulong m = LINK_NONE ;
-		unsigned use = find_dg_usage ( id, &m, def ) ;
-		ENC_dg_name_classmem ( bs ) ;
-		bs = enc_dg_decl ( bs, id, m, ( use | USAGE_DECL ) ) ;
-		done = 1 ;
-	    }
-	    break ;
-	}
-	case id_mem_func_tag : {
-	    /* Member functions */
-	    if ( !IS_NULL_ctype ( ct ) && !( ds & dspec_trivial ) ) {
-		ulong m = LINK_NONE ;
-		unsigned use = find_dg_usage ( id, &m, def ) ;
-		ENC_dg_function_classmem ( bs ) ;
-		bs = enc_dg_decl ( bs, id, m, ( use | USAGE_DECL ) ) ;
-		if ( ds & dspec_virtual ) {
+		if (is_zero_offset(off)) {
-		    /* Offset from start of virtual function table */
-		    BITSTREAM *ts ;
-		    VIRTUAL vt = DEREF_virt ( ctype_virt ( ct ) ) ;
-		    ulong n = virtual_no ( id, vt ) ;
-		    ENC_ON ( bs ) ;
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
-		    bs = enc_special ( bs, TOK_vtab_off ) ;
-		    ts = enc_make_snat ( ts, ( int ) n ) ;
-		    bs = enc_bitstream ( bs, ts ) ;
-		} else {
-		    ENC_OFF ( bs ) ;
+			ENC_OFF(bs);
-		}
-		done = 1 ;
-	    }
-	    break ;
-	}
-	case id_stat_mem_func_tag : {
-	    /* Static member functions */
-	    if ( !IS_NULL_ctype ( ct ) ) {
-		ulong m = LINK_NONE ;
-		unsigned use = find_dg_usage ( id, &m, def ) ;
-		ENC_dg_name_classmem ( bs ) ;
-		bs = enc_dg_decl ( bs, id, m, ( use | USAGE_DECL ) ) ;
-		done = 1 ;
-	    }
-	    break ;
-	}
-	case id_class_name_tag :
-	case id_enum_name_tag :
-	case id_class_alias_tag :
-	case id_enum_alias_tag :
-	case id_type_alias_tag : {
-	    /* Nested types */
-	    if ( !IS_NULL_ctype ( ct ) || blk ) {
-		ulong m = LINK_NONE ;
-		unsigned use = find_dg_usage ( id, &m, 1 ) ;
-		if ( blk ) {
-		    use = ( ( use & USAGE_DEFN ) | USAGE_DECL ) ;
-		    ENC_name_decl_dg ( bs ) ;
 		} else {
-		    ENC_dg_name_classmem ( bs ) ;
+			/* Base class offset */
+			ENC_ON(bs);
+			bs = enc_dg_offset(bs, off, LINK_NONE, -1);
+		}
-		bs = enc_dg_decl ( bs, id, m, use ) ;
+		bs = enc_dg_access(bs, acc);
-		done = 1 ;
+		bs = enc_dg_virtual(bs, acc);
-	    }
-	    break ;
+		br = TAIL_list(br);
+	}
+	return (bs);
+}
+/*
+    ENCODE A DIAGNOSTIC CLASS MEMBER
+    This routine adds the class member id to the bitstream bs as a
+    DG_CLASSMEM if ct is not null, or as a DG_FIELD otherwise.  The
+    number of members is recorded in pm.  The routine is also used to
+    handle type members of blocks when blk is true.
+*/
+static BITSTREAM *
+enc_dg_member(BITSTREAM *bs, IDENTIFIER id, unsigned *pm, CLASS_TYPE ct,
+	      int blk)
+{
+	int def = 0;
+	unsigned done = 0;
+	DECL_SPEC ds = DEREF_dspec(id_storage(id));
+	if (IS_id_function_etc(id)) {
+		/* Allow for overloaded functions */
+		IDENTIFIER fid = DEREF_id(id_function_etc_over(id));
+		if (!IS_NULL_id(fid)) {
+			bs = enc_dg_member(bs, fid, pm, ct, blk);
+		}
+	}
+	if (ds & (dspec_alias | dspec_inherit | dspec_token)) {
+		/* Ignore inherited members */
+		return (bs);
+	}
+	if (ds & dspec_defn) {
+		def = 1;
+	}
+	switch (TAG_id(id)) {
+	case id_member_tag: {
+		/* Data members */
+		HASHID nm = DEREF_hashid(id_name(id));
+		if (!IS_hashid_anon(nm)) {
+			TYPE t = DEREF_type(id_member_type(id));
+			OFFSET off = DEREF_off(id_member_off(id));
+			ENC_dg_field_classmem(bs);
+			bs = enc_dg_name(bs, id, NULL_type);
+			bs = enc_dg_loc(bs, id_loc(id), id_loc(id));
+			bs = enc_offset(bs, off);
+			bs = enc_dg_type(bs, t, 0);
+			bs = enc_dg_access(bs, ds);
+			ENC_OFFS(bs, 2);
+			done = 1;
+		}
+		break;
+	}
+	case id_stat_member_tag: {
+		/* Static data members */
+		if (!IS_NULL_ctype(ct)) {
+			ulong m = LINK_NONE;
+			unsigned use = find_dg_usage(id, &m, def);
+			ENC_dg_name_classmem(bs);
+			bs = enc_dg_decl(bs, id, m,(use | USAGE_DECL));
+			done = 1;
+		}
+		break;
+	}
+	case id_mem_func_tag: {
+		/* Member functions */
+		if (!IS_NULL_ctype(ct) && !(ds & dspec_trivial)) {
+			ulong m = LINK_NONE;
+			unsigned use = find_dg_usage(id, &m, def);
+			ENC_dg_function_classmem(bs);
+			bs = enc_dg_decl(bs, id, m,(use | USAGE_DECL));
+			if (ds & dspec_virtual) {
+				/* Offset from start of virtual function table */
+				BITSTREAM *ts;
+				VIRTUAL vt = DEREF_virt(ctype_virt(ct));
+				ulong n = virtual_no(id, vt);
+				ENC_ON(bs);
+				ts = start_bitstream(NIL(FILE), bs->link);
+				bs = enc_special(bs, TOK_vtab_off);
+				ts = enc_make_snat(ts,(int)n);
+				bs = enc_bitstream(bs, ts);
+			} else {
+				ENC_OFF(bs);
+			}
+			done = 1;
+		}
+		break;
+	}
+	case id_stat_mem_func_tag: {
+		/* Static member functions */
+		if (!IS_NULL_ctype(ct)) {
+			ulong m = LINK_NONE;
+			unsigned use = find_dg_usage(id, &m, def);
+			ENC_dg_name_classmem(bs);
+			bs = enc_dg_decl(bs, id, m,(use | USAGE_DECL));
+			done = 1;
+		}
+		break;
+	}
+	case id_class_name_tag:
+	case id_enum_name_tag:
+	case id_class_alias_tag:
+	case id_enum_alias_tag:
+	case id_type_alias_tag: {
+		/* Nested types */
+		if (!IS_NULL_ctype(ct) || blk) {
+			ulong m = LINK_NONE;
+			unsigned use = find_dg_usage(id, &m, 1);
+			if (blk) {
+				use = ((use & USAGE_DEFN) | USAGE_DECL);
+				ENC_name_decl_dg(bs);
+			} else {
+				ENC_dg_name_classmem(bs);
-    }
+			}
+			bs = enc_dg_decl(bs, id, m, use);
+			done = 1;
+		}
+		break;
+	}
+	}
-    *pm += done ;
+	*pm += done;
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LIST OF DIAGNOSTIC MEMBERS
     This routine calls enc_dg_member for all the members of the
     namespace ns.
 */
-static BITSTREAM *enc_dg_namespace
+static BITSTREAM *
-    PROTO_N ( ( bs, ns, pm, ct ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns X unsigned *pm X CLASS_TYPE ct )
+enc_dg_namespace(BITSTREAM *bs, NAMESPACE ns, unsigned *pm, CLASS_TYPE ct)
 {
-    MEMBER mem ;
+	MEMBER mem;
-    int blk = 0 ;
+	int blk = 0;
-    if ( IS_nspace_ctype ( ns ) ) {
+	if (IS_nspace_ctype(ns)) {
-	mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
+		mem = DEREF_member(nspace_ctype_first(ns));
-    } else {
+	} else {
-	mem = DEREF_member ( nspace_last ( ns ) ) ;
+		mem = DEREF_member(nspace_last(ns));
-	blk = 1 ;
+		blk = 1;
-    }
+	}
-    while ( !IS_NULL_member ( mem ) ) {
+	while (!IS_NULL_member(mem)) {
-	/* Class members */
+		/* Class members */
-	IDENTIFIER mid = DEREF_id ( member_id ( mem ) ) ;
+		IDENTIFIER mid = DEREF_id(member_id(mem));
-	IDENTIFIER nid = DEREF_id ( member_alt ( mem ) ) ;
+		IDENTIFIER nid = DEREF_id(member_alt(mem));
-	if ( !IS_NULL_id ( mid ) ) {
+		if (!IS_NULL_id(mid)) {
-	    bs = enc_dg_member ( bs, mid, pm, ct, blk ) ;
+			bs = enc_dg_member(bs, mid, pm, ct, blk);
-	}
+		}
-	if ( !IS_NULL_id ( nid ) && !EQ_id ( nid, mid ) ) {
+		if (!IS_NULL_id(nid) && !EQ_id(nid, mid)) {
-	    bs = enc_dg_member ( bs, nid, pm, ct, blk ) ;
+			bs = enc_dg_member(bs, nid, pm, ct, blk);
+		}
+		mem = DEREF_member(member_next(mem));
+	}
-	mem = DEREF_member ( member_next ( mem ) ) ;
-    }
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE VIRTUAL FUNCTION TABLE INFORMATION
     This routine adds the information for the virtual function table
     and run-time type information associated with the polymorphic class
     t to the bitstream bs in the form of a number of dummy class members.
     Information on these members is returned via vtags.
+}
 #endif
 /*
     ENCODE A DIAGNOSTIC CLASS
     This routine adds the definition of the class type t to the bitstream
     bs.  force is 2 to indicate that a tag name should be output for this
     class.
 */
-static BITSTREAM *enc_dg_class
+static BITSTREAM *
-    PROTO_N ( ( bs, t, force ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int force )
+enc_dg_class(BITSTREAM *bs, TYPE t, int force)
 {
-    BITSTREAM *ts ;
+	BITSTREAM *ts;
-    unsigned m = 0 ;
+	unsigned m = 0;
-    ulong vtags [4] ;
+	ulong vtags[4];
-    CLASS_TYPE cs = NULL_ctype ;
+	CLASS_TYPE cs = NULL_ctype;
-    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));
-    NAMESPACE ns = DEREF_nspace ( ctype_member ( ct ) ) ;
+	NAMESPACE ns = DEREF_nspace(ctype_member(ct));
-    if ( force == 0 ) {
+	if (force == 0) {
-	ENC_dg_unknown_type ( bs ) ;
+		ENC_dg_unknown_type(bs);
-	bs = enc_shape ( bs, t ) ;
+		bs = enc_shape(bs, t);
-	return ( bs ) ;
+		return (bs);
-    }
+	}
-    if ( ( ci & cinfo_complete ) && ( ci & cinfo_defined ) ) {
+	if ((ci & cinfo_complete) && (ci & cinfo_defined)) {
-	/* Complete class */
+		/* Complete class */
-	IGNORE compile_class ( ct ) ;
+		IGNORE compile_class(ct);
-	if ( ci & ( cinfo_static | cinfo_function | cinfo_base ) ) {
+		if (ci & (cinfo_static | cinfo_function | cinfo_base)) {
-	    cs = ct ;
+			cs = ct;
-	} else if ( ( ci & cinfo_trivial ) != cinfo_trivial ) {
+		} else if ((ci & cinfo_trivial)!= cinfo_trivial) {
-	    cs = ct ;
+			cs = ct;
-	} else {
+		} else {
-	    LIST ( IDENTIFIER ) ft ;
+			LIST(IDENTIFIER)ft;
-	    ft = DEREF_list ( ctype_nest ( ct ) ) ;
+			ft = DEREF_list(ctype_nest(ct));
-	    if ( !IS_NULL_list ( ft ) ) cs = ct ;
+			if (!IS_NULL_list(ft)) {
+				cs = ct;
+			}
-	    ft = DEREF_list ( ctype_pals ( ct ) ) ;
+			ft = DEREF_list(ctype_pals(ct));
-	    if ( !IS_NULL_list ( ft ) ) cs = ct ;
+			if (!IS_NULL_list(ft)) {
+				cs = ct;
+			}
-	}
+		}
-    } else {
+	} else {
-	/* Incomplete class */
+		/* Incomplete class */
-	ENC_dg_is_spec_type ( bs ) ;
+		ENC_dg_is_spec_type(bs);
-	t = NULL_type ;
+		t = NULL_type;
-    }
+	}
-    if ( !IS_NULL_ctype ( cs ) ) {
+	if (!IS_NULL_ctype(cs)) {
-	/* Class type */
+		/* Class type */
-	GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
+		GRAPH gr = DEREF_graph(ctype_base(ct));
-	LIST ( GRAPH ) br = DEREF_list ( graph_tails ( gr ) ) ;
+		LIST(GRAPH)br = DEREF_list(graph_tails(gr));
-	ENC_dg_class_type ( bs ) ;
+		ENC_dg_class_type(bs);
-	bs = enc_dg_bases ( bs, br ) ;
+		bs = enc_dg_bases(bs, br);
-    } else {
+	} else {
-	/* Structure type */
+		/* Structure type */
-	ENC_dg_struct_type ( bs ) ;
+		ENC_dg_struct_type(bs);
-    }
+	}
-    vtags [0] = LINK_NONE ;
+	vtags[0] = LINK_NONE;
-    vtags [1] = LINK_NONE ;
+	vtags[1] = LINK_NONE;
-    vtags [2] = LINK_NONE ;
+	vtags[2] = LINK_NONE;
-    vtags [3] = LINK_NONE ;
+	vtags[3] = LINK_NONE;
-    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+	ts = start_bitstream(NIL(FILE), bs->link);
-    ts = enc_dg_namespace ( ts, ns, &m, cs ) ;
+	ts = enc_dg_namespace(ts, ns, &m, cs);
 #if LANGUAGE_CPP
-    if ( !IS_NULL_ctype ( cs ) ) {
+	if (!IS_NULL_ctype(cs)) {
-	if ( ci & cinfo_polymorphic ) {
+		if (ci & cinfo_polymorphic) {
-	    ts = enc_dg_vtable ( ts, t, vtags ) ;
+			ts = enc_dg_vtable(ts, t, vtags);
-	    if ( output_rtti ) m += 2 ;
+			if (output_rtti) {
-	    m += 2 ;
+				m += 2;
+			}
+			m += 2;
-	}
+		}
-    }
+	}
 #endif
-    ENC_LIST ( bs, m ) ;
+	ENC_LIST(bs, m);
-    bs = join_bitstreams ( bs, ts ) ;
+	bs = join_bitstreams(bs, ts);
-    if ( !IS_NULL_ctype ( cs ) ) {
+	if (!IS_NULL_ctype(cs)) {
-	/* Friends */
+		/* Friends */
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-	ENC_LIST_SMALL ( bs, 0 ) ;
+		ENC_LIST_SMALL(bs, 0);
-    }
+	}
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	/* Class shape */
+		/* Class shape */
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	bs = enc_shape ( bs, t ) ;
+		bs = enc_shape(bs, t);
-    } else {
+	} else {
-	ENC_OFF ( bs ) ;
+		ENC_OFF(bs);
-    }
+	}
-    if ( !IS_NULL_ctype ( cs ) ) {
+	if (!IS_NULL_ctype(cs)) {
-	/* Virtual function table information */
+		/* Virtual function table information */
-	if ( vtags [0] == LINK_NONE ) {
+		if (vtags[0] == LINK_NONE) {
-	    ENC_OFFS ( bs, 2 ) ;
+			ENC_OFFS(bs, 2);
+		} else {
+			ENC_ON(bs);
+			vtags[2] = link_no(bs, vtags[2], VAR_dgtag);
+			ENC_make_dg_tag(bs, vtags[2]);
+			ENC_ON(bs);
+			vtags[0] = link_no(bs, vtags[0], VAR_dgtag);
+			ENC_make_dg_tag(bs, vtags[0]);
+		}
+	}
+	if (force == 2) {
+		/* Output tag name */
+		IDENTIFIER cid = DEREF_id(ctype_name(ct));
+		TYPE form = DEREF_type(ctype_form(ct));
+		ENC_ON(bs);
+		bs = enc_dg_name(bs, cid, form);
+		ENC_ON(bs);
+		bs = enc_dg_loc(bs, id_loc(cid), id_loc(cid));
 	} else {
-	    ENC_ON ( bs ) ;
-	    vtags [2] = link_no ( bs, vtags [2], VAR_dgtag ) ;
-	    ENC_make_dg_tag ( bs, vtags [2] ) ;
-	    ENC_ON ( bs ) ;
+		ENC_OFFS(bs, 2);
-	    vtags [0] = link_no ( bs, vtags [0], VAR_dgtag ) ;
-	    ENC_make_dg_tag ( bs, vtags [0] ) ;
+	}
-    }
-    if ( force == 2 ) {
+	if (IS_NULL_ctype(cs)) {
-	/* Output tag name */
-	IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
-	TYPE form = DEREF_type ( ctype_form ( ct ) ) ;
-	ENC_ON ( bs ) ;
-	bs = enc_dg_name ( bs, cid, form ) ;
-	ENC_ON ( bs ) ;
+		ENC_OFF(bs);
-	bs = enc_dg_loc ( bs, id_loc ( cid ), id_loc ( cid ) ) ;
-    } else {
-	ENC_OFFS ( bs, 2 ) ;
-    }
+	}
-    if ( IS_NULL_ctype ( cs ) ) ENC_OFF ( bs ) ;
-    bs = enc_bool ( bs, ( ( ci & cinfo_union ) ? 1 : 0 ) ) ;
+	bs = enc_bool(bs,((ci & cinfo_union)? 1 : 0));
-    if ( !IS_NULL_ctype ( cs ) ) {
+	if (!IS_NULL_ctype(cs)) {
-	/* Run-time type information */
+		/* Run-time type information */
-	if ( vtags [1] == LINK_NONE ) {
+		if (vtags[1] == LINK_NONE) {
-	    ENC_OFFS ( bs, 2 ) ;
+			ENC_OFFS(bs, 2);
-	} else {
+		} else {
-	    ENC_ON ( bs ) ;
+			ENC_ON(bs);
-	    vtags [3] = link_no ( bs, vtags [3], VAR_dgtag ) ;
+			vtags[3] = link_no(bs, vtags[3], VAR_dgtag);
-	    ENC_make_dg_tag ( bs, vtags [3] ) ;
+			ENC_make_dg_tag(bs, vtags[3]);
-	    ENC_ON ( bs ) ;
+			ENC_ON(bs);
-	    vtags [1] = link_no ( bs, vtags [1], VAR_dgtag ) ;
+			vtags[1] = link_no(bs, vtags[1], VAR_dgtag);
-	    ENC_make_dg_tag ( bs, vtags [1] ) ;
+			ENC_make_dg_tag(bs, vtags[1]);
+		}
+	}
+	bs = enc_bool(bs, LANGUAGE_CPP);
+	if (!IS_NULL_ctype(cs)) {
+		ENC_OFF(bs);
+	}
-    }
-    bs = enc_bool ( bs, LANGUAGE_CPP ) ;
-    if ( !IS_NULL_ctype ( cs ) ) ENC_OFF ( bs ) ;
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC ENUMERATION TYPE
     This routine adds the definition of the enumeration type t to the
     bitstream bs.  force is 2 to indicate that a tag name should be
     output for this enumeration type.
 */
-static BITSTREAM *enc_dg_etype
+static BITSTREAM *
-    PROTO_N ( ( bs, t, force ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int force )
+enc_dg_etype(BITSTREAM *bs, TYPE t, int force)
+{
-    ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+	ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
-    LIST ( IDENTIFIER ) p = DEREF_list ( etype_values ( et ) ) ;
+	LIST(IDENTIFIER)p = DEREF_list(etype_values(et));
-    CLASS_INFO ei = DEREF_cinfo ( etype_info ( et ) ) ;
+	CLASS_INFO ei = DEREF_cinfo(etype_info(et));
-    if ( !( ei & cinfo_complete ) || force == 0 ) {
+	if (!(ei & cinfo_complete) || force == 0) {
-	t = DEREF_type ( etype_rep ( et ) ) ;
+		t = DEREF_type(etype_rep(et));
-	bs = enc_dg_type ( bs, t, 0 ) ;
+		bs = enc_dg_type(bs, t, 0);
-	return ( bs ) ;
+		return (bs);
-    }
+	}
-    ENC_dg_enum_type ( bs ) ;
+	ENC_dg_enum_type(bs);
-    ENC_LIST ( bs, LENGTH_list ( p ) ) ;
+	ENC_LIST(bs, LENGTH_list(p));
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(p));
-	EXP e = DEREF_exp ( id_enumerator_value ( pid ) ) ;
+		EXP e = DEREF_exp(id_enumerator_value(pid));
-	ENC_make_dg_enum ( bs ) ;
+		ENC_make_dg_enum(bs);
-	bs = enc_exp ( bs, e ) ;
+		bs = enc_exp(bs, e);
-	bs = enc_dg_name ( bs, pid, NULL_type ) ;
+		bs = enc_dg_name(bs, pid, NULL_type);
-	bs = enc_dg_loc ( bs, id_loc ( pid ), id_loc ( pid ) ) ;
+		bs = enc_dg_loc(bs, id_loc(pid), id_loc(pid));
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    if ( force == 2 ) {
+	if (force == 2) {
-	/* Output tag name */
+		/* Output tag name */
-	IDENTIFIER eid = DEREF_id ( etype_name ( et ) ) ;
+		IDENTIFIER eid = DEREF_id(etype_name(et));
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	bs = enc_dg_name ( bs, eid, NULL_type ) ;
+		bs = enc_dg_name(bs, eid, NULL_type);
-	ENC_ON ( bs ) ;
+		ENC_ON(bs);
-	bs = enc_dg_loc ( bs, id_loc ( eid ), id_loc ( eid ) ) ;
+		bs = enc_dg_loc(bs, id_loc(eid), id_loc(eid));
-    } else {
+	} else {
-	ENC_OFFS ( bs, 2 ) ;
+		ENC_OFFS(bs, 2);
-    }
+	}
-    bs = enc_shape ( bs, t ) ;
+	bs = enc_shape(bs, t);
-    bs = enc_bool ( bs, LANGUAGE_CPP ) ;
+	bs = enc_bool(bs, LANGUAGE_CPP);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC TYPE
     This routine adds the diagnostic information for the type t to the
     bitstream bs.
 */
-BITSTREAM *enc_dg_type
+BITSTREAM *
-    PROTO_N ( ( bs, t, force ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t X int force )
+enc_dg_type(BITSTREAM *bs, TYPE t, int force)
 {
-    ulong n ;
+	ulong n;
-    CV_SPEC cv ;
+	CV_SPEC cv;
-    if ( IS_NULL_type ( t ) ) {
+	if (IS_NULL_type(t)) {
-	ENC_dg_void_type ( bs ) ;
+		ENC_dg_void_type(bs);
-	return ( bs ) ;
+		return (bs);
-    }
+	}
-    cv = DEREF_cv ( type_qual ( t ) ) ;
+	cv = DEREF_cv(type_qual(t));
-    if ( cv & cv_const ) {
+	if (cv & cv_const) {
-	/* Allow for const qualifier */
+		/* Allow for const qualifier */
-	ENC_dg_qualified_type ( bs ) ;
+		ENC_dg_qualified_type(bs);
-	ENC_dg_const_qualifier ( bs ) ;
+		ENC_dg_const_qualifier(bs);
-    }
+	}
-    if ( cv & cv_volatile ) {
+	if (cv & cv_volatile) {
-	/* Allow for volatile qualifier */
+		/* Allow for volatile qualifier */
-	ENC_dg_qualified_type ( bs ) ;
+		ENC_dg_qualified_type(bs);
-	ENC_dg_volatile_qualifier ( bs ) ;
+		ENC_dg_volatile_qualifier(bs);
-    }
+	}
-    /* Check type name */
+	/* Check type name */
-    if ( !force ) {
+	if (!force) {
-	IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
+		IDENTIFIER tid = DEREF_id(type_name(t));
-	if ( !IS_NULL_id ( tid ) ) {
+		if (!IS_NULL_id(tid)) {
-	    tid = DEREF_id ( id_alias ( tid ) ) ;
+			tid = DEREF_id(id_alias(tid));
-	    n = DEREF_ulong ( id_no ( tid ) ) ;
+			n = DEREF_ulong(id_no(tid));
-	    if ( n == LINK_NONE ) {
+			if (n == LINK_NONE) {
-		enc_dg_id ( tid, 1 ) ;
+				enc_dg_id(tid, 1);
-		n = DEREF_ulong ( id_no ( tid ) ) ;
+				n = DEREF_ulong(id_no(tid));
-		if ( n == LINK_NONE ) goto type_label ;
+				if (n == LINK_NONE) {
+					goto type_label;
-	    }
+				}
+			}
-	    ENC_dg_named_type ( bs ) ;
+			ENC_dg_named_type(bs);
-	    n = link_no ( bs, n, VAR_dgtag ) ;
+			n = link_no(bs, n, VAR_dgtag);
-	    ENC_make_dg_tag ( bs, n ) ;
+			ENC_make_dg_tag(bs, n);
-	    return ( bs ) ;
+			return (bs);
+		}
+	}
-    }
+		    }
+		    case type_array_tag: {
+			    /* Array types */
+			    TYPE s = DEREF_type(type_array_sub(t));
+			    NAT m = DEREF_nat(type_array_size(t));
+			    ENC_dg_array_type(bs);
+			    bs = enc_dg_type(bs, s, 0);
+			    bs = enc_shape_offset(bs, s);
+			    ENC_OFF(bs);
+			    ENC_LIST_SMALL(bs, 1);
+			    if (IS_NULL_nat(m)) {
+				    ENC_dg_unspecified_dim(bs);
+			    } else {
+				    TYPE i = type_sint;
+				    unsigned long v = get_nat_value(m);
+				    ENC_dg_bounds_dim(bs);
+				    ENC_dg_static_bound(bs);
+				    bs = enc_make_int(bs, i, 0);
+				    ENC_dg_static_bound(bs);
+				    if (v < SMALL_ARRAY_BOUND) {
+					    /* Small value */
+					    if (v) {
+						    v--;
+					    }
+					    bs = enc_make_int(bs, i, (int)v);
+				    } else {
+					    ENC_minus(bs);
+					    bs = enc_error_treatment(bs, i);
+					    ENC_make_int(bs);
+					    bs = enc_variety(bs, i);
+					    bs = enc_snat(bs, m, 0, 1);
+					    bs = enc_make_int(bs, i, 1);
+				    }
-		    bs = enc_dg_type ( bs, i, 0 ) ;
+				    bs = enc_dg_type(bs, i, 0);
-		}
+			    }
-		break ;
+			    break;
-	    }
+		    }
-	    case type_bitfield_tag : {
+		    case type_bitfield_tag: {
-		/* Bitfield types */
+			    /* Bitfield types */
-		INT_TYPE bf = DEREF_itype ( type_bitfield_defn ( t ) ) ;
+			    INT_TYPE bf = DEREF_itype(type_bitfield_defn(t));
-		TYPE s = DEREF_type ( itype_bitfield_sub ( bf ) ) ;
+			    TYPE s = DEREF_type(itype_bitfield_sub(bf));
-		ENC_dg_bitfield_type ( bs ) ;
+			    ENC_dg_bitfield_type(bs);
-		bs = enc_dg_type ( bs, s, 0 ) ;
+			    bs = enc_dg_type(bs, s, 0);
-		bs = enc_bfvar ( bs, t ) ;
+			    bs = enc_bfvar(bs, t);
-		bs = enc_shape ( bs, s ) ;
+			    bs = enc_shape(bs, s);
-		break ;
+			    break;
-	    }
+		    }
-	    case type_compound_tag : {
+		    case type_compound_tag: {
-		/* Class types */
+			    /* Class types */
-		bs = enc_dg_class ( bs, t, force ) ;
+			    bs = enc_dg_class(bs, t, force);
-		break ;
+			    break;
-	    }
+		    }
-	    case type_enumerate_tag : {
+		    case type_enumerate_tag: {
-		/* Enumeration types */
+			    /* Enumeration types */
-		bs = enc_dg_etype ( bs, t, force ) ;
+			    bs = enc_dg_etype(bs, t, force);
-		break ;
+			    break;
-	    }
+		    }
-	    default : {
+		    default: {
-		/* Other types */
+			    /* Other types */
-		ENC_dg_unknown_type ( bs ) ;
+			    ENC_dg_unknown_type(bs);
-		bs = enc_shape ( bs, t ) ;
+			    bs = enc_shape(bs, t);
-		break ;
+			    break;
-	    }
+		    }
-	}
+		    }
-    }
+	    }
-    return ( bs ) ;
+	    return (bs);
 }
 /*
     ENCODE A LOCAL DIAGNOSTIC IDENTIFIER
     This routine adds the diagnostic information for the local identifier
     id to the bitstream bs.  ts gives the encoding of the scope of id.
 */
-BITSTREAM *enc_dg_local
+BITSTREAM *
-    PROTO_N ( ( bs, id, ts ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER id X BITSTREAM *ts )
+enc_dg_local(BITSTREAM *bs, IDENTIFIER id, BITSTREAM *ts)
+{
-    bs = enc_diag_start ( bs ) ;
+	bs = enc_diag_start(bs);
-    ENC_name_decl_dg ( ts ) ;
+	ENC_name_decl_dg(ts);
-    ts = enc_dg_decl ( ts, id, LINK_NONE, USAGE_DEFN ) ;
+	ts = enc_dg_decl(ts, id, LINK_NONE, USAGE_DEFN);
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A LIST OF DIAGNOSTIC PARAMETERS
     This routine adds the diagnostic information for the list of function
     parameters p to the bitstream bs.  ts and e give the function body.
 */
-BITSTREAM *enc_dg_params
+BITSTREAM *
-    PROTO_N ( ( bs, p, ts, e ) )
-    PROTO_T ( BITSTREAM *bs X LIST ( IDENTIFIER ) p X BITSTREAM *ts X EXP e )
+enc_dg_params(BITSTREAM *bs, LIST(IDENTIFIER)p, BITSTREAM *ts, EXP e)
+{
-    bs = enc_diag_start ( bs ) ;
+	bs = enc_diag_start(bs);
-    ENC_list_dg ( ts ) ;
+	ENC_list_dg(ts);
-    ENC_LIST_SMALL ( ts, 2 ) ;
+	ENC_LIST_SMALL(ts, 2);
-    ENC_params_dg ( ts ) ;
+	ENC_params_dg(ts);
-    ENC_LIST ( ts, LENGTH_list ( p ) ) ;
+	ENC_LIST(ts, LENGTH_list(p));
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(p));
-	ts = enc_dg_decl ( ts, pid, LINK_NONE, USAGE_DEFN ) ;
+		ts = enc_dg_decl(ts, pid, LINK_NONE, USAGE_DEFN);
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    ENC_OFF ( ts ) ;
+	ENC_OFF(ts);
-    ts = enc_dg_stmt ( ts, e, 1 ) ;
+	ts = enc_dg_stmt(ts, e, 1);
-    bs = enc_bitstream ( bs, ts ) ;
+	bs = enc_bitstream(bs, ts);
-    return ( bs ) ;
+	return (bs);
+}
 /*
     ENCODE A DIAGNOSTIC STATEMENT
     This routine adds the diagnostic information associated with the
     statement e to the bitstream bs.
 */
-BITSTREAM *enc_dg_stmt
+BITSTREAM *
-    PROTO_N ( ( bs, e, stmt ) )
-    PROTO_T ( BITSTREAM *bs X EXP e X int stmt )
+enc_dg_stmt(BITSTREAM *bs, EXP e, int stmt)
+{
-    PTR ( LOCATION ) loc = crt_enc_loc ;
+	PTR(LOCATION)loc = crt_enc_loc;
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	switch ( TAG_exp ( e ) ) {
+		switch (TAG_exp(e)) {
-	    case exp_sequence_tag : {
+		case exp_sequence_tag: {
-		/* Lexical block */
+			/* Lexical block */
-		int blk = DEREF_int ( exp_sequence_block ( e ) ) ;
+			int blk = DEREF_int(exp_sequence_block(e));
-		NAMESPACE ns = DEREF_nspace ( exp_sequence_decl ( e ) ) ;
+			NAMESPACE ns = DEREF_nspace(exp_sequence_decl(e));
-		if ( blk ) {
+			if (blk) {
-		    BITSTREAM *ts ;
+				BITSTREAM *ts;
-		    unsigned m = 0 ;
+				unsigned m = 0;
-		    PTR ( LOCATION ) start_loc = block_loc ( e, 0 ) ;
+				PTR(LOCATION)start_loc = block_loc(e, 0);
-		    ts = start_bitstream ( NIL ( FILE ), bs->link ) ;
+				ts = start_bitstream(NIL(FILE), bs->link);
-		    ts = enc_dg_namespace ( ts, ns, &m, NULL_ctype ) ;
+				ts = enc_dg_namespace(ts, ns, &m, NULL_ctype);
-		    if ( blk > 1 ) m++ ;
+				if (blk > 1) {
+					m++;
+				}
-		    if ( m != 1 ) {
+				if (m != 1) {
-			ENC_list_dg ( bs ) ;
+					ENC_list_dg(bs);
-			ENC_LIST ( bs, m ) ;
+					ENC_LIST(bs, m);
-		    }
+				}
-		    if ( blk > 1 ) {
+				if (blk > 1) {
-			ENC_lexical_block_dg ( bs ) ;
+					ENC_lexical_block_dg(bs);
-			ENC_OFF ( bs ) ;
+					ENC_OFF(bs);
-			bs = enc_dg_loc ( bs, start_loc, loc ) ;
+					bs = enc_dg_loc(bs, start_loc, loc);
-		    }
+				}
-		    bs = join_bitstreams ( bs, ts ) ;
+				bs = join_bitstreams(bs, ts);
-		    return ( bs ) ;
+				return (bs);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case exp_solve_stmt_tag : {
+		case exp_solve_stmt_tag: {
-		EXP a = DEREF_exp ( exp_solve_stmt_body ( e ) ) ;
+			EXP a = DEREF_exp(exp_solve_stmt_body(e));
-		bs = enc_dg_stmt ( bs, a, stmt ) ;
+			bs = enc_dg_stmt(bs, a, stmt);
-		return ( bs ) ;
+			return (bs);
-	    }
+		}
-	    case exp_decl_stmt_tag : {
+		case exp_decl_stmt_tag: {
-		IDENTIFIER id = DEREF_id ( exp_decl_stmt_id ( e ) ) ;
+			IDENTIFIER id = DEREF_id(exp_decl_stmt_id(e));
-		loc = id_loc ( id ) ;
+			loc = id_loc(id);
-		break ;
+			break;
-	    }
+		}
-	    case exp_label_stmt_tag : {
+		case exp_label_stmt_tag: {
-		IDENTIFIER id = DEREF_id ( exp_label_stmt_label ( e ) ) ;
+			IDENTIFIER id = DEREF_id(exp_label_stmt_label(e));
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-		loc = id_loc ( id ) ;
+			loc = id_loc(id);
-		if ( !IS_hashid_anon ( nm ) ) {
+			if (!IS_hashid_anon(nm)) {
-		    /* Named label */
+				/* Named label */
-		    ENC_label_dg ( bs ) ;
+				ENC_label_dg(bs);
-		    bs = enc_dg_name ( bs, id, NULL_type ) ;
+				bs = enc_dg_name(bs, id, NULL_type);
-		    bs = enc_dg_loc ( bs, loc, loc ) ;
+				bs = enc_dg_loc(bs, loc, loc);
-		    return ( bs ) ;
+				return (bs);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
 #if LANGUAGE_CPP
-	    case exp_try_block_tag : {
+		case exp_try_block_tag: {
-		/* Try block */
+			/* Try block */
-		EXP a ;
+			EXP a;
-		unsigned np ;
+			unsigned np;
-		LIST ( EXP ) p ;
+			LIST(EXP)p;
-		a = DEREF_exp ( exp_try_block_ellipsis ( e ) ) ;
+			a = DEREF_exp(exp_try_block_ellipsis(e));
-		p = DEREF_list ( exp_try_block_handlers ( e ) ) ;
+			p = DEREF_list(exp_try_block_handlers(e));
-		np = LENGTH_list ( p ) ;
+			np = LENGTH_list(p);
-		if ( IS_exp_handler ( a ) ) np++ ;
+			if (IS_exp_handler(a)) {
+				np++;
+			}
-		ENC_list_dg ( bs ) ;
+			ENC_list_dg(bs);
-		ENC_LIST_SMALL ( bs, 2 ) ;
+			ENC_LIST_SMALL(bs, 2);
-		ENC_exception_scope_dg ( bs ) ;
+			ENC_exception_scope_dg(bs);
-		ENC_LIST ( bs, np ) ;
+			ENC_LIST(bs, np);
-		while ( !IS_NULL_list ( p ) ) {
+			while (!IS_NULL_list(p)) {
-		    EXP b = DEREF_exp ( HEAD_list ( p ) ) ;
+				EXP b = DEREF_exp(HEAD_list(p));
-		    ulong m = capsule_no ( NULL_string, VAR_dgtag ) ;
+				ulong m = capsule_no(NULL_string, VAR_dgtag);
-		    COPY_ulong ( exp_handler_diag ( b ), m ) ;
+				COPY_ulong(exp_handler_diag(b), m);
-		    m = link_no ( bs, m, VAR_dgtag ) ;
+				m = link_no(bs, m, VAR_dgtag);
-		    ENC_make_dg_tag ( bs, m ) ;
+				ENC_make_dg_tag(bs, m);
-		    p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
+			}
+			if (IS_exp_handler(a)) {
+				ulong m = capsule_no(NULL_string, VAR_dgtag);
+				COPY_ulong(exp_handler_diag(a), m);
+				m = link_no(bs, m, VAR_dgtag);
+				ENC_make_dg_tag(bs, m);
+			}
+			e = DEREF_exp(exp_try_block_body(e));
+			bs = enc_dg_stmt(bs, e, stmt);
+			return (bs);
+		}
+		case exp_handler_tag: {
+			/* Exception handler */
+			ulong m = DEREF_ulong(exp_handler_diag(e));
+			IDENTIFIER id = DEREF_id(exp_handler_except(e));
+			record_usage(m, VAR_dgtag, USAGE_DEFN);
+			ENC_list_dg(bs);
+			ENC_LIST_SMALL(bs, 2);
+			ENC_make_tag_dg(bs);
+			m = link_no(bs, m, VAR_dgtag);
+			ENC_make_dg_tag(bs, m);
+			ENC_exception_handler_dg(bs);
+			if (!IS_NULL_id(id)) {
+				ENC_ON(bs);
+				bs = enc_dg_decl(bs, id, LINK_NONE, USAGE_DEFN);
+			} else {
+				ENC_OFF(bs);
+			}
+			e = DEREF_exp(exp_handler_body(e));
+			bs = enc_dg_stmt(bs, e, stmt);
+			return (bs);
+		}
-		if ( IS_exp_handler ( a ) ) {
-		    ulong m = capsule_no ( NULL_string, VAR_dgtag ) ;
-		    COPY_ulong ( exp_handler_diag ( a ), m ) ;
-		    m = link_no ( bs, m, VAR_dgtag ) ;
-		    ENC_make_dg_tag ( bs, m ) ;
-		}
-		e = DEREF_exp ( exp_try_block_body ( e ) ) ;
-		bs = enc_dg_stmt ( bs, e, stmt ) ;
-		return ( bs ) ;
-	    }
+#endif
-	    case exp_handler_tag : {
-		/* Exception handler */
-		ulong m = DEREF_ulong ( exp_handler_diag ( e ) ) ;
-		IDENTIFIER id = DEREF_id ( exp_handler_except ( e ) ) ;
-		record_usage ( m, VAR_dgtag, USAGE_DEFN ) ;
-		ENC_list_dg ( bs ) ;
-		ENC_LIST_SMALL ( bs, 2 ) ;
-		ENC_make_tag_dg ( bs ) ;
-		m = link_no ( bs, m, VAR_dgtag ) ;
-		ENC_make_dg_tag ( bs, m ) ;
-		ENC_exception_handler_dg ( bs ) ;
-		if ( !IS_NULL_id ( id ) ) {
-		    ENC_ON ( bs ) ;
-		    bs = enc_dg_decl ( bs, id, LINK_NONE, USAGE_DEFN ) ;
-		} else {
-		    ENC_OFF ( bs ) ;
+		}
-		e = DEREF_exp ( exp_handler_body ( e ) ) ;
-		bs = enc_dg_stmt ( bs, e, stmt ) ;
-		return ( bs ) ;
-	    }
-#endif
+	}
-    }
-    if ( stmt == 2 ) {
+	if (stmt == 2) {
-	/* Used to mark conditionals */
+		/* Used to mark conditionals */
-	ENC_list_dg ( bs ) ;
+		ENC_list_dg(bs);
-	ENC_LIST_SMALL ( bs, 2 ) ;
+		ENC_LIST_SMALL(bs, 2);
-	ENC_branch_dg ( bs ) ;
+		ENC_branch_dg(bs);
-	bs = enc_dg_loc ( bs, loc, loc ) ;
+		bs = enc_dg_loc(bs, loc, loc);
-    }
+	}
-    ENC_singlestep_dg ( bs ) ;
+	ENC_singlestep_dg(bs);
-    bs = enc_dg_loc ( bs, loc, loc ) ;
+	bs = enc_dg_loc(bs, loc, loc);
-    return ( bs ) ;
+	return (bs);
+}
 #endif /* TDF_OUTPUT && TDF_NEW_DIAG */

Subversion Repositories tendra.SVN

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