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

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "symbols.h"
 #include "syntax.h"
 #include "token.h"
 #include "ustring.h"
 #include "xalloc.h"
 /*
     FORWARD DECLARATIONS
     The following forward declarations are required in the spec input
     routines.
 */
-static EXP load_exp PROTO_S ( ( BITSTREAM *, TYPE ) ) ;
+static EXP load_exp(BITSTREAM *, TYPE);
-static TYPE load_type PROTO_S ( ( BITSTREAM *, IDENTIFIER ) ) ;
+static TYPE load_type(BITSTREAM *, IDENTIFIER);
-static TYPE load_ctype PROTO_S ( ( BITSTREAM *, IDENTIFIER, CLASS_TYPE * ) ) ;
+static TYPE load_ctype(BITSTREAM *, IDENTIFIER, CLASS_TYPE *);
-static IDENTIFIER load_id PROTO_S ( ( BITSTREAM *, NAMESPACE ) ) ;
+static IDENTIFIER load_id(BITSTREAM *, NAMESPACE);
-static LIST ( TYPE ) load_type_list PROTO_S ( ( BITSTREAM * ) ) ;
+static LIST(TYPE)load_type_list(BITSTREAM *);
-static TOKEN load_tok PROTO_S ( ( BITSTREAM *, int ) ) ;
+static TOKEN load_tok(BITSTREAM *, int);
-static void load_nspace PROTO_S ( ( BITSTREAM *, NAMESPACE, int ) ) ;
+static void load_nspace(BITSTREAM *, NAMESPACE, int);
 /*
     SPEC INPUT ERROR FLAG
     This flag is set to true to indicate a spec input error.
 */
-static int spec_error = 0 ;
+static int spec_error = 0;
 /*
     SPEC ERROR ROUTINE
     This routine is called when a spec input error occurs.  code gives
     the reason for the error.
 */
-static void spec_fail
+static void
-    PROTO_N ( ( code ) )
-    PROTO_T ( int code )
+spec_fail(int code)
 {
+	if (!spec_error) {
-    if ( !spec_error ) spec_error = code ;
+		spec_error = code;
+	}
-    return ;
+	return;
 }
 /*
     SPEC ERROR CODES
     The spec error codes are given by the corresponding source line.
     This macro gives a convenient shorthand for calling spec_fail.
 */
 #ifdef __LINE__
-#define SPEC_ERROR()		spec_fail ( __LINE__ )
+#define SPEC_ERROR()		spec_fail(__LINE__)
 #else
-#define SPEC_ERROR()		spec_fail ( 100 )
+#define SPEC_ERROR()		spec_fail(100)
 #endif
 /*
     SIMPLE READING ROUTINES
     These macros give the simple reading routines for the enumeration
     types etc.  Note that DE_BITS_2 is used for types which occupy more
     than 16 bits.
 */
-#define load_btype( A )		( BASE_TYPE ) DE_BITS_2 ( ( A ), BITS_btype )
+#define load_btype(A)		(BASE_TYPE)DE_BITS_2((A), BITS_btype)
-#define load_cinfo( A )		( CLASS_INFO ) DE_BITS_2 ( ( A ), BITS_cinfo )
+#define load_cinfo(A)		(CLASS_INFO)DE_BITS_2((A), BITS_cinfo)
-#define load_cusage( A )	( CLASS_USAGE ) DE_BITS ( ( A ), BITS_cusage )
+#define load_cusage(A)	(CLASS_USAGE)DE_BITS((A), BITS_cusage)
-#define load_cv( A )		( CV_SPEC ) DE_BITS ( ( A ), BITS_cv_qual )
+#define load_cv(A)		(CV_SPEC)DE_BITS((A), BITS_cv_qual)
-#define load_dspec( A )		( DECL_SPEC ) DE_BITS_2 ( ( A ), BITS_dspec )
+#define load_dspec(A)		(DECL_SPEC)DE_BITS_2((A), BITS_dspec)
-#define load_mqual( A )		( CV_SPEC ) DE_BITS ( ( A ), BITS_cv )
+#define load_mqual(A)		(CV_SPEC)DE_BITS((A), BITS_cv)
-#define load_qual( A )		( QUALIFIER ) DE_BITS ( ( A ), BITS_qual )
+#define load_qual(A)		(QUALIFIER)DE_BITS((A), BITS_qual)
 /*
     READ A LEXICAL TOKEN NUMBER
     This routine reads a lexical token number from the bitstream bs.
 */
-static int load_lex
+static int
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_lex(BITSTREAM *bs)
+{
-    int t = ( int ) DE_BITS ( bs, BITS_lex ) ;
+	int t = (int)DE_BITS(bs, BITS_lex);
-    if ( t > LAST_TOKEN ) {
+	if (t > LAST_TOKEN) {
-	t = lex_unknown ;
+		t = lex_unknown;
-	SPEC_ERROR () ;
+		SPEC_ERROR();
-    }
+	}
-    return ( t ) ;
+	return (t);
+}
 /*
     READ A LIST OF PREPROCESSING TOKENS
     This routine reads a list of preprocessing tokens from the
     bitstream bs.
 */
-static PPTOKEN *load_pptoks
+static PPTOKEN *
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_pptoks(BITSTREAM *bs)
+{
-    /* NOT YET IMPLEMENTED */
+	/* NOT YET IMPLEMENTED */
-    UNUSED ( bs ) ;
+	UNUSED(bs);
-    return ( NULL ) ;
+	return (NULL);
+}
 /*
     READ A LOCATION
     This routine reads the current location from the bitstream bs.
 */
-static void load_loc
+static void
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_loc(BITSTREAM *bs)
+{
-    if ( DE_BOOL ( bs ) ) {
+	if (DE_BOOL(bs)) {
-	/* Line number has changed */
+		/* Line number has changed */
-	crt_loc.line = DE_INT ( bs ) ;
+		crt_loc.line = DE_INT(bs);
-	crt_loc.column = 0 ;
+		crt_loc.column = 0;
-	if ( DE_BOOL ( bs ) ) {
+		if (DE_BOOL(bs)) {
-	    /* File position has changed */
+			/* File position has changed */
-	    string file ;
+			string file;
-	    string input ;
+			string input;
-	    ulong date, date2 ;
+			ulong date, date2;
-	    STAT_TYPE *fs = NULL ;
+			STAT_TYPE *fs = NULL;
-	    PTR ( POSITION ) posn ;
+			PTR(POSITION)posn;
-	    PTR ( LOCATION ) from = NULL_ptr ( LOCATION ) ;
+			PTR(LOCATION)from = NULL_ptr(LOCATION);
-	    unsigned long off = DE_INT ( bs ) ;
+			unsigned long off = DE_INT(bs);
-	    if ( DE_BOOL ( bs ) ) {
+			if (DE_BOOL(bs)) {
-		STAT_TYPE fstr ;
+				STAT_TYPE fstr;
-		BUFFER *bf = clear_buffer ( &token_buff, NIL ( FILE ) ) ;
+				BUFFER *bf = clear_buffer(&token_buff,
+							  NIL(FILE));
-		de_tdfstring ( bs, bf ) ;
+				de_tdfstring(bs, bf);
-		file = xustrcpy ( bf->start ) ;
+				file = xustrcpy(bf->start);
-		if ( DE_BOOL ( bs ) ) {
+				if (DE_BOOL(bs)) {
-		    bf = clear_buffer ( &token_buff, NIL ( FILE ) ) ;
+					bf = clear_buffer(&token_buff,
+							  NIL(FILE));
-		    de_tdfstring ( bs, bf ) ;
+					de_tdfstring(bs, bf);
-		    input = xustrcpy ( bf->start ) ;
+					input = xustrcpy(bf->start);
-		} else {
+				} else {
-		    input = file ;
+					input = file;
-		}
+				}
-		date = DE_INT ( bs ) ;
+				date = DE_INT(bs);
-		fs = stat_func ( strlit ( input ), &fstr ) ;
+				fs = stat_func(strlit(input), &fstr);
-		date2 = stat_date ( fs ) ;
+				date2 = stat_date(fs);
-	    } else {
+			} else {
-		posn = crt_loc.posn ;
+				posn = crt_loc.posn;
-		file = DEREF_string ( posn_file ( posn ) ) ;
+				file = DEREF_string(posn_file(posn));
-		input = DEREF_string ( posn_input ( posn ) ) ;
+				input = DEREF_string(posn_input(posn));
-		date = DEREF_ulong ( posn_datestamp ( posn ) ) ;
+				date = DEREF_ulong(posn_datestamp(posn));
-		date2 = date ;
+				date2 = date;
-	    }
+			}
-	    posn = MAKE_ptr ( SIZE_posn ) ;
+			posn = MAKE_ptr(SIZE_posn);
-	    MAKE_posn ( file, input, input, NULL, off, from, date, posn ) ;
+			MAKE_posn(file, input, input, NULL, off, from, date,
+				  posn);
-	    crt_loc.posn = posn ;
+			crt_loc.posn = posn;
-	    if ( date && date2 && date != date2 ) {
+			if (date && date2 && date != date2) {
-		/* File has changed on disk */
+				/* File has changed on disk */
-		if ( !already_included ( input, fs, 4 ) ) {
+				if (!already_included(input, fs, 4)) {
-		    report ( crt_loc, ERR_cpp_include_date () ) ;
+					report(crt_loc, ERR_cpp_include_date());
-		}
+				}
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     READ AN IDENTIFIER NAME
     This routine reads an identifier name from the bitstream bs.  ns gives
     the current namespace.
 */
-static HASHID load_hashid
+static HASHID
-    PROTO_N ( ( bs, ns ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns )
+load_hashid(BITSTREAM *bs, NAMESPACE ns)
+{
-    HASHID nm = NULL_hashid ;
+	HASHID nm = NULL_hashid;
-    unsigned n = DE_BITS ( bs, BITS_hashid ) ;
+	unsigned n = DE_BITS(bs, BITS_hashid);
-    if ( n ) {
+	if (n) {
-	if ( n <= ORDER_hashid ) {
+		if (n <= ORDER_hashid) {
-	    unsigned tag = n - 1 ;
+			unsigned tag = n - 1;
-	    ASSERT ( ORDER_hashid == 7 ) ;
+			ASSERT(ORDER_hashid == 7);
-	    switch ( tag ) {
+			switch (tag) {
-		case hashid_name_tag :
+			case hashid_name_tag:
-		case hashid_ename_tag : {
+			case hashid_ename_tag: {
-		    string s ;
+				string s;
-		    int ext = 0 ;
+				int ext = 0;
-		    unsigned long h ;
+				unsigned long h;
-		    BUFFER *bf = clear_buffer ( &token_buff, NIL ( FILE ) ) ;
+				BUFFER *bf = clear_buffer(&token_buff,
+							  NIL(FILE));
-		    de_tdfstring ( bs, bf ) ;
+				de_tdfstring(bs, bf);
-		    s = bf->start ;
+				s = bf->start;
-		    h = hash ( s ) ;
+				h = hash(s);
-		    if ( tag == hashid_ename_tag ) ext = 1 ;
+				if (tag == hashid_ename_tag) {
+					ext = 1;
+				}
-		    nm = lookup_name ( s, h, ext, lex_unknown ) ;
+				nm = lookup_name(s, h, ext, lex_unknown);
-		    break ;
+				break;
-		}
+			}
-		case hashid_constr_tag : {
+			case hashid_constr_tag: {
-		    if ( IS_nspace_ctype ( ns ) ) {
+				if (IS_nspace_ctype(ns)) {
+					IDENTIFIER cid =
-			IDENTIFIER cid = DEREF_id ( nspace_name ( ns ) ) ;
+					    DEREF_id(nspace_name(ns));
-			if ( IS_id_class_name ( cid ) ) {
+					if (IS_id_class_name(cid)) {
-			    TYPE t ;
+						TYPE t;
-			    t = DEREF_type ( id_class_name_defn ( cid ) ) ;
+						t = DEREF_type(id_class_name_defn(cid));
-			    nm = lookup_constr ( t, cid ) ;
+						nm = lookup_constr(t, cid);
-			    break ;
+						break;
+					}
+				}
+				SPEC_ERROR();
+				break;
+			}
-		    }
-		    SPEC_ERROR () ;
-		    break ;
-		}
-		case hashid_destr_tag : {
+			case hashid_destr_tag: {
-		    if ( IS_nspace_ctype ( ns ) ) {
+				if (IS_nspace_ctype(ns)) {
+					IDENTIFIER cid =
-			IDENTIFIER cid = DEREF_id ( nspace_name ( ns ) ) ;
+					    DEREF_id(nspace_name(ns));
-			if ( IS_id_class_name ( cid ) ) {
+					if (IS_id_class_name(cid)) {
-			    TYPE t ;
+						TYPE t;
-			    t = DEREF_type ( id_class_name_defn ( cid ) ) ;
+						t = DEREF_type(id_class_name_defn(cid));
-			    nm = lookup_destr ( t, cid ) ;
+						nm = lookup_destr(t, cid);
-			    break ;
+						break;
+					}
+				}
+				SPEC_ERROR();
+				break;
+			}
+			case hashid_conv_tag: {
+				TYPE t = load_type(bs, NULL_id);
+				if (!IS_NULL_type(t)) {
+					nm = lookup_conv(t);
+					break;
-		    }
+				}
-		    SPEC_ERROR () ;
+				SPEC_ERROR();
+				break;
+			}
+			case hashid_op_tag: {
+				int op = load_lex(bs);
+				nm = lookup_op(op);
+				break;
+			}
+			case hashid_anon_tag: {
+				nm = lookup_anon();
-		    break ;
+				break;
+			}
+			}
+		} else {
+			SPEC_ERROR();
+		}
-		case hashid_conv_tag : {
-		    TYPE t = load_type ( bs, NULL_id ) ;
-		    if ( !IS_NULL_type ( t ) ) {
-			nm = lookup_conv ( t ) ;
-			break ;
-		    }
-		    SPEC_ERROR () ;
-		    break ;
-		}
-		case hashid_op_tag : {
-		    int op = load_lex ( bs ) ;
-		    nm = lookup_op ( op ) ;
-		    break ;
-		}
-		case hashid_anon_tag : {
-		    nm = lookup_anon () ;
-		    break ;
-		}
-	    }
-	} else {
-	    SPEC_ERROR () ;
 	}
-    }
-    return ( nm ) ;
+	return (nm);
 }
 /*
     READ A LIST OF IDENTIFIER NAMES
     This routine reads a list of identifier names from the bitstream bs.
 */
-static LIST ( HASHID ) load_hashid_list
+static LIST(HASHID)
-    PROTO_N ( ( bs, ns ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns )
+load_hashid_list(BITSTREAM *bs, NAMESPACE ns)
 {
-    LIST ( HASHID ) p = NULL_list ( HASHID ) ;
+	LIST(HASHID)p = NULL_list(HASHID);
-    while ( DE_BOOL ( bs ) ) {
+	while (DE_BOOL(bs)) {
-	HASHID nm = load_hashid ( bs, ns ) ;
+		HASHID nm = load_hashid(bs, ns);
-	if ( IS_NULL_hashid ( nm ) ) {
+		if (IS_NULL_hashid(nm)) {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	    break ;
+			break;
-	}
+		}
-	CONS_hashid ( nm, p, p ) ;
+		CONS_hashid(nm, p, p);
-    }
+	}
-    p = REVERSE_list ( p ) ;
+	p = REVERSE_list(p);
-    return ( p ) ;
+	return (p);
 }
+/*
+    IDENTIFIER LOOK-UP TABLE
+    These variables give the table which gives the mapping between identifier
+    numbers and identifiers.
+*/
+static IDENTIFIER *id_table = NULL;
+static ulong id_table_size = 0;
+static ulong ids_pending = 0;
 /*
-    IDENTIFIER LOOK-UP TABLE
-    These variables give the table which gives the mapping between identifier
-    numbers and identifiers.
-*/
-static IDENTIFIER *id_table = NULL ;
-static ulong id_table_size = 0 ;
-static ulong ids_pending = 0 ;
-/*
     LOOK UP IDENTIFIER IN TABLE
     This routine returns a pointer to the dth element of the table above,
     extending it if necessary.
 */
-static IDENTIFIER *id_lookup
+static IDENTIFIER *
-    PROTO_N ( ( d ) )
-    PROTO_T ( ulong d )
+id_lookup(ulong d)
+{
-    ulong m = id_table_size ;
+	ulong m = id_table_size;
-    IDENTIFIER *p = id_table ;
+	IDENTIFIER *p = id_table;
-    if ( d >= m ) {
+	if (d >= m) {
-	ulong n = d + 100 ;
+		ulong n = d + 100;
-	p = xrealloc_nof ( p, IDENTIFIER, n ) ;
+		p = xrealloc_nof(p, IDENTIFIER, n);
-	while ( m < n ) {
+		while (m < n) {
-	    p [m] = NULL_id ;
+			p[m] = NULL_id;
-	    m++ ;
+			m++;
+		}
+		id_table_size = n;
+		id_table = p;
+	}
-	id_table_size = n ;
-	id_table = p ;
-    }
-    return ( p + d ) ;
+	return (p + d);
 }
 /*
     READ AN IDENTIFIER NUMBER
     This routine reads an identifier number from the bitstream bs.  It is
     possible for an identifier to be used before it is declared using
     load_id.
 */
-static IDENTIFIER load_use
+static IDENTIFIER
-    PROTO_N ( ( bs, tag ) )
-    PROTO_T ( BITSTREAM *bs X unsigned tag )
+load_use(BITSTREAM *bs, unsigned tag)
 {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    IDENTIFIER *pid ;
+	IDENTIFIER *pid;
-    ulong d = DE_INT ( bs ) ;
+	ulong d = DE_INT(bs);
-    if ( d == 0 ) {
+	if (d == 0) {
-	/* Null identifier */
+		/* Null identifier */
-	return ( NULL_id ) ;
+		return (NULL_id);
-    }
+	}
-    pid = id_lookup ( d ) ;
+	pid = id_lookup(d);
-    id = *pid ;
+	id = *pid;
-    if ( IS_NULL_id ( id ) ) {
+	if (IS_NULL_id(id)) {
-	/* Create dummy identifier */
+		/* Create dummy identifier */
-	HASHID nm = KEYWORD ( lex_zzzz ) ;
+		HASHID nm = KEYWORD(lex_zzzz);
-	MAKE_id_pending ( nm, dspec_none, NULL_nspace, crt_loc,
+		MAKE_id_pending(nm, dspec_none, NULL_nspace, crt_loc,
-			  tag, NULL_type, id ) ;
+				tag, NULL_type, id);
-	COPY_ulong ( id_dump ( id ), d ) ;
+		COPY_ulong(id_dump(id), d);
-	ids_pending++ ;
+		ids_pending++;
-	*pid = id ;
+		*pid = id;
-    }
+	}
-    return ( id ) ;
+	return (id);
 }
 /*
     READ A LIST OF IDENTIFIER NUMBERS
     This routine reads a list of identifier numbers from the bitstream bs.
 */
-static LIST ( IDENTIFIER ) load_use_list
+static LIST(IDENTIFIER)
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_use_list(BITSTREAM *bs)
 {
-    LIST ( IDENTIFIER ) p = NULL_list ( IDENTIFIER ) ;
+	LIST(IDENTIFIER)p = NULL_list(IDENTIFIER);
-    while ( DE_BOOL ( bs ) ) {
+	while (DE_BOOL(bs)) {
-	IDENTIFIER id = load_use ( bs, null_tag ) ;
+		IDENTIFIER id = load_use(bs, null_tag);
-	if ( spec_error ) break ;
+		if (spec_error) {
+			break;
+		}
-	CONS_id ( id, p, p ) ;
+		CONS_id(id, p, p);
-    }
+	}
-    p = REVERSE_list ( p ) ;
+	p = REVERSE_list(p);
-    return ( p ) ;
+	return (p);
 }
 /*
     READ A LIST OF TOKENS
     This routine reads a list of tokens from the bitstream bs.  def is
     as in load_tok.
 */
-static LIST ( TOKEN ) load_tok_list
+static LIST(TOKEN)
-    PROTO_N ( ( bs, def ) )
-    PROTO_T ( BITSTREAM *bs X int def )
+load_tok_list(BITSTREAM *bs, int def)
 {
-    LIST ( TOKEN ) p = NULL_list ( TOKEN ) ;
+	LIST(TOKEN)p = NULL_list(TOKEN);
-    while ( DE_BOOL ( bs ) ) {
+	while (DE_BOOL(bs)) {
-	TOKEN tok = load_tok ( bs, def ) ;
+		TOKEN tok = load_tok(bs, def);
-	if ( spec_error ) break ;
+		if (spec_error) {
+			break;
+		}
-	CONS_tok ( tok, p, p ) ;
+		CONS_tok(tok, p, p);
-    }
+	}
-    p = REVERSE_list ( p ) ;
+	p = REVERSE_list(p);
-    return ( p ) ;
+	return (p);
 }
 /*
     READ AN INTEGER CONSTANT
     This routine reads an integer constant from the bitstream bs.
 */
-static NAT load_nat
+static NAT
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_nat(BITSTREAM *bs)
 {
-    NAT m = NULL_nat ;
+	NAT m = NULL_nat;
-    unsigned n = DE_BITS ( bs, BITS_nat ) ;
+	unsigned n = DE_BITS(bs, BITS_nat);
-    if ( n == 0 ) {
+	if (n == 0) {
-	/* Null constants */
+		/* Null constants */
-	return ( m ) ;
+		return (m);
-    }
+	}
-    if ( n > ORDER_nat ) {
+	if (n > ORDER_nat) {
-	SPEC_ERROR () ;
+		SPEC_ERROR();
-	return ( m ) ;
+		return (m);
-    }
+	}
-    ASSERT ( ORDER_nat == 5 ) ;
+	ASSERT(ORDER_nat == 5);
-    switch ( n - 1 ) {
+	switch (n - 1) {
-	case nat_small_tag : {
+	case nat_small_tag: {
-	    unsigned long v = DE_INT ( bs ) ;
+		unsigned long v = DE_INT(bs);
-	    m = make_nat_value ( v ) ;
+		m = make_nat_value(v);
-	    break ;
+		break;
 	}
-	case nat_large_tag : {
+	case nat_large_tag: {
-	    int count = 0 ;
+		int count = 0;
-	    LIST ( unsigned ) p = NULL_list ( unsigned ) ;
+		LIST(unsigned)p = NULL_list(unsigned);
-	    while ( DE_BOOL ( bs ) ) {
+		while (DE_BOOL(bs)) {
-		unsigned v = ( unsigned ) DE_INT ( bs ) ;
+			unsigned v = (unsigned)DE_INT(bs);
-		CONS_unsigned ( v, p, p ) ;
+			CONS_unsigned(v, p, p);
-		if ( ++count == 10 ) {
+			if (++count == 10) {
-		    /* Check for end of file */
+				/* Check for end of file */
-		    if ( de_eof ( bs ) ) {
+				if (de_eof(bs)) {
-			SPEC_ERROR () ;
+					SPEC_ERROR();
-			break ;
+					break;
-		    }
+				}
-		    count = 0 ;
+				count = 0;
-		}
+			}
-	    }
+		}
-	    p = REVERSE_list ( p ) ;
+		p = REVERSE_list(p);
-	    m = make_large_nat ( p ) ;
+		m = make_large_nat(p);
-	    break ;
+		break;
 	}
-	case nat_calc_tag : {
+	case nat_calc_tag: {
-	    EXP e = load_exp ( bs, type_sint ) ;
+		EXP e = load_exp(bs, type_sint);
-	    if ( !IS_NULL_exp ( e ) ) {
+		if (!IS_NULL_exp(e)) {
-		MAKE_nat_calc ( e, m ) ;
+			MAKE_nat_calc(e, m);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case nat_neg_tag : {
+	case nat_neg_tag: {
-	    m = load_nat ( bs ) ;
+		m = load_nat(bs);
-	    if ( !IS_NULL_nat ( m ) ) {
+		if (!IS_NULL_nat(m)) {
-		m = negate_nat ( m ) ;
+			m = negate_nat(m);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case nat_token_tag : {
+	case nat_token_tag: {
-	    IDENTIFIER tok = load_use ( bs, null_tag ) ;
+		IDENTIFIER tok = load_use(bs, null_tag);
-	    if ( !IS_NULL_id ( tok ) ) {
+		if (!IS_NULL_id(tok)) {
-		LIST ( TOKEN ) args = load_tok_list ( bs, 1 ) ;
+			LIST(TOKEN)args = load_tok_list(bs, 1);
-		MAKE_nat_token ( tok, args, m ) ;
+			MAKE_nat_token(tok, args, m);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-    }
+	}
-    return ( m ) ;
+	return (m);
 }
 /*
     READ AN OFFSET
     This routine reads an offset from the bitstream bs.
 */
-static OFFSET load_off
+static OFFSET
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_off(BITSTREAM *bs)
+{
-    /* NOT YET IMPLEMENTED */
+	/* NOT YET IMPLEMENTED */
-    UNUSED ( bs ) ;
+	UNUSED(bs);
-    return ( NULL_off ) ;
+	return (NULL_off);
+}
 /*
     READ AN EXPRESSION
     This routine reads an expression from the bitstream bs.
 */
-static EXP load_exp
+static EXP
-    PROTO_N ( ( bs, t ) )
-    PROTO_T ( BITSTREAM *bs X TYPE t )
+load_exp(BITSTREAM *bs, TYPE t)
+{
-    unsigned tag ;
+	unsigned tag;
-    EXP e = NULL_exp ;
+	EXP e = NULL_exp;
-    unsigned n = DE_BITS ( bs, BITS_exp ) ;
+	unsigned n = DE_BITS(bs, BITS_exp);
-    if ( n == 0 ) {
+	if (n == 0) {
-	/* Null expressions */
+		/* Null expressions */
-	return ( e ) ;
-    }
-    if ( n > ORDER_exp ) {
-	SPEC_ERROR () ;
-	return ( e ) ;
+		return (e);
-    }
-    tag = n - 1 ;
-    switch ( tag ) {
-	case exp_int_lit_tag : {
-	    NAT m = load_nat ( bs ) ;
-	    if ( !IS_NULL_nat ( m ) ) {
-		unsigned etag = DE_BITS ( bs, BITS_exp ) ;
-		if ( etag < ORDER_exp ) {
-		    MAKE_exp_int_lit ( t, m, etag, e ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
+	}
+	if (n > ORDER_exp) {
+		SPEC_ERROR();
+		return (e);
+	}
+	tag = n - 1;
+	switch (tag) {
+	case exp_int_lit_tag: {
+		NAT m = load_nat(bs);
+		if (!IS_NULL_nat(m)) {
+			unsigned etag = DE_BITS(bs, BITS_exp);
+			if (etag < ORDER_exp) {
+				MAKE_exp_int_lit(t, m, etag, e);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
-	case exp_token_tag : {
+	case exp_token_tag: {
-	    IDENTIFIER tok = load_use ( bs, null_tag ) ;
+		IDENTIFIER tok = load_use(bs, null_tag);
-	    if ( !IS_NULL_id ( tok ) ) {
+		if (!IS_NULL_id(tok)) {
-		LIST ( TOKEN ) args = load_tok_list ( bs, 1 ) ;
+			LIST(TOKEN)args = load_tok_list(bs, 1);
-		MAKE_exp_token ( t, tok, args, e ) ;
+			MAKE_exp_token(t, tok, args, e);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
+	}
-	default : {
+	default: {
-	    /* NOT YET IMPLEMENTED */
+		/* NOT YET IMPLEMENTED */
-	    MAKE_exp_value ( t, e ) ;
+		MAKE_exp_value(t, e);
-	    break ;
+		break;
+	}
-    }
+	}
-    return ( e ) ;
+	return (e);
+}
 /*
     READ A BUILT-IN TYPE
     This routine reads a built-in type number from the bitstream bs.
 */
-static BUILTIN_TYPE load_ntype
+static BUILTIN_TYPE
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_ntype(BITSTREAM *bs)
-{
-    BUILTIN_TYPE nt = ( BUILTIN_TYPE ) DE_BITS ( bs, BITS_ntype ) ;
-    if ( nt >= ORDER_ntype ) {
-	nt = ntype_none ;
-	SPEC_ERROR () ;
-    }
-    return ( nt ) ;
-}
-/*
-    READ AN INTEGRAL TYPE
-    This routine reads a integral type from the bitstream bs.  Note that
-    the result is returned as a type rather than an integral type.
-*/
-static TYPE load_itype
-    PROTO_N ( ( bs, cv, tag ) )
-    PROTO_T ( BITSTREAM *bs X CV_SPEC cv X unsigned tag )
+{
-    TYPE t = NULL_type ;
-    unsigned n = DE_BITS ( bs, BITS_itype ) ;
+	BUILTIN_TYPE nt = (BUILTIN_TYPE)DE_BITS(bs, BITS_ntype);
-    if ( n == 0 ) {
+	if (nt >= ORDER_ntype) {
-	/* Null types */
+		nt = ntype_none;
-	return ( t ) ;
-    }
-    if ( n > ORDER_itype ) {
-	SPEC_ERROR () ;
+		SPEC_ERROR();
-	return ( t ) ;
-    }
-    switch ( n - 1 ) {
-	case itype_basic_tag : {
-	    BUILTIN_TYPE nt = load_ntype ( bs ) ;
-	    t = type_builtin [ nt ] ;
-	    break ;
+	}
+	return (nt);
+}
+/*
+    READ AN INTEGRAL TYPE
+    This routine reads a integral type from the bitstream bs.  Note that
+    the result is returned as a type rather than an integral type.
+*/
+static TYPE
+load_itype(BITSTREAM *bs, CV_SPEC cv, unsigned tag)
+{
+	TYPE t = NULL_type;
+	unsigned n = DE_BITS(bs, BITS_itype);
+	if (n == 0) {
+		/* Null types */
+		return (t);
+	}
+	if (n > ORDER_itype) {
+		SPEC_ERROR();
+		return (t);
+	}
+	switch (n - 1) {
+	case itype_basic_tag: {
+		BUILTIN_TYPE nt = load_ntype(bs);
+		t = type_builtin[nt];
+		break;
+	}
-	case itype_bitfield_tag : {
+	case itype_bitfield_tag: {
-	    TYPE s = load_type ( bs, NULL_id ) ;
+		TYPE s = load_type(bs, NULL_id);
-	    if ( !IS_NULL_type ( s ) ) {
+		if (!IS_NULL_type(s)) {
-		BASE_TYPE bt = load_btype ( bs ) ;
+			BASE_TYPE bt = load_btype(bs);
-		NAT m = load_nat ( bs ) ;
+			NAT m = load_nat(bs);
-		if ( !IS_NULL_nat ( m ) ) {
+			if (!IS_NULL_nat(m)) {
-		    t = check_bitfield_type ( cv, s, bt, m, 1 ) ;
+				t = check_bitfield_type(cv, s, bt, m, 1);
-		    cv = cv_none ;
+				cv = cv_none;
-		    break ;
+				break;
-		}
+			}
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case itype_promote_tag : {
+	case itype_promote_tag: {
-	    TYPE s = load_itype ( bs, cv_none, type_integer_tag ) ;
+		TYPE s = load_itype(bs, cv_none, type_integer_tag);
-	    if ( !IS_NULL_type ( s ) ) {
+		if (!IS_NULL_type(s)) {
-		t = promote_type ( s ) ;
+			t = promote_type(s);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case itype_arith_tag : {
+	case itype_arith_tag: {
-	    TYPE s = load_itype ( bs, cv_none, type_integer_tag ) ;
+		TYPE s = load_itype(bs, cv_none, type_integer_tag);
-	    if ( !IS_NULL_type ( s ) ) {
+		if (!IS_NULL_type(s)) {
-		TYPE r = load_itype ( bs, cv_none, type_integer_tag ) ;
+			TYPE r = load_itype(bs, cv_none, type_integer_tag);
-		if ( !IS_NULL_type ( r ) ) {
+			if (!IS_NULL_type(r)) {
-		    t = arith_itype ( s, r, NULL_exp, NULL_exp ) ;
+				t = arith_itype(s, r, NULL_exp, NULL_exp);
-		    break ;
+				break;
-		}
+			}
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case itype_literal_tag : {
+	case itype_literal_tag: {
-	    NAT m = load_nat ( bs ) ;
+		NAT m = load_nat(bs);
-	    if ( !IS_NULL_nat ( m ) ) {
+		if (!IS_NULL_nat(m)) {
-		int form = ( int ) DE_BITS ( bs, 2 ) ;
+			int form = (int)DE_BITS(bs, 2);
-		if ( form >= 0 && form < BASE_NO ) {
+			if (form >= 0 && form < BASE_NO) {
-		    int suff = ( int ) DE_BITS ( bs, 3 ) ;
+				int suff = (int)DE_BITS(bs, 3);
-		    if ( suff >= 0 && suff < SUFFIX_NO ) {
+				if (suff >= 0 && suff < SUFFIX_NO) {
-			int fit = 0 ;
+					int fit = 0;
-			string str = NULL_string ;
+					string str = NULL_string;
-			t = find_literal_type ( m, form, suff, str, &fit ) ;
+					t = find_literal_type(m, form, suff,
+							      str, &fit);
-			break ;
+					break;
-		    }
+				}
-		}
+			}
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case itype_token_tag : {
+	case itype_token_tag: {
-	    IDENTIFIER tok = load_use ( bs, null_tag ) ;
+		IDENTIFIER tok = load_use(bs, null_tag);
-	    if ( !IS_NULL_id ( tok ) ) {
+		if (!IS_NULL_id(tok)) {
-		LIST ( TOKEN ) args = load_tok_list ( bs, 1 ) ;
+			LIST(TOKEN)args = load_tok_list(bs, 1);
-		t = apply_itype_token ( tok, args ) ;
+			t = apply_itype_token(tok, args);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-    }
+	}
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	if ( TAG_type ( t ) == tag ) {
+		if (TAG_type(t) == tag) {
+			if (cv) {
-	    if ( cv ) t = qualify_type ( t, cv, 0 ) ;
+				t = qualify_type(t, cv, 0);
+			}
-	} else {
+		} else {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	}
+		}
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     READ A FLOATING POINT TYPE
     This routine reads a floating point type from the bitstream bs.  Note
     that the result is returned as a type rather than a floating point type.
 */
-static TYPE load_ftype
+static TYPE
-    PROTO_N ( ( bs, cv ) )
-    PROTO_T ( BITSTREAM *bs X CV_SPEC cv )
+load_ftype(BITSTREAM *bs, CV_SPEC cv)
 {
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    unsigned n = DE_BITS ( bs, BITS_ftype ) ;
+	unsigned n = DE_BITS(bs, BITS_ftype);
-    if ( n == 0 ) {
+	if (n == 0) {
-	/* Null types */
+		/* Null types */
-	return ( t ) ;
+		return (t);
-    }
+	}
-    if ( n > ORDER_ftype ) {
+	if (n > ORDER_ftype) {
-	SPEC_ERROR () ;
+		SPEC_ERROR();
-	return ( t ) ;
+		return (t);
-    }
+	}
-    ASSERT ( ORDER_ftype == 4 ) ;
+	ASSERT(ORDER_ftype == 4);
-    switch ( n - 1 ) {
+	switch (n - 1) {
-	case ftype_basic_tag : {
+	case ftype_basic_tag: {
-	    BUILTIN_TYPE nt = load_ntype ( bs ) ;
+		BUILTIN_TYPE nt = load_ntype(bs);
-	    t = type_builtin [ nt ] ;
+		t = type_builtin[nt];
-	    break ;
+		break;
 	}
-	case ftype_arg_promote_tag : {
+	case ftype_arg_promote_tag: {
-	    TYPE s = load_ftype ( bs, cv_none ) ;
+		TYPE s = load_ftype(bs, cv_none);
-	    if ( !IS_NULL_type ( s ) ) {
+		if (!IS_NULL_type(s)) {
-		t = arg_promote_type ( s, KILL_err ) ;
+			t = arg_promote_type(s, KILL_err);
-		break ;
+			break;
-	    }
+		}
-	    SPEC_ERROR () ;
+		SPEC_ERROR();
-	    break ;
+		break;
 	}
-	case ftype_arith_tag : {
+	case ftype_arith_tag: {
-	    TYPE s = load_ftype ( bs, cv_none ) ;
+		TYPE s = load_ftype(bs, cv_none);
-	    if ( !IS_NULL_type ( s ) ) {
+		if (!IS_NULL_type(s)) {
-		TYPE r = load_ftype ( bs, cv_none ) ;
+			TYPE r = load_ftype(bs, cv_none);
-		if ( !IS_NULL_type ( r ) ) {
+			if (!IS_NULL_type(r)) {
-		    t = arith_ftype ( s, r ) ;
+				t = arith_ftype(s, r);
-		    break ;
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case ftype_token_tag: {
+		IDENTIFIER tok = load_use(bs, null_tag);
+		if (!IS_NULL_id(tok)) {
+			LIST(TOKEN)args = load_tok_list(bs, 1);
+			t = apply_ftype_token(tok, args);
+			break;
+		}
+		break;
+	}
+	}
+	if (!IS_NULL_type(t)) {
+		if (IS_type_floating(t)) {
+			if (cv)t = qualify_type(t, cv, 0);
+		} else {
+			SPEC_ERROR();
+			t = NULL_type;
+		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
+	}
-	case ftype_token_tag : {
-	    IDENTIFIER tok = load_use ( bs, null_tag ) ;
-	    if ( !IS_NULL_id ( tok ) ) {
-		LIST ( TOKEN ) args = load_tok_list ( bs, 1 ) ;
-		t = apply_ftype_token ( tok, args ) ;
-		break ;
-	    }
-	    break ;
-	}
-    }
-    if ( !IS_NULL_type ( t ) ) {
-	if ( IS_type_floating ( t ) ) {
-	    if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-	} else {
-	    SPEC_ERROR () ;
-	    t = NULL_type ;
-	}
-    }
-    return ( t ) ;
+	return (t);
 }
 /*
     READ A BASE CLASS GRAPH
     This routine reads a base class from the bitstream bs.  gu gives the
     parent graph and gt gives the top of the graph.
 */
-static GRAPH load_graph
+static GRAPH
-    PROTO_N ( ( bs, gu, gt ) )
-    PROTO_T ( BITSTREAM *bs X GRAPH gu X GRAPH gt )
+load_graph(BITSTREAM *bs, GRAPH gu, GRAPH gt)
+{
-    GRAPH gr ;
+	GRAPH gr;
-    LIST ( GRAPH ) br = NULL_list ( GRAPH ) ;
+	LIST(GRAPH)br = NULL_list(GRAPH);
-    if ( IS_NULL_graph ( gu ) ) {
+	if (IS_NULL_graph(gu)) {
-	/* Top graph node */
+		/* Top graph node */
-	gr = gt ;
+		gr = gt;
-    } else {
-	/* Read graph node */
-	CLASS_TYPE ct = NULL_ctype ;
-	IGNORE load_ctype ( bs, NULL_id, &ct ) ;
-	if ( !IS_NULL_ctype ( ct ) ) {
-	    DECL_SPEC acc = load_dspec ( bs ) ;
-	    MAKE_graph_basic ( ct, acc, gr ) ;
 	} else {
+		/* Read graph node */
+		CLASS_TYPE ct = NULL_ctype;
+		IGNORE load_ctype(bs, NULL_id, &ct);
+		if (!IS_NULL_ctype(ct)) {
+			DECL_SPEC acc = load_dspec(bs);
+			MAKE_graph_basic(ct, acc, gr);
+		} else {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	    return ( NULL_graph ) ;
+			return (NULL_graph);
+		}
+	}
+	while (DE_BOOL(bs)) {
+		/* Read base classes */
+		GRAPH gs = load_graph(bs, gr, gt);
+		if (IS_NULL_graph(gs)) {
+			break;
+		}
+		CONS_graph(gs, br, br);
+	}
-    }
-    while ( DE_BOOL ( bs ) ) {
-	/* Read base classes */
-	GRAPH gs = load_graph ( bs, gr, gt ) ;
-	if ( IS_NULL_graph ( gs ) ) break ;
-	CONS_graph ( gs, br, br ) ;
-    }
-    br = REVERSE_list ( br ) ;
+	br = REVERSE_list(br);
-    COPY_list ( graph_tails ( gr ), br ) ;
+	COPY_list(graph_tails(gr), br);
-    COPY_graph ( graph_top ( gr ), gt ) ;
+	COPY_graph(graph_top(gr), gt);
-    COPY_graph ( graph_up ( gr ), gu ) ;
+	COPY_graph(graph_up(gr), gu);
-    return ( gr ) ;
+	return (gr);
+}
 /*
     READ A CLASS TYPE
     This routine reads a class type from the bitstream bs.  If def is not
     null then the full class definition is read, otherwise just a use is
     read.
 */
-static TYPE load_ctype
+static TYPE
-    PROTO_N ( ( bs, def, pct ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER def X CLASS_TYPE *pct )
+load_ctype(BITSTREAM *bs, IDENTIFIER def, CLASS_TYPE *pct)
 {
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    if ( !IS_NULL_id ( def ) ) {
+	if (!IS_NULL_id(def)) {
-	if ( IS_id_class_name ( def ) ) {
+		if (IS_id_class_name(def)) {
-	    /* Read class definition */
+			/* Read class definition */
-	    GRAPH gr ;
+			GRAPH gr;
-	    CLASS_TYPE ct ;
+			CLASS_TYPE ct;
-	    DECL_SPEC acc ;
+			DECL_SPEC acc;
-	    NAMESPACE mns ;
+			NAMESPACE mns;
-	    /* Read the class information */
+			/* Read the class information */
-	    CLASS_INFO ci = load_cinfo ( bs ) ;
+			CLASS_INFO ci = load_cinfo(bs);
-	    CLASS_USAGE cu = load_cusage ( bs ) ;
+			CLASS_USAGE cu = load_cusage(bs);
-	    /* Create the class type */
+			/* Create the class type */
-	    acc = ( dspec_public | dspec_defn ) ;
+			acc = (dspec_public | dspec_defn);
-	    MAKE_graph_basic ( NULL_ctype, acc, gr ) ;
+			MAKE_graph_basic(NULL_ctype, acc, gr);
-	    mns = make_namespace ( def, nspace_ctype_tag, 20 ) ;
+			mns = make_namespace(def, nspace_ctype_tag, 20);
-	    MAKE_ctype_basic ( def, ci, cu, mns, gr, 1, NULL_type, ct ) ;
+			MAKE_ctype_basic(def, ci, cu, mns, gr, 1, NULL_type,
+					 ct);
-	    COPY_ctype ( graph_head ( gr ), ct ) ;
+			COPY_ctype(graph_head(gr), ct);
-	    MAKE_type_compound ( cv_none, ct, t ) ;
+			MAKE_type_compound(cv_none, ct, t);
-	    COPY_type ( id_class_name_defn ( def ), t ) ;
+			COPY_type(id_class_name_defn(def), t);
-	    COPY_id ( type_name ( t ), def ) ;
+			COPY_id(type_name(t), def);
-	    IGNORE lookup_constr ( t, def ) ;
+			IGNORE lookup_constr(t, def);
-	    IGNORE lookup_destr ( t, def ) ;
+			IGNORE lookup_destr(t, def);
-	    crt_class = ct ;
+			crt_class = ct;
-	    *pct = ct ;
+			*pct = ct;
-	    /* Read the base class graph */
+			/* Read the base class graph */
-	    IGNORE load_graph ( bs, NULL_graph, gr ) ;
+			IGNORE load_graph(bs, NULL_graph, gr);
-	    end_base_class ( ct, 1 ) ;
+			end_base_class(ct, 1);
-	    /* Read template form */
+			/* Read template form */
-	    if ( DE_BOOL ( bs ) ) {
+			if (DE_BOOL(bs)) {
-		TYPE form = load_type ( bs, NULL_id ) ;
+				TYPE form = load_type(bs, NULL_id);
-		COPY_type ( ctype_form ( ct ), form ) ;
+				COPY_type(ctype_form(ct), form);
-	    }
+			}
-	} else {
+		} else {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	}
+		}
-    } else {
+	} else {
-	/* Read class name */
+		/* Read class name */
-	IDENTIFIER cid = load_use ( bs, id_class_name_tag ) ;
+		IDENTIFIER cid = load_use(bs, id_class_name_tag);
-	if ( !IS_NULL_id ( cid ) ) {
+		if (!IS_NULL_id(cid)) {
-	    if ( IS_id_class_name ( cid ) ) {
+			if (IS_id_class_name(cid)) {
-		t = DEREF_type ( id_class_name_defn ( cid ) ) ;
+				t = DEREF_type(id_class_name_defn(cid));
-	    }
+			}
-	}
+		}
-	if ( !IS_NULL_type ( t ) ) {
+		if (!IS_NULL_type(t)) {
-	    while ( IS_type_templ ( t ) ) {
+			while (IS_type_templ(t)) {
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
+				t = DEREF_type(type_templ_defn(t));
-	    }
+			}
-	    if ( IS_type_compound ( t ) ) {
+			if (IS_type_compound(t)) {
+				CLASS_TYPE ct =
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				    DEREF_ctype(type_compound_defn(t));
-		*pct = ct ;
+				*pct = ct;
-	    } else {
+			} else {
-		t = NULL_type ;
+				t = NULL_type;
-		SPEC_ERROR () ;
+				SPEC_ERROR();
-	    }
+			}
-	} else {
+		} else {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	}
+		}
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     READ AN ENUMERATION TYPE
     This routine reads an enumeration type from the bitstream bs.  If def
     is not null then the full enumeration definition is read, otherwise
     just a use is read.
 */
-static TYPE load_etype
+static TYPE
-    PROTO_N ( ( bs, def, pet ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER def X ENUM_TYPE *pet )
+load_etype(BITSTREAM *bs, IDENTIFIER def, ENUM_TYPE *pet)
 {
-    TYPE t = NULL_type ;
+	TYPE t = NULL_type;
-    if ( !IS_NULL_id ( def ) ) {
+	if (!IS_NULL_id(def)) {
-	if ( IS_id_enum_name ( def ) ) {
+		if (IS_id_enum_name(def)) {
-	    /* Read enumeration definition */
+			/* Read enumeration definition */
-	    ENUM_TYPE et ;
+			ENUM_TYPE et;
-	    CLASS_INFO ei = load_cinfo ( bs ) ;
+			CLASS_INFO ei = load_cinfo(bs);
-	    TYPE s = load_type ( bs, NULL_id ) ;
+			TYPE s = load_type(bs, NULL_id);
-	    if ( !IS_NULL_type ( s ) ) {
+			if (!IS_NULL_type(s)) {
-		MAKE_etype_basic ( def, ei, s, et ) ;
+				MAKE_etype_basic(def, ei, s, et);
-		if ( DE_BOOL ( bs ) ) {
+				if (DE_BOOL(bs)) {
-		    TYPE form = load_type ( bs, NULL_id ) ;
+					TYPE form = load_type(bs, NULL_id);
-		    COPY_type ( etype_form ( et ), form ) ;
+					COPY_type(etype_form(et), form);
-		}
+				}
-		MAKE_type_enumerate ( cv_none, et, t ) ;
+				MAKE_type_enumerate(cv_none, et, t);
-		COPY_type ( id_enum_name_defn ( def ), t ) ;
+				COPY_type(id_enum_name_defn(def), t);
-		COPY_id ( type_name ( t ), def ) ;
+				COPY_id(type_name(t), def);
-		*pet = et ;
+				*pet = et;
-	    } else {
+			} else {
-		SPEC_ERROR () ;
+				SPEC_ERROR();
-	    }
+			}
-	} else {
+		} else {
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	}
+		}
-    } else {
+	} else {
-	/* Read enumeration name */
+		/* Read enumeration name */
-	IDENTIFIER eid = load_use ( bs, id_enum_name_tag ) ;
+		IDENTIFIER eid = load_use(bs, id_enum_name_tag);
-	if ( !IS_NULL_id ( eid ) ) {
+		if (!IS_NULL_id(eid)) {
-	    if ( IS_id_enum_name ( eid ) ) {
+			if (IS_id_enum_name(eid)) {
-		t = DEREF_type ( id_enum_name_defn ( eid ) ) ;
+				t = DEREF_type(id_enum_name_defn(eid));
-	    }
+			}
-	}
+		}
-	if ( !IS_NULL_type ( t ) && IS_type_enumerate ( t ) ) {
+		if (!IS_NULL_type(t) && IS_type_enumerate(t)) {
-	    ENUM_TYPE et ;
+			ENUM_TYPE et;
-	    et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+			et = DEREF_etype(type_enumerate_defn(t));
-	    *pet = et ;
+			*pet = et;
-	} else {
+		} else {
-	    t = NULL_type ;
+			t = NULL_type;
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	}
+		}
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     READ A FUNCTION PARAMETER LIST
     This routine reads a list of function or template parameters (as
     indicated by tag) from the bitstream bs into the namespace ns.
 */
-static LIST ( IDENTIFIER ) load_param_list
+static LIST(IDENTIFIER)
-    PROTO_N ( ( bs, ns, tag ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns X unsigned tag )
+load_param_list(BITSTREAM *bs, NAMESPACE ns, unsigned tag)
-{
-    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
-    while ( DE_BOOL ( bs ) ) {
-	HASHID nm ;
-	MEMBER mem ;
-	IDENTIFIER pid = load_id ( bs, ns ) ;
-	if ( IS_NULL_id ( pid ) || TAG_id ( pid ) != tag ) {
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	nm = DEREF_hashid ( id_name ( pid ) ) ;
-	mem = search_member ( ns, nm, 1 ) ;
-	COPY_id ( member_id ( mem ), pid ) ;
-	CONS_id ( pid, pids, pids ) ;
-    }
-    pids = REVERSE_list ( pids ) ;
-    return ( pids ) ;
-}
-/*
-    READ A TYPE
-    This routine reads a type from the bitstream bs.  def is passed to
-    load_ctype and load_etype.
-*/
-static TYPE load_type
-    PROTO_N ( ( bs, def ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER def )
+{
-    unsigned n ;
-    CV_SPEC cv ;
-    unsigned tag ;
-    TYPE t = NULL_type ;
-    if ( DE_BOOL ( bs ) ) {
-	/* Built-in types */
-	BUILTIN_TYPE nt ;
-	cv = load_cv ( bs ) ;
-	nt = load_ntype ( bs ) ;
-	t = type_builtin [ nt ] ;
-	if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-	return ( t ) ;
-    }
-    /* Read type independent fields */
-    n = DE_BITS ( bs, BITS_type ) ;
-    if ( n == 0 ) {
-	/* Null types */
-	return ( t ) ;
-    }
-    if ( n > ORDER_type ) {
-	SPEC_ERROR () ;
-	return ( NULL_type ) ;
-    }
-    tag = n - 1 ;
-    cv = load_cv ( bs ) ;
-    /* Read type dependent fields */
-    ASSERT ( ORDER_type == 18 ) ;
-    switch ( tag ) {
-	case type_pre_tag : {
-	    IDENTIFIER tid = load_use ( bs, null_tag ) ;
+	LIST(IDENTIFIER)pids = NULL_list(IDENTIFIER);
-	    QUALIFIER qual = load_qual ( bs ) ;
-	    BASE_TYPE bt = load_btype ( bs ) ;
-	    MAKE_type_pre ( cv, bt, qual, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
-	    break ;
-	}
-	case type_integer_tag : {
-	    t = load_itype ( bs, cv, tag ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		if ( DE_BOOL ( bs ) ) {
+	while (DE_BOOL(bs)) {
-		    TYPE s = load_itype ( bs, cv_none, tag ) ;
-		    if ( !IS_NULL_type ( s ) ) {
-			INT_TYPE it, is ;
-			it = DEREF_itype ( type_integer_rep ( t ) ) ;
-			is = DEREF_itype ( type_integer_rep ( s ) ) ;
-			t = make_itype ( it, is ) ;
-		    }
-		}
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_floating_tag : {
-	    t = load_ftype ( bs, cv ) ;
-	    break ;
-	}
-	case type_top_tag :
-	case type_bottom_tag : {
-	    /* Should not happen */
-	    MAKE_type_top_etc ( tag, cv, t ) ;
-	    break ;
-	}
-	case type_ptr_tag :
-	case type_ref_tag : {
-	    /* Pointer and reference types */
-	    TYPE s = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( s ) ) {
-		MAKE_type_ptr_etc ( tag, cv, s, t ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_ptr_mem_tag : {
-	    /* Pointer to member types */
-	    CLASS_TYPE cs = NULL_ctype ;
-	    IGNORE load_ctype ( bs, NULL_id, &cs ) ;
-	    if ( !IS_NULL_ctype ( cs ) ) {
-		TYPE r = load_type ( bs, NULL_id ) ;
-		if ( !IS_NULL_type ( r ) ) {
-		    MAKE_type_ptr_mem ( cv, cs, r, t ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_func_tag : {
-	    /* Function types */
-	    TYPE r = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( r ) ) {
-		int ell ;
-		NAMESPACE pns ;
+		HASHID nm;
-		CV_SPEC mqual ;
+		MEMBER mem;
-		LIST ( IDENTIFIER ) pids ;
-		CLASS_TYPE cs = NULL_ctype ;
-		LIST ( TYPE ) ex = univ_type_set ;
-		begin_param ( NULL_id ) ;
-		pns = crt_namespace ;
-		pids = load_param_list ( bs, pns, id_parameter_tag ) ;
-		DESTROY_list ( pids, SIZE_id ) ;
+		IDENTIFIER pid = load_id(bs, ns);
-		ell = ( int ) DE_BITS ( bs, BITS_ellipsis ) ;
-		mqual = load_mqual ( bs ) ;
-		if ( DE_BOOL ( bs ) ) {
-		    /* Read member function type */
-		    IGNORE load_ctype ( bs, NULL_id, &cs ) ;
-		}
-		if ( DE_BOOL ( bs ) ) {
-		    /* Read exception specifier */
-		    ex = load_type_list ( bs ) ;
-		}
-		t = make_func_type ( r, ell, mqual, ex ) ;
-		end_param () ;
-		if ( !IS_NULL_ctype ( cs ) ) {
+		if (IS_NULL_id(pid) || TAG_id(pid) != tag) {
-		    member_func_type ( cs, id_mem_func_tag, t ) ;
-		}
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_array_tag : {
-	    /* Array types */
-	    TYPE s = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( s ) ) {
-		NAT m = load_nat ( bs ) ;
-		MAKE_type_array ( cv, s, m, t ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_bitfield_tag : {
-	    /* Bitfield types */
-	    t = load_itype ( bs, cv, tag ) ;
-	    break ;
-	}
-	case type_compound_tag : {
-	    /* Class types */
-	    CLASS_TYPE ct = NULL_ctype ;
-	    t = load_ctype ( bs, def, &ct ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_enumerate_tag : {
-	    /* Enumeration types */
-	    ENUM_TYPE et = NULL_etype ;
-	    t = load_etype ( bs, def, &et ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
+			SPEC_ERROR();
-	    break ;
-	}
-	case type_token_tag : {
-	    IDENTIFIER tok = load_use ( bs, null_tag ) ;
-	    if ( !IS_NULL_id ( tok ) ) {
-		LIST ( TOKEN ) args = load_tok_list ( bs, 1 ) ;
-		MAKE_type_token ( cv, tok, args, t ) ;
-		break ;
+			break;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_templ_tag : {
-	    TOKEN tok = load_tok ( bs, 0 ) ;
-	    if ( !IS_NULL_tok ( tok ) && IS_tok_templ ( tok ) ) {
-		TYPE s = load_type ( bs, def ) ;
-		if ( !IS_NULL_type ( s ) ) {
-		    int fix = DE_BOOL ( bs ) ;
-		    MAKE_type_templ ( cv, tok, s, fix, t ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case type_instance_tag : {
-	    IDENTIFIER tid = load_use ( bs, null_tag ) ;
-	    if ( !IS_NULL_id ( tid ) ) {
-		IDENTIFIER id = load_use ( bs, null_tag ) ;
-		if ( !IS_NULL_id ( id ) ) {
-		    DECL_SPEC acc = load_dspec ( bs ) ;
-		    MAKE_type_instance ( cv, id, acc, t ) ;
-		    COPY_id ( type_name ( t ), tid ) ;
-		    break ;
+		}
+		nm = DEREF_hashid(id_name(pid));
-	    }
+		mem = search_member(ns, nm, 1);
-	    SPEC_ERROR () ;
+		COPY_id(member_id(mem), pid);
-	    break ;
+		CONS_id(pid, pids, pids);
+	}
+	pids = REVERSE_list(pids);
+	return (pids);
+}
-	case type_dummy_tag : {
-	    int tok = ( int ) DE_INT ( bs ) ;
-	    MAKE_type_dummy ( cv, tok, t ) ;
-	    break ;
-	}
+/*
+    READ A TYPE
+    This routine reads a type from the bitstream bs.  def is passed to
+    load_ctype and load_etype.
+*/
+static TYPE
+load_type(BITSTREAM *bs, IDENTIFIER def)
+{
+	unsigned n;
+	CV_SPEC cv;
+	unsigned tag;
+	TYPE t = NULL_type;
+	if (DE_BOOL(bs)) {
+		/* Built-in types */
+		BUILTIN_TYPE nt;
+		cv = load_cv(bs);
+		nt = load_ntype(bs);
+		t = type_builtin[nt];
+		if (cv) {
+			t = qualify_type(t, cv, 0);
+		}
+		return (t);
+	}
+	/* Read type independent fields */
+	n = DE_BITS(bs, BITS_type);
+	if (n == 0) {
+		/* Null types */
+		return (t);
+	}
+	if (n > ORDER_type) {
+		SPEC_ERROR();
+		return (NULL_type);
+	}
+	tag = n - 1;
+	cv = load_cv(bs);
+	/* Read type dependent fields */
+	ASSERT(ORDER_type == 18);
+	switch (tag) {
+	case type_pre_tag: {
+		IDENTIFIER tid = load_use(bs, null_tag);
+		QUALIFIER qual = load_qual(bs);
+		BASE_TYPE bt = load_btype(bs);
+		MAKE_type_pre(cv, bt, qual, t);
+		COPY_id(type_name(t), tid);
+		break;
+	}
+	case type_integer_tag: {
+		t = load_itype(bs, cv, tag);
+		if (!IS_NULL_type(t)) {
+			if (DE_BOOL(bs)) {
+				TYPE s = load_itype(bs, cv_none, tag);
+				if (!IS_NULL_type(s)) {
+					INT_TYPE it, is;
+					it = DEREF_itype(type_integer_rep(t));
+					is = DEREF_itype(type_integer_rep(s));
+					t = make_itype(it, is);
+				}
+			}
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_floating_tag: {
+		t = load_ftype(bs, cv);
+		break;
+	}
+	case type_top_tag:
+	case type_bottom_tag: {
+		/* Should not happen */
+		MAKE_type_top_etc(tag, cv, t);
+		break;
+	}
+	case type_ptr_tag:
+	case type_ref_tag: {
+		/* Pointer and reference types */
+		TYPE s = load_type(bs, NULL_id);
+		if (!IS_NULL_type(s)) {
+			MAKE_type_ptr_etc(tag, cv, s, t);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_ptr_mem_tag: {
+		/* Pointer to member types */
+		CLASS_TYPE cs = NULL_ctype;
+		IGNORE load_ctype(bs, NULL_id, &cs);
+		if (!IS_NULL_ctype(cs)) {
+			TYPE r = load_type(bs, NULL_id);
+			if (!IS_NULL_type(r)) {
+				MAKE_type_ptr_mem(cv, cs, r, t);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_func_tag: {
+		/* Function types */
+		TYPE r = load_type(bs, NULL_id);
+		if (!IS_NULL_type(r)) {
+			int ell;
+			NAMESPACE pns;
+			CV_SPEC mqual;
+			LIST(IDENTIFIER)pids;
+			CLASS_TYPE cs = NULL_ctype;
+			LIST(TYPE)ex = univ_type_set;
+			begin_param(NULL_id);
+			pns = crt_namespace;
+			pids = load_param_list(bs, pns, id_parameter_tag);
+			DESTROY_list(pids, SIZE_id);
+			ell = (int)DE_BITS(bs, BITS_ellipsis);
+			mqual = load_mqual(bs);
+			if (DE_BOOL(bs)) {
+				/* Read member function type */
+				IGNORE load_ctype(bs, NULL_id, &cs);
+			}
+			if (DE_BOOL(bs)) {
+				/* Read exception specifier */
+				ex = load_type_list(bs);
+			}
+			t = make_func_type(r, ell, mqual, ex);
+			end_param();
+			if (!IS_NULL_ctype(cs)) {
+				member_func_type(cs, id_mem_func_tag, t);
+			}
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_array_tag: {
+		/* Array types */
+		TYPE s = load_type(bs, NULL_id);
+		if (!IS_NULL_type(s)) {
+			NAT m = load_nat(bs);
+			MAKE_type_array(cv, s, m, t);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_bitfield_tag: {
+		/* Bitfield types */
+		t = load_itype(bs, cv, tag);
+		break;
+	}
+	case type_compound_tag: {
+		/* Class types */
+		CLASS_TYPE ct = NULL_ctype;
+		t = load_ctype(bs, def, &ct);
+		if (!IS_NULL_type(t)) {
+			if (cv)t = qualify_type(t, cv, 0);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_enumerate_tag: {
+		/* Enumeration types */
+		ENUM_TYPE et = NULL_etype;
+		t = load_etype(bs, def, &et);
+		if (!IS_NULL_type(t)) {
+			if (cv)t = qualify_type(t, cv, 0);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_token_tag: {
+		IDENTIFIER tok = load_use(bs, null_tag);
+		if (!IS_NULL_id(tok)) {
+			LIST(TOKEN)args = load_tok_list(bs, 1);
+			MAKE_type_token(cv, tok, args, t);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_templ_tag: {
+		TOKEN tok = load_tok(bs, 0);
+		if (!IS_NULL_tok(tok) && IS_tok_templ(tok)) {
+			TYPE s = load_type(bs, def);
+			if (!IS_NULL_type(s)) {
+				int fix = DE_BOOL(bs);
+				MAKE_type_templ(cv, tok, s, fix, t);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_instance_tag: {
+		IDENTIFIER tid = load_use(bs, null_tag);
+		if (!IS_NULL_id(tid)) {
+			IDENTIFIER id = load_use(bs, null_tag);
+			if (!IS_NULL_id(id)) {
+				DECL_SPEC acc = load_dspec(bs);
+				MAKE_type_instance(cv, id, acc, t);
+				COPY_id(type_name(t), tid);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case type_dummy_tag: {
+		int tok = (int)DE_INT(bs);
+		MAKE_type_dummy(cv, tok, t);
+		break;
+	}
-	case type_error_tag : {
+	case type_error_tag: {
-	    t = type_error ;
+		t = type_error;
-	    if ( cv ) t = qualify_type ( t, cv, 0 ) ;
+		if (cv)t = qualify_type(t, cv, 0);
-	    break ;
+		break;
+	}
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     READ A LIST OF TYPES
     This routine reads a list of types from the bitstream bs.
 */
-static LIST ( TYPE ) load_type_list
+static LIST(TYPE)
-    PROTO_N ( ( bs ) )
-    PROTO_T ( BITSTREAM *bs )
+load_type_list(BITSTREAM *bs)
+{
-    LIST ( TYPE ) p = NULL_list ( TYPE ) ;
+	LIST(TYPE)p = NULL_list(TYPE);
-    while ( DE_BOOL ( bs ) ) {
+	while (DE_BOOL(bs)) {
-	TYPE t = load_type ( bs, NULL_id ) ;
+		TYPE t = load_type(bs, NULL_id);
-	if ( spec_error ) break ;
+		if (spec_error) {
+			break;
+		}
-	CONS_type ( t, p, p ) ;
+		CONS_type(t, p, p);
-    }
+	}
-    p = REVERSE_list ( p ) ;
+	p = REVERSE_list(p);
-    return ( p ) ;
+	return (p);
+}
 /*
     READ A TOKEN
     This routine reads a token from the bitstream bs.  If def is true
     then the token value is also read.
 */
-static TOKEN load_tok
+static TOKEN
-    PROTO_N ( ( bs, def ) )
-    PROTO_T ( BITSTREAM *bs X int def )
+load_tok(BITSTREAM *bs, int def)
+{
-    unsigned tag ;
+	unsigned tag;
-    TOKEN tok = NULL_tok ;
+	TOKEN tok = NULL_tok;
-    unsigned n = DE_BITS ( bs, BITS_tok ) ;
+	unsigned n = DE_BITS(bs, BITS_tok);
-    if ( n == 0 ) {
+	if (n == 0) {
-	return ( tok ) ;
-    }
-    if ( n > ORDER_tok ) {
-	SPEC_ERROR () ;
-	return ( tok ) ;
+		return (tok);
-    }
-    ASSERT ( ORDER_tok == 10 ) ;
-    tag = n - 1 ;
-    switch ( tag ) {
-	case tok_exp_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		EXP e = NULL_exp ;
-		int c = DE_BOOL ( bs ) ;
-		if ( def ) e = load_exp ( bs, t ) ;
-		MAKE_tok_exp ( t, c, e, tok ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case tok_stmt_tag : {
-	    EXP e = NULL_exp ;
-	    if ( def ) e = load_exp ( bs, type_void ) ;
-	    MAKE_tok_stmt ( e, tok ) ;
-	    break ;
-	}
-	case tok_nat_tag :
-	case tok_snat_tag : {
-	    NAT m = NULL_nat ;
-	    if ( def ) m = load_nat ( bs ) ;
-	    MAKE_tok_nat_etc ( tag, m, tok ) ;
-	    break ;
-	}
-	case tok_type_tag : {
-	    BASE_TYPE kind = load_btype ( bs ) ;
-	    TYPE s = load_type ( bs, NULL_id ) ;
-	    TYPE t = NULL_type ;
-	    if ( def ) t = load_type ( bs, NULL_id ) ;
-	    MAKE_tok_type ( kind, t, tok ) ;
-	    COPY_type ( tok_type_alt ( tok ), s ) ;
-	    break ;
-	}
-	case tok_func_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) && IS_type_func ( t ) ) {
-		TOKEN proc = load_tok ( bs, 0 ) ;
-		IDENTIFIER id = NULL_id ;
-		if ( def ) id = load_use ( bs, null_tag ) ;
-		MAKE_tok_func ( t, tok ) ;
-		COPY_tok ( tok_func_proc ( tok ), proc ) ;
-		COPY_id ( tok_func_defn ( tok ), id ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case tok_member_tag : {
-	    TYPE s = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( s ) ) {
-		TYPE t = load_type ( bs, NULL_id ) ;
-		if ( !IS_NULL_type ( t ) ) {
-		    OFFSET off = NULL_off ;
-		    if ( def ) off = load_off ( bs ) ;
-		    MAKE_tok_member ( s, t, off, tok ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case tok_class_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		TYPE s = load_type ( bs, NULL_id ) ;
-		IDENTIFIER id = NULL_id ;
-		if ( def ) id = load_use ( bs, null_tag ) ;
-		MAKE_tok_class ( t, id, tok ) ;
-		COPY_type ( tok_class_alt ( tok ), s ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
+	}
+	if (n > ORDER_tok) {
+		SPEC_ERROR();
+		return (tok);
+	}
+	ASSERT(ORDER_tok == 10);
+	tag = n - 1;
+	switch (tag) {
+	case tok_exp_tag: {
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
+			EXP e = NULL_exp;
+			int c = DE_BOOL(bs);
+			if (def) {
+				e = load_exp(bs, t);
+			}
+			MAKE_tok_exp(t, c, e, tok);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case tok_stmt_tag: {
+		EXP e = NULL_exp;
+		if (def) {
+			e = load_exp(bs, type_void);
+		}
+		MAKE_tok_stmt(e, tok);
+		break;
+	}
+	case tok_nat_tag:
+	case tok_snat_tag: {
+		NAT m = NULL_nat;
+		if (def) {
+			m = load_nat(bs);
+		}
+		MAKE_tok_nat_etc(tag, m, tok);
+		break;
+	}
+	case tok_type_tag: {
+		BASE_TYPE kind = load_btype(bs);
+		TYPE s = load_type(bs, NULL_id);
+		TYPE t = NULL_type;
+		if (def) {
+			t = load_type(bs, NULL_id);
+		}
+		MAKE_tok_type(kind, t, tok);
+		COPY_type(tok_type_alt(tok), s);
+		break;
+	}
+	case tok_func_tag: {
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t) && IS_type_func(t)) {
+			TOKEN proc = load_tok(bs, 0);
+			IDENTIFIER id = NULL_id;
+			if (def) {
+				id = load_use(bs, null_tag);
+			}
+			MAKE_tok_func(t, tok);
+			COPY_tok(tok_func_proc(tok), proc);
+			COPY_id(tok_func_defn(tok), id);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case tok_member_tag: {
+		TYPE s = load_type(bs, NULL_id);
+		if (!IS_NULL_type(s)) {
+			TYPE t = load_type(bs, NULL_id);
+			if (!IS_NULL_type(t)) {
+				OFFSET off = NULL_off;
+				if (def) {
+					off = load_off(bs);
+				}
+				MAKE_tok_member(s, t, off, tok);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case tok_class_tag: {
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
+			TYPE s = load_type(bs, NULL_id);
+			IDENTIFIER id = NULL_id;
+			if (def) {
+				id = load_use(bs, null_tag);
+			}
+			MAKE_tok_class(t, id, tok);
+			COPY_type(tok_class_alt(tok), s);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
-	case tok_proc_tag : {
+	case tok_proc_tag: {
-	    TOKEN res ;
+		TOKEN res;
-	    NAMESPACE pns ;
+		NAMESPACE pns;
-	    int key = lex_identifier ;
+		int key = lex_identifier;
-	    LIST ( IDENTIFIER ) bids ;
+		LIST(IDENTIFIER)bids;
-	    LIST ( IDENTIFIER ) pids ;
+		LIST(IDENTIFIER)pids;
-	    begin_param ( NULL_id ) ;
+		begin_param(NULL_id);
-	    pns = crt_namespace ;
+		pns = crt_namespace;
-	    bids = load_param_list ( bs, pns, id_token_tag ) ;
+		bids = load_param_list(bs, pns, id_token_tag);
-	    if ( DE_BOOL ( bs ) ) {
+		if (DE_BOOL(bs)) {
-		pids = bids ;
+			pids = bids;
-	    } else {
+		} else {
-		pids = load_use_list ( bs ) ;
+			pids = load_use_list(bs);
-	    }
+		}
-	    end_param () ;
+		end_param();
-	    res = load_tok ( bs, def ) ;
+		res = load_tok(bs, def);
+		if (DE_BOOL(bs)) {
-	    if ( DE_BOOL ( bs ) ) key = load_lex ( bs ) ;
+			key = load_lex(bs);
+		}
-	    if ( !IS_NULL_tok ( res ) ) {
+		if (!IS_NULL_tok(res)) {
-		MAKE_tok_proc ( res, pns, key, tok ) ;
+			MAKE_tok_proc(res, pns, key, tok);
-		tok = cont_proc_token ( tok, bids, pids ) ;
+			tok = cont_proc_token(tok, bids, pids);
-	    } else {
+		} else {
-		SPEC_ERROR () ;
+			SPEC_ERROR();
+		}
+		break;
+	}
+	case tok_templ_tag: {
+		DECL_SPEC ex = load_dspec(bs);
+		if (DE_BOOL(bs)) {
+			NAMESPACE pns;
+			LIST(TOKEN)dargs;
+			LIST(IDENTIFIER)pids;
+			pns = make_namespace(NULL_id, nspace_templ_tag, 0);
+			pids = load_param_list(bs, pns, id_token_tag);
+			set_proc_token(pids);
+			dargs = load_tok_list(bs, 1);
+			MAKE_tok_templ(ex, pns, tok);
+			COPY_list(tok_templ_pids(tok), pids);
+			COPY_list(tok_templ_dargs(tok), dargs);
+		} else {
+			MAKE_tok_templ(ex, NULL_nspace, tok);
-	    }
+		}
-	    break ;
+		break;
+	}
-	case tok_templ_tag : {
-	    DECL_SPEC ex = load_dspec ( bs ) ;
-	    if ( DE_BOOL ( bs ) ) {
-		NAMESPACE pns ;
-		LIST ( TOKEN ) dargs ;
-		LIST ( IDENTIFIER ) pids ;
-		pns = make_namespace ( NULL_id, nspace_templ_tag, 0 ) ;
-		pids = load_param_list ( bs, pns, id_token_tag ) ;
-		set_proc_token ( pids ) ;
-		dargs = load_tok_list ( bs, 1 ) ;
-		MAKE_tok_templ ( ex, pns, tok ) ;
-		COPY_list ( tok_templ_pids ( tok ), pids ) ;
-		COPY_list ( tok_templ_dargs ( tok ), dargs ) ;
-	    } else {
-		MAKE_tok_templ ( ex, NULL_nspace, tok ) ;
-	    }
-	    break ;
+	}
-    }
-    return ( tok ) ;
+	return (tok);
+}
 /*
     READ AN IDENTIFIER
     This routine reads a member of the namespace ns from the bitstream bs.
 */
-static IDENTIFIER load_id
+static IDENTIFIER
-    PROTO_N ( ( bs, ns ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns )
+load_id(BITSTREAM *bs, NAMESPACE ns)
-{
-    ulong d ;
-    HASHID nm ;
-    unsigned n ;
-    unsigned tag ;
-    DECL_SPEC ds ;
-    IDENTIFIER qid ;
-    IDENTIFIER *pid ;
-    IDENTIFIER id = NULL_id ;
-    IDENTIFIER lid = NULL_id ;
-    /* Read identifier number */
-    d = DE_INT ( bs ) ;
-    if ( d == 0 ) {
-	/* Null identifiers */
-	return ( id ) ;
-    }
-    /* Read identifier tag */
-    n = DE_BITS ( bs, BITS_id ) ;
-    if ( n == 0 ) {
-	/* Null identifiers */
-	return ( id ) ;
-    }
-    if ( n > ORDER_id ) {
-	SPEC_ERROR () ;
-	return ( id ) ;
-    }
-    /* Check previous look-up */
-    pid = id_lookup ( d ) ;
-    qid = *pid ;
-    if ( !IS_NULL_id ( qid ) ) {
-	if ( !IS_id_pending ( qid ) ) {
-	    SPEC_ERROR () ;
-	    qid = NULL_id ;
-	}
-    }
-    /* Read identifier independent information */
-    nm = load_hashid ( bs, ns ) ;
-    if ( IS_NULL_hashid ( nm ) ) {
-	SPEC_ERROR () ;
-	return ( id ) ;
-    }
-    tag = n - 1 ;
-    ds = load_dspec ( bs ) ;
-    load_loc ( bs ) ;
-    if ( DE_BOOL ( bs ) ) {
-	/* Read alias */
-	lid = load_use ( bs, tag ) ;
-    }
-    /* Read identifier dependent information */
-    ASSERT ( ORDER_id == 28 ) ;
-    switch ( tag ) {
-	case id_dummy_tag : {
-	    id = DEREF_id ( hashid_id ( nm ) ) ;
-	    id = underlying_id ( id ) ;
-	    break ;
-	}
-	case id_keyword_tag :
-	case id_iso_keyword_tag :
-	case id_reserved_tag : {
-	    int key = load_lex ( bs ) ;
-	    id = make_keyword ( nm, key, NULL_id ) ;
-	    break ;
-	}
-	case id_builtin_tag : {
-	    TYPE r = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( r ) ) {
-		LIST ( TYPE ) p = load_type_list ( bs ) ;
-		MAKE_id_builtin ( nm, ds, ns, crt_loc, r, p, id ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_obj_macro_tag : {
-	    PPTOKEN *def = load_pptoks ( bs ) ;
-	    MAKE_id_obj_macro ( nm, ds, ns, crt_loc, def, id ) ;
-	    break ;
-	}
-	case id_func_macro_tag : {
-	    PPTOKEN *def = load_pptoks ( bs ) ;
-	    LIST ( HASHID ) pars = load_hashid_list ( bs, NULL_nspace ) ;
-	    unsigned npars = LENGTH_list ( pars ) ;
-	    MAKE_id_func_macro ( nm, ds, ns, crt_loc, def, pars, npars, id ) ;
-	    break ;
-	}
-	case id_predicate_tag : {
-	    /* NOT YET IMPLEMENTED */
-	    MAKE_id_undef ( nm, ds, ns, crt_loc, id ) ;
-	    break ;
-	}
-	case id_class_name_tag : {
-	    /* Class names */
-	    TYPE t = type_error ;
-	    MAKE_id_class_name ( nm, ds, ns, crt_loc, t, id ) ;
-	    if ( ds & dspec_implicit ) {
-		if ( !IS_NULL_id ( lid ) && IS_id_class_name ( lid ) ) {
-		    t = DEREF_type ( id_class_name_defn ( lid ) ) ;
-		}
-	    } else {
-		*pid = id ;
-		t = load_type ( bs, id ) ;
-	    }
-	    if ( type_tag ( t ) == type_compound_tag ) {
-		COPY_type ( id_class_name_defn ( id ), t ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_enum_name_tag : {
-	    /* Enumeration names */
-	    TYPE t = type_error ;
-	    MAKE_id_enum_name ( nm, ds, ns, crt_loc, t, id ) ;
-	    t = load_type ( bs, id ) ;
-	    if ( type_tag ( t ) == type_enumerate_tag ) {
-		COPY_type ( id_enum_name_defn ( id ), t ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_class_alias_tag :
-	case id_enum_alias_tag :
-	case id_type_alias_tag : {
-	    /* Type aliases */
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		id = make_typedef ( ns, nm, t, ds ) ;
-		if ( TAG_id ( id ) != tag ) SPEC_ERROR () ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_nspace_name_tag : {
-	    /* Namespace names */
-	    NAMESPACE pns = NULL_nspace ;
-	    unsigned ntag = nspace_named_tag ;
-	    if ( IS_hashid_anon ( nm ) ) ntag = nspace_unnamed_tag ;
-	    MAKE_id_nspace_name ( nm, ds, ns, crt_loc, pns, id ) ;
-	    pns = make_namespace ( id, ntag, 50 ) ;
-	    COPY_nspace ( id_nspace_name_defn ( id ), pns ) ;
-	    break ;
-	}
-	case id_nspace_alias_tag : {
-	    /* Namespace aliases */
-	    IDENTIFIER nid = load_use ( bs, id_nspace_name_tag ) ;
-	    if ( !IS_NULL_id ( nid ) ) {
-		NAMESPACE pns = find_namespace ( nid ) ;
-		if ( !IS_NULL_nspace ( pns ) ) {
-		    MAKE_id_nspace_alias ( nm, ds, ns, crt_loc, pns, id ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_variable_tag :
-	case id_parameter_tag :
-	case id_stat_member_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		MAKE_id_variable_etc ( tag, nm, ds, ns, crt_loc, t, id ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_function_tag :
-	case id_mem_func_tag :
-	case id_stat_mem_func_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		MAKE_id_function_etc ( tag, nm, ds, ns, crt_loc, t,
-				       NULL_id, id ) ;
-		*pid = id ;
-		if ( DE_BOOL ( bs ) ) {
-		    /* Read function template form */
-		    TYPE form = load_type ( bs, NULL_id ) ;
-		    COPY_type ( id_function_etc_form ( id ), form ) ;
-		}
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_member_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		MAKE_id_member ( nm, ds, ns, crt_loc, t, id ) ;
-		break ;
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_enumerator_tag : {
-	    TYPE t = load_type ( bs, NULL_id ) ;
-	    if ( !IS_NULL_type ( t ) ) {
-		EXP e = load_exp ( bs, t ) ;
-		if ( !IS_NULL_exp ( e ) ) {
-		    MAKE_id_enumerator ( nm, ds, ns, crt_loc, t, e, id ) ;
-		    break ;
-		}
-	    }
-	    SPEC_ERROR () ;
-	    break ;
-	}
-	case id_label_tag :
-	case id_weak_param_tag : {
-	    /* NOT YET IMPLEMENTED */
-	    MAKE_id_undef ( nm, ds, ns, crt_loc, id ) ;
-	    break ;
-	}
-	case id_token_tag : {
-	    TOKEN tok = load_tok ( bs, 0 ) ;
-	    if ( !IS_NULL_tok ( tok ) ) {
-		MAKE_id_token ( nm, ds, ns, crt_loc, tok, NULL_id, id ) ;
-		COPY_id ( id_token_alt ( id ), id ) ;
-		break ;
-	    }
-	    break ;
-	}
-	case id_ambig_tag : {
-	    LIST ( IDENTIFIER ) ids = load_use_list ( bs ) ;
-	    int over = DE_BOOL ( bs ) ;
-	    MAKE_id_ambig ( nm, ds, ns, crt_loc, ids, over, id ) ;
-	    break ;
-	}
-	case id_undef_tag : {
-	    MAKE_id_undef ( nm, ds, ns, crt_loc, id ) ;
-	    if ( DE_BOOL ( bs ) ) {
-		TYPE form = load_type ( bs, NULL_id ) ;
-		COPY_type ( id_undef_form ( id ), form ) ;
-	    }
-	    break ;
-	}
-	case id_pending_tag : {
-	    /* This shouldn't happen */
-	    SPEC_ERROR () ;
-	    break ;
-	}
-    }
-    /* Set identifier look up */
-    if ( !IS_NULL_id ( id ) ) {
-	if ( !IS_NULL_id ( lid ) ) {
-	    COPY_id ( id_alias ( id ), lid ) ;
-	}
-	if ( !IS_NULL_id ( qid ) ) {
-	    COPY_id ( id_alias ( qid ), id ) ;
-	    ids_pending-- ;
-	}
-	*pid = id ;
-    }
-    return ( id ) ;
-}
-/*
-    READ NAMESPACE MEMBERS
-    This routine reads the members of a class or namespace and the instances
-    of a template class or template function.
-*/
-static void load_members
-    PROTO_N ( ( bs, id ) )
-    PROTO_T ( BITSTREAM *bs X IDENTIFIER id )
+{
+	ulong d;
+	HASHID nm;
+	unsigned n;
+	unsigned tag;
+	DECL_SPEC ds;
+	IDENTIFIER qid;
+	IDENTIFIER *pid;
+	IDENTIFIER id = NULL_id;
+	IDENTIFIER lid = NULL_id;
+	/* Read identifier number */
+	d = DE_INT(bs);
+	if (d == 0) {
+		/* Null identifiers */
+		return (id);
+	}
+	/* Read identifier tag */
+	n = DE_BITS(bs, BITS_id);
+	if (n == 0) {
+		/* Null identifiers */
+		return (id);
+	}
+	if (n > ORDER_id) {
+		SPEC_ERROR();
+		return (id);
+	}
+	/* Check previous look-up */
+	pid = id_lookup(d);
+	qid = *pid;
-    switch ( TAG_id ( id ) ) {
+	if (!IS_NULL_id(qid)) {
+		if (!IS_id_pending(qid)) {
+			SPEC_ERROR();
+			qid = NULL_id;
+		}
+	}
+	/* Read identifier independent information */
+	nm = load_hashid(bs, ns);
+	if (IS_NULL_hashid(nm)) {
+		SPEC_ERROR();
+		return (id);
+	}
+	tag = n - 1;
+	ds = load_dspec(bs);
+	load_loc(bs);
+	if (DE_BOOL(bs)) {
+		/* Read alias */
+		lid = load_use(bs, tag);
+	}
+	/* Read identifier dependent information */
+	ASSERT(ORDER_id == 28);
+	switch (tag) {
+	case id_dummy_tag: {
+		id = DEREF_id(hashid_id(nm));
+		id = underlying_id(id);
+		break;
+	}
+	case id_keyword_tag:
+	case id_iso_keyword_tag:
+	case id_reserved_tag: {
+		int key = load_lex(bs);
+		id = make_keyword(nm, key, NULL_id);
+		break;
+	}
+	case id_builtin_tag: {
+		TYPE r = load_type(bs, NULL_id);
+		if (!IS_NULL_type(r)) {
+			LIST(TYPE)p = load_type_list(bs);
+			MAKE_id_builtin(nm, ds, ns, crt_loc, r, p, id);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_obj_macro_tag: {
+		PPTOKEN *def = load_pptoks(bs);
+		MAKE_id_obj_macro(nm, ds, ns, crt_loc, def, id);
+		break;
+	}
+	case id_func_macro_tag: {
+		PPTOKEN *def = load_pptoks(bs);
+		LIST(HASHID)pars = load_hashid_list(bs, NULL_nspace);
+		unsigned npars = LENGTH_list(pars);
+		MAKE_id_func_macro(nm, ds, ns, crt_loc, def, pars, npars, id);
+		break;
+	}
+	case id_predicate_tag: {
+		/* NOT YET IMPLEMENTED */
+		MAKE_id_undef(nm, ds, ns, crt_loc, id);
+		break;
+	}
-	case id_class_name_tag : {
+	case id_class_name_tag: {
-	    /* Read class members */
+		/* Class names */
+		TYPE t = type_error;
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+		MAKE_id_class_name(nm, ds, ns, crt_loc, t, id);
-	    if ( !( ds & dspec_implicit ) ) {
+		if (ds & dspec_implicit) {
+			if (!IS_NULL_id(lid) && IS_id_class_name(lid)) {
+				t = DEREF_type(id_class_name_defn(lid));
+			}
+		} else {
-		int templ = 0 ;
+			*pid = id;
+			t = load_type(bs, id);
+		}
+		if (type_tag(t) == type_compound_tag) {
-		TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
+			COPY_type(id_class_name_defn(id), t);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_enum_name_tag: {
+		/* Enumeration names */
+		TYPE t = type_error;
+		MAKE_id_enum_name(nm, ds, ns, crt_loc, t, id);
+		t = load_type(bs, id);
+		if (type_tag(t) == type_enumerate_tag) {
+			COPY_type(id_enum_name_defn(id), t);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_class_alias_tag:
+	case id_enum_alias_tag:
-		while ( IS_type_templ ( t ) ) {
+	case id_type_alias_tag: {
-		    templ = 1 ;
+		/* Type aliases */
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
-		    t = DEREF_type ( type_templ_defn ( t ) ) ;
+			id = make_typedef(ns, nm, t, ds);
+			if (TAG_id(id) != tag) {
+				SPEC_ERROR();
+			}
+			break;
 		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_nspace_name_tag: {
+		/* Namespace names */
+		NAMESPACE pns = NULL_nspace;
+		unsigned ntag = nspace_named_tag;
-		if ( IS_type_compound ( t ) ) {
+		if (IS_hashid_anon(nm)) {
+			ntag = nspace_unnamed_tag;
+		}
+		MAKE_id_nspace_name(nm, ds, ns, crt_loc, pns, id);
+		pns = make_namespace(id, ntag, 50);
+		COPY_nspace(id_nspace_name_defn(id), pns);
+		break;
+	}
+	case id_nspace_alias_tag: {
+		/* Namespace aliases */
-		    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		IDENTIFIER nid = load_use(bs, id_nspace_name_tag);
+		if (!IS_NULL_id(nid)) {
-		    NAMESPACE cns = DEREF_nspace ( ctype_member ( ct ) ) ;
+			NAMESPACE pns = find_namespace(nid);
+			if (!IS_NULL_nspace(pns)) {
+				MAKE_id_nspace_alias(nm, ds, ns, crt_loc, pns,
+						     id);
+				break;
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_variable_tag:
+	case id_parameter_tag:
+	case id_stat_member_tag: {
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
+			MAKE_id_variable_etc(tag, nm, ds, ns, crt_loc, t, id);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_function_tag:
+	case id_mem_func_tag:
+	case id_stat_mem_func_tag: {
-		    load_nspace ( bs, cns, 0 ) ;
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
+			MAKE_id_function_etc(tag, nm, ds, ns, crt_loc, t,
+					     NULL_id, id);
+			*pid = id;
-		    if ( templ ) {
+			if (DE_BOOL(bs)) {
-			/* Read template class instances */
+				/* Read function template form */
+				TYPE form = load_type(bs, NULL_id);
+				COPY_type(id_function_etc_form(id), form);
+			}
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_member_tag: {
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
-			NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+			MAKE_id_member(nm, ds, ns, crt_loc, t, id);
+			break;
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_enumerator_tag: {
-			load_nspace ( bs, ns, 1 ) ;
+		TYPE t = load_type(bs, NULL_id);
+		if (!IS_NULL_type(t)) {
+			EXP e = load_exp(bs, t);
+			if (!IS_NULL_exp(e)) {
+				MAKE_id_enumerator(nm, ds, ns, crt_loc, t, e,
+						   id);
+				break;
-		    }
+			}
+		}
+		SPEC_ERROR();
+		break;
+	}
+	case id_label_tag:
+	case id_weak_param_tag: {
+		/* NOT YET IMPLEMENTED */
+		MAKE_id_undef(nm, ds, ns, crt_loc, id);
+		break;
+	}
+	case id_token_tag: {
+		TOKEN tok = load_tok(bs, 0);
+		if (!IS_NULL_tok(tok)) {
+			MAKE_id_token(nm, ds, ns, crt_loc, tok, NULL_id, id);
+			COPY_id(id_token_alt(id), id);
+			break;
+		}
+		break;
+	}
+	case id_ambig_tag: {
+		LIST(IDENTIFIER)ids = load_use_list(bs);
+		int over = DE_BOOL(bs);
+		MAKE_id_ambig(nm, ds, ns, crt_loc, ids, over, id);
+		break;
+	}
+	case id_undef_tag: {
+		MAKE_id_undef(nm, ds, ns, crt_loc, id);
+		if (DE_BOOL(bs)) {
+			TYPE form = load_type(bs, NULL_id);
+			COPY_type(id_undef_form(id), form);
+		}
+		break;
+	}
+	case id_pending_tag: {
+		/* This shouldn't happen */
+		SPEC_ERROR();
+		break;
+	}
+	}
+	/* Set identifier look up */
+	if (!IS_NULL_id(id)) {
+		if (!IS_NULL_id(lid)) {
+			COPY_id(id_alias(id), lid);
+		}
+		if (!IS_NULL_id(qid)) {
+			COPY_id(id_alias(qid), id);
+			ids_pending--;
+		}
+		*pid = id;
+	}
+	return (id);
+}
+/*
+    READ NAMESPACE MEMBERS
+    This routine reads the members of a class or namespace and the instances
+    of a template class or template function.
+*/
+static void
+load_members(BITSTREAM *bs, IDENTIFIER id)
+{
+	switch (TAG_id(id)) {
+	case id_class_name_tag: {
+		/* Read class members */
+		DECL_SPEC ds = DEREF_dspec(id_storage(id));
+		if (!(ds & dspec_implicit)) {
+			int templ = 0;
+			TYPE t = DEREF_type(id_class_name_defn(id));
+			while (IS_type_templ(t)) {
+				templ = 1;
+				t = DEREF_type(type_templ_defn(t));
+			}
+			if (IS_type_compound(t)) {
+				CLASS_TYPE ct =
+				    DEREF_ctype(type_compound_defn(t));
+				NAMESPACE cns = DEREF_nspace(ctype_member(ct));
+				load_nspace(bs, cns, 0);
+				if (templ) {
+					/* Read template class instances */
+					NAMESPACE ns =
+					    DEREF_nspace(id_parent(id));
+					load_nspace(bs, ns, 1);
-	    }
+				}
+			}
+		}
+		break;
+	}
+	case id_nspace_name_tag: {
+		/* Read namespace members */
+		NAMESPACE cns = DEREF_nspace(id_nspace_name_defn(id));
+		load_nspace(bs, cns, 0);
+		break;
+	}
+	case id_function_tag:
+	case id_mem_func_tag:
+	case id_stat_mem_func_tag: {
+		TYPE t = DEREF_type(id_function_etc_type(id));
+		if (IS_type_templ(t)) {
+			/* Read template function instances */
+			NAMESPACE ns = DEREF_nspace(id_parent(id));
+			load_nspace(bs, ns, 1);
+		}
-	    break ;
+		break;
+	}
-	case id_nspace_name_tag : {
-	    /* Read namespace members */
-	    NAMESPACE cns = DEREF_nspace ( id_nspace_name_defn ( id ) ) ;
-	    load_nspace ( bs, cns, 0 ) ;
-	    break ;
-	}
-	case id_function_tag :
-	case id_mem_func_tag :
-	case id_stat_mem_func_tag : {
-	    TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
-	    if ( IS_type_templ ( t ) ) {
-		/* Read template function instances */
-		NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
-		load_nspace ( bs, ns, 1 ) ;
-	    }
-	    break ;
+	}
-    }
-    return ;
+	return;
+}
 /*
     READ A LIST OF NAMESPACE MEMBERS
     This routine reads the members of the namespace ns from the bitstream
     bs.  The list is terminated by a null identifier.  The routine is
     also used with inst true to read a list of template instances.
 */
-static void load_nspace
+static void
-    PROTO_N ( ( bs, ns, inst ) )
-    PROTO_T ( BITSTREAM *bs X NAMESPACE ns X int inst )
+load_nspace(BITSTREAM *bs, NAMESPACE ns, int inst)
 {
-    int v = verbose ;
+	int v = verbose;
-    for ( ; ; ) {
+	for (;;) {
-	/* Read identifier */
+		/* Read identifier */
-	IDENTIFIER id = load_id ( bs, ns ) ;
+		IDENTIFIER id = load_id(bs, ns);
-	if ( IS_NULL_id ( id ) || spec_error ) break ;
+		if (IS_NULL_id(id) || spec_error) {
+			break;
+		}
+		if (v) {
-	if ( v ) commentary ( id ) ;
+			commentary(id);
+		}
-	/* Set namespace member */
+		/* Set namespace member */
-	if ( !IS_NULL_nspace ( ns ) && !inst ) {
+		if (!IS_NULL_nspace(ns) && !inst) {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( ( ds & dspec_extern ) || IS_nspace_block_etc ( ns ) ) {
+			if ((ds & dspec_extern) || IS_nspace_block_etc(ns)) {
-		/* External linkage */
+				/* External linkage */
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+				HASHID nm = DEREF_hashid(id_name(id));
-		MEMBER mem = search_member ( ns, nm, 1 ) ;
+				MEMBER mem = search_member(ns, nm, 1);
-		IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
+				IDENTIFIER pid = DEREF_id(member_id(mem));
-		if ( is_tagged_type ( id ) ) {
+				if (is_tagged_type(id)) {
-		    /* Type members */
+					/* Type members */
-		    COPY_id ( member_alt ( mem ), id ) ;
+					COPY_id(member_alt(mem), id);
-		    if ( IS_NULL_id ( pid ) ) {
+					if (IS_NULL_id(pid)) {
-			COPY_id ( member_id ( mem ), id ) ;
+						COPY_id(member_id(mem), id);
-		    }
+					}
-		} else {
+				} else {
-		    /* Non-type members */
+					/* Non-type members */
+					if (!IS_NULL_id(pid) &&
-		    if ( !IS_NULL_id ( pid ) && IS_id_function_etc ( pid ) ) {
+					    IS_id_function_etc(pid)) {
-			if ( IS_id_function_etc ( id ) ) {
+						if (IS_id_function_etc(id)) {
-			    /* Allow for overloaded functions */
+							/* Allow for overloaded
+							 * functions */
-			    COPY_id ( id_function_etc_over ( id ), pid ) ;
+							COPY_id(id_function_etc_over(id), pid);
-			}
+						}
-		    }
+					}
-		    COPY_id ( member_id ( mem ), id ) ;
+					COPY_id(member_id(mem), id);
-		}
+				}
-	    } else {
+			} else {
-		/* Internal linkage */
+				/* Internal linkage */
-		LIST ( IDENTIFIER ) ids ;
+				LIST(IDENTIFIER)ids;
-		ids = DEREF_list ( nspace_named_etc_extra ( ns ) ) ;
+				ids = DEREF_list(nspace_named_etc_extra(ns));
-		CONS_id ( id, ids, ids ) ;
+				CONS_id(id, ids, ids);
-		COPY_list ( nspace_named_etc_extra ( ns ), ids ) ;
+				COPY_list(nspace_named_etc_extra(ns), ids);
-	    }
+			}
-	}
+		}
-	/* Check for classes, namespaces and templates */
+		/* Check for classes, namespaces and templates */
-	load_members ( bs, id ) ;
+		load_members(bs, id);
-    }
+	}
-    return ;
+	return;
+}
 /*
     READ A SPEC FILE
     This routine reads a spec file from the input file.  It returns zero
     for a legal spec file.  The identifiers are initially read into a
     dummy namespace which is then merged with the existing namespace.
 */
-int read_spec
+int
-    PROTO_Z ()
+read_spec(void)
+{
-    /* Read file identifier */
+	/* Read file identifier */
-    int e = 0 ;
+	int e = 0;
-    char buff [20] ;
+	char buff[20];
-    CONST char *msg = NULL ;
+	CONST char *msg = NULL;
-    NAMESPACE gns = NULL_nspace ;
+	NAMESPACE gns = NULL_nspace;
-    BITSTREAM *bs = start_bitstream ( input_file, NULL_gen_ptr ) ;
+	BITSTREAM *bs = start_bitstream(input_file, NULL_gen_ptr);
-    unsigned c1 = DE_BITS ( bs, BYTE_SIZE ) ;
+	unsigned c1 = DE_BITS(bs, BYTE_SIZE);
-    unsigned c2 = DE_BITS ( bs, BYTE_SIZE ) ;
+	unsigned c2 = DE_BITS(bs, BYTE_SIZE);
-    unsigned c3 = DE_BITS ( bs, BYTE_SIZE ) ;
+	unsigned c3 = DE_BITS(bs, BYTE_SIZE);
-    unsigned c4 = DE_BITS ( bs, BYTE_SIZE ) ;
+	unsigned c4 = DE_BITS(bs, BYTE_SIZE);
-    if ( c1 == ascii_T && c2 == ascii_D && c3 == ascii_F && c4 == ascii_K ) {
+	if (c1 == ascii_T && c2 == ascii_D && c3 == ascii_F && c4 == ascii_K) {
-	unsigned long n1 = DE_INT ( bs ) ;
+		unsigned long n1 = DE_INT(bs);
-	unsigned long n2 = DE_INT ( bs ) ;
+		unsigned long n2 = DE_INT(bs);
-	unsigned long n3 = DE_INT ( bs ) ;
+		unsigned long n3 = DE_INT(bs);
-	DE_ALIGN ( bs ) ;
+		DE_ALIGN(bs);
-	if ( n1 == SPEC_major && n2 <= SPEC_minor ) {
+		if (n1 == SPEC_major && n2 <= SPEC_minor) {
-	    /* Read main file body */
+			/* Read main file body */
-	    if ( n3 > LANGUAGE_CPP ) {
+			if (n3 > LANGUAGE_CPP) {
-		msg = "bad source language" ;
+				msg = "bad source language";
-		e = 1 ;
+				e = 1;
-	    }
+			}
-	    if ( e == 0 ) {
+			if (e == 0) {
-		int d = do_dump ;
+				int d = do_dump;
-		do_dump = 0 ;
+				do_dump = 0;
-		spec_error = 0 ;
+				spec_error = 0;
-		gns = make_global_nspace ( "<global>", 50 ) ;
+				gns = make_global_nspace("<global>", 50);
-		load_nspace ( bs, gns, 0 ) ;
+				load_nspace(bs, gns, 0);
-		if ( ids_pending ) SPEC_ERROR () ;
+				if (ids_pending) {
+					SPEC_ERROR();
+				}
-		crt_class = NULL_ctype ;
+				crt_class = NULL_ctype;
-		e = spec_error ;
+				e = spec_error;
-		if ( e == 0 ) {
+				if (e == 0) {
-		    DE_ALIGN ( bs ) ;
+					DE_ALIGN(bs);
-		    if ( !de_eof ( bs ) ) {
+					if (!de_eof(bs)) {
-			msg = "end of file expected" ;
+						msg = "end of file expected";
-			e = 1 ;
+						e = 1;
-		    }
+					}
+				} else {
+					sprintf_v(buff, "code %d", e);
+					msg = buff;
+				}
+				do_dump = d;
+			}
 		} else {
-		    sprintf_v ( buff, "code %d", e ) ;
+			msg = "bad version number";
-		    msg = buff ;
+			e = 1;
+		}
-		do_dump = d ;
-	    }
 	} else {
-	    msg = "bad version number" ;
+		msg = "bad magic number";
-	    e = 1 ;
+		e = 1;
 	}
-    } else {
-	msg = "bad magic number" ;
-	e = 1 ;
-    }
-    /* Check for errors */
-    if ( msg ) fail ( ERR_fail_spec_bad ( input_name, ustrlit ( msg ) ) ) ;
-    if ( !output_spec ) e = 1 ;
-    xfree_nof ( id_table ) ;
-    id_table_size = 0 ;
-    id_table = NULL ;
-    spec_error = 0 ;
+	/* Check for errors */
+	if (msg) {
+		fail(ERR_fail_spec_bad(input_name, ustrlit(msg)));
+	}
+	if (!output_spec) {
+		e = 1;
+	}
+	xfree_nof(id_table);
+	id_table_size = 0;
+	id_table = NULL;
+	spec_error = 0;
-    /* Merge read identifiers */
+	/* Merge read identifiers */
-    if ( !IS_NULL_nspace ( gns ) ) {
+	if (!IS_NULL_nspace(gns)) {
-	merge_namespaces ( global_namespace, gns ) ;
+		merge_namespaces(global_namespace, gns);
-    }
+	}
-    return ( e ) ;
+	return (e);
+}

Subversion Repositories tendra.SVN

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