WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/construct/basetype.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 "preproc.h"
 #include "redeclare.h"
 #include "syntax.h"
 #include "template.h"
 #include "token.h"
 /*
     CREATE A QUALIFIED TYPE
     This routine creates a type consisting of t qualified by the const-
     volatile qualifiers cv.  Note that the existing qualifiers for t are
     not taken into account in the result.  If t already has qualifier cv
     and force is false then t itself is returned, otherwise a copy of t
     with the appropriate qualifier is constructed.
+}
 /*
     COPY A TYPEDEF TYPE
 		const array var ;
     the type of var is 'const int [3]'.  Also any qualifiers applied to
     reference and function types are ignored.
 */
-TYPE copy_typedef
+TYPE
-    PROTO_N ( ( id, t, cv ) )
-    PROTO_T ( IDENTIFIER id X TYPE t X CV_SPEC cv )
+copy_typedef(IDENTIFIER id, TYPE t, CV_SPEC cv)
+{
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    CV_SPEC qual_new = ( qual | cv ) ;
+	CV_SPEC qual_new = (qual | cv);
-    CV_SPEC qual_join = ( qual & cv ) ;
+	CV_SPEC qual_join = (qual & cv);
-    if ( qual_join && !IS_NULL_id ( id ) ) {
+	if (qual_join && !IS_NULL_id(id)) {
-	/* Warn about duplicate qualifiers */
+		/* Warn about duplicate qualifiers */
-	report ( crt_loc, ERR_dcl_type_type_cv ( id, qual_join ) ) ;
+		report(crt_loc, ERR_dcl_type_type_cv(id, qual_join));
-    }
+	}
-    /* Check types */
+	/* Check types */
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_ptr_tag : {
+	case type_ptr_tag: {
-	    /* Copy pointer types */
+		/* Copy pointer types */
-	    TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_sub(t));
-	    TYPE r = copy_typedef ( id, s, cv_none ) ;
+		TYPE r = copy_typedef(id, s, cv_none);
-	    if ( !EQ_type ( r, s ) || qual_new != qual ) {
+		if (!EQ_type(r, s) || qual_new != qual) {
-		IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
+			IDENTIFIER tid = DEREF_id(type_name(t));
-		MAKE_type_ptr ( qual_new, r, t ) ;
+			MAKE_type_ptr(qual_new, r, t);
-		COPY_id ( type_name ( t ), tid ) ;
+			COPY_id(type_name(t), tid);
-	    }
-	    break ;
-	}
+		}
-	case type_ref_tag : {
-	    /* Ignore qualifiers for references */
-	    TYPE s, r ;
-	    if ( cv && !IS_NULL_id ( id ) ) {
-		report ( crt_loc, ERR_dcl_ref_cv_type ( cv, id ) ) ;
-	    }
-	    s = DEREF_type ( type_ref_sub ( t ) ) ;
-	    r = copy_typedef ( id, s, cv_none ) ;
-	    if ( !EQ_type ( r, s ) ) {
-		IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
-		MAKE_type_ref ( qual, r, t ) ;
-		COPY_id ( type_name ( t ), tid ) ;
-	    }
-	    break ;
+		break;
+	}
+	case type_ref_tag: {
+		/* Ignore qualifiers for references */
+		TYPE s, r;
+		if (cv && !IS_NULL_id(id)) {
+			report(crt_loc, ERR_dcl_ref_cv_type(cv, id));
+		}
+		s = DEREF_type(type_ref_sub(t));
+		r = copy_typedef(id, s, cv_none);
+		if (!EQ_type(r, s)) {
+			IDENTIFIER tid = DEREF_id(type_name(t));
+			MAKE_type_ref(qual, r, t);
+			COPY_id(type_name(t), tid);
+		}
+		break;
+	}
 #if LANGUAGE_CPP
-	case type_ptr_mem_tag : {
+	case type_ptr_mem_tag: {
-	    /* Copy pointer member types */
+		/* Copy pointer member types */
-	    TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_ptr_mem_sub(t));
-	    TYPE r = copy_typedef ( id, s, cv_none ) ;
+		TYPE r = copy_typedef(id, s, cv_none);
-	    if ( !EQ_type ( r, s ) || qual_new != qual ) {
+		if (!EQ_type(r, s) || qual_new != qual) {
-		IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
+			IDENTIFIER tid = DEREF_id(type_name(t));
-		CLASS_TYPE of = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+			CLASS_TYPE of = DEREF_ctype(type_ptr_mem_of(t));
-		MAKE_type_ptr_mem ( qual_new, of, r, t ) ;
+			MAKE_type_ptr_mem(qual_new, of, r, t);
-		COPY_id ( type_name ( t ), tid ) ;
+			COPY_id(type_name(t), tid);
-	    }
+		}
-	    break ;
+		break;
+	}
 #endif
+	case type_func_tag: {
+		/* Ignore qualifiers for functions */
+		int ell;
+		TYPE ret;
+		CV_SPEC mqual;
+		IDENTIFIER tid;
+		NAMESPACE pars;
+		LIST(TYPE)except;
+		LIST(TYPE)ptypes;
+		LIST(TYPE)mtypes;
+		LIST(IDENTIFIER)pids;
+		LIST(TYPE)mtypes_new;
+		LIST(TYPE)ptypes_new = NULL_list(TYPE);
+		LIST(IDENTIFIER)pids_new = NULL_list(IDENTIFIER);
-	case type_func_tag : {
-	    /* Ignore qualifiers for functions */
-	    int ell ;
-	    TYPE ret ;
-	    CV_SPEC mqual ;
-	    IDENTIFIER tid ;
-	    NAMESPACE pars ;
-	    LIST ( TYPE ) except ;
-	    LIST ( TYPE ) ptypes ;
-	    LIST ( TYPE ) mtypes ;
-	    LIST ( IDENTIFIER ) pids ;
-	    LIST ( TYPE ) mtypes_new ;
-	    LIST ( TYPE ) ptypes_new = NULL_list ( TYPE ) ;
-	    LIST ( IDENTIFIER ) pids_new = NULL_list ( IDENTIFIER ) ;
-	    /* Warn about qualifiers */
+		/* Warn about qualifiers */
-	    if ( cv && !IS_NULL_id ( id ) ) {
+		if (cv && !IS_NULL_id(id)) {
-		report ( crt_loc, ERR_dcl_fct_qual ( cv, id ) ) ;
+			report(crt_loc, ERR_dcl_fct_qual(cv, id));
-	    }
+		}
-	    /* Decompose old function type */
+		/* Decompose old function type */
-	    DECONS_type_func ( qual, tid, ret, ptypes, ell, mqual,
+		DECONS_type_func(qual, tid, ret, ptypes, ell, mqual,
-			       mtypes, pars, pids, except, t ) ;
+				 mtypes, pars, pids, except, t);
-	    /* Copy appropriate components */
+		/* Copy appropriate components */
-	    ret = copy_typedef ( id, ret, cv_none ) ;
+		ret = copy_typedef(id, ret, cv_none);
-	    while ( !IS_NULL_list ( pids ) ) {
+		while (!IS_NULL_list(pids)) {
-		/* Redeclare each parameter */
+			/* Redeclare each parameter */
-		TYPE s ;
+			TYPE s;
-		IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
+			IDENTIFIER pid = DEREF_id(HEAD_list(pids));
-		pid = copy_id ( pid, 1 ) ;
+			pid = copy_id(pid, 1);
-		CONS_id ( pid, pids_new, pids_new ) ;
+			CONS_id(pid, pids_new, pids_new);
-		s = DEREF_type ( id_parameter_type ( pid ) ) ;
+			s = DEREF_type(id_parameter_type(pid));
-		s = qualify_type ( s, cv_none, 0 ) ;
+			s = qualify_type(s, cv_none, 0);
-		CONS_type ( s, ptypes_new, ptypes_new ) ;
+			CONS_type(s, ptypes_new, ptypes_new);
-		pids = TAIL_list ( pids ) ;
+			pids = TAIL_list(pids);
-	    }
+		}
-	    pids_new = REVERSE_list ( pids_new ) ;
+		pids_new = REVERSE_list(pids_new);
-	    ptypes_new = REVERSE_list ( ptypes_new ) ;
+		ptypes_new = REVERSE_list(ptypes_new);
-	    if ( EQ_list ( ptypes, mtypes ) ) {
+		if (EQ_list(ptypes, mtypes)) {
-		mtypes_new = ptypes_new ;
+			mtypes_new = ptypes_new;
-	    } else {
+		} else {
-		TYPE r = DEREF_type ( HEAD_list ( mtypes ) ) ;
+			TYPE r = DEREF_type(HEAD_list(mtypes));
-		CONS_type ( r, ptypes_new, mtypes_new ) ;
+			CONS_type(r, ptypes_new, mtypes_new);
-	    }
-	    /* Construct new function type */
-	    MAKE_type_func ( qual, ret, ptypes_new, ell, mqual,
-			     mtypes_new, pars, pids_new, except, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
-	    break ;
-	}
-	case type_array_tag : {
-	    /* Qualify the base type of an array */
-	    NAT n = DEREF_nat ( type_array_size ( t ) ) ;
-	    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-	    TYPE r = copy_typedef ( id, s, cv ) ;
-	    IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
-	    MAKE_type_array ( qual, r, n, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
-	    break ;
-	}
-	case type_token_tag : {
-	    /* Tokenised types */
-	    IDENTIFIER tok = DEREF_id ( type_token_tok ( t ) ) ;
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( tok ) ) ;
-	    if ( !( ds & dspec_defn ) ) goto default_lab ;
-	    t = expand_type ( t, 0 ) ;
-	    t = qualify_type ( t, qual_new, 0 ) ;
-	    break ;
-	}
+		}
-	case type_templ_tag : {
-	    /* Template types */
+		/* Construct new function type */
-	    TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
+		MAKE_type_func(qual, ret, ptypes_new, ell, mqual,
-	    TOKEN tok = DEREF_tok ( type_templ_sort ( t ) ) ;
-	    IDENTIFIER tid = DEREF_id ( type_name ( t ) ) ;
-	    MAKE_type_templ ( qual_new, tok, s, 1, t ) ;
+			       mtypes_new, pars, pids_new, except, t);
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_id(type_name(t), tid);
-	    break ;
+		break;
+	}
+	case type_array_tag: {
+		/* Qualify the base type of an array */
+		NAT n = DEREF_nat(type_array_size(t));
+		TYPE s = DEREF_type(type_array_sub(t));
+		TYPE r = copy_typedef(id, s, cv);
+		IDENTIFIER tid = DEREF_id(type_name(t));
+		MAKE_type_array(qual, r, n, t);
+		COPY_id(type_name(t), tid);
+		break;
+	}
+	case type_token_tag: {
+		/* Tokenised types */
+		IDENTIFIER tok = DEREF_id(type_token_tok(t));
+		DECL_SPEC ds = DEREF_dspec(id_storage(tok));
+		if (!(ds & dspec_defn))goto default_lab;
+		t = expand_type(t, 0);
+		t = qualify_type(t, qual_new, 0);
+		break;
+	}
+	case type_templ_tag: {
+		/* Template types */
+		TYPE s = DEREF_type(type_templ_defn(t));
+		TOKEN tok = DEREF_tok(type_templ_sort(t));
+		IDENTIFIER tid = DEREF_id(type_name(t));
+		MAKE_type_templ(qual_new, tok, s, 1, t);
+		COPY_id(type_name(t), tid);
+		break;
+	}
-	default :
+	default:
-	default_lab : {
+default_lab:
-	    /* Other types */
+		/* Other types */
-	    if ( qual_new != qual ) {
+		if (qual_new != qual) {
-		t = qualify_type ( t, qual_new, 0 ) ;
+			t = qualify_type(t, qual_new, 0);
-	    }
+		}
-	    break ;
+		break;
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     CREATE AN LVALUE TYPE
     This routine creates a type which is an lvalue qualified version of t
     (also preserving any other type qualifiers).
 */
-TYPE lvalue_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+lvalue_type(TYPE t)
 {
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( qual & cv_lvalue ) return ( t ) ;
+	if (qual & cv_lvalue) {
+		return (t);
+	}
-    qual |= cv_lvalue ;
+	qual |= cv_lvalue;
-    return ( qualify_type ( t, qual, 0 ) ) ;
+	return (qualify_type(t, qual, 0));
 }
 /*
     CREATE AN RVALUE TYPE
     This routine creates a type which is identical to t except that it
     is an rvalue rather than an lvalue.
 */
-TYPE rvalue_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+rvalue_type(TYPE t)
 {
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( !( qual & cv_lvalue ) ) return ( t ) ;
+	if (!(qual & cv_lvalue)) {
+		return (t);
+	}
-    qual &= ~cv_lvalue ;
+	qual &= ~cv_lvalue;
-    return ( qualify_type ( t, qual, 0 ) ) ;
+	return (qualify_type(t, qual, 0));
 }
 /*
     COMBINE TWO PRE-TYPES
     The pre-types are a construction mechanism for allowing built-in types
     such as 'unsigned long int' to be built up.  Each pre-type is associated
     with a bitmask giving the basic keywords used in defining the type.
     This routine is the main constructor function, which combines two
     pre-types and returns the result.
 */
-BASE_TYPE join_pre_types
+BASE_TYPE
-    PROTO_N ( ( b1, b2 ) )
-    PROTO_T ( BASE_TYPE b1 X BASE_TYPE b2 )
+join_pre_types(BASE_TYPE b1, BASE_TYPE b2)
 {
-    BASE_TYPE bt = ( b1 | b2 ) ;
+	BASE_TYPE bt = (b1 | b2);
-    BASE_TYPE bs = ( b1 & b2 ) ;
+	BASE_TYPE bs = (b1 & b2);
-    if ( bs ) {
+	if (bs) {
-	if ( bs == btype_long ) {
+		if (bs == btype_long) {
-	    if ( !( bt & btype_long2 ) ) {
+			if (!(bt & btype_long2)) {
-		/* Allow 'long long' */
+				/* Allow 'long long' */
-		bt |= btype_long2 ;
+				bt |= btype_long2;
-		return ( bt ) ;
+				return (bt);
-	    }
+			}
+		}
+		report(crt_loc, ERR_dcl_type_simple_dup(bs));
+	}
-	report ( crt_loc, ERR_dcl_type_simple_dup ( bs ) ) ;
-    }
-    return ( bt ) ;
+	return (bt);
+}
 /*
     INJECT A TYPE INTO A PRE-TYPE
     This routine injects the type t into the pre-type p, returning the
     result.  p will be built up of pointers, arrays etc. but its base
     It also checks for illegal type constructions.  Note that p itself
     is built up using inject_pre_type, so all such illegal constructions
     will be detected.  Some of the error recovery for such constructions
     is mildly interesting.  Also note that bitfields are handled by a
     separate routine, make_bitfield_type.
-	    default : {
+		default: {
-		/* Only the types above should appear */
+			/* Only the types above should appear */
-		q = NULL_type ;
+			q = NULL_type;
-		n-- ;
+			n--;
-		break ;
+			break;
+		}
-	    }
+		}
+		n++;
+	} while (!IS_NULL_type(q));
+	if (chk) {
+		IGNORE check_value(OPT_VAL_declarator_max, n);
+	}
-	n++ ;
-    } while ( !IS_NULL_type ( q ) ) ;
-    if ( chk ) IGNORE check_value ( OPT_VAL_declarator_max, n ) ;
-    return ( p ) ;
+	return (p);
+}
 /*
     CHECK FOR INFERRED TYPES
     This routine checks whether the type t is formed from the inferred
     type type_inferred.  It returns INFERRED_EMPTY if there were no
     specifiers or qualifiers in the description of p,  INFERRED_QUAL if
     the only type specifiers were const or volatile, INFERRED_SPEC for
     other inferred types, and INFERRED_NOT for non-inferred types.
 */
+int
-int is_type_inferred
+is_type_inferred(TYPE t)
+{
+	if (EQ_type(t, type_inferred)) {
+		return (INFERRED_EMPTY);
+	}
+	while (!IS_NULL_type(t)) {
+		switch (TAG_type(t)) {
+		case type_integer_tag: {
+			/* Check integer types */
+			if (EQ_type(t, type_inferred)) {
+				return (INFERRED_SPEC);
+			} else {
+				INT_TYPE it = DEREF_itype(type_integer_rep(t));
+				t = DEREF_type(itype_prom(it));
+				if (EQ_type(t, type_inferred)) {
+					/* Qualified inferred type */
+					return (INFERRED_QUAL);
+				}
+			}
+			return (INFERRED_NOT);
+		}
+		case type_ptr_tag:
+		case type_ref_tag: {
+			/* Check pointer and reference types */
+			t = DEREF_type(type_ptr_etc_sub(t));
+			break;
+		}
+#if LANGUAGE_CPP
+		case type_ptr_mem_tag: {
+			/* Check pointer to member types */
+			t = DEREF_type(type_ptr_mem_sub(t));
+			break;
+		}
+#endif
+		case type_func_tag: {
+			/* Check function return types only */
+			t = DEREF_type(type_func_ret(t));
+			break;
+		}
+		case type_array_tag: {
+			/* Check array types */
+			t = DEREF_type(type_array_sub(t));
+			break;
+		}
+		case type_bitfield_tag: {
+			/* Check bitfield types */
+			t = find_bitfield_type(t);
+			break;
+		}
+		case type_templ_tag: {
+			/* Check template types */
+			t = DEREF_type(type_templ_defn(t));
+			break;
+		}
+		default : {
+			/* Other types are not inferred */
+			return (INFERRED_NOT);
+		}
+		}
+	}
+	return (INFERRED_QUAL);
+}
+/*
-    PROTO_N ( ( t ) )
+    CLEAN AN INFERRED TYPE
+    This routine returns an equivalent type to the inferred type t, but
+    with any inferred components replaced by 'signed int'.
+*/
+TYPE
-    PROTO_T ( TYPE t )
+clean_inferred_type(TYPE t)
+{
+	TYPE sub;
-    if ( EQ_type ( t, type_inferred ) ) return ( INFERRED_EMPTY ) ;
+	CV_SPEC qual;
-    while ( !IS_NULL_type ( t ) ) {
+	IDENTIFIER tid;
-	switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	    case type_integer_tag : {
+	case type_integer_tag: {
-		/* Check integer types */
+		if (EQ_type(t, type_inferred)) {
-		if ( EQ_type ( t, type_inferred ) ) {
+			/* Simple inferred type */
-		    return ( INFERRED_SPEC ) ;
+			t = type_sint;
 		} else {
-		    INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+			INT_TYPE it = DEREF_itype(type_integer_rep(t));
-		    t = DEREF_type ( itype_prom ( it ) ) ;
+			TYPE pt = DEREF_type(itype_prom(it));
-		    if ( EQ_type ( t, type_inferred ) ) {
+			if (EQ_type(pt, type_inferred)) {
-			/* Qualified inferred type */
+				/* Qualified inferred type */
-			return ( INFERRED_QUAL ) ;
+				qual = DEREF_cv(type_qual(t));
+				t = qualify_type(type_sint, qual, 0);
-		    }
+			}
+		}
-		return ( INFERRED_NOT ) ;
+		break;
-	    }
+	}
-	    case type_ptr_tag :
+	case type_ptr_tag: {
+		DECONS_type_ptr(qual, tid, sub, t);
+		sub = clean_inferred_type(sub);
+		MAKE_type_ptr(qual, sub, t);
+		COPY_id(type_name(t), tid);
+		break;
+	}
-	    case type_ref_tag : {
+	case type_ref_tag: {
+		DECONS_type_ref(qual, tid, sub, t);
-		/* Check pointer and reference types */
+		sub = clean_inferred_type(sub);
-		t = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+		MAKE_type_ref(qual, sub, t);
+		COPY_id(type_name(t), tid);
-		break ;
+		break;
-	    }
+	}
 #if LANGUAGE_CPP
-	    case type_ptr_mem_tag : {
+	case type_ptr_mem_tag: {
-		/* Check pointer to member types */
-		t = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
-		break ;
-	    }
-#endif
-	    case type_func_tag : {
-		/* Check function return types only */
-		t = DEREF_type ( type_func_ret ( t ) ) ;
-		break ;
+		CLASS_TYPE of;
-	    }
-	    case type_array_tag : {
-		/* Check array types */
-		t = DEREF_type ( type_array_sub ( t ) ) ;
+		DECONS_type_ptr_mem(qual, tid, of, sub, t);
-		break ;
-	    }
-	    case type_bitfield_tag : {
-		/* Check bitfield types */
-		t = find_bitfield_type ( t ) ;
+		sub = clean_inferred_type(sub);
-		break ;
-	    }
-	    case type_templ_tag : {
-		/* Check template types */
+		MAKE_type_ptr_mem(qual, of, sub, t);
-		t = DEREF_type ( type_templ_defn ( t ) ) ;
+		COPY_id(type_name(t), tid);
-		break ;
+		break;
-	    }
-	    default : {
-		/* Other types are not inferred */
-		return ( INFERRED_NOT ) ;
-	    }
+	}
-    }
+#endif
-    return ( INFERRED_QUAL ) ;
-}
-/*
-    CLEAN AN INFERRED TYPE
-    This routine returns an equivalent type to the inferred type t, but
-    with any inferred components replaced by 'signed int'.
-*/
-TYPE clean_inferred_type
-    PROTO_N ( ( t ) )
+	case type_func_tag: {
-    PROTO_T ( TYPE t )
-{
-    TYPE sub ;
+		int ell;
-    CV_SPEC qual ;
+		CV_SPEC mqual;
-    IDENTIFIER tid ;
+		NAMESPACE pars;
-    switch ( TAG_type ( t ) ) {
-	case type_integer_tag : {
+		LIST(TYPE)ptypes;
-	    if ( EQ_type ( t, type_inferred ) ) {
-		/* Simple inferred type */
+		LIST(TYPE)mtypes;
-		t = type_sint ;
+		LIST(TYPE)except;
-	    } else {
+		LIST(IDENTIFIER)pids;
-		INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		DECONS_type_func(qual, tid, sub, ptypes, ell, mqual,
-		TYPE pt = DEREF_type ( itype_prom ( it ) ) ;
-		if ( EQ_type ( pt, type_inferred ) ) {
+				 mtypes, pars, pids, except, t);
-		    /* Qualified inferred type */
+		sub = clean_inferred_type(sub);
-		    qual = DEREF_cv ( type_qual ( t ) ) ;
-		    t = qualify_type ( type_sint, qual, 0 ) ;
-		}
-	    }
-	    break ;
-	}
-	case type_ptr_tag : {
-	    DECONS_type_ptr ( qual, tid, sub, t ) ;
+		MAKE_type_func(qual, sub, ptypes, ell, mqual,
-	    sub = clean_inferred_type ( sub ) ;
-	    MAKE_type_ptr ( qual, sub, t ) ;
+			       mtypes, pars, pids, except, t);
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_id(type_name(t), tid);
-	    break ;
+		break;
+	}
-	case type_ref_tag : {
+	case type_array_tag: {
+		NAT size;
-	    DECONS_type_ref ( qual, tid, sub, t ) ;
+		DECONS_type_array(qual, tid, sub, size, t);
-	    sub = clean_inferred_type ( sub ) ;
+		sub = clean_inferred_type(sub);
-	    MAKE_type_ref ( qual, sub, t ) ;
+		MAKE_type_array(qual, sub, size, t);
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_id(type_name(t), tid);
-	    break ;
+		break;
+	}
-#if LANGUAGE_CPP
-	case type_ptr_mem_tag : {
+	case type_bitfield_tag: {
-	    CLASS_TYPE of ;
+		INT_TYPE bf;
-	    DECONS_type_ptr_mem ( qual, tid, of, sub, t ) ;
+		DECONS_type_bitfield(qual, tid, bf, t);
-	    sub = clean_inferred_type ( sub ) ;
+		sub = DEREF_type(itype_bitfield_sub(bf));
-	    MAKE_type_ptr_mem ( qual, of, sub, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
-	    break ;
-	}
-#endif
-	case type_func_tag : {
-	    int ell ;
-	    CV_SPEC mqual ;
-	    NAMESPACE pars ;
-	    LIST ( TYPE ) ptypes ;
-	    LIST ( TYPE ) mtypes ;
-	    LIST ( TYPE ) except ;
-	    LIST ( IDENTIFIER ) pids ;
-	    DECONS_type_func ( qual, tid, sub, ptypes, ell, mqual,
-			       mtypes, pars, pids, except, t ) ;
-	    sub = clean_inferred_type ( sub ) ;
+		sub = clean_inferred_type(sub);
-	    MAKE_type_func ( qual, sub, ptypes, ell, mqual,
-			     mtypes, pars, pids, except, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_type(itype_bitfield_sub(bf), sub);
-	    break ;
-	}
-	case type_array_tag : {
-	    NAT size ;
-	    DECONS_type_array ( qual, tid, sub, size, t ) ;
-	    sub = clean_inferred_type ( sub ) ;
-	    MAKE_type_array ( qual, sub, size, t ) ;
+		MAKE_type_bitfield(qual, bf, t);
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_id(type_name(t), tid);
-	    break ;
+		break;
+	}
-	case type_bitfield_tag : {
+	case type_templ_tag: {
+		int fix;
-	    INT_TYPE bf ;
+		TOKEN sort;
-	    DECONS_type_bitfield ( qual, tid, bf, t ) ;
+		DECONS_type_templ(qual, tid, sort, sub, fix, t);
-	    sub = DEREF_type ( itype_bitfield_sub ( bf ) ) ;
-	    sub = clean_inferred_type ( sub ) ;
+		sub = clean_inferred_type(sub);
-	    COPY_type ( itype_bitfield_sub ( bf ), sub ) ;
-	    MAKE_type_bitfield ( qual, bf, t ) ;
+		MAKE_type_templ(qual, sort, sub, fix, t);
-	    COPY_id ( type_name ( t ), tid ) ;
+		COPY_id(type_name(t), tid);
-	    break ;
+		break;
+	}
-	case type_templ_tag : {
-	    int fix ;
-	    TOKEN sort ;
-	    DECONS_type_templ ( qual, tid, sort, sub, fix, t ) ;
-	    sub = clean_inferred_type ( sub ) ;
-	    MAKE_type_templ ( qual, sort, sub, fix, t ) ;
-	    COPY_id ( type_name ( t ), tid ) ;
-	    break ;
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     REPORT AN INFERRED TYPE
     This routine returns an error suitable for the inferred type t.
     infer gives the value of is_type_inferred on t.
 */
-ERROR report_inferred_type
+ERROR
-    PROTO_N ( ( t, infer ) )
-    PROTO_T ( TYPE t X int infer )
+report_inferred_type(TYPE t, int infer)
 {
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    switch ( infer ) {
+	switch (infer) {
-	case INFERRED_EMPTY :
+	case INFERRED_EMPTY:
-	case INFERRED_SPEC : {
+	case INFERRED_SPEC:
-	    err = ERR_dcl_type_none () ;
+		err = ERR_dcl_type_none();
-	    break ;
+		break;
-	}
-	case INFERRED_QUAL : {
+	case INFERRED_QUAL:
-	    err = ERR_dcl_type_qual () ;
+		err = ERR_dcl_type_qual();
-	    break ;
+		break;
 	}
-    }
-    err = concat_error ( err, ERR_dcl_type_infer ( t ) ) ;
+	err = concat_error(err, ERR_dcl_type_infer(t));
-    return ( err ) ;
+	return (err);
 }
 /*
     BASE TYPE SHIFT
     This macro is used to shift a base type specifier into a more sensible
     range for use in a switch statement.
 */
-#define BTYPE( B )		( ( B ) >> 3 )
+#define BTYPE(B)	((B) >> 3)
 /*
     FIND A BASE TYPE
     This routine determines the type given by the base type specifiers bt.
+		}
+	} else {
-	    }
+		do {
+			/* Deal with obvious integral cases */
+			switch (BTYPE(bm)) {
+			case BTYPE(btype_char): {
+				bm = btype_char;
+				t = type_char;
+				break;
+			}
+			case BTYPE(btype_signed | btype_char): {
+				bm = btype_schar;
+				t = type_schar;
+				break;
+			}
+			case BTYPE(btype_unsigned | btype_char): {
+				bm = btype_uchar;
+				t = type_uchar;
+				break;
+			}
+			case BTYPE(btype_short):
+			case BTYPE(btype_short | btype_int):
+			case BTYPE(btype_signed | btype_short):
+			case BTYPE(btype_signed | btype_short | btype_int): {
+				bm = btype_sshort;
+				t = type_sshort;
+				break;
+			}
+			case BTYPE(btype_unsigned | btype_short):
+			case BTYPE(btype_unsigned | btype_short | btype_int): {
+				bm = btype_ushort;
+				t = type_ushort;
+				break;
+			}
+			case BTYPE(btype_int):
+			case BTYPE(btype_none):
+			case BTYPE(btype_signed):
+			case BTYPE(btype_signed | btype_int): {
+				bm = btype_sint;
+				t = type_sint;
+				break;
+			}
+			case BTYPE(btype_unsigned):
+			case BTYPE(btype_unsigned | btype_int): {
+				bm = btype_uint;
+				t = type_uint;
+				break;
+			}
+			case BTYPE(btype_long):
+			case BTYPE(btype_long | btype_int):
+			case BTYPE(btype_signed | btype_long):
+			case BTYPE(btype_signed | btype_long | btype_int): {
+				bm = btype_slong;
+				t = type_slong;
+				break;
+			}
+			case BTYPE(btype_unsigned | btype_long):
+			case BTYPE(btype_unsigned | btype_long | btype_int): {
+				bm = btype_ulong;
+				t = type_ulong;
+				break;
+			}
+			case BTYPE(btype_llong):
+			case BTYPE(btype_llong | btype_int):
+			case BTYPE(btype_signed | btype_llong):
+			case BTYPE(btype_signed | btype_llong | btype_int): {
+				/* Allow for 'signed long long' */
+				if (basetype_info[ntype_sllong].key) {
+					report(crt_loc,
+					       ERR_dcl_type_simple_llong(bm));
+					bm = btype_sllong;
+					t = type_sllong;
+				} else {
+					bm = btype_slong;
+					t = type_slong;
+				}
+				break;
+			}
+			case BTYPE(btype_unsigned | btype_llong):
+			case BTYPE(btype_unsigned | btype_llong | btype_int): {
+				/* Allow for 'unsigned long long' */
+				if (basetype_info[ntype_sllong].key) {
+					report(crt_loc,
+					       ERR_dcl_type_simple_llong(bm));
+					bm = btype_ullong;
+					t = type_ullong;
+				} else {
+					bm = btype_ulong;
+					t = type_ulong;
+				}
+				break;
+			}
+			case BTYPE(btype_long | btype_char): {
+				/* Map 'long char' to 'wchar_t' */
+				bm = (btype_long | btype_char);
+				bo = btype_wchar_t;
+				t = type_wchar_t;
+				break;
+			}
+			default : {
+				/* Invalid type specifier */
+				bm = btype_none;
+				if (bt & btype_signed) {
+					bm |= btype_signed;
+				} else if (bt & btype_unsigned) {
+					bm |= btype_unsigned;
+				}
+				if (bt & btype_char) {
+					bm |= btype_char;
+				} else if (bt & btype_short) {
+					bm |= btype_short;
+				} else if (bt & btype_long2) {
+					bm |= btype_llong;
+				} else if (bt & btype_long) {
+					bm |= btype_long;
+				}
+				t = NULL_type;
+				break;
+			}
+			}
-	} while ( IS_NULL_type ( t ) ) ;
+		} while (IS_NULL_type(t));
-    }
+	}
-    /* Check result */
+	/* Check result */
-    if ( bt & ~bm ) {
+	if (bt & ~bm) {
-	/* Report excess type specifiers */
+		/* Report excess type specifiers */
-	if ( bo == btype_none ) bo = ( bt & bm ) ;
+		if (bo == btype_none) {
+			bo = (bt & bm);
+		}
-	report ( crt_loc, ERR_dcl_type_simple_bad ( bt, bo ) ) ;
+		report(crt_loc, ERR_dcl_type_simple_bad(bt, bo));
-    } else if ( bo ) {
+	} else if (bo) {
-	/* Report non-standard type specifiers */
+		/* Report non-standard type specifiers */
-	report ( crt_loc, ERR_dcl_type_simple_bad ( bt, bo ) ) ;
+		report(crt_loc, ERR_dcl_type_simple_bad(bt, bo));
-    }
+	}
-    return ( t ) ;
+	return (t);
 }
 /*
     SHOULD A TYPE NAME BE MARKED AS USED?
     This flag is used by complete_pre_type to decide whether a type
     name should be marked as having been used.  This is not the case,
     for example, in a class definition.
 */
-static int use_type_name = 1 ;
+static int use_type_name = 1;
 /*
     COMPLETE A PRE-TYPE
     This routine turns a pre-type comprising the base type qualifiers bt
     and the type specifier t, used during the type construction routines,
     into a genuine type.  The original type is destroyed.  The routine
     also assigns the const-volatile qualifier cv to the output type.
 */
-TYPE complete_pre_type
+TYPE
-    PROTO_N ( ( bt, t, cv, infer ) )
-    PROTO_T ( BASE_TYPE bt X TYPE t X CV_SPEC cv X int infer )
+complete_pre_type(BASE_TYPE bt, TYPE t, CV_SPEC cv, int infer)
+{
-    /* Deal with named types */
+	/* Deal with named types */
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	if ( bt ) report ( crt_loc, ERR_dcl_type_simple_undecl ( bt, t ) ) ;
-	if ( IS_type_pre ( t ) ) {
-	    CV_SPEC qual ;
-	    QUALIFIER it ;
-	    IDENTIFIER id ;
-	    DESTROY_type_pre ( destroy, qual, id, bt, it, t ) ;
-	    qual |= cv ;
-	    switch ( bt ) {
+		if (bt) {
-		case btype_class :
-		case btype_struct :
-		case btype_union :
-		case btype_enum : {
-		    /* Deal with elaborated types */
-		    DECL_SPEC mode = dspec_used ;
-		    if ( it != qual_none ) mode = dspec_alias ;
+			report(crt_loc, ERR_dcl_type_simple_undecl(bt, t));
-		    id = find_elaborate_type ( id, bt, NULL_type, mode ) ;
-		    break ;
+		}
+		if (IS_type_pre(t)) {
+			CV_SPEC qual;
+			QUALIFIER it;
+			IDENTIFIER id;
+			DESTROY_type_pre(destroy, qual, id, bt, it, t);
+			qual |= cv;
+			switch (bt) {
+			case btype_class:
+			case btype_struct:
+			case btype_union:
+			case btype_enum: {
+				/* Deal with elaborated types */
+				DECL_SPEC mode = dspec_used;
+				if (it != qual_none) {
+					mode = dspec_alias;
-	    }
+				}
+				id = find_elaborate_type(id, bt, NULL_type,
+							 mode);
+				break;
+			}
+			}
-	    if ( IS_id_class_name_etc ( id ) ) {
+			if (IS_id_class_name_etc(id)) {
-		t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+				t = DEREF_type(id_class_name_etc_defn(id));
-		if ( IS_type_templ ( t ) ) {
+				if (IS_type_templ(t)) {
-		    t = deduce_type_template ( id, use_type_name ) ;
+					t = deduce_type_template(id,
+								 use_type_name);
-		}
+				}
-		t = copy_typedef ( id, t, qual ) ;
+				t = copy_typedef(id, t, qual);
-		COPY_id ( type_name ( t ), id ) ;
+				COPY_id(type_name(t), id);
-		if ( use_type_name ) use_id ( id, 0 ) ;
+				if (use_type_name) {
+					use_id(id, 0);
+				}
-	    } else {
+			} else {
-		report ( crt_loc, ERR_dcl_type_simple_undef ( id ) ) ;
+				report(crt_loc, ERR_dcl_type_simple_undef(id));
-		t = type_error ;
+				t = type_error;
-	    }
+			}
+		} else {
+			t = copy_typedef(NULL_id, t, cv);
+		}
+		return (t);
+	}
+	/* Deal with type specifiers */
+	if (bt == btype_none) {
+		t = type_inferred;
 	} else {
-	    t = copy_typedef ( NULL_id, t, cv ) ;
+		t = make_base_type(bt);
+	}
-	return ( t ) ;
+	if (cv) {
-    }
-    /* Deal with type specifiers */
-    if ( bt == btype_none ) {
-	t = type_inferred ;
-    } else {
-	t = make_base_type ( bt ) ;
+		t = qualify_type(t, cv, 0);
-    }
+	}
-    if ( cv ) t = qualify_type ( t, cv, 0 ) ;
-    if ( infer ) {
+	if (infer) {
-	/* Check for inferred types */
+		/* Check for inferred types */
-	int i = is_type_inferred ( t ) ;
+		int i = is_type_inferred(t);
-	if ( i != INFERRED_NOT ) {
+		if (i != INFERRED_NOT) {
-	    ERROR err ;
+			ERROR err;
-	    t = clean_inferred_type ( t ) ;
+			t = clean_inferred_type(t);
-	    err = report_inferred_type ( t, i ) ;
+			err = report_inferred_type(t, i);
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
+		}
+	}
-    }
-    return ( t ) ;
+	return (t);
+}
 /*
     COMPLETE A NON-ELABORATED PRE-TYPE
     elaborated type declarations (such as 'struct s') as pre-types.  It is
     used in declarations without declarators where such declarations
     resolve differently than in the main case.
 */
-TYPE empty_complete_pre_type
+TYPE
-    PROTO_N ( ( bt, t, cv, infer ) )
-    PROTO_T ( BASE_TYPE bt X TYPE t X CV_SPEC cv X int infer )
+empty_complete_pre_type(BASE_TYPE bt, TYPE t, CV_SPEC cv, int infer)
+{
-    /* Check for elaborated type declarations */
+	/* Check for elaborated type declarations */
-    if ( !IS_NULL_type ( t ) && IS_type_pre ( t ) ) {
+	if (!IS_NULL_type(t) && IS_type_pre(t)) {
-	BASE_TYPE key = DEREF_btype ( type_pre_rep ( t ) ) ;
+		BASE_TYPE key = DEREF_btype(type_pre_rep(t));
-	switch ( key ) {
+		switch (key) {
-	    case btype_class :
+		case btype_class:
-	    case btype_struct :
+		case btype_struct:
-	    case btype_union :
+		case btype_union:
-	    case btype_enum : {
+		case btype_enum: {
-		if ( bt ) {
+			if (bt) {
-		    ERROR err = ERR_dcl_type_simple_undecl ( bt, t ) ;
+				ERROR err = ERR_dcl_type_simple_undecl(bt, t);
-		    report ( crt_loc, err ) ;
+				report(crt_loc, err);
+			}
+			COPY_cv(type_qual(t), cv);
+			COPY_btype(type_pre_rep(t), key);
+			return (t);
+		}
+		}
-		COPY_cv ( type_qual ( t ), cv ) ;
-		COPY_btype ( type_pre_rep ( t ), key ) ;
-		return ( t ) ;
-	    }
+	}
-    }
-    /* Otherwise obtain the completed type */
+	/* Otherwise obtain the completed type */
-    use_type_name = 0 ;
+	use_type_name = 0;
-    t = complete_pre_type ( bt, t, cv, infer ) ;
+	t = complete_pre_type(bt, t, cv, infer);
-    use_type_name = 1 ;
+	use_type_name = 1;
-    return ( t ) ;
+	return (t);
+}
 /*
     FIND UNDERLYING BITFIELD TYPE
     This routine returns the type underlying the bitfield type t.
 */
-TYPE find_bitfield_type
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+find_bitfield_type(TYPE t)
 {
-    INT_TYPE it = DEREF_itype ( type_bitfield_defn ( t ) ) ;
+	INT_TYPE it = DEREF_itype(type_bitfield_defn(t));
-    t = DEREF_type ( itype_bitfield_sub ( it ) ) ;
+	t = DEREF_type(itype_bitfield_sub(it));
-    return ( t ) ;
+	return (t);
 }
 /*
     FIND A BITFIELD REPRESENTATION
     This routine finds the bitfield representation for a bitfield originally
     declared with representation bt which expands to the type t.
 */
-BASE_TYPE get_bitfield_rep
+BASE_TYPE
-    PROTO_N ( ( t, bt ) )
-    PROTO_T ( TYPE t X BASE_TYPE bt )
+get_bitfield_rep(TYPE t, BASE_TYPE bt)
 {
-    int depth = 0 ;
+	int depth = 0;
-    IDENTIFIER id = DEREF_id ( type_name ( t ) ) ;
+	IDENTIFIER id = DEREF_id(type_name(t));
-    while ( !IS_NULL_id ( id ) && depth < 100 ) {
+	while (!IS_NULL_id(id) && depth < 100) {
-	/* Scan down to original typedef definition */
+		/* Scan down to original typedef definition */
-	bt = DEREF_btype ( id_class_name_etc_rep ( id ) ) ;
+		bt = DEREF_btype(id_class_name_etc_rep(id));
-	t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
+		t = DEREF_type(id_class_name_etc_defn(id));
-	id = DEREF_id ( type_name ( t ) ) ;
+		id = DEREF_id(type_name(t));
-	depth++ ;
+		depth++;
-    }
+	}
-    if ( IS_type_integer ( t ) ) {
+	if (IS_type_integer(t)) {
-	INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	if ( IS_itype_basic ( it ) ) {
+		if (IS_itype_basic(it)) {
-	    BASE_TYPE br = DEREF_btype ( itype_basic_rep ( it ) ) ;
+			BASE_TYPE br = DEREF_btype(itype_basic_rep(it));
-	    if ( bt & br ) {
+			if (bt & br) {
-		if ( !( br & btype_char ) ) br &= ~btype_signed ;
+				if (!(br & btype_char)) {
+					br &= ~btype_signed;
+				}
-		if ( bt & btype_signed ) br |= btype_signed ;
+				if (bt & btype_signed) {
+					br |= btype_signed;
-	    }
+				}
+			}
-	    bt = br ;
+			bt = br;
+		}
+	}
-    }
-    return ( bt ) ;
+	return (bt);
+}
 /*
     CHECK A BITFIELD TYPE
     the pre-type which gave rise to t, bt (in this case 'int'), is also
     given.  The zero argument is true if zero sized bitfields are
     allowed.
 */
-TYPE check_bitfield_type
+TYPE
-    PROTO_N ( ( cv, t, bt, n, zero ) )
-    PROTO_T ( CV_SPEC cv X TYPE t X BASE_TYPE bt X NAT n X int zero )
+check_bitfield_type(CV_SPEC cv, TYPE t, BASE_TYPE bt, NAT n, int zero)
+{
-    INT_TYPE bf ;
+	INT_TYPE bf;
-    TYPE p = NULL_type ;
+	TYPE p = NULL_type;
-    DECL_SPEC info = dspec_none ;
+	DECL_SPEC info = dspec_none;
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( qual ) {
+	if (qual) {
-	/* Move any cv-qualifiers to top level */
+		/* Move any cv-qualifiers to top level */
-	t = qualify_type ( t, cv_none, 0 ) ;
+		t = qualify_type(t, cv_none, 0);
-	cv |= qual ;
+		cv |= qual;
-    }
-    switch ( TAG_type ( t ) ) {
-	case type_integer_tag :
-	case type_enumerate_tag : {
-	    /* Integral types are allowed */
-	    int ok = 1 ;
-	    bt = get_bitfield_rep ( t, bt ) ;
-	    if ( bt & btype_int ) {
-		if ( bt & ( btype_short | btype_long ) ) ok = 0 ;
-	    } else {
-		ok = 0 ;
-	    }
-	    if ( !ok ) {
-		/* Only 'int' types allowed in C */
-		report ( crt_loc, ERR_class_bit_base_int ( t ) ) ;
-	    }
-	    if ( !( bt & ( btype_signed | btype_unsigned ) ) ) {
-		/* No sign given in type specifier */
-		report ( crt_loc, ERR_class_bit_sign ( bt ) ) ;
-	    }
-	    break ;
+	}
+	switch (TAG_type(t)) {
+	case type_integer_tag:
+	case type_enumerate_tag: {
+		/* Integral types are allowed */
+		int ok = 1;
+		bt = get_bitfield_rep(t, bt);
+		if (bt & btype_int) {
+			if (bt & (btype_short | btype_long)) {
+				ok = 0;
+			}
+		} else {
+			ok = 0;
+		}
+		if (!ok) {
+			/* Only 'int' types allowed in C */
+			report(crt_loc, ERR_class_bit_base_int(t));
+		}
+		if (!(bt & (btype_signed | btype_unsigned))) {
+			/* No sign given in type specifier */
+			report(crt_loc, ERR_class_bit_sign(bt));
+		}
+		break;
+	}
-	case type_token_tag : {
+	case type_token_tag: {
-	    /* Allow template parameter types */
+		/* Allow template parameter types */
-	    if ( is_templ_type ( t ) ) {
+		if (is_templ_type(t)) {
-		IDENTIFIER id = DEREF_id ( type_token_tok ( t ) ) ;
+			IDENTIFIER id = DEREF_id(type_token_tok(t));
-		LIST ( TOKEN ) args = DEREF_list ( type_token_args ( t ) ) ;
+			LIST(TOKEN)args = DEREF_list(type_token_args(t));
-		t = apply_itype_token ( id, args ) ;
+			t = apply_itype_token(id, args);
-		bt = ( btype_named | btype_template ) ;
+			bt = (btype_named | btype_template);
-		break ;
+			break;
-	    }
+		}
-	    report ( crt_loc, ERR_class_bit_base ( t ) ) ;
+		report(crt_loc, ERR_class_bit_base(t));
-	    return ( t ) ;
+		return (t);
 	}
-	case type_error_tag : {
+	case type_error_tag: {
-	    /* Ignore error types */
+		/* Ignore error types */
-	    return ( t ) ;
+		return (t);
+	}
+	default: {
+		/* Other types are not allowed */
+		report(crt_loc, ERR_class_bit_base(t));
+		return (t);
+	}
+	}
+	/* Check the range of n */
+	if (IS_NULL_nat(n) || is_zero_nat(n)) {
+		/* Only anonymous bitfields can have size zero */
+		if (!zero) {
+			report(crt_loc, ERR_class_bit_dim_zero());
+		}
+		info |= dspec_pure;
+		n = small_nat[0];
+		p = type_sint;
+	} else {
+		if (is_negative_nat(n)) {
+			/* Bitfield size cannot be negative */
+			report(crt_loc, ERR_class_bit_dim_neg(n));
+			n = negate_nat(n);
+		}
+		if (check_type_size(t, n) > 0) {
+			report(crt_loc, ERR_class_bit_dim_big(n, t));
+		}
+		if (IS_nat_small(n)) {
+			unsigned sz = DEREF_unsigned(nat_small_value(n));
+			unsigned si = basetype_info[ntype_sint].min_bits;
+			if (sz < si) {
+				/* Fits into 'signed int' */
+				p = type_sint;
+			} else if (sz == si && (bt & btype_unsigned)) {
+				/* Fits into 'unsigned int' */
+				p = type_uint;
+			}
+		}
+	}
-	default : {
+	if (IS_NULL_type(p)) {
-	    /* Other types are not allowed */
+		/* NOT YET IMPLEMENTED */
-	    report ( crt_loc, ERR_class_bit_base ( t ) ) ;
-	    return ( t ) ;
+		p = promote_type(t);
+	}
-    }
-    /* Check the range of n */
-    if ( IS_NULL_nat ( n ) || is_zero_nat ( n ) ) {
-	/* Only anonymous bitfields can have size zero */
+	/* Construct bitfield type */
-	if ( !zero ) report ( crt_loc, ERR_class_bit_dim_zero () ) ;
-	info |= dspec_pure ;
-	n = small_nat [0] ;
-	p = type_sint ;
-    } else {
+	if (zero) {
-	if ( is_negative_nat ( n ) ) {
-	    /* Bitfield size cannot be negative */
-	    report ( crt_loc, ERR_class_bit_dim_neg ( n ) ) ;
-	    n = negate_nat ( n ) ;
+		info |= dspec_ignore;
-	}
-	if ( check_type_size ( t, n ) > 0 ) {
-	    report ( crt_loc, ERR_class_bit_dim_big ( n, t ) ) ;
+	}
-	if ( IS_nat_small ( n ) ) {
-	    unsigned sz = DEREF_unsigned ( nat_small_value ( n ) ) ;
-	    unsigned si = basetype_info [ ntype_sint ].min_bits ;
-	    if ( sz < si ) {
-		/* Fits into 'signed int' */
-		p = type_sint ;
-	    } else if ( sz == si && ( bt & btype_unsigned ) ) {
-		/* Fits into 'unsigned int' */
-		p = type_uint ;
-	    }
-	}
-    }
-    if ( IS_NULL_type ( p ) ) {
-	/* NOT YET IMPLEMENTED */
-	p = promote_type ( t ) ;
-    }
-    /* Construct bitfield type */
-    if ( zero ) info |= dspec_ignore ;
-    MAKE_itype_bitfield ( p, NULL_list ( TYPE ), t, bt, n, info, bf ) ;
+	MAKE_itype_bitfield(p, NULL_list(TYPE), t, bt, n, info, bf);
-    MAKE_type_bitfield ( cv, bf, t ) ;
+	MAKE_type_bitfield(cv, bf, t);
-    return ( t ) ;
+	return (t);
+}
 /*
     CREATE A BITFIELD TYPE
     This routine is identical to check_bitfield_type except that it
     takes a constant-expression e rather than the integer constant n.
 */
-TYPE make_bitfield_type
+TYPE
-    PROTO_N ( ( t, bt, e, zero ) )
-    PROTO_T ( TYPE t X BASE_TYPE bt X EXP e X int zero )
+make_bitfield_type(TYPE t, BASE_TYPE bt, EXP e, int zero)
 {
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    NAT n = make_nat_exp ( e, &err ) ;
+	NAT n = make_nat_exp(e, &err);
-    if ( !IS_NULL_err ( err ) ) {
+	if (!IS_NULL_err(err)) {
-	err = concat_error ( err, ERR_class_bit_dim_const () ) ;
+		err = concat_error(err, ERR_class_bit_dim_const());
-	report ( crt_loc, err ) ;
+		report(crt_loc, err);
-    }
+	}
-    t = check_bitfield_type ( cv_none, t, bt, n, zero ) ;
+	t = check_bitfield_type(cv_none, t, bt, n, zero);
-    return ( t ) ;
+	return (t);
 }
 /*
     CHECK AN ARRAY BOUND
     This routine checks the array bound n.  n can be null, indicating an
     unbounded array, or a positive constant.
 */
-NAT check_array_dim
+NAT
-    PROTO_N ( ( n ) )
-    PROTO_T ( NAT n )
+check_array_dim(NAT n)
 {
-    if ( !IS_NULL_nat ( n ) ) {
+	if (!IS_NULL_nat(n)) {
-	if ( is_zero_nat ( n ) ) {
+		if (is_zero_nat(n)) {
-	    report ( crt_loc, ERR_dcl_array_dim_zero () ) ;
+			report(crt_loc, ERR_dcl_array_dim_zero());
-	} else if ( is_negative_nat ( n ) ) {
+		} else if (is_negative_nat(n)) {
-	    report ( crt_loc, ERR_dcl_array_dim_neg ( n ) ) ;
+			report(crt_loc, ERR_dcl_array_dim_neg(n));
-	    n = negate_nat ( n ) ;
+			n = negate_nat(n);
+		}
+	}
-    }
-    return ( n ) ;
+	return (n);
+}
 /*
     CREATE AN ARRAY BOUND
     This routine turns the integer constant expression e into an array
     bound.  e may also be the null expression, indicating an unbounded
     array.
 */
-NAT make_array_dim
+NAT
-    PROTO_N ( ( e ) )
-    PROTO_T ( EXP e )
+make_array_dim(EXP e)
 {
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	ERROR err = NULL_err ;
+		ERROR err = NULL_err;
-	NAT n = make_nat_exp ( e, &err ) ;
+		NAT n = make_nat_exp(e, &err);
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    err = concat_error ( err, ERR_dcl_array_dim_const () ) ;
+			err = concat_error(err, ERR_dcl_array_dim_const());
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
-	}
+		}
-	n = check_array_dim ( n ) ;
+		n = check_array_dim(n);
-	return ( n ) ;
+		return (n);
-    }
+	}
-    return ( NULL_nat ) ;
+	return (NULL_nat);
 }
 /*
     CHECK AN INTEGER TYPE
     This routine checks whether t is an integral type containing the base
     type specifiers m.  It is used to spot signed types, unsigned types,
     character types and so on.
 */
-int check_int_type
+int
-    PROTO_N ( ( t, m ) )
-    PROTO_T ( TYPE t X BASE_TYPE m )
+check_int_type(TYPE t, BASE_TYPE m)
 {
-    if ( IS_type_integer ( t ) ) {
+	if (IS_type_integer(t)) {
-	INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	switch ( TAG_itype ( it ) ) {
+		switch (TAG_itype(it)) {
-	    case itype_basic_tag : {
+		case itype_basic_tag: {
-		BASE_TYPE bt = DEREF_btype ( itype_basic_rep ( it ) ) ;
+			BASE_TYPE bt = DEREF_btype(itype_basic_rep(it));
-		if ( ( bt & m ) == m ) return ( 1 ) ;
+			if ((bt & m) == m) {
+				return (1);
+			}
-		break ;
+			break;
-	    }
+		}
-	    case itype_token_tag : {
+		case itype_token_tag: {
-		/* Tokenised types */
+			/* Tokenised types */
-		IDENTIFIER tid = DEREF_id ( itype_token_tok ( it ) ) ;
+			IDENTIFIER tid = DEREF_id(itype_token_tok(it));
-		TOKEN tok = DEREF_tok ( id_token_sort ( tid ) ) ;
+			TOKEN tok = DEREF_tok(id_token_sort(tid));
-		if ( IS_tok_proc ( tok ) ) {
+			if (IS_tok_proc(tok)) {
-		    tok = DEREF_tok ( tok_proc_res ( tok ) ) ;
+				tok = DEREF_tok(tok_proc_res(tok));
+			}
+			if (IS_tok_type(tok)) {
+				BASE_TYPE bt = DEREF_btype(tok_type_kind(tok));
+				if ((bt & m) == m) {
+					return (1);
+				}
+			}
+			break;
+		}
-		if ( IS_tok_type ( tok ) ) {
-		    BASE_TYPE bt = DEREF_btype ( tok_type_kind ( tok ) ) ;
-		    if ( ( bt & m ) == m ) return ( 1 ) ;
+		}
-		break ;
-	    }
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     LISTS OF COMPATIBLE TYPES
     These lists are used to record the compatible types set by the
     routines below.
 */
-static LIST ( TYPE ) arg1_types = NULL_list ( TYPE ) ;
+static LIST(TYPE) arg1_types = NULL_list(TYPE);
-static LIST ( TYPE ) arg2_types = NULL_list ( TYPE ) ;
+static LIST(TYPE) arg2_types = NULL_list(TYPE);
-static LIST ( TYPE ) ell_types = NULL_list ( TYPE ) ;
+static LIST(TYPE) ell_types = NULL_list(TYPE);
 /*
     SET TWO TYPES TO BE COMPATIBLE
     This routine sets the types t and s to be compatible with option
     level opt.
 */
-void set_compatible_type
+void
-    PROTO_N ( ( t, s, opt ) )
-    PROTO_T ( TYPE t X TYPE s X unsigned opt )
+set_compatible_type(TYPE t, TYPE s, unsigned opt)
+{
-    TYPE pt = type_char_star ;
+	TYPE pt = type_char_star;
-    TYPE ps = type_void_star ;
+	TYPE ps = type_void_star;
-    if ( eq_type ( t, pt ) && eq_type ( s, ps ) ) {
+	if (eq_type(t, pt) && eq_type(s, ps)) {
-	set_option ( OPT_gen_ptr_char, opt ) ;
+		set_option(OPT_gen_ptr_char, opt);
-    } else {
+	} else {
-	report ( preproc_loc, ERR_pragma_compat_type () ) ;
+		report(preproc_loc, ERR_pragma_compat_type());
-    }
+	}
-    return ;
+	return;
+}
 /*
     FIND CANONICAL ARGUMENT TYPE
     This routine finds the canonical argument type for the type t by
     chasing down the lists of compatible argument types.  It returns
     the null type if t is not compatible with a type from this list.
 */
-static TYPE find_arg_type
+static
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+TYPE find_arg_type(TYPE t)
 {
-    LIST ( TYPE ) p = arg1_types ;
+	LIST(TYPE)p = arg1_types;
-    LIST ( TYPE ) q = arg2_types ;
+	LIST(TYPE)q = arg2_types;
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	TYPE r = DEREF_type ( HEAD_list ( p ) ) ;
+		TYPE r = DEREF_type(HEAD_list(p));
-	r = type_composite ( t, r, 0, 1, KILL_err, 0 ) ;
+		r = type_composite(t, r, 0, 1, KILL_err, 0);
-	if ( !IS_NULL_type ( r ) ) {
+		if (!IS_NULL_type(r)) {
-	    r = DEREF_type ( HEAD_list ( q ) ) ;
+			r = DEREF_type(HEAD_list(q));
-	    return ( r ) ;
+			return (r);
+		}
+		q = TAIL_list(q);
+		p = TAIL_list(p);
+	}
-	q = TAIL_list ( q ) ;
-	p = TAIL_list ( p ) ;
-    }
-    return ( NULL_type ) ;
+	return (NULL_type);
+}
 /*
     SET TWO TYPES TO BE ARGUMENT COMPATIBLE
     This routine sets the types t and s to be compatible as function
     parameters.
 */
-void accept_argument
-    PROTO_N ( ( t, s ) )
-    PROTO_T ( TYPE t X TYPE s )
-{
-    TYPE pt, ps ;
-    LIST ( TYPE ) p ;
-    t = qualify_type ( t, cv_none, 0 ) ;
-    t = make_param_type ( t, CONTEXT_PARAMETER ) ;
-    s = qualify_type ( s, cv_none, 0 ) ;
-    s = make_param_type ( s, CONTEXT_PARAMETER ) ;
-    pt = find_arg_type ( t ) ;
-    ps = find_arg_type ( s ) ;
-    if ( IS_NULL_type ( ps ) ) ps = s ;
-    if ( !IS_NULL_type ( pt ) ) {
-	/* Already have entry for t */
-	if ( !eq_type ( ps, pt ) ) {
-	    report ( preproc_loc, ERR_pragma_arg_dup ( t ) ) ;
-	}
-	return ;
-    }
-    pt = type_composite ( ps, t, 0, 1, KILL_err, 0 ) ;
-    if ( !IS_NULL_type ( pt ) ) {
-	report ( preproc_loc, ERR_pragma_arg_cycle () ) ;
-	return ;
-    }
-    p = arg2_types ;
-    CONS_type ( t, arg1_types, arg1_types ) ;
-    CONS_type ( ps, p, arg2_types ) ;
-    while ( !IS_NULL_list ( p ) ) {
-	pt = DEREF_type ( HEAD_list ( p ) ) ;
-	pt = type_composite ( pt, t, 0, 1, KILL_err, 0 ) ;
-	if ( !IS_NULL_type ( pt ) ) COPY_type ( HEAD_list ( p ), ps ) ;
-	p = TAIL_list ( p ) ;
-    }
+void
-    return ;
-}
-/*
-    SET A TYPE TO BE ELLIPSIS COMPATIBLE
-    This routine sets the type t to be compatible with an ellipsis in
-    function parameters.
-*/
-void accept_ellipsis
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+accept_argument(TYPE t, TYPE s)
+{
+	TYPE pt, ps;
-    TYPE r ;
+	LIST(TYPE)p;
-    t = qualify_type ( t, cv_none, 0 ) ;
+	t = qualify_type(t, cv_none, 0);
-    t = make_param_type ( t, CONTEXT_PARAMETER ) ;
+	t = make_param_type(t, CONTEXT_PARAMETER);
+	s = qualify_type(s, cv_none, 0);
+	s = make_param_type(s, CONTEXT_PARAMETER);
+	pt = find_arg_type(t);
+	ps = find_arg_type(s);
+	if (IS_NULL_type(ps)) {
+		ps = s;
+	}
+	if (!IS_NULL_type(pt)) {
+		/* Already have entry for t */
-    r = eq_ellipsis ( t ) ;
+		if (!eq_type(ps, pt)) {
+			report(preproc_loc, ERR_pragma_arg_dup(t));
+		}
+		return;
+	}
+	pt = type_composite(ps, t, 0, 1, KILL_err, 0);
-    if ( IS_NULL_type ( r ) ) {
+	if (!IS_NULL_type(pt)) {
+		report(preproc_loc, ERR_pragma_arg_cycle());
+		return;
+	}
+	p = arg2_types;
-	CONS_type ( t, ell_types, ell_types ) ;
+	CONS_type(t, arg1_types, arg1_types);
+	CONS_type(ps, p, arg2_types);
+	while (!IS_NULL_list(p)) {
+		pt = DEREF_type(HEAD_list(p));
+		pt = type_composite(pt, t, 0, 1, KILL_err, 0);
+		if (!IS_NULL_type(pt)) {
+			COPY_type(HEAD_list(p), ps);
-    }
+		}
+		p = TAIL_list(p);
+	}
-    return ;
+	return;
+}
+/*
+    SET A TYPE TO BE ELLIPSIS COMPATIBLE
+    This routine sets the type t to be compatible with an ellipsis in
+    function parameters.
+*/
+void
+accept_ellipsis(TYPE t)
+{
+	TYPE r;
+	t = qualify_type(t, cv_none, 0);
+	t = make_param_type(t, CONTEXT_PARAMETER);
+	r = eq_ellipsis(t);
+	if (IS_NULL_type(r)) {
+		CONS_type(t, ell_types, ell_types);
+	}
+	return;
+}
 /*
     ARE TWO TYPES ARGUMENT COMPATIBLE?
     This routine checks whether the types t and s are compatible as
     function parameters.  If eq is true then compatibility is only
     checked if one of the types appears in the list of types.  The
     routine returns the composite type.
 */
-TYPE eq_argument
+TYPE
-    PROTO_N ( ( t, s, eq ) )
-    PROTO_T ( TYPE t X TYPE s X int eq )
+eq_argument(TYPE t, TYPE s, int eq)
+{
-    TYPE pt = find_arg_type ( t ) ;
+	TYPE pt = find_arg_type(t);
-    TYPE ps = find_arg_type ( s ) ;
+	TYPE ps = find_arg_type(s);
-    if ( EQ_type ( pt, ps ) ) {
+	if (EQ_type(pt, ps)) {
-	if ( !IS_NULL_type ( pt ) ) return ( pt ) ;
+		if (!IS_NULL_type(pt)) {
+			return (pt);
+		}
+		if (eq) {
-	if ( eq ) return ( NULL_type ) ;
+			return (NULL_type);
-    }
+		}
+	}
-    if ( IS_NULL_type ( pt ) ) pt = t ;
+	if (IS_NULL_type(pt)) {
+		pt = t;
+	}
-    if ( IS_NULL_type ( ps ) ) ps = s ;
+	if (IS_NULL_type(ps)) {
+		ps = s;
+	}
-    pt = type_composite ( pt, ps, 0, 1, KILL_err, 1 ) ;
+	pt = type_composite(pt, ps, 0, 1, KILL_err, 1);
-    return ( pt ) ;
+	return (pt);
+}
 /*
     IS A TYPE ELLIPSIS COMPATIBLE?
     This routine checks whether the type t is compatible with an ellipsis
     in function parameters.
 */
-TYPE eq_ellipsis
+TYPE
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+eq_ellipsis(TYPE t)
 {
-    LIST ( TYPE ) p = ell_types ;
+	LIST(TYPE)p = ell_types;
-    while ( !IS_NULL_list ( p ) ) {
+	while (!IS_NULL_list(p)) {
-	TYPE r = DEREF_type ( HEAD_list ( p ) ) ;
+		TYPE r = DEREF_type(HEAD_list(p));
-	TYPE s = eq_argument ( t, r, 0 ) ;
+		TYPE s = eq_argument(t, r, 0);
-	if ( !IS_NULL_type ( s ) ) return ( s ) ;
+		if (!IS_NULL_type(s)) {
+			return (s);
+		}
-	p = TAIL_list ( p ) ;
+		p = TAIL_list(p);
-    }
+	}
-    return ( NULL_type ) ;
+	return (NULL_type);
 }
 /*
     BASIC TYPES
     These variables stand for the basic types which arise naturally in
     C and C++.  This includes the basic integer and floating-point types,
     bool, size_t and related construct types, void and bottom (the type
     of an expression which does not return), plus a few useful composite
     types.
 */
-TYPE type_builtin [ ORDER_ntype ] ;
+TYPE type_builtin[ORDER_ntype];
-TYPE ptr_type_builtin [ ORDER_ntype ] ;
+TYPE ptr_type_builtin[ORDER_ntype];
-TYPE type_func_void ;
+TYPE type_func_void;
-TYPE type_temp_func ;
+TYPE type_temp_func;
-TYPE type_ellipsis ;
+TYPE type_ellipsis;
-TYPE type_error ;
+TYPE type_error;
 /*
     INITIALISE BASIC TYPES
     This routine initialises the basic types above.
 */
-void init_types
+void
-    PROTO_Z ()
+init_types(void)
+{
-    unsigned long n ;
+	unsigned long n;
-    init_itypes ( 1 ) ;
+	init_itypes(1);
-    for ( n = 0 ; n < ORDER_ntype ; n++ ) {
+	for (n = 0; n < ORDER_ntype; n++) {
-	MAKE_type_ptr ( cv_none, type_builtin [n], ptr_type_builtin [n] ) ;
+		MAKE_type_ptr(cv_none, type_builtin[n], ptr_type_builtin[n]);
-    }
+	}
-    MAKE_type_func ( cv_lvalue, type_void, NULL_list ( TYPE ), 0, cv_lang,
+	MAKE_type_func(cv_lvalue, type_void, NULL_list(TYPE), 0, cv_lang,
-		     NULL_list ( TYPE ), NULL_nspace, NULL_list ( IDENTIFIER ),
+		       NULL_list(TYPE), NULL_nspace, NULL_list(IDENTIFIER),
-		     NULL_list ( TYPE ), type_func_void ) ;
+		       NULL_list(TYPE), type_func_void);
-    MAKE_type_func ( cv_none, type_void, NULL_list ( TYPE ), 0, cv_lang,
+	MAKE_type_func(cv_none, type_void, NULL_list(TYPE), 0, cv_lang,
-		     NULL_list ( TYPE ), NULL_nspace, NULL_list ( IDENTIFIER ),
+		       NULL_list(TYPE), NULL_nspace, NULL_list(IDENTIFIER),
-		     NULL_list ( TYPE ), type_temp_func ) ;
+		       NULL_list(TYPE), type_temp_func);
-    MAKE_type_error ( cv_none, type_error ) ;
+	MAKE_type_error(cv_none, type_error);
-    type_ellipsis = NULL_type ;
+	type_ellipsis = NULL_type;
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

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