WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/construct/chktype.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 "printf.h"
 #include "template.h"
 #include "tok.h"
 #include "tokdef.h"
 #include "token.h"
 /*
     FIND A TYPE TAG
     This routine finds the tag of the type t, ignoring any template
     qualifiers.
 */
-unsigned type_tag
+unsigned
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+type_tag(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	unsigned tag = TAG_type ( t ) ;
+		unsigned tag = TAG_type(t);
-	if ( tag == type_templ_tag ) {
+		if (tag == type_templ_tag) {
-	    TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
+			TYPE s = DEREF_type(type_templ_defn(t));
-	    tag = type_tag ( s ) ;
+			tag = type_tag(s);
+		}
+		return (tag);
+	}
-	return ( tag ) ;
-    }
-    return ( null_tag ) ;
+	return (null_tag);
+}
 /*
     FIND THE CATEGORY OF A TYPE
     to by pt.  If this is a reference type then the result is the category
     of the referenced type (which is always an lvalue).  If it is a tokenised
     type then the token is expanded and returned via pt.
 */
-unsigned type_category
+unsigned
-    PROTO_N ( ( pt ) )
-    PROTO_T ( TYPE *pt )
+type_category(TYPE *pt)
+{
-    TYPE t = *pt ;
+	TYPE t = *pt;
-    unsigned res = CTYPE_NONE ;
+	unsigned res = CTYPE_NONE;
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+		CV_SPEC qual = DEREF_cv(type_qual(t));
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_integer_tag : res = CTYPE_INTEGER ; break ;
+		case type_integer_tag:
+			res = CTYPE_INTEGER;
+			break;
-	    case type_floating_tag : res = CTYPE_FLOAT ; break ;
+		case type_floating_tag:
+			res = CTYPE_FLOAT;
+			break;
-	    case type_top_tag : res = CTYPE_VOID ; break ;
+		case type_top_tag:
+			res = CTYPE_VOID;
+			break;
-	    case type_bottom_tag : res = CTYPE_VOID ; break ;
+		case type_bottom_tag:
+			res = CTYPE_VOID;
+			break;
-	    case type_ptr_tag : res = CTYPE_PTR ; break ;
+		case type_ptr_tag:
+			res = CTYPE_PTR;
+			break;
-	    case type_ptr_mem_tag : res = CTYPE_PTR_MEM ; break ;
+		case type_ptr_mem_tag:
+			res = CTYPE_PTR_MEM;
+			break;
-	    case type_bitfield_tag : res = CTYPE_BITF ; break ;
+		case type_bitfield_tag:
+			res = CTYPE_BITF;
+			break;
-	    case type_compound_tag : res = CTYPE_CLASS ; break ;
+		case type_compound_tag:
+			res = CTYPE_CLASS;
+			break;
-	    case type_enumerate_tag : res = CTYPE_ENUM ; break ;
+		case type_enumerate_tag:
+			res = CTYPE_ENUM;
+			break;
-	    case type_error_tag : res = CTYPE_ERROR ; break ;
+		case type_error_tag:
+			res = CTYPE_ERROR;
+			break;
-	    case type_func_tag :
+		case type_func_tag:
-	    case type_array_tag : {
+		case type_array_tag: {
-		/* Allow for lvalue conversions */
+			/* Allow for lvalue conversions */
-		if ( qual & cv_lvalue ) res = CTYPE_PTR ;
+			if (qual & cv_lvalue) {
+				res = CTYPE_PTR;
+			}
-		break ;
+			break;
-	    }
+		}
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		/* Deal with reference types */
+			/* Deal with reference types */
-		TYPE r = DEREF_type ( type_ref_sub ( t ) ) ;
+			TYPE r = DEREF_type(type_ref_sub(t));
-		TYPE s = r ;
+			TYPE s = r;
-		res = type_category ( &r ) ;
+			res = type_category(&r);
-		if ( !EQ_type ( r, s ) ) {
+			if (!EQ_type(r, s)) {
-		    MAKE_type_ref ( qual, r, r ) ;
+				MAKE_type_ref(qual, r, r);
-		    *pt = r ;
+				*pt = r;
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case type_token_tag : {
+		case type_token_tag: {
-		/* Deal with tokenised types */
+			/* Deal with tokenised types */
-		IDENTIFIER id = DEREF_id ( type_token_tok ( t ) ) ;
+			IDENTIFIER id = DEREF_id(type_token_tok(t));
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		if ( ds & dspec_temp ) {
+			if (ds & dspec_temp) {
-		    /* Check for recursive tokens */
+				/* Check for recursive tokens */
-		    report ( crt_loc, ERR_token_recursive ( id ) ) ;
+				report(crt_loc, ERR_token_recursive(id));
-		} else {
+			} else {
-		    /* Expand token definition */
+				/* Expand token definition */
-		    TYPE r = expand_type ( t, 0 ) ;
+				TYPE r = expand_type(t, 0);
-		    if ( !EQ_type ( r, t ) ) {
+				if (!EQ_type(r, t)) {
-			COPY_dspec ( id_storage ( id ), ( ds | dspec_temp ) ) ;
+					COPY_dspec(id_storage(id),
+						   (ds | dspec_temp));
-			res = type_category ( &r ) ;
+					res = type_category(&r);
-			COPY_dspec ( id_storage ( id ), ds ) ;
+					COPY_dspec(id_storage(id), ds);
-			*pt = r ;
+					*pt = r;
-		    } else {
+				} else {
-			if ( is_templ_param ( id ) && in_template_decl ) {
+					if (is_templ_param(id) &&
+					    in_template_decl) {
-			    res |= CTYPE_TEMPL ;
+						res |= CTYPE_TEMPL;
-			}
+					}
-		    }
+				}
-		}
+			}
-		res |= CTYPE_TOKEN ;
+			res |= CTYPE_TOKEN;
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-	if ( qual & cv_lvalue ) res |= CTYPE_LVALUE ;
+		if (qual & cv_lvalue) {
+			res |= CTYPE_LVALUE;
-    }
+		}
+	}
-    return ( res ) ;
+	return (res);
 }
 /*
     ARE TWO INTEGRAL TYPES EQUAL?
     This routine checks whether the integral types s and t are equal.
 */
-int eq_itype
+int
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( INT_TYPE s X INT_TYPE t )
+eq_itype(INT_TYPE s, INT_TYPE t)
 {
-    int eq = 0 ;
+	int eq = 0;
-    unsigned ns, nt ;
+	unsigned ns, nt;
-    if ( EQ_itype ( s, t ) ) return ( 1 ) ;
+	if (EQ_itype(s, t)) {
+		return (1);
+	}
-    if ( IS_NULL_itype ( s ) ) return ( 0 ) ;
+	if (IS_NULL_itype(s)) {
+		return (0);
+	}
-    if ( IS_NULL_itype ( t ) ) return ( 0 ) ;
+	if (IS_NULL_itype(t)) {
+		return (0);
+	}
-    s = expand_itype ( s ) ;
+	s = expand_itype(s);
-    t = expand_itype ( t ) ;
+	t = expand_itype(t);
-    if ( EQ_itype ( s, t ) ) return ( 1 ) ;
+	if (EQ_itype(s, t)) {
+		return (1);
+	}
-    ns = TAG_itype ( s ) ;
+	ns = TAG_itype(s);
-    nt = TAG_itype ( t ) ;
+	nt = TAG_itype(t);
-    if ( ns == nt ) {
+	if (ns == nt) {
-	ASSERT ( ORDER_itype == 6 ) ;
+		ASSERT(ORDER_itype == 6);
-	switch ( ns ) {
+		switch (ns) {
-	    case itype_basic_tag : {
+		case itype_basic_tag: {
-		/* Built-in types */
+			/* Built-in types */
-		BUILTIN_TYPE bs = DEREF_ntype ( itype_basic_no ( s ) ) ;
+			BUILTIN_TYPE bs = DEREF_ntype(itype_basic_no(s));
-		BUILTIN_TYPE bt = DEREF_ntype ( itype_basic_no ( t ) ) ;
+			BUILTIN_TYPE bt = DEREF_ntype(itype_basic_no(t));
-		if ( bs == bt ) eq = 1 ;
+			if (bs == bt) {
+				eq = 1;
+			}
-		break ;
+			break;
-	    }
+		}
-	    case itype_bitfield_tag : {
+		case itype_bitfield_tag: {
-		/* Bitfield types */
+			/* Bitfield types */
-		BASE_TYPE bs = DEREF_btype ( itype_bitfield_rep ( s ) ) ;
+			BASE_TYPE bs = DEREF_btype(itype_bitfield_rep(s));
-		BASE_TYPE bt = DEREF_btype ( itype_bitfield_rep ( t ) ) ;
+			BASE_TYPE bt = DEREF_btype(itype_bitfield_rep(t));
-		if ( bs == bt ) {
+			if (bs == bt) {
-		    NAT ms = DEREF_nat ( itype_bitfield_size ( s ) ) ;
+				NAT ms = DEREF_nat(itype_bitfield_size(s));
-		    NAT mt = DEREF_nat ( itype_bitfield_size ( t ) ) ;
+				NAT mt = DEREF_nat(itype_bitfield_size(t));
-		    if ( EQ_nat ( ms, mt ) || eq_nat ( ms, mt ) ) {
+				if (EQ_nat(ms, mt) || eq_nat(ms, mt)) {
+					TYPE ps =
-			TYPE ps = DEREF_type ( itype_bitfield_sub ( s ) ) ;
+					    DEREF_type(itype_bitfield_sub(s));
+					TYPE pt =
-			TYPE pt = DEREF_type ( itype_bitfield_sub ( t ) ) ;
+					    DEREF_type(itype_bitfield_sub(t));
-			eq = eq_type ( ps, pt ) ;
+					eq = eq_type(ps, pt);
-		    }
+				}
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case itype_promote_tag : {
+		case itype_promote_tag: {
-		/* Promotion types */
+			/* Promotion types */
-		s = DEREF_itype ( itype_promote_arg ( s ) ) ;
+			s = DEREF_itype(itype_promote_arg(s));
-		t = DEREF_itype ( itype_promote_arg ( t ) ) ;
+			t = DEREF_itype(itype_promote_arg(t));
-		eq = eq_itype ( s, t ) ;
+			eq = eq_itype(s, t);
-		break ;
+			break;
-	    }
+		}
-	    case itype_arith_tag : {
+		case itype_arith_tag: {
-		/* Arithmetic types */
+			/* Arithmetic types */
-		INT_TYPE s1 = DEREF_itype ( itype_arith_arg1 ( s ) ) ;
+			INT_TYPE s1 = DEREF_itype(itype_arith_arg1(s));
-		INT_TYPE s2 = DEREF_itype ( itype_arith_arg2 ( s ) ) ;
+			INT_TYPE s2 = DEREF_itype(itype_arith_arg2(s));
-		INT_TYPE t1 = DEREF_itype ( itype_arith_arg1 ( t ) ) ;
+			INT_TYPE t1 = DEREF_itype(itype_arith_arg1(t));
-		INT_TYPE t2 = DEREF_itype ( itype_arith_arg2 ( t ) ) ;
+			INT_TYPE t2 = DEREF_itype(itype_arith_arg2(t));
-		if ( eq_itype ( s1, t1 ) ) {
+			if (eq_itype(s1, t1)) {
-		    eq = eq_itype ( s2, t2 ) ;
+				eq = eq_itype(s2, t2);
-		} else if ( eq_itype ( s1, t2 ) ) {
+			} else if (eq_itype(s1, t2)) {
-		    eq = eq_itype ( s2, t1 ) ;
+				eq = eq_itype(s2, t1);
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case itype_literal_tag : {
+		case itype_literal_tag: {
-		/* Literal types */
+			/* Literal types */
-		int bs = DEREF_int ( itype_literal_spec ( s ) ) ;
+			int bs = DEREF_int(itype_literal_spec(s));
-		int bt = DEREF_int ( itype_literal_spec ( t ) ) ;
+			int bt = DEREF_int(itype_literal_spec(t));
-		IDENTIFIER is = DEREF_id ( itype_literal_tok ( s ) ) ;
+			IDENTIFIER is = DEREF_id(itype_literal_tok(s));
-		IDENTIFIER it = DEREF_id ( itype_literal_tok ( t ) ) ;
+			IDENTIFIER it = DEREF_id(itype_literal_tok(t));
-		NAT ms = DEREF_nat ( itype_literal_nat ( s ) ) ;
+			NAT ms = DEREF_nat(itype_literal_nat(s));
-		NAT mt = DEREF_nat ( itype_literal_nat ( t ) ) ;
+			NAT mt = DEREF_nat(itype_literal_nat(t));
-		if ( bs == bt && EQ_id ( is, it ) && eq_nat ( ms, mt ) ) {
+			if (bs == bt && EQ_id(is, it) && eq_nat(ms, mt)) {
-		    eq = 1 ;
+				eq = 1;
-		}
+			}
-		break ;
+			break;
-	    }
+		}
-	    case itype_token_tag : {
+		case itype_token_tag: {
-		/* Token applications */
+			/* Token applications */
-		IDENTIFIER is = DEREF_id ( itype_token_tok ( s ) ) ;
+			IDENTIFIER is = DEREF_id(itype_token_tok(s));
-		IDENTIFIER it = DEREF_id ( itype_token_tok ( t ) ) ;
+			IDENTIFIER it = DEREF_id(itype_token_tok(t));
-		LIST ( TOKEN ) ps = DEREF_list ( itype_token_args ( s ) ) ;
+			LIST(TOKEN)ps = DEREF_list(itype_token_args(s));
-		LIST ( TOKEN ) pt = DEREF_list ( itype_token_args ( t ) ) ;
+			LIST(TOKEN)pt = DEREF_list(itype_token_args(t));
-		eq = eq_token_args ( is, it, ps, pt ) ;
+			eq = eq_token_args(is, it, ps, pt);
-		break ;
+			break;
-	    }
+		}
-	}
+		}
-    }
+	}
-    return ( eq ) ;
+	return (eq);
 }
 /*
     ARE TWO FLOATING POINT TYPES EQUAL?
     This routine checks whether the floating point types s and t are equal.
 */
-int eq_ftype
+int
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( FLOAT_TYPE s X FLOAT_TYPE t )
+eq_ftype(FLOAT_TYPE s, FLOAT_TYPE t)
+{
-    int eq = 0 ;
+	int eq = 0;
-    unsigned ns, nt ;
+	unsigned ns, nt;
-    if ( EQ_ftype ( s, t ) ) return ( 1 ) ;
-    if ( IS_NULL_ftype ( s ) ) return ( 0 ) ;
-    if ( IS_NULL_ftype ( t ) ) return ( 0 ) ;
-    ns = TAG_ftype ( s ) ;
-    nt = TAG_ftype ( t ) ;
-    if ( ns == nt ) {
-	ASSERT ( ORDER_ftype == 4 ) ;
-	switch ( ns ) {
-	    case ftype_basic_tag : {
-		/* Built-in types */
-		BUILTIN_TYPE bs = DEREF_ntype ( ftype_basic_no ( s ) ) ;
-		BUILTIN_TYPE bt = DEREF_ntype ( ftype_basic_no ( t ) ) ;
-		if ( bs == bt ) eq = 1 ;
-		break ;
-	    }
-	    case ftype_arg_promote_tag : {
-		/* Argument promotion types */
-		FLOAT_TYPE s1 = DEREF_ftype ( ftype_arg_promote_arg ( s ) ) ;
-		FLOAT_TYPE t1 = DEREF_ftype ( ftype_arg_promote_arg ( t ) ) ;
-		eq = eq_ftype ( s1, t1 ) ;
-		break ;
-	    }
-	    case ftype_arith_tag : {
-		/* Arithmetic types */
-		FLOAT_TYPE s1 = DEREF_ftype ( ftype_arith_arg1 ( s ) ) ;
-		FLOAT_TYPE s2 = DEREF_ftype ( ftype_arith_arg2 ( s ) ) ;
-		FLOAT_TYPE t1 = DEREF_ftype ( ftype_arith_arg1 ( t ) ) ;
-		FLOAT_TYPE t2 = DEREF_ftype ( ftype_arith_arg2 ( t ) ) ;
-		if ( eq_ftype ( s1, t1 ) ) {
+	if (EQ_ftype(s, t)) {
-		    eq = eq_ftype ( s2, t2 ) ;
-		} else if ( eq_ftype ( s1, t2 ) ) {
-		    eq = eq_ftype ( s2, t1 ) ;
-		}
-		break ;
-	    }
-	    case ftype_token_tag : {
-		/* Token applications */
-		IDENTIFIER is = DEREF_id ( ftype_token_tok ( s ) ) ;
-		IDENTIFIER it = DEREF_id ( ftype_token_tok ( t ) ) ;
-		LIST ( TOKEN ) ps = DEREF_list ( ftype_token_args ( s ) ) ;
-		LIST ( TOKEN ) pt = DEREF_list ( ftype_token_args ( t ) ) ;
-		eq = eq_token_args ( is, it, ps, pt ) ;
-		break ;
+		return (1);
-	    }
+	}
+	if (IS_NULL_ftype(s)) {
+		return (0);
+	}
+	if (IS_NULL_ftype(t)) {
+		return (0);
+	}
+	ns = TAG_ftype(s);
+	nt = TAG_ftype(t);
+	if (ns == nt) {
+		ASSERT(ORDER_ftype == 4);
+		switch (ns) {
+		case ftype_basic_tag: {
+			/* Built-in types */
+			BUILTIN_TYPE bs = DEREF_ntype(ftype_basic_no(s));
+			BUILTIN_TYPE bt = DEREF_ntype(ftype_basic_no(t));
+			if (bs == bt) {
+				eq = 1;
+			}
+			break;
+		}
+		case ftype_arg_promote_tag: {
+			/* Argument promotion types */
+			FLOAT_TYPE s1 = DEREF_ftype(ftype_arg_promote_arg(s));
+			FLOAT_TYPE t1 = DEREF_ftype(ftype_arg_promote_arg(t));
+			eq = eq_ftype(s1, t1);
+			break;
+		}
+		case ftype_arith_tag: {
+			/* Arithmetic types */
+			FLOAT_TYPE s1 = DEREF_ftype(ftype_arith_arg1(s));
+			FLOAT_TYPE s2 = DEREF_ftype(ftype_arith_arg2(s));
+			FLOAT_TYPE t1 = DEREF_ftype(ftype_arith_arg1(t));
+			FLOAT_TYPE t2 = DEREF_ftype(ftype_arith_arg2(t));
+			if (eq_ftype(s1, t1)) {
+				eq = eq_ftype(s2, t2);
+			} else if (eq_ftype(s1, t2)) {
+				eq = eq_ftype(s2, t1);
-    }
+			}
+			break;
+		}
+		case ftype_token_tag: {
+			/* Token applications */
+			IDENTIFIER is = DEREF_id(ftype_token_tok(s));
+			IDENTIFIER it = DEREF_id(ftype_token_tok(t));
+			LIST(TOKEN)ps = DEREF_list(ftype_token_args(s));
+			LIST(TOKEN)pt = DEREF_list(ftype_token_args(t));
+			eq = eq_token_args(is, it, ps, pt);
+			break;
+		}
+		}
+	}
-    return ( eq ) ;
+	return (eq);
+}
 /*
     FIND THE CV-QUALIFIER FOR A TYPE
     This routine finds the cv-qualifier for the type t.  In most cases this
     is trivial, but for arrays the qualifier is that of the subtype.
 */
-CV_SPEC find_cv_qual
+CV_SPEC
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+find_cv_qual(TYPE t)
+{
-    CV_SPEC qt = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qt = DEREF_cv(type_qual(t));
-    while ( IS_type_array ( t ) ) {
+	while (IS_type_array(t)) {
-	CV_SPEC qs ;
+		CV_SPEC qs;
-	t = DEREF_type ( type_array_sub ( t ) ) ;
+		t = DEREF_type(type_array_sub(t));
-	qs = DEREF_cv ( type_qual ( t ) ) ;
+		qs = DEREF_cv(type_qual(t));
-	qt |= qs ;
+		qt |= qs;
-    }
+	}
-    return ( qt ) ;
+	return (qt);
+}
 /*
     IS ONE TYPE MORE CV-QUALIFIED THAN ANOTHER?
     type t.  That is to say, if t is const then so is s, and if t is volatile
     then so is s.  Otherwise it returns those cv-qualifiers for which s
     fails to be more qualified than t.
 */
-CV_SPEC cv_compare
+CV_SPEC
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( TYPE s X TYPE t )
+cv_compare(TYPE s, TYPE t)
+{
-    CV_SPEC qs = find_cv_qual ( s ) ;
+	CV_SPEC qs = find_cv_qual(s);
-    CV_SPEC qt = find_cv_qual ( t ) ;
+	CV_SPEC qt = find_cv_qual(t);
-    qs &= cv_qual ;
+	qs &= cv_qual;
-    qt &= cv_qual ;
+	qt &= cv_qual;
-    return ( qt & ~qs ) ;
+	return (qt & ~qs);
+}
 /*
     ARE TWO FUNCTION LINKAGE SPECIFIERS THE SAME?
     This routine compares the function linkage specifiers for the function
     types s and t.
 */
-static int eq_func_lang
+static int
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( TYPE s X TYPE t )
+eq_func_lang(TYPE s, TYPE t)
+{
-    CV_SPEC qs = DEREF_cv ( type_func_mqual ( s ) ) ;
+	CV_SPEC qs = DEREF_cv(type_func_mqual(s));
-    CV_SPEC qt = DEREF_cv ( type_func_mqual ( t ) ) ;
+	CV_SPEC qt = DEREF_cv(type_func_mqual(t));
-    if ( qs != qt ) {
+	if (qs != qt) {
-	CV_SPEC ps = ( qs & cv_language ) ;
+		CV_SPEC ps = (qs & cv_language);
-	CV_SPEC pt = ( qt & cv_language ) ;
+		CV_SPEC pt = (qt & cv_language);
-	if ( ps != pt ) {
+		if (ps != pt) {
-	    if ( ps == cv_none ) {
+			if (ps == cv_none) {
-		if ( force_tokdef ) {
+				if (force_tokdef) {
-		    ps = pt ;
+					ps = pt;
-		    COPY_cv ( type_func_mqual ( s ), ( qs | ps ) ) ;
+					COPY_cv(type_func_mqual(s), (qs | ps));
-		} else {
+				} else {
-		    ps = cv_lang ;
+					ps = cv_lang;
-		}
+				}
-	    }
+			}
-	    if ( pt == cv_none ) {
+			if (pt == cv_none) {
-		if ( force_tokdef ) {
+				if (force_tokdef) {
-		    pt = ps ;
+					pt = ps;
-		    COPY_cv ( type_func_mqual ( t ), ( qt | pt ) ) ;
+					COPY_cv(type_func_mqual(t), (qt | pt));
-		} else {
+				} else {
-		    pt = cv_lang ;
+					pt = cv_lang;
-		}
+				}
-	    }
+			}
-	    if ( ps != pt ) return ( 0 ) ;
+			if (ps != pt) {
+				return (0);
+			}
-	}
+		}
-    }
+	}
-    return ( 1 ) ;
+	return (1);
 }
 /*
     ARE TWO FUNCTION TYPES EQUAL?
     This routine checks whether the function types s and t are equal.
     Member function qualifiers are only considered if mq is true.
     If rf is true then any parameter of type 'X' is considered to match
     one of type 'X &'.  The routine returns 3 if the types are precisely
     equal, 2 if they differ only in the linkage specifier, 1 if they
     differ only in the return type or in one of these reference
     equalities, and 0 otherwise.
 */
-int eq_func_type
+int
-    PROTO_N ( ( s, t, mq, rf ) )
-    PROTO_T ( TYPE s X TYPE t X int mq X int rf )
+eq_func_type(TYPE s, TYPE t, int mq, int rf)
 {
-    int eq = 3 ;
+	int eq = 3;
-    int es, et ;
+	int es, et;
-    unsigned ns, nt ;
+	unsigned ns, nt;
-    LIST ( TYPE ) ls, lt ;
+	LIST(TYPE)ls, lt;
-    /* Check for obvious equality */
+	/* Check for obvious equality */
-    if ( EQ_type ( s, t ) ) return ( 3 ) ;
+	if (EQ_type(s, t)) {
+		return (3);
+	}
-    ns = TAG_type ( s ) ;
+	ns = TAG_type(s);
-    nt = TAG_type ( t ) ;
+	nt = TAG_type(t);
-    if ( ns != type_func_tag || nt != type_func_tag ) {
+	if (ns != type_func_tag || nt != type_func_tag) {
-	if ( ns == type_templ_tag && nt == type_templ_tag ) {
+		if (ns == type_templ_tag && nt == type_templ_tag) {
-	    /* Allow for template functions */
+			/* Allow for template functions */
-	    eq = eq_template ( s, t, 1, mq, rf ) ;
+			eq = eq_template(s, t, 1, mq, rf);
-	    return ( eq ) ;
+			return (eq);
-	} else {
+		} else {
-	    /* Otherwise just check type equality */
+			/* Otherwise just check type equality */
-	    eq = eq_type ( s, t ) ;
+			eq = eq_type(s, t);
-	    if ( eq == 1 ) return ( 3 ) ;
+			if (eq == 1) {
+				return (3);
+			}
-	    return ( 0 ) ;
+			return (0);
-	}
+		}
-    }
+	}
-    /* Check number of parameters */
+	/* Check number of parameters */
-    es = DEREF_int ( type_func_ellipsis ( s ) ) ;
+	es = DEREF_int(type_func_ellipsis(s));
-    et = DEREF_int ( type_func_ellipsis ( t ) ) ;
+	et = DEREF_int(type_func_ellipsis(t));
-    ls = DEREF_list ( type_func_ptypes ( s ) ) ;
+	ls = DEREF_list(type_func_ptypes(s));
-    lt = DEREF_list ( type_func_ptypes ( t ) ) ;
+	lt = DEREF_list(type_func_ptypes(t));
-    if ( es != et || LENGTH_list ( ls ) != LENGTH_list ( lt ) ) {
+	if (es != et || LENGTH_list(ls)!= LENGTH_list(lt)) {
-	return ( 0 ) ;
+		return (0);
-    }
+	}
-    /* Check parameter types */
+	/* Check parameter types */
-    while ( !IS_NULL_list ( ls ) ) {
+	while (!IS_NULL_list(ls)) {
-	/* Check next parameter */
+		/* Check next parameter */
-	TYPE as = DEREF_type ( HEAD_list ( ls ) ) ;
+		TYPE as = DEREF_type(HEAD_list(ls));
-	TYPE at = DEREF_type ( HEAD_list ( lt ) ) ;
+		TYPE at = DEREF_type(HEAD_list(lt));
-	if ( es & FUNC_PARAMS ) {
+		if (es & FUNC_PARAMS) {
-	    /* Compare unpromoted types */
+			/* Compare unpromoted types */
-	    as = unpromote_type ( as ) ;
+			as = unpromote_type(as);
-	    at = unpromote_type ( at ) ;
+			at = unpromote_type(at);
-	}
+		}
-	if ( rf ) {
+		if (rf) {
-	    /* Allow for references */
+			/* Allow for references */
-	    if ( IS_type_ref ( as ) ) {
+			if (IS_type_ref(as)) {
-		if ( !IS_type_ref ( at ) ) {
+				if (!IS_type_ref(at)) {
-		    as = DEREF_type ( type_ref_sub ( as ) ) ;
+					as = DEREF_type(type_ref_sub(as));
-		    eq = 1 ;
+					eq = 1;
-		}
+				}
-	    } else if ( IS_type_ref ( at ) ) {
+			} else if (IS_type_ref(at)) {
-		at = DEREF_type ( type_ref_sub ( at ) ) ;
+				at = DEREF_type(type_ref_sub(at));
-		eq = 1 ;
+				eq = 1;
-	    }
+			}
-	}
+		}
-	if ( eq_type ( as, at ) != 1 ) return ( 0 ) ;
+		if (eq_type(as, at) != 1) {
+			return (0);
+		}
-	if ( force_tokdef ) {
+		if (force_tokdef) {
-	    /* Preserve printf and scanf types */
+			/* Preserve printf and scanf types */
-	    if ( is_printf_type ( as ) ) {
+			if (is_printf_type(as)) {
-		IDENTIFIER id = DEREF_id ( type_name ( as ) ) ;
+				IDENTIFIER id = DEREF_id(type_name(as));
-		COPY_id ( type_name ( at ), id ) ;
+				COPY_id(type_name(at), id);
-	    } else if ( is_printf_type ( at ) ) {
+			} else if (is_printf_type(at)) {
-		IDENTIFIER id = DEREF_id ( type_name ( at ) ) ;
+				IDENTIFIER id = DEREF_id(type_name(at));
-		COPY_id ( type_name ( as ), id ) ;
+				COPY_id(type_name(as), id);
+			}
+		}
+		ls = TAIL_list(ls);
+		lt = TAIL_list(lt);
+	}
+	/* Check return type */
+	if (eq == 3) {
+		TYPE rs = DEREF_type(type_func_ret(s));
+		TYPE rt = DEREF_type(type_func_ret(t));
+		if (eq_type(rt, rs)!= 1) {
+			if (IS_type_top_etc(rs)) {
+				/* Check for 'void' and 'bottom' */
+				TYPE r = type_composite(rs, rt, 0, 1, KILL_err,
+);
+				if (IS_NULL_type(r)) {
+					eq = 1;
-	    }
+				}
+			} else {
+				eq = 1;
+			}
+		}
+	}
-	ls = TAIL_list ( ls ) ;
-	lt = TAIL_list ( lt ) ;
-    }
-    /* Check return type */
+	/* Check member qualifiers */
-    if ( eq == 3 ) {
+	if (eq) {
-	TYPE rs = DEREF_type ( type_func_ret ( s ) ) ;
+		CV_SPEC qs = DEREF_cv(type_func_mqual(s));
-	TYPE rt = DEREF_type ( type_func_ret ( t ) ) ;
+		CV_SPEC qt = DEREF_cv(type_func_mqual(t));
-	if ( eq_type ( rt, rs ) != 1 ) {
+		if (qs != qt) {
-	    if ( IS_type_top_etc ( rs ) ) {
+			if (mq && (qs & cv_qual)!= (qt & cv_qual)) {
+				eq = 0;
-		/* Check for 'void' and 'bottom' */
+			} else if (!eq_func_lang(s, t)) {
-		TYPE r = type_composite ( rs, rt, 0, 1, KILL_err, 0 ) ;
+				/* Linkage specifiers don't match */
-		if ( IS_NULL_type ( r ) ) eq = 1 ;
+				if (eq == 3 && option(OPT_func_linkage)) {
-	    } else {
+					eq = 2;
-		eq = 1 ;
+				}
-	    }
+			}
+		}
+	}
-    }
-    /* Check member qualifiers */
-    if ( eq ) {
-	CV_SPEC qs = DEREF_cv ( type_func_mqual ( s ) ) ;
-	CV_SPEC qt = DEREF_cv ( type_func_mqual ( t ) ) ;
-	if ( qs != qt ) {
-	    if ( mq && ( qs & cv_qual ) != ( qt & cv_qual ) ) {
-		eq = 0 ;
-	    } else if ( !eq_func_lang ( s, t ) ) {
-		/* Linkage specifiers don't match */
-		if ( eq == 3 && option ( OPT_func_linkage ) ) eq = 2 ;
-	    }
-	}
-    }
-    return ( eq ) ;
+	return (eq);
 }
 /*
     CHECK EQUALITY OF NESTED TEMPLATE CLASS
     This routine checks whether the instance s of a nested class or
     enumeration type of a template class equals the type tid.
 */
-static int eq_instance
+static int
-    PROTO_N ( ( s, tid ) )
-    PROTO_T ( TYPE s X IDENTIFIER tid )
+eq_instance(TYPE s, IDENTIFIER tid)
+{
-    if ( IS_type_instance ( s ) ) {
+	if (IS_type_instance(s)) {
-	IDENTIFIER sid = DEREF_id ( type_instance_id ( s ) ) ;
+		IDENTIFIER sid = DEREF_id(type_instance_id(s));
-	if ( EQ_id ( sid, tid ) ) {
+		if (EQ_id(sid, tid)) {
-	    CLASS_TYPE cs, ct ;
+			CLASS_TYPE cs, ct;
-	    sid = DEREF_id ( type_name ( s ) ) ;
+			sid = DEREF_id(type_name(s));
-	    if ( EQ_id ( sid, tid ) ) return ( 1 ) ;
+			if (EQ_id(sid, tid)) {
+				return (1);
+			}
-	    cs = parent_class ( sid ) ;
+			cs = parent_class(sid);
-	    ct = parent_class ( tid ) ;
+			ct = parent_class(tid);
-	    if ( IS_NULL_ctype ( cs ) ) return ( 0 ) ;
+			if (IS_NULL_ctype(cs)) {
+				return (0);
+			}
-	    if ( IS_NULL_ctype ( ct ) ) return ( 0 ) ;
+			if (IS_NULL_ctype(ct)) {
+				return (0);
+			}
-	    return ( eq_ctype ( cs, ct ) ) ;
+			return (eq_ctype(cs, ct));
+		}
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CHECK EQUALITY OF CLASS TYPES
     This routine checks for equality of the class types cs and ct.
 */
-int eq_ctype
+int
-    PROTO_N ( ( cs, ct ) )
-    PROTO_T ( CLASS_TYPE cs X CLASS_TYPE ct )
+eq_ctype(CLASS_TYPE cs, CLASS_TYPE ct)
 {
-    if ( EQ_ctype ( cs, ct ) ) {
+	if (EQ_ctype(cs, ct)) {
-	/* Simple class equality */
+		/* Simple class equality */
-	return ( 1 ) ;
+		return (1);
-    }
+	}
-    if ( !IS_NULL_ctype ( cs ) && !IS_NULL_ctype ( ct ) ) {
+	if (!IS_NULL_ctype(cs) && !IS_NULL_ctype(ct)) {
-	TYPE s = DEREF_type ( ctype_form ( cs ) ) ;
+		TYPE s = DEREF_type(ctype_form(cs));
-	TYPE t = DEREF_type ( ctype_form ( ct ) ) ;
+		TYPE t = DEREF_type(ctype_form(ct));
-	if ( !IS_NULL_type ( s ) || !IS_NULL_type ( t ) ) {
+		if (!IS_NULL_type(s) || !IS_NULL_type(t)) {
-	    /* Allow for template classes */
+			/* Allow for template classes */
-	    unsigned ns, nt ;
+			unsigned ns, nt;
+			if (IS_NULL_type(s)) {
-	    if ( IS_NULL_type ( s ) ) s = make_class_type ( cs ) ;
+				s = make_class_type(cs);
+			}
+			if (IS_NULL_type(t)) {
-	    if ( IS_NULL_type ( t ) ) t = make_class_type ( ct ) ;
+				t = make_class_type(ct);
+			}
-	    ns = TAG_type ( s ) ;
+			ns = TAG_type(s);
-	    nt = TAG_type ( t ) ;
+			nt = TAG_type(t);
-	    if ( ns != nt ) {
+			if (ns != nt) {
-		if ( ns == type_instance_tag ) {
+				if (ns == type_instance_tag) {
+					IDENTIFIER tid =
-		    IDENTIFIER tid = DEREF_id ( ctype_name ( ct ) ) ;
+					    DEREF_id(ctype_name(ct));
-		    if ( eq_instance ( s, tid ) ) return ( 1 ) ;
+					if (eq_instance(s, tid)) {
+						return (1);
+					}
-		}
+				}
-		if ( nt == type_instance_tag ) {
+				if (nt == type_instance_tag) {
+					IDENTIFIER sid =
-		    IDENTIFIER sid = DEREF_id ( ctype_name ( cs ) ) ;
+					    DEREF_id(ctype_name(cs));
-		    if ( eq_instance ( t, sid ) ) return ( 1 ) ;
+					if (eq_instance(t, sid)) {
+						return (1);
+					}
-		}
+				}
-	    }
+			}
-	    return ( eq_type ( s, t ) ) ;
+			return (eq_type(s, t));
-	}
+		}
-	if ( force_merge ) {
+		if (force_merge) {
-	    /* Allow for merging of type names */
+			/* Allow for merging of type names */
-	    IDENTIFIER sid = DEREF_id ( ctype_name ( cs ) ) ;
+			IDENTIFIER sid = DEREF_id(ctype_name(cs));
-	    IDENTIFIER tid = DEREF_id ( ctype_name ( ct ) ) ;
+			IDENTIFIER tid = DEREF_id(ctype_name(ct));
-	    return ( merge_type ( sid, tid ) ) ;
+			return (merge_type(sid, tid));
-	}
+		}
-    }
-    return ( 0 ) ;
-}
-/*
-    CHECK EQUALITY OF ENUMERATION TYPES
-    This routine checks for equality of the enumeration types es and et.
-*/
-int eq_etype
-    PROTO_N ( ( es, et ) )
-    PROTO_T ( ENUM_TYPE es X ENUM_TYPE et )
-{
-    if ( EQ_etype ( es, et ) ) {
-	/* Simple equality */
-	return ( 1 ) ;
-    }
-    if ( !IS_NULL_etype ( es ) && !IS_NULL_etype ( et ) ) {
-	TYPE s = DEREF_type ( etype_form ( es ) ) ;
-	TYPE t = DEREF_type ( etype_form ( et ) ) ;
-	if ( !IS_NULL_type ( s ) && !IS_NULL_type ( t ) ) {
-	    return ( eq_type ( s, t ) ) ;
+	}
+	return (0);
+}
+/*
-	if ( !IS_NULL_type ( s ) ) {
+    CHECK EQUALITY OF ENUMERATION TYPES
-	    IDENTIFIER tid = DEREF_id ( etype_name ( et ) ) ;
+    This routine checks for equality of the enumeration types es and et.
+*/
+int
+eq_etype(ENUM_TYPE es, ENUM_TYPE et)
+{
-	    return ( eq_instance ( s, tid ) ) ;
+	if (EQ_etype(es, et)) {
+		/* Simple equality */
+		return (1);
+	}
+	if (!IS_NULL_etype(es) && !IS_NULL_etype(et)) {
+		TYPE s = DEREF_type(etype_form(es));
+		TYPE t = DEREF_type(etype_form(et));
+		if (!IS_NULL_type(s) && !IS_NULL_type(t)) {
+			return (eq_type(s, t));
+		}
+		if (!IS_NULL_type(s)) {
+			IDENTIFIER tid = DEREF_id(etype_name(et));
+			return (eq_instance(s, tid));
+		}
-	if ( !IS_NULL_type ( t ) ) {
+		if (!IS_NULL_type(t)) {
-	    IDENTIFIER sid = DEREF_id ( etype_name ( es ) ) ;
+			IDENTIFIER sid = DEREF_id(etype_name(es));
-	    return ( eq_instance ( t, sid ) ) ;
+			return (eq_instance(t, sid));
+		}
+		if (force_merge) {
+			/* Allow for merging of type names */
+			IDENTIFIER sid = DEREF_id(etype_name(es));
+			IDENTIFIER tid = DEREF_id(etype_name(et));
+			return (merge_type(sid, tid));
+		}
+	}
-	if ( force_merge ) {
-	    /* Allow for merging of type names */
-	    IDENTIFIER sid = DEREF_id ( etype_name ( es ) ) ;
-	    IDENTIFIER tid = DEREF_id ( etype_name ( et ) ) ;
-	    return ( merge_type ( sid, tid ) ) ;
-	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CHECK TYPE EQUALITY
     This is an auxiliary routine used by eq_type_qual which checks the
     types s and t for equality ignoring qualifiers according to the
     value of qu.  If either s or t is a template type and force_template
     is true then 1 is returned if the types are precisely equal, 2 is
     returned if t is a specialisation of s, 3 if s is a specialisation
     of t, 4 if each is a specialisation of the other (but they are not
     equal) and 0 otherwise.
 */
-static int eq_type_aux
+static int
-    PROTO_N ( ( s, t, qu ) )
-    PROTO_T ( TYPE s X TYPE t X int qu )
+eq_type_aux(TYPE s, TYPE t, int qu)
+{
-    /* Check for obvious equality */
+	/* Check for obvious equality */
-    unsigned ns, nt ;
+	unsigned ns, nt;
-    if ( EQ_type ( s, t ) ) return ( 1 ) ;
+	if (EQ_type(s, t)) {
+		return (1);
+	}
-    if ( IS_NULL_type ( s ) ) return ( 0 ) ;
+	if (IS_NULL_type(s)) {
+		return (0);
+	}
-    if ( IS_NULL_type ( t ) ) return ( 0 ) ;
+	if (IS_NULL_type(t)) {
+		return (0);
+	}
-    /* Tags should be equal */
+	/* Tags should be equal */
-    ns = TAG_type ( s ) ;
+	ns = TAG_type(s);
-    nt = TAG_type ( t ) ;
+	nt = TAG_type(t);
-    if ( ns != nt ) {
+	if (ns != nt) {
-	if ( ns == type_templ_tag && force_template ) {
+		if (ns == type_templ_tag && force_template) {
-	    /* Allow for template types */
+			/* Allow for template types */
-	    if ( deduce_template ( s, t, qu ) ) return ( 2 ) ;
+			if (deduce_template(s, t, qu)) {
+				return (2);
+			}
-	}
+		}
-	if ( nt == type_templ_tag && force_template ) {
+		if (nt == type_templ_tag && force_template) {
-	    /* Allow for template types */
+			/* Allow for template types */
-	    if ( deduce_template ( t, s, qu ) ) return ( 3 ) ;
+			if (deduce_template(t, s, qu)) {
+				return (3);
+			}
-	}
+		}
-	return ( 0 ) ;
+		return (0);
-    }
+	}
-    /* Qualifiers should be equal */
+	/* Qualifiers should be equal */
-    if ( qu == 0 ) {
+	if (qu == 0) {
-	CV_SPEC qs = DEREF_cv ( type_qual ( s ) ) ;
+		CV_SPEC qs = DEREF_cv(type_qual(s));
-	CV_SPEC qt = DEREF_cv ( type_qual ( t ) ) ;
+		CV_SPEC qt = DEREF_cv(type_qual(t));
-	if ( qs != qt ) {
+		if (qs != qt) {
-	    /* Try again allowing for lvalues */
+			/* Try again allowing for lvalues */
-	    qs &= cv_qual ;
+			qs &= cv_qual;
-	    qt &= cv_qual ;
+			qt &= cv_qual;
-	    if ( qs != qt ) return ( 0 ) ;
+			if (qs != qt) {
+				return (0);
+			}
-	}
+		}
-    }
+	}
-    /* Check on type components */
+	/* Check on type components */
-    ASSERT ( ORDER_type == 18 ) ;
+	ASSERT(ORDER_type == 18);
-    switch ( ns ) {
+	switch (ns) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    /* Check integer types */
+		/* Check integer types */
-	    INT_TYPE is = DEREF_itype ( type_integer_rep ( s ) ) ;
+		INT_TYPE is = DEREF_itype(type_integer_rep(s));
-	    INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
-	    if ( EQ_itype ( is, it ) ) return ( 1 ) ;
+		if (EQ_itype(is, it)) {
+			return (1);
+		}
-	    return ( eq_itype ( is, it ) ) ;
+		return (eq_itype(is, it));
 	}
-	case type_floating_tag : {
+	case type_floating_tag: {
-	    /* Check floating types */
+		/* Check floating types */
-	    FLOAT_TYPE fs = DEREF_ftype ( type_floating_rep ( s ) ) ;
+		FLOAT_TYPE fs = DEREF_ftype(type_floating_rep(s));
-	    FLOAT_TYPE ft = DEREF_ftype ( type_floating_rep ( t ) ) ;
+		FLOAT_TYPE ft = DEREF_ftype(type_floating_rep(t));
-	    if ( EQ_ftype ( fs, ft ) ) return ( 1 ) ;
+		if (EQ_ftype(fs, ft)) {
+			return (1);
+		}
-	    return ( eq_ftype ( fs, ft ) ) ;
+		return (eq_ftype(fs, ft));
 	}
-	case type_ptr_tag : {
+	case type_ptr_tag: {
-	    /* Check pointer sub-types */
+		/* Check pointer sub-types */
-	    s = DEREF_type ( type_ptr_sub ( s ) ) ;
+		s = DEREF_type(type_ptr_sub(s));
-	    t = DEREF_type ( type_ptr_sub ( t ) ) ;
+		t = DEREF_type(type_ptr_sub(t));
-	    if ( qu == 1 ) qu = 0 ;
+		if (qu == 1) {
+			qu = 0;
+		}
-	    return ( eq_type_qual ( s, t, qu ) ) ;
+		return (eq_type_qual(s, t, qu));
 	}
-	case type_ref_tag : {
+	case type_ref_tag: {
-	    /* Check reference sub-types */
+		/* Check reference sub-types */
-	    s = DEREF_type ( type_ref_sub ( s ) ) ;
+		s = DEREF_type(type_ref_sub(s));
-	    t = DEREF_type ( type_ref_sub ( t ) ) ;
+		t = DEREF_type(type_ref_sub(t));
-	    return ( eq_type_qual ( s, t, qu ) ) ;
+		return (eq_type_qual(s, t, qu));
+	}
 #if LANGUAGE_CPP
-	case type_instance_tag : {
+	case type_dummy_tag: {
-	    /* Check instance types */
+		/* Check dummy types */
-	    IDENTIFIER is = DEREF_id ( type_instance_id ( s ) ) ;
-	    IDENTIFIER it = DEREF_id ( type_instance_id ( t ) ) ;
-	    if ( EQ_id ( is, it ) ) {
-		/* Derived from same member */
-		CLASS_TYPE cs, ct ;
-		is = DEREF_id ( type_name ( s ) ) ;
+		int is = DEREF_int(type_dummy_tok(s));
-		it = DEREF_id ( type_name ( t ) ) ;
+		int it = DEREF_int(type_dummy_tok(t));
-		if ( EQ_id ( is, it ) ) return ( 1 ) ;
-		cs = parent_class ( is ) ;
-		ct = parent_class ( it ) ;
-		if ( IS_NULL_ctype ( cs ) ) return ( 0 ) ;
-		if ( IS_NULL_ctype ( ct ) ) return ( 0 ) ;
-		return ( eq_ctype ( cs, ct ) ) ;
-	    }
-	    return ( 0 ) ;
+		return (is == it);
+	}
-	case type_dummy_tag : {
-	    /* Check dummy types */
-	    int is = DEREF_int ( type_dummy_tok ( s ) ) ;
-	    int it = DEREF_int ( type_dummy_tok ( t ) ) ;
-	    return ( is == it ) ;
+	}
-    }
-    /* Simple types compare equal */
+	/* Simple types compare equal */
-    return ( 1 ) ;
+	return (1);
+}
 /*
     UNIFY TWO TYPES
     This routine unifies the types s and t by defining tokens if necessary.
     cv gives the type qualifiers which are in t but not in s.  It returns
     true if a value is assigned to a token.
 */
-int unify_type
+int
-    PROTO_N ( ( s, t, cv, qual ) )
-    PROTO_T ( TYPE s X TYPE t X CV_SPEC cv X int qual )
+unify_type(TYPE s, TYPE t, CV_SPEC cv, int qual)
 {
-    IDENTIFIER id ;
+	IDENTIFIER id;
-    LIST ( TOKEN ) args ;
+	LIST(TOKEN)args;
-    unsigned tag = TAG_type ( s ) ;
+	unsigned tag = TAG_type(s);
-    switch ( tag ) {
+	switch (tag) {
-	case type_integer_tag : {
+	case type_integer_tag: {
-	    /* Integral types */
+		/* Integral types */
-	    INT_TYPE is = DEREF_itype ( type_integer_rep ( s ) ) ;
+		INT_TYPE is = DEREF_itype(type_integer_rep(s));
-	    switch ( TAG_itype ( is ) ) {
+		switch (TAG_itype(is)) {
-		case itype_basic_tag : {
+		case itype_basic_tag: {
-		    /* Built-in integral types */
+			/* Built-in integral types */
-		    BUILTIN_TYPE n = DEREF_ntype ( itype_basic_no ( is ) ) ;
+			BUILTIN_TYPE n = DEREF_ntype(itype_basic_no(is));
-		    id = get_special ( base_token [n].tok, 0 ) ;
+			id = get_special(base_token[n].tok, 0);
-		    if ( IS_NULL_id ( id ) ) return ( 0 ) ;
+			if (IS_NULL_id(id)) {
+				return (0);
+			}
-		    args = NULL_list ( TOKEN ) ;
+			args = NULL_list(TOKEN);
-		    break ;
+			break;
 		}
-		case itype_token_tag : {
+		case itype_token_tag: {
-		    /* Tokenised integral types */
+			/* Tokenised integral types */
-		    id = DEREF_id ( itype_token_tok ( is ) ) ;
+			id = DEREF_id(itype_token_tok(is));
-		    args = DEREF_list ( itype_token_args ( is ) ) ;
+			args = DEREF_list(itype_token_args(is));
-		    break ;
+			break;
 		}
-		default : {
+		default:
-		    /* Other integral types */
+			/* Other integral types */
-		    return ( 0 ) ;
+			return (0);
 		}
-	    }
-	    break ;
+		break;
 	}
-	case type_floating_tag : {
+	case type_floating_tag: {
-	    /* Floating types */
+		/* Floating types */
-	    FLOAT_TYPE fs = DEREF_ftype ( type_floating_rep ( s ) ) ;
+		FLOAT_TYPE fs = DEREF_ftype(type_floating_rep(s));
-	    if ( IS_ftype_token ( fs ) ) {
+		if (IS_ftype_token(fs)) {
-		id = DEREF_id ( ftype_token_tok ( fs ) ) ;
+			id = DEREF_id(ftype_token_tok(fs));
-		args = DEREF_list ( ftype_token_args ( fs ) ) ;
+			args = DEREF_list(ftype_token_args(fs));
-		break ;
+			break;
-	    }
+		}
-	    return ( 0 ) ;
+		return (0);
 	}
-	case type_compound_tag : {
+	case type_compound_tag: {
-	    /* Class types */
+		/* Class types */
-	    CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
+		CLASS_TYPE cs = DEREF_ctype(type_compound_defn(s));
-	    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( cs ) ) ;
+		CLASS_INFO ci = DEREF_cinfo(ctype_info(cs));
-	    if ( ci & cinfo_token ) {
+		if (ci & cinfo_token) {
-		TYPE r = DEREF_type ( ctype_form ( cs ) ) ;
+			TYPE r = DEREF_type(ctype_form(cs));
-		if ( !IS_NULL_type ( r ) && IS_type_token ( r ) ) {
+			if (!IS_NULL_type(r) && IS_type_token(r)) {
-		    id = DEREF_id ( type_token_tok ( r ) ) ;
+				id = DEREF_id(type_token_tok(r));
-		    args = DEREF_list ( type_token_args ( r ) ) ;
+				args = DEREF_list(type_token_args(r));
-		    break ;
+				break;
-		}
+			}
-	    }
+		}
-	    return ( 0 ) ;
+		return (0);
 	}
-	case type_token_tag : {
+	case type_token_tag: {
-	    /* Tokenised types */
+		/* Tokenised types */
-	    id = DEREF_id ( type_token_tok ( s ) ) ;
+		id = DEREF_id(type_token_tok(s));
-	    args = DEREF_list ( type_token_args ( s ) ) ;
+		args = DEREF_list(type_token_args(s));
-	    break ;
+		break;
 	}
-	default : {
+	default:
-	    /* Other types */
+		/* Other types */
-	    return ( 0 ) ;
+		return (0);
 	}
-    }
-    if ( defining_token ( id ) ) {
+	if (defining_token(id)) {
-	TOKEN sort ;
+		TOKEN sort;
-	if ( IS_NULL_list ( args ) ) {
+		if (IS_NULL_list(args)) {
-	    t = qualify_type ( t, cv, 0 ) ;
+			t = qualify_type(t, cv, 0);
-	    return ( define_type_token ( id, t, qual ) ) ;
+			return (define_type_token(id, t, qual));
-	}
+		}
-	sort = DEREF_tok ( id_token_sort ( id ) ) ;
+		sort = DEREF_tok(id_token_sort(id));
-	if ( IS_tok_class ( sort ) && IS_type_compound ( t ) ) {
+		if (IS_tok_class(sort) && IS_type_compound(t)) {
-	    /* Check for template template parameters */
+			/* Check for template template parameters */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	    TYPE r = DEREF_type ( ctype_form ( ct ) ) ;
+			TYPE r = DEREF_type(ctype_form(ct));
-	    if ( !IS_NULL_type ( r ) && IS_type_token ( r ) ) {
+			if (!IS_NULL_type(r) && IS_type_token(r)) {
-		IDENTIFIER tid = DEREF_id ( type_token_tok ( r ) ) ;
+				IDENTIFIER tid = DEREF_id(type_token_tok(r));
-		if ( IS_id_class_name ( tid ) ) {
+				if (IS_id_class_name(tid)) {
-		    LIST ( TOKEN ) targs ;
+					LIST(TOKEN)targs;
-		    targs = DEREF_list ( type_token_args ( r ) ) ;
+					targs = DEREF_list(type_token_args(r));
-		    if ( eq_token_args ( tid, tid, args, targs ) ) {
+					if (eq_token_args(tid, tid, args, targs)) {
-			return ( define_templ_token ( id, tid ) ) ;
+						return (define_templ_token(id, tid));
-		    }
+					}
+				}
-		}
+			}
-	    }
+		}
+	}
-    }
-    if ( expand_tokdef ) {
+	if (expand_tokdef) {
-	/* Expand token definitions */
+		/* Expand token definitions */
-	TOKEN sort = find_tokdef ( id ) ;
+		TOKEN sort = find_tokdef(id);
-	if ( !IS_NULL_tok ( sort ) && IS_tok_type ( sort ) ) {
+		if (!IS_NULL_tok(sort) && IS_tok_type(sort)) {
-	    TYPE r = DEREF_type ( tok_type_value ( sort ) ) ;
+			TYPE r = DEREF_type(tok_type_value(sort));
-	    if ( !IS_NULL_type ( r ) && eq_type ( r, t ) ) return ( 1 ) ;
+			if (!IS_NULL_type(r) && eq_type(r, t)) {
+				return (1);
+			}
+		}
+	}
-    }
-    return ( 0 ) ;
+	return (0);
+}
 /*
     CAN TWO TYPES BE UNIFIED?
     This routine checks whether the type s can be unified with t or vice
     versa using token definitions.
 */
-static int unify_types
+static int
-    PROTO_N ( ( s, t, qu ) )
-    PROTO_T ( TYPE s X TYPE t X int qu )
+unify_types(TYPE s, TYPE t, int qu)
 {
-    if ( force_tokdef || force_template || expand_tokdef ) {
+	if (force_tokdef || force_template || expand_tokdef) {
-	CV_SPEC qs, qt ;
+		CV_SPEC qs, qt;
-	CV_SPEC rs, rt ;
+		CV_SPEC rs, rt;
-	if ( IS_NULL_type ( s ) ) return ( 0 ) ;
+		if (IS_NULL_type(s)) {
+			return (0);
+		}
-	if ( IS_NULL_type ( t ) ) return ( 0 ) ;
+		if (IS_NULL_type(t)) {
+			return (0);
+		}
-	qs = DEREF_cv ( type_qual ( s ) ) ;
+		qs = DEREF_cv(type_qual(s));
-	qt = DEREF_cv ( type_qual ( t ) ) ;
+		qt = DEREF_cv(type_qual(t));
-	qs &= cv_qual ;
+		qs &= cv_qual;
-	qt &= cv_qual ;
+		qt &= cv_qual;
-	rs = ( qs & ~qt ) ;
+		rs = (qs & ~qt);
-	rt = ( qt & ~qs ) ;
+		rt = (qt & ~qs);
-	if ( rs == cv_none || qu ) {
+		if (rs == cv_none || qu) {
-	    if ( unify_type ( s, t, rt, 0 ) ) return ( 1 ) ;
+			if (unify_type(s, t, rt, 0)) {
+				return (1);
+			}
-	}
+		}
-	if ( rt == cv_none || qu ) {
+		if (rt == cv_none || qu) {
-	    if ( unify_type ( t, s, rs, 0 ) ) return ( 1 ) ;
+			if (unify_type(t, s, rs, 0)) {
+				return (1);
+			}
-	}
+		}
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     ARE TWO TYPES EQUAL?
     This routine checks whether the types s and t are equal (excluding
     lvalue qualifiers).  If qu is 1 then the top level qualifiers
     are completely ignored, if it is 2 all qualifiers are ignored.
     The return values are as in eq_type_aux.  The routine is usually
     accessed through the macros eq_type and eq_type_unqual.
 */
-int eq_type_qual
+int
-    PROTO_N ( ( s, t, qu ) )
-    PROTO_T ( TYPE s X TYPE t X int qu )
+eq_type_qual(TYPE s, TYPE t, int qu)
+{
-    int eq ;
+	int eq;
-    if ( EQ_type ( s, t ) ) return ( 1 ) ;
+	if (EQ_type(s, t)) {
+		return (1);
+	}
-    eq = eq_type_aux ( s, t, qu ) ;
+	eq = eq_type_aux(s, t, qu);
+	if (eq == 0) {
-    if ( eq == 0 ) eq = unify_types ( s, t, qu ) ;
+		eq = unify_types(s, t, qu);
+	}
-    return ( eq ) ;
+	return (eq);
+}
 /*
     IS THE OFFSET OF TWO TYPES EQUAL?
     has the same size and alignment requirements.  Note that the value 6
     is used in the builtin_casts table to indicate integral types which
     are equivalent in this way.
 */
-int eq_type_offset
+int
-    PROTO_N ( ( s, t ) )
-    PROTO_T ( TYPE s X TYPE t )
+eq_type_offset(TYPE s, TYPE t)
+{
-    unsigned ns = TAG_type ( s ) ;
+	unsigned ns = TAG_type(s);
-    unsigned nt = TAG_type ( t ) ;
+	unsigned nt = TAG_type(t);
-    if ( ns != nt ) return ( 0 ) ;
+	if (ns != nt) {
-    if ( ns == type_integer_tag ) {
-	INT_TYPE is = DEREF_itype ( type_integer_rep ( s ) ) ;
-	INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
-	if ( IS_itype_basic ( is ) && IS_itype_basic ( it ) ) {
-	    BUILTIN_TYPE bs = DEREF_ntype ( itype_basic_no ( is ) ) ;
-	    BUILTIN_TYPE bt = DEREF_ntype ( itype_basic_no ( it ) ) ;
-	    if ( bs == bt ) return ( 1 ) ;
-	    if ( builtin_cast ( bs, bt ) == 6 ) return ( 1 ) ;
-	    return ( 0 ) ;
+		return (0);
+	}
+	if (ns == type_integer_tag) {
+		INT_TYPE is = DEREF_itype(type_integer_rep(s));
+		INT_TYPE it = DEREF_itype(type_integer_rep(t));
+		if (IS_itype_basic(is) && IS_itype_basic(it)) {
+			BUILTIN_TYPE bs = DEREF_ntype(itype_basic_no(is));
+			BUILTIN_TYPE bt = DEREF_ntype(itype_basic_no(it));
+			if (bs == bt) {
+				return (1);
-    }
+			}
+			if (builtin_cast(bs, bt) == 6) {
+				return (1);
+			}
+			return (0);
+		}
+	}
-    return ( eq_type_unqual ( s, t ) ) ;
+	return (eq_type_unqual(s, t));
+}
 /*
     FIND THE COMPOSITE OF TWO FUNCTION TYPES
     This routine finds the composite type (in the C sense) of the function
     types s and t.  eq gives the result of a previous call to eq_func_type.
     If the types are compatible then a new composite function type, based
     on s, is returned.  Otherwise the null type is returned.
 */
 #if LANGUAGE_C
-static TYPE func_composite
+static TYPE
-    PROTO_N ( ( s, t, eq, err, mk ) )
-    PROTO_T ( TYPE s X TYPE t X int eq X ERROR *err X int mk )
+func_composite(TYPE s, TYPE t, int eq, ERROR *err, int mk)
 {
-    TYPE rs, rt ;
+	TYPE rs, rt;
-    CV_SPEC qs, qt ;
+	CV_SPEC qs, qt;
-    TYPE mt = NULL_type ;
+	TYPE mt = NULL_type;
-    int es = DEREF_int ( type_func_ellipsis ( s ) ) ;
+	int es = DEREF_int(type_func_ellipsis(s));
-    NAMESPACE ns = DEREF_nspace ( type_func_pars ( s ) ) ;
+	NAMESPACE ns = DEREF_nspace(type_func_pars(s));
-    LIST ( TYPE ) ps = DEREF_list ( type_func_ptypes ( s ) ) ;
+	LIST(TYPE)ps = DEREF_list(type_func_ptypes(s));
-    LIST ( TYPE ) pt = DEREF_list ( type_func_mtypes ( s ) ) ;
+	LIST(TYPE)pt = DEREF_list(type_func_mtypes(s));
-    LIST ( IDENTIFIER ) pids = DEREF_list ( type_func_pids ( s ) ) ;
+	LIST(IDENTIFIER)pids = DEREF_list(type_func_pids(s));
-    /* Check parameter types */
+	/* Check parameter types */
+	if (!EQ_list(ps, pt)) {
-    if ( !EQ_list ( ps, pt ) ) mt = DEREF_type ( HEAD_list ( pt ) ) ;
+		mt = DEREF_type(HEAD_list(pt));
+	}
-    if ( eq == 0 ) {
+	if (eq == 0) {
-	int et = DEREF_int ( type_func_ellipsis ( t ) ) ;
+		int et = DEREF_int(type_func_ellipsis(t));
-	if ( es & FUNC_NO_PARAMS ) {
+		if (es & FUNC_NO_PARAMS) {
-	    /* s has no parameter information - swap types */
+			/* s has no parameter information - swap types */
-	    if ( et != FUNC_NO_PARAMS ) {
+			if (et != FUNC_NO_PARAMS) {
-		ps = DEREF_list ( type_func_ptypes ( t ) ) ;
+				ps = DEREF_list(type_func_ptypes(t));
-		ns = DEREF_nspace ( type_func_pars ( t ) ) ;
+				ns = DEREF_nspace(type_func_pars(t));
-		pids = DEREF_list ( type_func_pids ( t ) ) ;
+				pids = DEREF_list(type_func_pids(t));
-		es = et ;
+				es = et;
-		et = FUNC_NO_PARAMS ;
+				et = FUNC_NO_PARAMS;
-	    }
-	}
-	if ( et & FUNC_NO_PARAMS ) {
-	    /* One type has no parameter information */
-	    if ( es & FUNC_ELLIPSIS ) {
-		OPTION opt = option ( OPT_ellipsis_extra ) ;
-		add_error ( err, ERR_dcl_fct_compat_ellipsis () ) ;
-		if ( opt == OPTION_DISALLOW ) return ( NULL_type ) ;
-	    }
-	    if ( !( es & FUNC_WEAK ) ) {
-		pt = ps ;
-		while ( !IS_NULL_list ( pt ) ) {
-		    TYPE at = DEREF_type ( HEAD_list ( pt ) ) ;
-		    if ( !is_arg_promote ( at ) ) {
-			OPTION opt = option ( OPT_func_incompat ) ;
-			add_error ( err, ERR_dcl_fct_compat_prom ( at ) ) ;
-			if ( opt == OPTION_DISALLOW ) return ( NULL_type ) ;
-		    }
-		    pt = TAIL_list ( pt ) ;
-		}
+			}
-	    }
-	} else {
-	    /* Both types have parameter information */
-	    int prom = 0 ;
-	    int force = force_tokdef ;
-	    LIST ( TYPE ) pr = NULL_list ( TYPE ) ;
-	    pt = DEREF_list ( type_func_ptypes ( t ) ) ;
-	    if ( es & FUNC_ELLIPSIS ) {
-		if ( et & FUNC_ELLIPSIS ) {
-		    /* Both functions have ellipsis */
-		    /* EMPTY */
-		} else {
-		    /* One function has ellipsis */
-		    OPTION opt = option ( OPT_ellipsis_extra ) ;
-		    add_error ( err, ERR_dcl_fct_compat_ellipsis () ) ;
-		    if ( opt == OPTION_DISALLOW ) return ( NULL_type ) ;
-		    et |= FUNC_ELLIPSIS ;
+		}
-	    } else {
-		if ( et & FUNC_ELLIPSIS ) {
+		if (et & FUNC_NO_PARAMS) {
-		    /* One function has ellipsis */
+			/* One type has no parameter information */
-		    OPTION opt = option ( OPT_ellipsis_extra ) ;
-		    add_error ( err, ERR_dcl_fct_compat_ellipsis () ) ;
-		    if ( opt == OPTION_DISALLOW ) return ( NULL_type ) ;
-		    es |= FUNC_ELLIPSIS ;
+			if (es & FUNC_ELLIPSIS) {
-		} else {
-		    /* Neither function has ellipsis */
-		    if ( LENGTH_list ( ps ) != LENGTH_list ( pt ) ) {
-			return ( NULL_type ) ;
-		    }
-		}
-	    }
-	    if ( es & FUNC_PARAMS ) prom++ ;
-	    if ( et & FUNC_PARAMS ) prom++ ;
-	    while ( !IS_NULL_list ( ps ) && !IS_NULL_list ( pt ) ) {
-		TYPE ar ;
-		TYPE as = DEREF_type ( HEAD_list ( ps ) ) ;
-		TYPE at = DEREF_type ( HEAD_list ( pt ) ) ;
-		if ( prom == 2 ) {
-		    /* Compare unpromoted types */
-		    as = unpromote_type ( as ) ;
-		    at = unpromote_type ( at ) ;
-		}
-		ar = type_composite ( as, at, 0, 1, err, mk ) ;
-		if ( IS_NULL_type ( ar ) ) {
-		    /* Check for specified compatible types */
-		    ar = eq_argument ( as, at, 1 ) ;
-		    if ( IS_NULL_type ( ar ) && prom == 1 ) {
-			if ( es & FUNC_PARAMS ) as = unpromote_type ( as ) ;
-			if ( et & FUNC_PARAMS ) at = unpromote_type ( at ) ;
-			ar = eq_argument ( as, at, 0 ) ;
-			if ( !IS_NULL_type ( ar ) ) {
-			    OPTION opt = option ( OPT_func_incompat ) ;
+				OPTION opt = option(OPT_ellipsis_extra);
-			    ERROR err2 = ERR_dcl_fct_compat_prom ( as ) ;
+				add_error(err, ERR_dcl_fct_compat_ellipsis());
-			    add_error ( err, err2 ) ;
-			    if ( opt == OPTION_DISALLOW ) ar = NULL_type ;
+				if (opt == OPTION_DISALLOW) {
-			}
-		    }
-		    if ( IS_NULL_type ( ar ) ) {
-			DESTROY_list ( pr, SIZE_type ) ;
-			return ( NULL_type ) ;
+					return (NULL_type);
-		    }
-		}
+				}
-		if ( mk ) {
-		    if ( force ) {
-			/* Preserve printf and scanf types */
-			if ( is_printf_type ( as ) ) {
-			    IDENTIFIER id = DEREF_id ( type_name ( as ) ) ;
-			    COPY_id ( type_name ( ar ), id ) ;
-			} else if ( is_printf_type ( at ) ) {
-			    IDENTIFIER id = DEREF_id ( type_name ( at ) ) ;
-			    COPY_id ( type_name ( ar ), id ) ;
+			}
+}
 #endif
     indicate that differing qualifiers are allowed.  In C++ the qualifiers
     are allowed at any level; in C qual gives the maximum depth.  Type
     qualifiers at the top level are handled by adding an error to err.
 */
-TYPE type_composite
+TYPE
-    PROTO_N ( ( s, t, qual, depth, err, mk ) )
-    PROTO_T ( TYPE s X TYPE t X int qual X int depth X ERROR *err X int mk )
+type_composite(TYPE s, TYPE t, int qual, int depth, ERROR *err, int mk)
+{
-    TYPE r = s ;
+	TYPE r = s;
-    int eq = 1 ;
+	int eq = 1;
-    int checked = 0 ;
+	int checked = 0;
-    unsigned ns, nt ;
+	unsigned ns, nt;
-    CV_SPEC qr, qs, qt ;
+	CV_SPEC qr, qs, qt;
-    /* Check for obvious equality */
+	/* Check for obvious equality */
-    if ( EQ_type ( s, t ) ) return ( s ) ;
+	if (EQ_type(s, t)) {
+		return (s);
+	}
-    if ( IS_NULL_type ( s ) ) return ( NULL_type ) ;
+	if (IS_NULL_type(s)) {
+		return (NULL_type);
+	}
-    if ( IS_NULL_type ( t ) ) return ( NULL_type ) ;
+	if (IS_NULL_type(t)) {
+		return (NULL_type);
+	}
-    /* Compare type qualifiers */
+	/* Compare type qualifiers */
-    ns = TAG_type ( s ) ;
+	ns = TAG_type(s);
-    nt = TAG_type ( t ) ;
+	nt = TAG_type(t);
-    qs = DEREF_cv ( type_qual ( s ) ) ;
+	qs = DEREF_cv(type_qual(s));
-    qt = DEREF_cv ( type_qual ( t ) ) ;
+	qt = DEREF_cv(type_qual(t));
-    qr = ( qs | qt ) ;
+	qr = (qs | qt);
-    if ( qs != qt && qual <= 0 ) {
+	if (qs != qt && qual <= 0) {
-	/* Qualifiers should be equal up to lvalues */
+		/* Qualifiers should be equal up to lvalues */
-	CV_SPEC rs = ( qs & cv_qual ) ;
+		CV_SPEC rs = (qs & cv_qual);
-	CV_SPEC rt = ( qt & cv_qual ) ;
+		CV_SPEC rt = (qt & cv_qual);
-	if ( rs != rt ) {
+		if (rs != rt) {
-	    OPTION opt ;
+			OPTION opt;
-	    if ( unify_types ( s, t, 0 ) ) {
+			if (unify_types(s, t, 0)) {
-		/* Can happen with token definitions */
+				/* Can happen with token definitions */
+				if (mk) {
-		if ( mk ) r = qualify_type ( r, qr, 0 ) ;
+					r = qualify_type(r, qr, 0);
+				}
-		return ( r ) ;
+				return (r);
-	    }
+			}
-	    opt = option ( OPT_type_qual_incompat ) ;
+			opt = option(OPT_type_qual_incompat);
-	    if ( opt == OPTION_DISALLOW ) goto return_lab ;
+			if (opt == OPTION_DISALLOW) {
+				goto return_lab;
+			}
-	    add_error ( err, ERR_basic_link_qual ( rs, rt ) ) ;
+			add_error(err, ERR_basic_link_qual(rs, rt));
+		}
+	}
-    }
 #if LANGUAGE_C
-    qual-- ;
+	qual--;
 #endif
-    /* Check on type components */
+	/* Check on type components */
-    if ( ns == nt ) {
+	if (ns == nt) {
-	switch ( ns ) {
+		switch (ns) {
+		case type_ptr_tag:
+		case type_ref_tag: {
+			/* Check pointer sub-types */
+			TYPE pr;
+			TYPE ps = DEREF_type(type_ptr_etc_sub(s));
+			TYPE pt = DEREF_type(type_ptr_etc_sub(t));
+			pr = type_composite(ps, pt, qual, depth + 1, err, mk);
+			if (IS_NULL_type(pr)) {
+				/* Check for generic pointer types */
+				OPTION opt = option(OPT_gen_ptr_char);
+				if (opt == OPTION_DISALLOW) {
+					return (NULL_type);
+				}
+				if (IS_type_top_etc(ps)) {
+					if (eq_type_unqual(pt, type_char)) {
+						CV_SPEC cv = DEREF_cv(type_qual(pt));
+						pt = qualify_type(ps, cv, 0);
+						add_error(err, ERR_conv_ptr_gen(t));
+					} else {
+						return (NULL_type);
+					}
+				} else if (IS_type_top_etc(pt)) {
+					if (eq_type_unqual(ps, type_char)) {
+						CV_SPEC cv = DEREF_cv(type_qual(ps));
+						ps = qualify_type(pt, cv, 0);
+						add_error(err, ERR_conv_ptr_gen(s));
+					} else {
+						return (NULL_type);
+					}
+				} else {
+					return (NULL_type);
+				}
+				pr = type_composite(ps, pt, qual, depth + 1, err, mk);
+				if (IS_NULL_type(pr)) {
+					return (NULL_type);
+				}
+			}
+			if (mk) {
+				if (EQ_type(pr, ps) && qr == qs) {
+					return (s);
+				}
+				if (EQ_type(pr, pt) && qr == qt) {
+					return (t);
+				}
+				MAKE_type_ptr_etc(ns, qr, pr, r);
+			}
+			return (r);
+		}
+#if LANGUAGE_CPP
+		case type_ptr_mem_tag: {
+			/* Check pointer to member class types */
+			TYPE ps, pt, pr;
+			CLASS_TYPE cs = DEREF_ctype(type_ptr_mem_of(s));
+			CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
+			if (!eq_ctype(cs, ct)) {
+				return (NULL_type);
+			}
-	    case type_ptr_tag :
-	    case type_ref_tag : {
-		/* Check pointer sub-types */
+			/* Check pointer to member sub-types */
-		TYPE pr ;
-		TYPE ps = DEREF_type ( type_ptr_etc_sub ( s ) ) ;
+			ps = DEREF_type(type_ptr_mem_sub(s));
-		TYPE pt = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
+			pt = DEREF_type(type_ptr_mem_sub(t));
-		pr = type_composite ( ps, pt, qual, depth + 1, err, mk ) ;
+			pr = type_composite(ps, pt, qual, depth + 1, err, mk);
-		if ( IS_NULL_type ( pr ) ) {
+			if (IS_NULL_type(pr)) {
-		    /* Check for generic pointer types */
-		    OPTION opt = option ( OPT_gen_ptr_char ) ;
-		    if ( opt == OPTION_DISALLOW ) return ( NULL_type ) ;
-		    if ( IS_type_top_etc ( ps ) ) {
-			if ( eq_type_unqual ( pt, type_char ) ) {
-			    CV_SPEC cv = DEREF_cv ( type_qual ( pt ) ) ;
-			    pt = qualify_type ( ps, cv, 0 ) ;
-			    add_error ( err, ERR_conv_ptr_gen ( t ) ) ;
-			} else {
-			    return ( NULL_type ) ;
+				return (NULL_type);
+			}
-		    } else if ( IS_type_top_etc ( pt ) ) {
+			if (mk) {
-			if ( eq_type_unqual ( ps, type_char ) ) {
+				if (EQ_type(pr, ps) && qr == qt) {
-			    CV_SPEC cv = DEREF_cv ( type_qual ( ps ) ) ;
+					return (s);
+				}
-			    ps = qualify_type ( pt, cv, 0 ) ;
+				if (EQ_type(pr, pt) && qr == qs) {
-			    add_error ( err, ERR_conv_ptr_gen ( s ) ) ;
+					return (t);
-			} else {
+				}
-			    return ( NULL_type ) ;
+				MAKE_type_ptr_mem(qr, cs, pr, r);
+			}
-		    } else {
-			return ( NULL_type ) ;
+			return (r);
-		    }
-		    pr = type_composite ( ps, pt, qual, depth + 1, err, mk ) ;
-		    if ( IS_NULL_type ( pr ) ) return ( NULL_type ) ;
+		}
-		if ( mk ) {
-		    if ( EQ_type ( pr, ps ) && qr == qs ) return ( s ) ;
-		    if ( EQ_type ( pr, pt ) && qr == qt ) return ( t ) ;
-		    MAKE_type_ptr_etc ( ns, qr, pr, r ) ;
-		}
-		return ( r ) ;
-	    }
+#endif
-#if LANGUAGE_CPP
-	    case type_ptr_mem_tag : {
-		/* Check pointer to member class types */
-		TYPE ps, pt, pr ;
-		CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( s ) ) ;
-		CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
-		if ( !eq_ctype ( cs, ct ) ) return ( NULL_type ) ;
+		case type_array_tag: {
-		/* Check pointer to member sub-types */
+			/* Check array sub-types */
+			TYPE pr;
+			NAT ms, mt, mr;
-		ps = DEREF_type ( type_ptr_mem_sub ( s ) ) ;
+			TYPE ps = DEREF_type(type_array_sub(s));
-		pt = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+			TYPE pt = DEREF_type(type_array_sub(t));
-		pr = type_composite ( ps, pt, qual, depth + 1, err, mk ) ;
+			pr = type_composite(ps, pt, qual, depth + 1, err, mk);
-		if ( IS_NULL_type ( pr ) ) return ( NULL_type ) ;
+			if (IS_NULL_type(pr)) {
-		if ( mk ) {
-		    if ( EQ_type ( pr, ps ) && qr == qt ) return ( s ) ;
-		    if ( EQ_type ( pr, pt ) && qr == qs ) return ( t ) ;
-		    MAKE_type_ptr_mem ( qr, cs, pr, r ) ;
-		}
-		return ( r ) ;
+				return (NULL_type);
-	    }
+			}
-#endif
-	    case type_array_tag : {
-		/* Check array sub-types */
-		TYPE pr ;
-		NAT ms, mt, mr ;
-		TYPE ps = DEREF_type ( type_array_sub ( s ) ) ;
-		TYPE pt = DEREF_type ( type_array_sub ( t ) ) ;
-		pr = type_composite ( ps, pt, qual, depth + 1, err, mk ) ;
-		if ( IS_NULL_type ( pr ) ) return ( NULL_type ) ;
-		/* Check array bounds */
+			/* Check array bounds */
-		ms = DEREF_nat ( type_array_size ( s ) ) ;
+			ms = DEREF_nat(type_array_size(s));
-		mt = DEREF_nat ( type_array_size ( t ) ) ;
+			mt = DEREF_nat(type_array_size(t));
-		if ( EQ_nat ( ms, mt ) || eq_nat ( ms, mt ) ) {
+			if (EQ_nat(ms, mt) || eq_nat(ms, mt)) {
-		    /* Equal bounds */
+				/* Equal bounds */
-		    if ( EQ_type ( pr, ps ) && qr == qs ) return ( s ) ;
+				if (EQ_type(pr, ps) && qr == qs) {
-		    if ( EQ_type ( pr, pt ) && qr == qt ) return ( t ) ;
-		    mr = ms ;
+					return (s);
+				}
-		} else if ( IS_NULL_nat ( ms ) ) {
+				if (EQ_type(pr, pt) && qr == qt) {
-		    /* s unbounded, t bounded */
-#if LANGUAGE_CPP
+					return (t);
-		    if ( depth ) return ( NULL_type ) ;
-#endif
+				}
-		    if ( EQ_type ( pr, pt ) && qr == qt ) return ( t ) ;
-		    mr = mt ;
+				mr = ms;
-		} else if ( IS_NULL_nat ( mt ) ) {
+			} else if (IS_NULL_nat(ms)) {
-		    /* s bounded, t unbounded */
+				/* s unbounded, t bounded */
 #if LANGUAGE_CPP
+				if (depth) {
-		    if ( depth ) return ( NULL_type ) ;
+					return (NULL_type);
+				}
 #endif
-		    if ( EQ_type ( pr, ps ) && qr == qs ) return ( s ) ;
+				if (EQ_type(pr, pt) && qr == qt) {
-		    mr = ms ;
+					return (t);
-		} else {
+				}
-		    /* Unequal bounds - check for error propagation */
-		    if ( is_error_nat ( ms ) ) {
-			mr = mt ;
+				mr = mt;
-		    } else if ( is_error_nat ( mt ) ) {
+			} else if (IS_NULL_nat(mt)) {
+				/* s bounded, t unbounded */
-			mr = ms ;
+#if LANGUAGE_CPP
-		    } else {
+				if (depth) {
-			return ( NULL_type ) ;
+					return (NULL_type);
-		    }
+				}
-		}
+#endif
-		if ( mk ) {
-		    MAKE_type_array ( qr, pr, mr, r ) ;
+				if (EQ_type(pr, ps) && qr == qs) {
-		}
-		return ( r ) ;
+					return (s);
-	    }
+				}
-	    case type_func_tag : {
-		/* Check function types */
-		int ret = eq_func_type ( s, t, 1, 0 ) ;
-#if LANGUAGE_C
+				mr = ms;
-		if ( ret < 2 ) {
+			} else {
-		    r = func_composite ( s, t, ret, err, mk ) ;
+				/* Unequal bounds - check for error
-		    return ( r ) ;
+				 * propagation */
-		}
-#else
-		if ( ret < 2 ) {
+				if (is_error_nat(ms)) {
-		    eq = 0 ;
+					mr = mt;
-		} else if ( depth && ret == 2 ) {
+				} else if (is_error_nat(mt)) {
-		    /* Differ in language specifiers */
-		    eq = 0 ;
+					mr = ms;
-		}
+				} else {
-#endif
-		checked = 1 ;
+					return (NULL_type);
-		break ;
+				}
-	    }
+			}
-#if LANGUAGE_C
+			if (mk) {
-	    case type_enumerate_tag : {
-		/* Check C enumeration types */
-		ENUM_TYPE es = DEREF_etype ( type_enumerate_defn ( s ) ) ;
-		ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
-		TYPE ps = DEREF_type ( etype_rep ( es ) ) ;
-		TYPE pt = DEREF_type ( etype_rep ( et ) ) ;
-		eq = eq_type_unqual ( ps, pt ) ;
+				MAKE_type_array(qr, pr, mr, r);
-		checked = 1 ;
-		break ;
-	    }
+			}
-#endif
+			return (r);
-	}
+		}
-    } else {
-	switch ( ns ) {
-	    case type_top_tag : {
+		case type_func_tag: {
-		/* Allow for 'void' and 'bottom' */
+			/* Check function types */
-		if ( nt == type_bottom_tag ) {
+			int ret = eq_func_type(s, t, 1, 0);
-		    checked = 1 ;
-		    r = t ;
-		}
-		break ;
-	    }
-	    case type_bottom_tag : {
-		/* Allow for 'void' and 'bottom' */
-		if ( nt == type_top_tag ) {
-		    checked = 1 ;
-		}
-		break ;
-	    }
 #if LANGUAGE_C
+			if (ret < 2) {
+				r = func_composite(s, t, ret, err, mk);
+				return (r);
+			}
+#else
+			if (ret < 2) {
+				eq = 0;
+			} else if (depth && ret == 2) {
+				/* Differ in language specifiers */
+				eq = 0;
+			}
+#endif
+			checked = 1;
+			break;
+		}
+#if LANGUAGE_C
+		case type_enumerate_tag: {
+			/* Check C enumeration types */
+			ENUM_TYPE es = DEREF_etype(type_enumerate_defn(s));
+			ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
+			TYPE ps = DEREF_type(etype_rep(es));
+			TYPE pt = DEREF_type(etype_rep(et));
+			eq = eq_type_unqual(ps, pt);
+			checked = 1;
+			break;
+		}
+#endif
+		}
+	} else {
+		switch (ns) {
+		case type_top_tag: {
+			/* Allow for 'void' and 'bottom' */
+			if (nt == type_bottom_tag) {
+				checked = 1;
+				r = t;
+			}
+			break;
+		}
+		case type_bottom_tag: {
+			/* Allow for 'void' and 'bottom' */
+			if (nt == type_top_tag) {
+				checked = 1;
+			}
+			break;
+		}
+#if LANGUAGE_C
-	    case type_integer_tag : {
+		case type_integer_tag: {
-		if ( nt == type_enumerate_tag ) {
+			if (nt == type_enumerate_tag) {
-		    /* Check C enumeration types */
+				/* Check C enumeration types */
-		    TYPE pt ;
+				TYPE pt;
-		    ENUM_TYPE et ;
+				ENUM_TYPE et;
-		    et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+				et = DEREF_etype(type_enumerate_defn(t));
-		    pt = DEREF_type ( etype_rep ( et ) ) ;
+				pt = DEREF_type(etype_rep(et));
-		    eq = eq_type_unqual ( s, pt ) ;
+				eq = eq_type_unqual(s, pt);
-		    checked = 1 ;
+				checked = 1;
-		    r = t ;
+				r = t;
+			}
+			break;
+		}
+		case type_enumerate_tag: {
+			if (nt == type_integer_tag) {
+				/* Check C enumeration types */
+				TYPE ps;
+				ENUM_TYPE es;
+				es = DEREF_etype(type_enumerate_defn(s));
+				ps = DEREF_type(etype_rep(es));
+				eq = eq_type_unqual(ps, t);
+				checked = 1;
+			}
+			break;
+		}
+#endif
+		}
-		break ;
-	    }
-	    case type_enumerate_tag : {
-		if ( nt == type_integer_tag ) {
-		    /* Check C enumeration types */
-		    TYPE ps ;
-		    ENUM_TYPE es ;
-		    es = DEREF_etype ( type_enumerate_defn ( s ) ) ;
-		    ps = DEREF_type ( etype_rep ( es ) ) ;
-		    eq = eq_type_unqual ( ps, t ) ;
-		    checked = 1 ;
-		}
-		break ;
-	    }
-#endif
 	}
-    }
-    /* In other cases compatibility is equality */
+	/* In other cases compatibility is equality */
-    if ( eq ) {
+	if (eq) {
-	if ( !checked ) eq = eq_type_unqual ( s, t ) ;
-	if ( eq == 1 ) {
-	    if ( mk ) {
-		if ( ns == nt ) {
+		if (!checked) {
-		    if ( qr == qs ) return ( s ) ;
-		    if ( qr == qt ) return ( t ) ;
+			eq = eq_type_unqual(s, t);
+		}
+		if (eq == 1) {
+			if (mk) {
+				if (ns == nt) {
+					if (qr == qs) {
+						return (s);
+					}
+					if (qr == qt) {
+						return (t);
+					}
+				}
-		r = qualify_type ( r, qr, 0 ) ;
+				r = qualify_type(r, qr, 0);
-	    }
+			}
-	    return ( r ) ;
+			return (r);
-	}
+		}
-    }
+	}
-    return_lab : {
+return_lab:
-	if ( ns == type_error_tag ) return ( t ) ;
+	if (ns == type_error_tag) {
+		return (t);
+	}
-	if ( nt == type_error_tag ) return ( s ) ;
+	if (nt == type_error_tag) {
-	return ( NULL_type ) ;
+		return (s);
-    }
+	}
+	return (NULL_type);
 }
 /*
     ARE TWO TYPES COMPATIBLE?
     This routine checks whether the types s and t are compatible, returning
     the composite type if they are (or either s or t if mk is false).  If
     the types are not compatible s is returned and an error is added to the
     end of err.  qual is as in type_composite.
 */
-TYPE check_compatible
+TYPE
-    PROTO_N ( ( s, t, qual, err, mk ) )
-    PROTO_T ( TYPE s X TYPE t X int qual X ERROR *err X int mk )
+check_compatible(TYPE s, TYPE t, int qual, ERROR *err, int mk)
 {
-    TYPE r ;
+	TYPE r;
-    force_tokdef++ ;
+	force_tokdef++;
-    r = type_composite ( s, t, qual, 0, err, mk ) ;
+	r = type_composite(s, t, qual, 0, err, mk);
-    if ( IS_NULL_type ( r ) ) {
+	if (IS_NULL_type(r)) {
-	add_error ( err, ERR_basic_link_incompat ( s, t ) ) ;
+		add_error(err, ERR_basic_link_incompat(s, t));
-	r = s ;
+		r = s;
-    }
+	}
-    force_tokdef-- ;
+	force_tokdef--;
-    return ( r ) ;
+	return (r);
 }
 /*
     IS A TYPE AN OBJECT TYPE?
     C++ types are partitioned into object types, reference types and
     function types.  Object types are further partitioned into complete
     and incomplete types.  This routine checks whether the type t is
     an object type.  It returns an error if it isn't.
 */
-ERROR check_object
+ERROR
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+check_object(TYPE t)
+{
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_func_tag : {
+	case type_func_tag: {
-	    /* Function types are not object types */
+		/* Function types are not object types */
-	    err = ERR_basic_types_obj_func ( t ) ;
+		err = ERR_basic_types_obj_func(t);
+		break;
+	}
+	case type_ref_tag: {
+		/* Reference types are not object types */
+		err = ERR_basic_types_obj_ref(t);
-	    break ;
+		break;
+	}
-	case type_ref_tag : {
+	case type_templ_tag: {
-	    /* Reference types are not object types */
+		/* Check template types */
-	    err = ERR_basic_types_obj_ref ( t ) ;
+		TYPE s = DEREF_type(type_templ_defn(t));
+		err = check_object(s);
-	    break ;
+		break;
+	}
-	case type_templ_tag : {
-	    /* Check template types */
-	    TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-	    err = check_object ( s ) ;
-	    break ;
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     IS A TYPE AN ABSTRACT CLASS?
     This routine checks whether the type t is an abstract class type.
     It returns an error if it is.  It also checks for arrays of abstract
     types, although it shouldn't be possible to construct these.
 */
-ERROR check_abstract
+ERROR
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+check_abstract(TYPE t)
+{
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_compound_tag : {
+	case type_compound_tag: {
-	    /* Check for abstract classes */
+		/* Check for abstract classes */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+		CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-	    if ( ci & cinfo_abstract ) {
+		if (ci & cinfo_abstract) {
-		err = class_info ( ct, cinfo_abstract, 1 ) ;
+			err = class_info(ct, cinfo_abstract, 1);
-	    }
+		}
+		break;
+	}
+	case type_array_tag: {
+		/* Check for abstract arrays */
+		TYPE s = DEREF_type(type_array_sub(t));
+		err = check_abstract(s);
-	    break ;
+		break;
+	}
-	case type_array_tag : {
+	case type_templ_tag: {
-	    /* Check for abstract arrays */
+		/* Check template types */
-	    TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+		TYPE s = DEREF_type(type_templ_defn(t));
-	    err = check_abstract ( s ) ;
+		err = check_abstract(s);
-	    break ;
+		break;
+	}
-	case type_templ_tag : {
-	    /* Check template types */
-	    TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-	    err = check_abstract ( s ) ;
-	    break ;
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     IS A TYPE INCOMPLETE?
     This routine checks whether the type t is an incomplete object type.
     It returns an error if it is.
 */
-ERROR check_incomplete
+ERROR
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+check_incomplete(TYPE t)
+{
-    ERROR err = NULL_err ;
+	ERROR err = NULL_err;
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_top_tag :
+	case type_top_tag:
-	case type_bottom_tag : {
+	case type_bottom_tag: {
-	    /* void and bottom are incomplete */
+		/* void and bottom are incomplete */
-	    err = ERR_basic_types_incompl ( t ) ;
+		err = ERR_basic_types_incompl(t);
-	    break ;
+		break;
+	}
-	case type_array_tag : {
+	case type_array_tag: {
-	    /* Check for incomplete arrays */
+		/* Check for incomplete arrays */
-	    NAT n = DEREF_nat ( type_array_size ( t ) ) ;
+		NAT n = DEREF_nat(type_array_size(t));
-	    if ( IS_NULL_nat ( n ) ) {
+		if (IS_NULL_nat(n)) {
-		err = ERR_basic_types_incompl ( t ) ;
+			err = ERR_basic_types_incompl(t);
-	    } else {
+		} else {
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_array_sub(t));
-		err = check_incomplete ( s ) ;
+			err = check_incomplete(s);
-	    }
+		}
+		break;
+	}
+	case type_compound_tag: {
+		/* Check for incomplete classes */
+		CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+		CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
+		if (!(ci & cinfo_defined)) {
+			complete_class(ct, 1);
+			ci = DEREF_cinfo(ctype_info(ct));
+		}
+		if (!(ci & cinfo_complete)) {
+			err = ERR_basic_types_incompl(t);
+		}
-	    break ;
+		break;
+	}
-	case type_compound_tag : {
+	case type_enumerate_tag: {
-	    /* Check for incomplete classes */
+		/* Check for incomplete enumerations */
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+		ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
-	    CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+		CLASS_INFO ei = DEREF_cinfo(etype_info(et));
-	    if ( !( ci & cinfo_defined ) ) {
-		complete_class ( ct, 1 ) ;
-		ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
-	    }
-	    if ( !( ci & cinfo_complete ) ) {
+		if (!(ei & cinfo_complete)) {
-		err = ERR_basic_types_incompl ( t ) ;
+			err = ERR_basic_types_incompl(t);
-	    }
+		}
-	    break ;
+		break;
+	}
-	case type_enumerate_tag : {
+	case type_templ_tag: {
-	    /* Check for incomplete enumerations */
+		/* Check template types */
-	    ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
+		TYPE s = DEREF_type(type_templ_defn(t));
-	    CLASS_INFO ei = DEREF_cinfo ( etype_info ( et ) ) ;
-	    if ( !( ei & cinfo_complete ) ) {
-		err = ERR_basic_types_incompl ( t ) ;
+		err = check_incomplete(s);
-	    }
-	    break ;
+		break;
+	}
-	case type_templ_tag : {
-	    /* Check template types */
-	    TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-	    err = check_incomplete ( s ) ;
-	    break ;
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     IS A TYPE A COMPLETE OBJECT TYPE?
     This routine checks whether the type t is a complete object type.  It
     returns an error if it isn't.
 */
-ERROR check_complete
+ERROR
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+check_complete(TYPE t)
 {
-    ERROR err = check_object ( t ) ;
+	ERROR err = check_object(t);
-    if ( IS_NULL_err ( err ) ) {
+	if (IS_NULL_err(err)) {
-	err = check_incomplete ( t ) ;
+		err = check_incomplete(t);
-	if ( !IS_NULL_err ( err ) ) {
+		if (!IS_NULL_err(err)) {
-	    err = concat_error ( err, ERR_basic_types_obj_incompl () ) ;
+			err = concat_error(err, ERR_basic_types_obj_incompl());
-	}
+		}
-    }
+	}
-    return ( err ) ;
+	return (err);
 }
 /*
     IS A TYPE A POINTER TO A COMPLETE OBJECT TYPE?
     This routine checks whether the type t is a pointer to a complete
     object type, adding an error to err.  It returns the type pointed to.
 */
-TYPE check_pointer
+TYPE
-    PROTO_N ( ( t, err ) )
-    PROTO_T ( TYPE t X ERROR *err )
+check_pointer(TYPE t, ERROR *err)
+{
-    TYPE s ;
+	TYPE s;
-    switch ( TAG_type ( t ) ) {
+	switch (TAG_type(t)) {
-	case type_ptr_tag : {
+	case type_ptr_tag: {
-	    /* Pointer type */
+		/* Pointer type */
-	    s = DEREF_type ( type_ptr_sub ( t ) ) ;
+		s = DEREF_type(type_ptr_sub(t));
-	    break ;
-	}
-	case type_array_tag : {
-	    /* Allow for array-to-pointer conversion */
-	    s = DEREF_type ( type_array_sub ( t ) ) ;
-	    break ;
+		break;
+	}
+	case type_array_tag: {
+		/* Allow for array-to-pointer conversion */
+		s = DEREF_type(type_array_sub(t));
+		break;
+	}
-	case type_func_tag : {
+	case type_func_tag: {
-	    /* Allow for function-to-pointer conversion */
+		/* Allow for function-to-pointer conversion */
-	    s = t ;
+		s = t;
-	    break ;
+		break;
+	}
+	case type_ref_tag: {
+		/* Reference type */
+		t = DEREF_type(type_ref_sub(t));
+		s = check_pointer(t, err);
+		return (s);
+	}
+	default:
+		/* Shouldn't happen */
+		return (t);
+	}
-	case type_ref_tag : {
-	    /* Reference type */
-	    t = DEREF_type ( type_ref_sub ( t ) ) ;
-	    s = check_pointer ( t, err ) ;
-	    return ( s ) ;
-	}
-	default : {
-	    /* Shouldn't happen */
-	    return ( t ) ;
-	}
-    }
-    if ( err != KILL_err ) {
+	if (err != KILL_err) {
-	switch ( TAG_type ( s ) ) {
+		switch (TAG_type(s)) {
-	    case type_top_tag :
+		case type_top_tag:
-	    case type_bottom_tag : {
+		case type_bottom_tag: {
-		add_error ( err, ERR_basic_types_obj_void ( t ) ) ;
+			add_error(err, ERR_basic_types_obj_void(t));
-		break ;
+			break;
-	    }
+		}
-	    default : {
+		default:
-		add_error ( err, check_complete ( s ) ) ;
+			add_error(err, check_complete(s));
-		break ;
+			break;
-	    }
+		}
+	}
-    }
-    return ( s ) ;
+	return (s);
+}
 /*
     IS A TYPE MODIFIABLE?
     modifiable lvalue.  If it is then the null error is returned, otherwise
     a sequence of errors giving the reasons why t is not modifiable is
     returned.
 */
-ERROR check_modifiable
+ERROR
-    PROTO_N ( ( t, a ) )
-    PROTO_T ( TYPE t X EXP a )
+check_modifiable(TYPE t, EXP a)
+{
-    ERROR err ;
+	ERROR err;
-    unsigned tag = TAG_type ( t ) ;
+	unsigned tag = TAG_type(t);
-    CV_SPEC qual = DEREF_cv ( type_qual ( t ) ) ;
+	CV_SPEC qual = DEREF_cv(type_qual(t));
-    if ( qual & cv_lvalue ) {
+	if (qual & cv_lvalue) {
-	while ( tag == type_templ_tag ) {
+		while (tag == type_templ_tag) {
-	    t = DEREF_type ( type_templ_defn ( t ) ) ;
+			t = DEREF_type(type_templ_defn(t));
-	    tag = TAG_type ( t ) ;
+			tag = TAG_type(t);
-	}
+		}
-	if ( tag == type_func_tag ) {
+		if (tag == type_func_tag) {
-	    /* Function types are not modifiable */
+			/* Function types are not modifiable */
-	    err = ERR_basic_lval_mod_func () ;
+			err = ERR_basic_lval_mod_func();
-	} else if ( tag == type_array_tag ) {
+		} else if (tag == type_array_tag) {
-	    /* Array types are not modifiable */
+			/* Array types are not modifiable */
-	    err = ERR_basic_lval_mod_array () ;
+			err = ERR_basic_lval_mod_array();
-	} else {
+		} else {
-	    err = check_complete ( t ) ;
+			err = check_complete(t);
-	    if ( !IS_NULL_err ( err ) ) {
+			if (!IS_NULL_err(err)) {
-		/* Incomplete types are not modifiable */
+				/* Incomplete types are not modifiable */
-		err = concat_error ( err, ERR_basic_lval_mod_incompl () ) ;
+				err = concat_error(err, ERR_basic_lval_mod_incompl());
-	    } else if ( qual & cv_const ) {
+			} else if (qual & cv_const) {
-		/* const objects are not modifiable */
+				/* const objects are not modifiable */
-		err = ERR_basic_lval_mod_const () ;
+				err = ERR_basic_lval_mod_const();
-	    } else if ( tag == type_compound_tag ) {
+			} else if (tag == type_compound_tag) {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+				CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-		CLASS_INFO ci = DEREF_cinfo ( ctype_info ( ct ) ) ;
+				CLASS_INFO ci = DEREF_cinfo(ctype_info(ct));
-		if ( ci & cinfo_const ) {
+				if (ci & cinfo_const) {
-		    /* Objects with const members are not modifiable */
+					/* Objects with const members are not modifiable */
-		    err = ERR_basic_lval_mod_member ( t ) ;
+					err = ERR_basic_lval_mod_member(t);
-		}
+				}
-	    } else if ( tag == type_integer_tag ) {
+			} else if (tag == type_integer_tag) {
-		if ( option ( OPT_const_string ) && cv_string == cv_none ) {
+				if (option(OPT_const_string) && cv_string == cv_none) {
-		    EXP b = NULL_exp ;
+					EXP b = NULL_exp;
-		    DECL_SPEC ds = find_exp_linkage ( a, &b, 1 ) ;
+					DECL_SPEC ds = find_exp_linkage(a, &b, 1);
-		    if ( ds & dspec_pure ) {
+					if (ds & dspec_pure) {
-			/* String literals are not modifiable */
+						/* String literals are not modifiable */
-			err = ERR_conv_array_str_mod () ;
+						err = ERR_conv_array_str_mod();
-		    }
+					}
+				}
+			}
+		}
+	} else {
+		/* rvalues are not modifiable */
+		if (tag == type_error_tag) {
+			err = NULL_err;
+		} else {
+			err = ERR_basic_lval_not();
+			err = concat_error(err, ERR_basic_lval_mod_rvalue());
+		}
-	    }
-	}
-    } else {
-	/* rvalues are not modifiable */
-	if ( tag == type_error_tag ) {
-	    err = NULL_err ;
-	} else {
-	    err = ERR_basic_lval_not () ;
-	    err = concat_error ( err, ERR_basic_lval_mod_rvalue () ) ;
+	}
-    }
-    return ( err ) ;
+	return (err);
+}
 /*
     DOES A TYPE HAVE LINKAGE?
     This routine returns true if the type t has external linkage and is
     not an anonymous type.  Not all the cases are fully checked yet.
 */
-int is_global_type
+int
-    PROTO_N ( ( t ) )
-    PROTO_T ( TYPE t )
+is_global_type(TYPE t)
+{
-    if ( !IS_NULL_type ( t ) ) {
+	if (!IS_NULL_type(t)) {
-	ASSERT ( ORDER_type == 18 ) ;
+		ASSERT(ORDER_type == 18);
-	switch ( TAG_type ( t ) ) {
+		switch (TAG_type(t)) {
-	    case type_ptr_tag : {
+		case type_ptr_tag: {
-		TYPE s = DEREF_type ( type_ptr_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_sub(t));
-		return ( is_global_type ( s ) ) ;
+			return (is_global_type(s));
-	    }
+		}
-	    case type_ref_tag : {
+		case type_ref_tag: {
-		TYPE s = DEREF_type ( type_ref_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ref_sub(t));
-		return ( is_global_type ( s ) ) ;
+			return (is_global_type(s));
-	    }
+		}
 #if LANGUAGE_CPP
-	    case type_ptr_mem_tag : {
+		case type_ptr_mem_tag: {
-		TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
+			TYPE s = DEREF_type(type_ptr_mem_sub(t));
-		CLASS_TYPE ct = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
+			CLASS_TYPE ct = DEREF_ctype(type_ptr_mem_of(t));
-		IDENTIFIER id = DEREF_id ( ctype_name ( ct ) ) ;
+			IDENTIFIER id = DEREF_id(ctype_name(ct));
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
+			HASHID nm = DEREF_hashid(id_name(id));
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-		if ( !( ds & dspec_extern ) ) return ( 0 ) ;
+			if (!(ds & dspec_extern)) {
+				return (0);
+			}
-		if ( IS_hashid_anon ( nm ) ) return ( 0 ) ;
+			if (IS_hashid_anon(nm)) {
+				return (0);
+			}
-		return ( is_global_type ( s ) ) ;
+			return (is_global_type(s));
-	    }
+		}
 #endif
-	    case type_func_tag : {
+		case type_func_tag: {
-		TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
+			TYPE r = DEREF_type(type_func_ret(t));
-		LIST ( TYPE ) p = DEREF_list ( type_func_ptypes ( t ) ) ;
+			LIST(TYPE)p = DEREF_list(type_func_ptypes(t));
-		if ( !is_global_type ( r ) ) return ( 0 ) ;
+			if (!is_global_type(r)) {
+				return (0);
+			}
-		while ( !IS_NULL_list ( p ) ) {
+			while (!IS_NULL_list(p)) {
-		    TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
+				TYPE s = DEREF_type(HEAD_list(p));
-		    if ( !is_global_type ( s ) ) return ( 0 ) ;
+				if (!is_global_type(s)) {
+					return (0);
+				}
-		    p = TAIL_list ( p ) ;
+				p = TAIL_list(p);
+			}
+			break;
+		}
+		case type_array_tag: {
+			TYPE s = DEREF_type(type_array_sub(t));
+			return (is_global_type(s));
+		}
+		case type_compound_tag: {
+			CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
+			IDENTIFIER id = DEREF_id(ctype_name(ct));
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
+			HASHID nm = DEREF_hashid(id_name(id));
+			if (!(ds & dspec_extern)) {
+				return (0);
+			}
+			if (IS_hashid_anon(nm)) {
+				return (0);
+			}
+			break;
+		}
+		case type_enumerate_tag: {
+			ENUM_TYPE et = DEREF_etype(type_enumerate_defn(t));
+			IDENTIFIER id = DEREF_id(etype_name(et));
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
+			HASHID nm = DEREF_hashid(id_name(id));
+			if (!(ds & dspec_extern)) {
+				return (0);
+			}
+			if (IS_hashid_anon(nm)) {
+				return (0);
+			}
+			break;
+		}
+		case type_templ_tag: {
+			TYPE s = DEREF_type(type_templ_defn(t));
+			return (is_global_type(s));
+		}
+		}
-		break ;
-	    }
-	    case type_array_tag : {
-		TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
-		return ( is_global_type ( s ) ) ;
-	    }
-	    case type_compound_tag : {
-		CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
-		IDENTIFIER id = DEREF_id ( ctype_name ( ct ) ) ;
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-		if ( !( ds & dspec_extern ) ) return ( 0 ) ;
-		if ( IS_hashid_anon ( nm ) ) return ( 0 ) ;
-		break ;
-	    }
-	    case type_enumerate_tag : {
-		ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
-		IDENTIFIER id = DEREF_id ( etype_name ( et ) ) ;
-		DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
-		HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
-		if ( !( ds & dspec_extern ) ) return ( 0 ) ;
-		if ( IS_hashid_anon ( nm ) ) return ( 0 ) ;
-		break ;
-	    }
-	    case type_templ_tag : {
-		TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
-		return ( is_global_type ( s ) ) ;
-	    }
+	}
-    }
-    return ( 1 ) ;
+	return (1);
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/construct/chktype.c – Rev 2 → 7