WebSVN – tendra.SVN – Diff – /branches/tendra5/src/producers/common/construct/access.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.
 */
     The flag do_access_checks may be set to false to suppress access
     checking.
 */
-int do_access_checks = 1 ;
+int do_access_checks = 1;
 /*
     CURRENT CLASS MEMBER ACCESS
     The variable crt_access is used to hold the current access specifier
     during a class definition.  prev_access is used to check for dubious
     base class access specifiers.
 */
-DECL_SPEC crt_access = dspec_public ;
+DECL_SPEC crt_access = dspec_public;
-DECL_SPEC prev_access = dspec_public ;
+DECL_SPEC prev_access = dspec_public;
 /*
     FIND THE COMPOSITE OF TWO ACCESSES
 	    dspec_public < dspec_protected < dspec_private
     the composite is just the maximum of the access components of a and b.
 */
-DECL_SPEC join_access
+DECL_SPEC
-    PROTO_N ( ( a, b ) )
-    PROTO_T ( DECL_SPEC a X DECL_SPEC b )
+join_access(DECL_SPEC a, DECL_SPEC b)
+{
-    DECL_SPEC p = ( a & dspec_access ) ;
+	DECL_SPEC p = (a & dspec_access);
-    DECL_SPEC q = ( b & dspec_access ) ;
+	DECL_SPEC q = (b & dspec_access);
-    if ( p >= q ) return ( p ) ;
+	if (p >= q) {
+		return (p);
+	}
-    return ( q ) ;
+	return (q);
+}
 /*
     ADJUST THE ACCESS FOR AN IDENTIFIER
     This routine adjusts the access to the identifier id to the access
     level acc.  expl is true for explicit using and access declarations
     and false for simple redeclarations.
 */
-void adjust_access
+void
-    PROTO_N ( ( id, acc, expl ) )
-    PROTO_T ( IDENTIFIER id X DECL_SPEC acc X int expl )
+adjust_access(IDENTIFIER id, DECL_SPEC acc, int expl)
+{
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+    DECL_SPEC ds = DEREF_dspec(id_storage(id));
-    DECL_SPEC pacc = ( ds & dspec_access ) ;
+    DECL_SPEC pacc = (ds & dspec_access);
-    if ( pacc && acc != pacc ) {
+    if (pacc && acc != pacc) {
-	if ( !expl ) {
+	if (!expl) {
 	    /* Access changed by redeclaration */
-	    PTR ( LOCATION ) loc = id_loc ( id ) ;
+	    PTR(LOCATION)loc = id_loc(id);
-	    report ( crt_loc, ERR_class_access_spec_change ( id, loc ) ) ;
+	    report(crt_loc, ERR_class_access_spec_change(id, loc));
+	}
-	if ( acc > pacc ) {
+	if (acc > pacc) {
-	    if ( expl ) {
+	    if (expl) {
 		/* Access reduced by using declaration */
-		PTR ( LOCATION ) loc = id_loc ( id ) ;
+		PTR(LOCATION)loc = id_loc(id);
-		report ( crt_loc, ERR_dcl_nspace_udecl_acc ( id, loc ) ) ;
+		report(crt_loc, ERR_dcl_nspace_udecl_acc(id, loc));
+	    }
-	    acc = pacc ;
+	    acc = pacc;
+	}
-	ds = ( ( ds & ~dspec_access ) | acc ) ;
+	ds = ((ds & ~dspec_access) | acc);
-	COPY_dspec ( id_storage ( id ), ds ) ;
+	COPY_dspec(id_storage(id), ds);
+    }
-    if ( IS_id_function_etc ( id ) && expl ) {
+    if (IS_id_function_etc(id) && expl) {
 	/* Deal with overloaded functions */
-	id = DEREF_id ( id_function_etc_over ( id ) ) ;
+	id = DEREF_id(id_function_etc_over(id));
-	if ( !IS_NULL_id ( id ) ) adjust_access ( id, acc, expl ) ;
+	if (!IS_NULL_id(id))adjust_access(id, acc, expl);
+    }
-    return ;
+    return;
+}
 /*
     ACCESS DECLARATION FLAG
     This flag is set to true by access_decl.
 */
-int have_access_decl = 0 ;
+int have_access_decl = 0;
 /*
     MAKE AN ACCESS DECLARATION
     This routine adjusts the access of the member id of the current class.
     This is equivalent to a using declaration for id.
 */
-IDENTIFIER access_decl
+IDENTIFIER
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+access_decl(IDENTIFIER id)
 {
-    report ( crt_loc, ERR_class_access_dcl_using ( id ) ) ;
+	report(crt_loc, ERR_class_access_dcl_using(id));
-    have_access_decl = 1 ;
+	have_access_decl = 1;
-    id = using_identifier ( id ) ;
+	id = using_identifier(id);
-    return ( id ) ;
+	return (id);
 }
 /*
     MAKE A FRIENDLY FUNCTION
     This routine makes the function id into a friend of the class cs.
     The effect of this is to add cs to id's chums list and id to cs's
     pals list.
 */
-void friend_function
+void
-    PROTO_N ( ( cs, id, expl ) )
-    PROTO_T ( CLASS_TYPE cs X IDENTIFIER id X int expl )
+friend_function(CLASS_TYPE cs, IDENTIFIER id, int expl)
+{
-    if ( !IS_NULL_ctype ( cs ) ) {
+    if (!IS_NULL_ctype(cs)) {
-	IDENTIFIER cid ;
+	IDENTIFIER cid;
-	LIST ( IDENTIFIER ) pl ;
+	LIST(IDENTIFIER)pl;
-	LIST ( CLASS_TYPE ) fr, fs ;
+	LIST(CLASS_TYPE)fr, fs;
 	/* Make cs a pal of id */
-	fr = DEREF_list ( id_function_etc_chums ( id ) ) ;
+	fr = DEREF_list(id_function_etc_chums(id));
-	fs = fr ;
+	fs = fr;
-	while ( !IS_NULL_list ( fs ) ) {
+	while (!IS_NULL_list(fs)) {
-	    CLASS_TYPE ct = DEREF_ctype ( HEAD_list ( fs ) ) ;
+	    CLASS_TYPE ct = DEREF_ctype(HEAD_list(fs));
-	    if ( eq_ctype ( ct, cs ) ) {
+	    if (eq_ctype(ct, cs)) {
 		/* id is already a friend of ns */
-		if ( expl ) {
+		if (expl) {
-		    ERROR err = ERR_class_friend_dup_func ( id, cs ) ;
+		    ERROR err = ERR_class_friend_dup_func(id, cs);
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
+		}
-		return ;
+		return;
+	    }
-	    fs = TAIL_list ( fs ) ;
+	    fs = TAIL_list(fs);
+	}
-	CONS_ctype ( cs, fr, fr ) ;
+	CONS_ctype(cs, fr, fr);
-	COPY_list ( id_function_etc_chums ( id ), fr ) ;
+	COPY_list(id_function_etc_chums(id), fr);
 	/* Make id a pal of cs */
-	pl = DEREF_list ( ctype_pals ( cs ) ) ;
+	pl = DEREF_list(ctype_pals(cs));
-	CONS_id ( id, pl, pl ) ;
+	CONS_id(id, pl, pl);
-	COPY_list ( ctype_pals ( cs ), pl ) ;
+	COPY_list(ctype_pals(cs), pl);
 	/* Apply access checks immediately */
-	cid = DEREF_id ( ctype_name ( cs ) ) ;
+	cid = DEREF_id(ctype_name(cs));
-	immediate_access ( cid, id ) ;
+	immediate_access(cid, id);
+    }
-    return ;
+    return;
+}
 /*
     MAKE A FRIENDLY CLASS
     This routine makes the class cid into a friend of the class cs.  The
     effect of this is to add cs to cid's chums list and cid to cs's pals
     list.
 */
-void friend_class
+void
-    PROTO_N ( ( cs, cid, expl ) )
-    PROTO_T ( CLASS_TYPE cs X IDENTIFIER cid X int expl )
+friend_class(CLASS_TYPE cs, IDENTIFIER cid, int expl)
+{
-    if ( !IS_NULL_ctype ( cs ) ) {
+    if (!IS_NULL_ctype(cs)) {
-	ERROR err ;
+	ERROR err;
-	TYPE t = DEREF_type ( id_class_name_etc_defn ( cid ) ) ;
+	TYPE t = DEREF_type(id_class_name_etc_defn(cid));
-	while ( IS_type_templ ( t ) ) {
+	while (IS_type_templ(t)) {
-	    t = DEREF_type ( type_templ_defn ( t ) ) ;
+	    t = DEREF_type(type_templ_defn(t));
 	}
-	if ( IS_type_compound ( t ) ) {
+	if (IS_type_compound(t)) {
-	    CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
+	    CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));
-	    if ( eq_ctype ( cs, ct ) ) {
+	    if (eq_ctype(cs, ct)) {
 		/* Any class is a friend of itself */
-		if ( expl ) {
+		if (expl) {
-		    err = ERR_class_friend_dup_class ( ct, cs ) ;
+		    err = ERR_class_friend_dup_class(ct, cs);
-		    report ( crt_loc, err ) ;
+		    report(crt_loc, err);
+		}
 	    } else {
-		IDENTIFIER sid ;
+		IDENTIFIER sid;
-		LIST ( IDENTIFIER ) pl ;
+		LIST(IDENTIFIER)pl;
 		/* Make cs a chum of ct */
-		LIST ( CLASS_TYPE ) fr = DEREF_list ( ctype_chums ( ct ) ) ;
+		LIST(CLASS_TYPE)fr = DEREF_list(ctype_chums(ct));
-		LIST ( CLASS_TYPE ) fs = fr ;
+		LIST(CLASS_TYPE)fs = fr;
-		while ( !IS_NULL_list ( fs ) ) {
+		while (!IS_NULL_list(fs)) {
-		    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fs ) ) ;
+		    CLASS_TYPE cr = DEREF_ctype(HEAD_list(fs));
-		    if ( eq_ctype ( cr, cs ) ) {
+		    if (eq_ctype(cr, cs)) {
 			/* ct is already a friend of cs */
-			if ( expl ) {
+			if (expl) {
-			    err = ERR_class_friend_dup_class ( ct, cs ) ;
+			    err = ERR_class_friend_dup_class(ct, cs);
-			    report ( crt_loc, err ) ;
+			    report(crt_loc, err);
+			}
-			return ;
+			return;
+		    }
-		    fs = TAIL_list ( fs ) ;
+		    fs = TAIL_list(fs);
+		}
-		CONS_ctype ( cs, fr, fr ) ;
+		CONS_ctype(cs, fr, fr);
-		COPY_list ( ctype_chums ( ct ), fr ) ;
+		COPY_list(ctype_chums(ct), fr);
 		/* Make ct a pal of cs */
-		pl = DEREF_list ( ctype_pals ( cs ) ) ;
+		pl = DEREF_list(ctype_pals(cs));
-		CONS_id ( cid, pl, pl ) ;
+		CONS_id(cid, pl, pl);
-		COPY_list ( ctype_pals ( cs ), pl ) ;
+		COPY_list(ctype_pals(cs), pl);
 		/* Apply access checks immediately */
-		sid = DEREF_id ( ctype_name ( cs ) ) ;
+		sid = DEREF_id(ctype_name(cs));
-		immediate_access ( sid, cid ) ;
+		immediate_access(sid, cid);
 	    }
 	}
+    }
-    return ;
+    return;
+}
 /*
     LISTS OF PENDING ACCESS CHECKS
     Access control checking cannot be performed immediately because, for
     example, it is not known until the end of a declaration whether that
     declaration represents a friend function.  The list crt_access_list
     is used to store any pending access checks.
 */
 ACCESS_LIST crt_access_list = {
-    NULL_list ( IDENTIFIER ), NULL_list ( GRAPH ),
+	NULL_list(IDENTIFIER), NULL_list(GRAPH),
-    NULL_list ( int ), 0, 0
+	NULL_list(int), 0, 0
-} ;
+};
 /*
     FIND ACCESS LEVEL
     This routine finds the access level for the members of the class
     namespace ns by the identifier pid (or a base class conversion from
     ns if base is true).  It returns the highest access level greater
     than acc which can be accessed.  It also returns a secondary access
     giving the access to base class members, plus markers for whether
     the access is via the actual class, a derived class or a friend.
 */
-static DECL_SPEC find_access
+static DECL_SPEC
-    PROTO_N ( ( pid, ns, acc, base ) )
-    PROTO_T ( IDENTIFIER *pid X NAMESPACE ns X DECL_SPEC acc X int base )
+find_access(IDENTIFIER *pid, NAMESPACE ns, DECL_SPEC acc, int base)
+{
-    NAMESPACE cns ;
+    NAMESPACE cns;
-    CLASS_TYPE ct ;
+    CLASS_TYPE ct;
-    TYPE t = NULL_type ;
+    TYPE t = NULL_type;
-    IDENTIFIER id = *pid ;
+    IDENTIFIER id = *pid;
     /* Find the namespace corresponding to id */
-    DECL_SPEC ok = ( dspec_public | dspec_public2 ) ;
+    DECL_SPEC ok = (dspec_public | dspec_public2);
-    if ( IS_NULL_id ( id ) ) return ( ok ) ;
+    if (IS_NULL_id(id)) {
+	    return (ok);
+    }
-    if ( IS_id_class_name ( id ) ) {
+    if (IS_id_class_name(id)) {
-	cns = find_namespace ( id ) ;
+	cns = find_namespace(id);
     } else {
-	cns = DEREF_nspace ( id_parent ( id ) ) ;
+	cns = DEREF_nspace(id_parent(id));
+    }
+    if (IS_NULL_nspace(cns)) {
+	    return (ok);
+    }
-    if ( IS_NULL_nspace ( cns ) ) return ( ok ) ;
     /* Map block identifiers to the corresponding function */
-    if ( IS_nspace_block ( cns ) ) {
+    if (IS_nspace_block(cns)) {
-	id = DEREF_id ( nspace_name ( cns ) ) ;
+	id = DEREF_id(nspace_name(cns));
-	cns = DEREF_nspace ( id_parent ( id ) ) ;
+	cns = DEREF_nspace(id_parent(id));
-	*pid = id ;
+	*pid = id;
+    }
     /* Allow for equal namespaces */
-    if ( base ) {
+    if (base) {
-	ok = ( dspec_private | dspec_public2 ) ;
+	ok = (dspec_private | dspec_public2);
     } else {
-	ok = ( dspec_private | dspec_protected2 ) ;
+	ok = (dspec_private | dspec_protected2);
+    }
-    if ( EQ_nspace ( cns, ns ) ) {
+    if (EQ_nspace(cns, ns)) {
-	ok |= dspec_defn ;
+	ok |= dspec_defn;
-	return ( ok ) ;
+	return (ok);
+    }
-    ct = namespace_class ( ns ) ;
+    ct = namespace_class(ns);
-    ct = expand_ctype ( ct, 2, &t ) ;
+    ct = expand_ctype(ct, 2, &t);
-    complete_class ( ct, 1 ) ;
+    complete_class(ct, 1);
     /* Check access for classes */
-    if ( IS_nspace_ctype ( cns ) ) {
+    if (IS_nspace_ctype(cns)) {
-	LIST ( CLASS_TYPE ) fr ;
+	LIST(CLASS_TYPE)fr;
-	CLASS_TYPE cs = namespace_class ( cns ) ;
+	CLASS_TYPE cs = namespace_class(cns);
-	if ( eq_ctype ( cs, ct ) ) {
+	if (eq_ctype(cs, ct)) {
 	    /* Same class */
-	    ok |= dspec_defn ;
+	    ok |= dspec_defn;
-	    return ( ok ) ;
+	    return (ok);
+	}
-	fr = DEREF_list ( ctype_chums ( cs ) ) ;
+	fr = DEREF_list(ctype_chums(cs));
-	while ( !IS_NULL_list ( fr ) ) {
+	while (!IS_NULL_list(fr)) {
-	    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fr ) ) ;
+	    CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));
-	    if ( eq_ctype ( cr, ct ) ) {
+	    if (eq_ctype(cr, ct)) {
 		/* Friend class */
-		ok |= ( dspec_defn | dspec_friend ) ;
+		ok |= (dspec_defn | dspec_friend);
-		return ( ok ) ;
+		return (ok);
+	    }
-	    fr = TAIL_list ( fr ) ;
+	    fr = TAIL_list(fr);
+	}
+    }
     /* Check for friend functions */
-    if ( IS_id_function_etc ( id ) ) {
+    if (IS_id_function_etc(id)) {
-	LIST ( CLASS_TYPE ) fr ;
+	LIST(CLASS_TYPE)fr;
-	fr = DEREF_list ( id_function_etc_chums ( id ) ) ;
+	fr = DEREF_list(id_function_etc_chums(id));
-	while ( !IS_NULL_list ( fr ) ) {
+	while (!IS_NULL_list(fr)) {
-	    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fr ) ) ;
+	    CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));
-	    if ( eq_ctype ( cr, ct ) ) {
+	    if (eq_ctype(cr, ct)) {
 		/* Friend function */
-		ok |= ( dspec_defn | dspec_friend ) ;
+		ok |= (dspec_defn | dspec_friend);
-		return ( ok ) ;
+		return (ok);
 	    }
-	    fr = TAIL_list ( fr ) ;
+	    fr = TAIL_list(fr);
 	}
     }
     /* End here for private members */
-    if ( acc == dspec_private || base ) {
+    if (acc == dspec_private || base) {
-	ok = ( dspec_public | dspec_public2 ) ;
+	ok = (dspec_public | dspec_public2);
-	return ( ok ) ;
+	return (ok);
     }
     /* Check access for derived classes */
-    ok = ( dspec_protected | dspec_protected2 ) ;
+    ok = (dspec_protected | dspec_protected2);
-    if ( IS_nspace_ctype ( cns ) ) {
+    if (IS_nspace_ctype(cns)) {
-	LIST ( CLASS_TYPE ) fr ;
+	LIST(CLASS_TYPE)fr;
-	CLASS_TYPE cs = namespace_class ( cns ) ;
+	CLASS_TYPE cs = namespace_class(cns);
-	GRAPH gr = find_base_class ( cs, ct, 0 ) ;
+	GRAPH gr = find_base_class(cs, ct, 0);
-	if ( !IS_NULL_graph ( gr ) ) {
+	if (!IS_NULL_graph(gr)) {
 	    /* Derived class */
-	    ok |= dspec_inherit ;
+	    ok |= dspec_inherit;
-	    return ( ok ) ;
+	    return (ok);
 	}
-	fr = DEREF_list ( ctype_chums ( cs ) ) ;
+	fr = DEREF_list(ctype_chums(cs));
-	while ( !IS_NULL_list ( fr ) ) {
+	while (!IS_NULL_list(fr)) {
-	    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fr ) ) ;
+	    CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));
-	    gr = find_base_class ( cr, ct, 0 ) ;
+	    gr = find_base_class(cr, ct, 0);
-	    if ( !IS_NULL_graph ( gr ) ) {
+	    if (!IS_NULL_graph(gr)) {
 		/* Friend class of derived class */
-		ok |= ( dspec_inherit | dspec_friend ) ;
+		ok |= (dspec_inherit | dspec_friend);
-		return ( ok ) ;
+		return (ok);
 	    }
-	    fr = TAIL_list ( fr ) ;
+	    fr = TAIL_list(fr);
 	}
     }
     /* Check for derived friend functions */
-    if ( IS_id_function_etc ( id ) ) {
+    if (IS_id_function_etc(id)) {
-	LIST ( CLASS_TYPE ) fr ;
+	LIST(CLASS_TYPE)fr;
-	fr = DEREF_list ( id_function_etc_chums ( id ) ) ;
+	fr = DEREF_list(id_function_etc_chums(id));
-	while ( !IS_NULL_list ( fr ) ) {
+	while (!IS_NULL_list(fr)) {
-	    CLASS_TYPE cr = DEREF_ctype ( HEAD_list ( fr ) ) ;
+	    CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));
-	    GRAPH gr = find_base_class ( cr, ct, 0 ) ;
+	    GRAPH gr = find_base_class(cr, ct, 0);
-	    if ( !IS_NULL_graph ( gr ) ) {
+	    if (!IS_NULL_graph(gr)) {
 		/* Friend function of derived class */
-		ok |= ( dspec_inherit | dspec_friend ) ;
+		ok |= (dspec_inherit | dspec_friend);
-		return ( ok ) ;
+		return (ok);
 	    }
-	    fr = TAIL_list ( fr ) ;
+	    fr = TAIL_list(fr);
 	}
     }
     /* Default access */
-    ok = ( dspec_public | dspec_public2 ) ;
+    ok = (dspec_public | dspec_public2);
-    return ( ok ) ;
+    return (ok);
+}
 /*
     COMPARE ACCESS LEVELS
     This routine checks whether the access level ok returned by find_access
     is sufficient to access a member of type tag with declaration specifiers
     ds.  It returns true if the access is an error.
 */
-static int compare_access
+static int
-    PROTO_N ( ( ok, ds, tag, mem ) )
-    PROTO_T ( DECL_SPEC ok X DECL_SPEC ds X unsigned tag X int mem )
+compare_access(DECL_SPEC ok, DECL_SPEC ds, unsigned tag, int mem)
 {
-    int ret = 0 ;
+	int ret = 0;
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    DECL_SPEC level = ( ok & dspec_access ) ;
+	DECL_SPEC level = (ok & dspec_access);
-    if ( level < acc ) {
+	if (level < acc) {
-	/* Straightforward case */
+		/* Straightforward case */
-	ret = 1 ;
+		ret = 1;
-    } else {
+	} else {
-	/* Deal with inheritance */
+		/* Deal with inheritance */
-	if ( ds & dspec_inherit ) {
+		if (ds & dspec_inherit) {
-	    DECL_SPEC acc2 = ( ds & dspec_access2 ) ;
+			DECL_SPEC acc2 = (ds & dspec_access2);
-	    level = ( ok & dspec_access2 ) ;
+			level = (ok & dspec_access2);
-	    if ( level < acc2 ) ret = 1 ;
+			if (level < acc2) {
+				ret = 1;
+			}
-	}
+		}
-    }
+	}
-    if ( !ret && !mem ) {
+	if (!ret && !mem) {
-	if ( tag == id_member_tag || tag == id_mem_func_tag ) {
+		if (tag == id_member_tag || tag == id_mem_func_tag) {
-	    /* Check for access through derived class */
+			/* Check for access through derived class */
-	    if ( ok & dspec_inherit ) ret = 1 ;
+			if (ok & dspec_inherit) {
+				ret = 1;
+			}
+		}
+	}
-    }
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CAN AN INHERITED MEMBER BE ACCESSED?
     This routine checks whether the inherited class member pid can be
     accessed by the identifier id.  If so it returns true.  The direct
     cases, such as a member of a derived class accessing a member of a
     base class are handled by the main part of do_member_access, this
     routine deals with the indirect cases such as friends of classes
     intermediate between the base class and the derived class.
 */
-static int inherit_access
+static int
-    PROTO_N ( ( id, pid, mem ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER pid X int mem )
+inherit_access(IDENTIFIER id, IDENTIFIER pid, int mem)
 {
-    /* Find inheritance base class */
+	/* Find inheritance base class */
-    unsigned tag = TAG_id ( pid ) ;
+	unsigned tag = TAG_id(pid);
-    IDENTIFIER bid = DEREF_id ( id_alias ( pid ) ) ;
+	IDENTIFIER bid = DEREF_id(id_alias(pid));
-    DECL_SPEC acc = DEREF_dspec ( id_storage ( bid ) ) ;
+	DECL_SPEC acc = DEREF_dspec(id_storage(bid));
-    NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
+	NAMESPACE pns = DEREF_nspace(id_parent(pid));
-    NAMESPACE bns = DEREF_nspace ( id_parent ( bid ) ) ;
+	NAMESPACE bns = DEREF_nspace(id_parent(bid));
-    CLASS_TYPE ct = namespace_class ( pns ) ;
+	CLASS_TYPE ct = namespace_class(pns);
-    CLASS_TYPE cs = namespace_class ( bns ) ;
+	CLASS_TYPE cs = namespace_class(bns);
-    GRAPH gr = find_base_class ( ct, cs, 0 ) ;
+	GRAPH gr = find_base_class(ct, cs, 0);
-    /* Scan through all base classes of ct containing bid */
+	/* Scan through all base classes of ct containing bid */
-    while ( !IS_NULL_graph ( gr ) ) {
+	while (!IS_NULL_graph(gr)) {
-	GRAPH gs = gr ;
+		GRAPH gs = gr;
-	while ( !IS_NULL_graph ( gs ) ) {
+		while (!IS_NULL_graph(gs)) {
-	    cs = DEREF_ctype ( graph_head ( gs ) ) ;
+			cs = DEREF_ctype(graph_head(gs));
-	    if ( !eq_ctype ( cs, ct ) ) {
+			if (!eq_ctype(cs, ct)) {
-		DECL_SPEC ds, ok ;
+				DECL_SPEC ds, ok;
-		ds = DEREF_dspec ( graph_access ( gr ) ) ;
+				ds = DEREF_dspec(graph_access(gr));
-		ds = join_access ( acc, ds ) ;
+				ds = join_access(acc, ds);
-		bns = DEREF_nspace ( ctype_member ( cs ) ) ;
+				bns = DEREF_nspace(ctype_member(cs));
-		ok = find_access ( &id, bns, ds, 2 ) ;
+				ok = find_access(&id, bns, ds, 2);
-		if ( ok & dspec_defn ) {
+				if (ok & dspec_defn) {
-		    /* id is a member or friend of cs */
+					/* id is a member or friend of cs */
-		    if ( !compare_access ( ok, ds, tag, mem ) ) {
+					if (!compare_access(ok, ds, tag, mem)) {
-			/* Can access bid */
+						/* Can access bid */
-			return ( 1 ) ;
+						return (1);
-		    }
+					}
-		}
+				}
-	    }
+			}
-	    gs = DEREF_graph ( graph_up ( gs ) ) ;
+			gs = DEREF_graph(graph_up(gs));
-	}
+		}
-	gr = DEREF_graph ( graph_equal ( gr ) ) ;
+		gr = DEREF_graph(graph_equal(gr));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
 }
 /*
     CHECK A MEMBER ACCESS
     This routine checks the access of the class member pid by the
     identifier id.  It prints an error and returns true if the access
     is illegal.
 */
-static int do_member_access
+static int
-    PROTO_N ( ( id, pid, mem ) )
-    PROTO_T ( IDENTIFIER id X IDENTIFIER pid X int mem )
+do_member_access(IDENTIFIER id, IDENTIFIER pid, int mem)
 {
-    int ret = 0 ;
+	int ret = 0;
-    NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
+	NAMESPACE pns = DEREF_nspace(id_parent(pid));
-    DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
+	DECL_SPEC ds = DEREF_dspec(id_storage(pid));
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    DECL_SPEC ok = find_access ( &id, pns, acc, 0 ) ;
+	DECL_SPEC ok = find_access(&id, pns, acc, 0);
-    if ( compare_access ( ok, ds, TAG_id ( pid ), mem ) ) {
+	if (compare_access(ok, ds, TAG_id(pid), mem)) {
-	if ( ( ds & dspec_inherit ) && inherit_access ( id, pid, mem ) ) {
+		if ((ds & dspec_inherit) && inherit_access(id, pid, mem)) {
-	    /* Can access through inheritance */
+			/* Can access through inheritance */
-	    /* EMPTY */
+			/* EMPTY */
-	} else {
+		} else {
-	    /* Report access error */
+			/* Report access error */
-	    ERROR err ;
+			ERROR err;
-	    if ( IS_NULL_id ( id ) ) {
+			if (IS_NULL_id(id)) {
-		err = ERR_class_access_spec_none ( pid, acc ) ;
+				err = ERR_class_access_spec_none(pid, acc);
-	    } else {
+			} else {
-		err = ERR_class_access_spec_id ( pid, acc, id ) ;
+				err = ERR_class_access_spec_id(pid, acc, id);
-	    }
+			}
-	    report ( crt_loc, err ) ;
+			report(crt_loc, err);
-	    ret = 1 ;
+			ret = 1;
+		}
+	}
-    }
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CHECK A BASE CLASS ACCESS
     This routine checks the access of the base class gr by the
     identifier id.  It prints an error and returns true if the access
     is illegal.
 */
-static int do_base_access
+static int
-    PROTO_N ( ( id, gr ) )
-    PROTO_T ( IDENTIFIER id X GRAPH gr )
+do_base_access(IDENTIFIER id, GRAPH gr)
 {
-    int ret = 0 ;
+	int ret = 0;
-    GRAPH gt = DEREF_graph ( graph_top ( gr ) ) ;
+	GRAPH gt = DEREF_graph(graph_top(gr));
-    CLASS_TYPE ct = DEREF_ctype ( graph_head ( gt ) ) ;
+	CLASS_TYPE ct = DEREF_ctype(graph_head(gt));
-    NAMESPACE pns = DEREF_nspace ( ctype_member ( ct ) ) ;
+	NAMESPACE pns = DEREF_nspace(ctype_member(ct));
-    DECL_SPEC ds = DEREF_dspec ( graph_access ( gr ) ) ;
+	DECL_SPEC ds = DEREF_dspec(graph_access(gr));
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    DECL_SPEC ok = find_access ( &id, pns, acc, 1 ) ;
+	DECL_SPEC ok = find_access(&id, pns, acc, 1);
-    if ( compare_access ( ok, ds, null_tag, 0 ) ) {
+	if (compare_access(ok, ds, null_tag, 0)) {
-	/* Report access error */
+		/* Report access error */
-	ERROR err ;
+		ERROR err;
-	CLASS_TYPE cs = DEREF_ctype ( graph_head ( gr ) ) ;
+		CLASS_TYPE cs = DEREF_ctype(graph_head(gr));
-	if ( IS_NULL_id ( id ) ) {
+		if (IS_NULL_id(id)) {
-	    err = ERR_class_access_base_none ( cs, ct, acc ) ;
+			err = ERR_class_access_base_none(cs, ct, acc);
-	} else {
+		} else {
-	    err = ERR_class_access_base_id ( cs, ct, acc, id ) ;
+			err = ERR_class_access_base_id(cs, ct, acc, id);
-	}
+		}
-	err = concat_error ( err, ERR_conv_ptr_access () ) ;
+		err = concat_error(err, ERR_conv_ptr_access());
-	report ( crt_loc, err ) ;
+		report(crt_loc, err);
-	ret = 1 ;
+		ret = 1;
-    }
+	}
-    return ( ret ) ;
+	return (ret);
 }
 /*
     CLEAR A LIST OF PENDING IDENTIFIER ACCESS CHECKS
     This routine clears the list of pending access checks given by p in
     the context given by the identifier id.  It returns true if any
     results in an error.
 */
-static int clear_id_access
+static int
-    PROTO_N ( ( id, p, r ) )
-    PROTO_T ( IDENTIFIER id X LIST ( IDENTIFIER ) p X LIST ( int ) r )
+clear_id_access(IDENTIFIER id, LIST(IDENTIFIER)p, LIST(int)r)
+{
-    int ret = 0 ;
+	int ret = 0;
-    if ( !IS_NULL_list ( p ) ) {
+	if (!IS_NULL_list(p)) {
-	int mem = DEREF_int ( HEAD_list ( r ) ) ;
+		int mem = DEREF_int(HEAD_list(r));
-	IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
+		IDENTIFIER pid = DEREF_id(HEAD_list(p));
-	ret = clear_id_access ( id, TAIL_list ( p ), TAIL_list ( r ) ) ;
+		ret = clear_id_access(id, TAIL_list(p), TAIL_list(r));
-	if ( !IS_NULL_id ( pid ) && do_member_access ( id, pid, mem ) ) {
+		if (!IS_NULL_id(pid) && do_member_access(id, pid, mem)) {
-	    COPY_id ( HEAD_list ( p ), NULL_id ) ;
+			COPY_id(HEAD_list(p), NULL_id);
-	    ret = 1 ;
+			ret = 1;
+		}
+	}
-    }
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CLEAR A LIST OF PENDING BASE CLASS ACCESS CHECKS
     This routine clears the list of pending base class access checks given
     by p in the context given by the identifier id.  It returns true if
     any results in an error.
 */
-static int clear_base_access
+static int
-    PROTO_N ( ( id, p ) )
-    PROTO_T ( IDENTIFIER id X LIST ( GRAPH ) p )
+clear_base_access(IDENTIFIER id, LIST(GRAPH)p)
+{
-    int ret = 0 ;
+	int ret = 0;
-    if ( !IS_NULL_list ( p ) ) {
+	if (!IS_NULL_list(p)) {
-	GRAPH gr = DEREF_graph ( HEAD_list ( p ) ) ;
+		GRAPH gr = DEREF_graph(HEAD_list(p));
-	ret = clear_base_access ( id, TAIL_list ( p ) ) ;
+		ret = clear_base_access(id, TAIL_list(p));
-	if ( !IS_NULL_graph ( gr ) && do_base_access ( id, gr ) ) {
+		if (!IS_NULL_graph(gr) && do_base_access(id, gr)) {
-	    COPY_graph ( HEAD_list ( p ), NULL_graph ) ;
+			COPY_graph(HEAD_list(p), NULL_graph);
-	    ret = 1 ;
+			ret = 1;
+		}
+	}
-    }
-    return ( ret ) ;
+	return (ret);
 }
 /*
     CLEAR A LIST OF PENDING ACCESS CHECKS
     This routine clears the list of pending access checks given by acc in
     the context given by the identifier id.  It returns true if any
     results in an error.
 */
-int clear_access
+int
-    PROTO_N ( ( id, acc ) )
-    PROTO_T ( IDENTIFIER id X ACCESS_LIST *acc )
+clear_access(IDENTIFIER id, ACCESS_LIST *acc)
 {
-    int ret = 0 ;
+	int ret = 0;
-    if ( acc->pending ) {
+	if (acc->pending) {
-	LIST ( IDENTIFIER ) p = acc->ids ;
+		LIST(IDENTIFIER)p = acc->ids;
-	LIST ( GRAPH ) q = acc->bases ;
+		LIST(GRAPH)q = acc->bases;
-	LIST ( int ) r = acc->info ;
+		LIST(int)r = acc->info;
-	if ( !IS_NULL_list ( p ) && clear_id_access ( id, p, r ) ) ret = 1 ;
+		if (!IS_NULL_list(p) && clear_id_access(id, p, r)) {
+			ret = 1;
+		}
-	if ( !IS_NULL_list ( q ) && clear_base_access ( id, q ) ) ret = 1 ;
+		if (!IS_NULL_list(q) && clear_base_access(id, q)) {
+			ret = 1;
-    }
+		}
+	}
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CLEAR THE LIST OF CURRENT ACCESSES
     This routine clears all outstanding accesses in the scope given by id.
     It returns true if any results in an error.
 */
-int report_access
+int
-    PROTO_N ( ( id ) )
-    PROTO_T ( IDENTIFIER id )
+report_access(IDENTIFIER id)
 {
-    ACCESS_LIST *acc = &crt_access_list ;
+	ACCESS_LIST *acc = &crt_access_list;
-    int ret = clear_access ( id, acc ) ;
+	int ret = clear_access(id, acc);
-    free_access ( acc ) ;
+	free_access(acc);
-    return ( ret ) ;
+	return (ret);
 }
 /*
     FREE AN ACCESS LIST
     This routine frees the list of accesses given by acc.
 */
-void free_access
-    PROTO_N ( ( acc ) )
-    PROTO_T ( ACCESS_LIST *acc )
-{
-    LIST ( IDENTIFIER ) p = acc->ids ;
-    LIST ( GRAPH ) q = acc->bases ;
-    LIST ( int ) r = acc->info ;
-    if ( !IS_NULL_list ( p ) ) {
-	DESTROY_list ( p, SIZE_id ) ;
-	acc->ids = NULL_list ( IDENTIFIER ) ;
-    }
-    if ( !IS_NULL_list ( q ) ) {
-	DESTROY_list ( q, SIZE_graph ) ;
-	acc->bases = NULL_list ( GRAPH ) ;
-    }
-    if ( !IS_NULL_list ( r ) ) {
-	DESTROY_list ( r, SIZE_int ) ;
-	acc->info = NULL_list ( int ) ;
-    }
-    acc->pending = 0 ;
-    acc->inherit = 0 ;
-    return ;
-}
-/*
-    SAVE AN ACCESS LIST
-    This routine saves the current access list into acc and clears the
-    list.
-*/
-void save_access
+void
-    PROTO_N ( ( acc ) )
-    PROTO_T ( ACCESS_LIST *acc )
+free_access(ACCESS_LIST *acc)
+{
-    ACCESS_LIST *crt = &crt_access_list ;
-    acc->ids = crt->ids ;
+	LIST(IDENTIFIER)p = acc->ids;
-    acc->bases = crt->bases ;
+	LIST(GRAPH)q = acc->bases;
-    acc->info = crt->info ;
+	LIST(int)r = acc->info;
-    acc->pending = crt->pending ;
+	if (!IS_NULL_list(p)) {
-    acc->inherit = crt->inherit ;
+		DESTROY_list(p, SIZE_id);
-    crt->ids = NULL_list ( IDENTIFIER ) ;
+		acc->ids = NULL_list(IDENTIFIER);
+	}
+	if (!IS_NULL_list(q)) {
+		DESTROY_list(q, SIZE_graph);
-    crt->bases = NULL_list ( GRAPH ) ;
+		acc->bases = NULL_list(GRAPH);
+	}
+	if (!IS_NULL_list(r)) {
+		DESTROY_list(r, SIZE_int);
-    crt->info = NULL_list ( int ) ;
+		acc->info = NULL_list(int);
+	}
-    crt->pending = 0 ;
+	acc->pending = 0;
-    crt->inherit = 0 ;
+	acc->inherit = 0;
-    return ;
+	return;
+}
 /*
-    RESTORE AN ACCESS LIST
+    SAVE AN ACCESS LIST
-    This routine clears the current access list in the scope given by
+    This routine saves the current access list into acc and clears the
-    id and resets the current access list the values stored in acc.
+    list.
 */
-int restore_access
+void
-    PROTO_N ( ( id, acc ) )
-    PROTO_T ( IDENTIFIER id X ACCESS_LIST *acc )
+save_access(ACCESS_LIST *acc)
+{
+	ACCESS_LIST *crt = &crt_access_list;
+	acc->ids = crt->ids;
+	acc->bases = crt->bases;
+	acc->info = crt->info;
+	acc->pending = crt->pending;
+	acc->inherit = crt->inherit;
+	crt->ids = NULL_list(IDENTIFIER);
+	crt->bases = NULL_list(GRAPH);
+	crt->info = NULL_list(int);
+	crt->pending = 0;
+	crt->inherit = 0;
+	return;
+}
+/*
+    RESTORE AN ACCESS LIST
+    This routine clears the current access list in the scope given by
+    id and resets the current access list the values stored in acc.
+*/
+int
+restore_access(IDENTIFIER id, ACCESS_LIST *acc)
+{
-    int ret = report_access ( id ) ;
+	int ret = report_access(id);
-    ACCESS_LIST *crt = &crt_access_list ;
+	ACCESS_LIST *crt = &crt_access_list;
-    crt->ids = acc->ids ;
+	crt->ids = acc->ids;
-    crt->bases = acc->bases ;
+	crt->bases = acc->bases;
-    crt->info = acc->info ;
+	crt->info = acc->info;
-    crt->pending = acc->pending ;
+	crt->pending = acc->pending;
-    crt->inherit = acc->inherit ;
+	crt->inherit = acc->inherit;
-    return ( ret ) ;
+	return (ret);
+}
 /*
     CHECK THE ACCESS TO AN IDENTIFIER
     This routine adds the identifier id with access acc to the list of
     pending access checks.  acc will always be dspec_public, dspec_protected
     or dspec_private.
 */
-void check_access
+void
-    PROTO_N ( ( id, acc ) )
-    PROTO_T ( IDENTIFIER id X DECL_SPEC acc )
+check_access(IDENTIFIER id, DECL_SPEC acc)
 {
-    if ( acc == dspec_public ) return ;
+	if (acc == dspec_public) {
+		return;
+	}
-    if ( do_access_checks ) {
+	if (do_access_checks) {
-	NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
+		NAMESPACE ns = DEREF_nspace(id_parent(id));
-	if ( IS_nspace_ctype ( ns ) ) {
+		if (IS_nspace_ctype(ns)) {
-	    ACCESS_LIST *crt = &crt_access_list ;
+			ACCESS_LIST *crt = &crt_access_list;
-	    if ( in_function_defn && !in_declaration ) {
+			if (in_function_defn && !in_declaration) {
-		/* Calculate access immediately */
+				/* Calculate access immediately */
-		IGNORE do_member_access ( crt_func_id, id, crt->inherit ) ;
+				IGNORE do_member_access(crt_func_id, id,
+							crt->inherit);
-	    } else {
+			} else {
-		/* Add to pending list */
+				/* Add to pending list */
-		CONS_id ( id, crt->ids, crt->ids ) ;
+				CONS_id(id, crt->ids, crt->ids);
-		CONS_int ( crt->inherit, crt->info, crt->info ) ;
+				CONS_int(crt->inherit, crt->info, crt->info);
-		crt->pending = 1 ;
+				crt->pending = 1;
-	    }
+			}
-	} else {
+		} else {
-	    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
+			DECL_SPEC ds = DEREF_dspec(id_storage(id));
-	    if ( ds & dspec_auto ) {
+			if (ds & dspec_auto) {
-		/* Used to mark for-init variables */
+				/* Used to mark for-init variables */
-		report ( crt_loc, ERR_stmt_for_init ( id ) ) ;
+				report(crt_loc, ERR_stmt_for_init(id));
-		ds &= ~dspec_access ;
+				ds &= ~dspec_access;
-		COPY_dspec ( id_storage ( id ), ds ) ;
+				COPY_dspec(id_storage(id), ds);
-	    }
+			}
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     CHECK THE ACCESS TO A BASE CLASS
     This routine adds the base class graph gr to the list of pending
     base access checks.
 */
-void check_base_access
+void
-    PROTO_N ( ( gr ) )
-    PROTO_T ( GRAPH gr )
+check_base_access(GRAPH gr)
 {
-    DECL_SPEC ds = DEREF_dspec ( graph_access ( gr ) ) ;
+	DECL_SPEC ds = DEREF_dspec(graph_access(gr));
-    DECL_SPEC acc = ( ds & dspec_access ) ;
+	DECL_SPEC acc = (ds & dspec_access);
-    DECL_SPEC acc2 = ( ds & dspec_access2 ) ;
+	DECL_SPEC acc2 = (ds & dspec_access2);
-    if ( acc == dspec_public ) return ;
+	if (acc == dspec_public) {
+		return;
+	}
-    if ( do_access_checks ) {
+	if (do_access_checks) {
-	/* Find best access to a virtual base */
+		/* Find best access to a virtual base */
-	GRAPH gs = DEREF_graph ( graph_equal ( gr ) ) ;
+		GRAPH gs = DEREF_graph(graph_equal(gr));
-	while ( !IS_NULL_graph ( gs ) ) {
+		while (!IS_NULL_graph(gs)) {
-	    DECL_SPEC pds = DEREF_dspec ( graph_access ( gs ) ) ;
+			DECL_SPEC pds = DEREF_dspec(graph_access(gs));
-	    DECL_SPEC pacc = ( pds & dspec_access ) ;
+			DECL_SPEC pacc = (pds & dspec_access);
-	    DECL_SPEC pacc2 = ( pds & dspec_access2 ) ;
+			DECL_SPEC pacc2 = (pds & dspec_access2);
-	    if ( pacc == dspec_public ) return ;
+			if (pacc == dspec_public) {
+				return;
+			}
-	    if ( pacc < acc || ( pacc == acc && pacc2 < acc2 ) ) {
+			if (pacc < acc || (pacc == acc && pacc2 < acc2)) {
-		acc = pacc ;
+				acc = pacc;
-		acc2 = pacc2 ;
+				acc2 = pacc2;
-		gr = gs ;
+				gr = gs;
-	    }
+			}
-	    gs = DEREF_graph ( graph_equal ( gs ) ) ;
+			gs = DEREF_graph(graph_equal(gs));
-	}
+		}
-	/* Check access control */
+		/* Check access control */
-	if ( in_function_defn && !in_declaration ) {
+		if (in_function_defn && !in_declaration) {
-	    /* Calculate access immediately */
+			/* Calculate access immediately */
-	    IGNORE do_base_access ( crt_func_id, gr ) ;
+			IGNORE do_base_access(crt_func_id, gr);
-	} else {
+		} else {
-	    /* Add to pending list */
+			/* Add to pending list */
-	    ACCESS_LIST *crt = &crt_access_list ;
+			ACCESS_LIST *crt = &crt_access_list;
-	    CONS_graph ( gr, crt->bases, crt->bases ) ;
+			CONS_graph(gr, crt->bases, crt->bases);
-	    crt->pending = 1 ;
+			crt->pending = 1;
-	}
+		}
-    }
+	}
-    return ;
+	return;
+}
 /*
     IMMEDIATELY CHECK THE ACCESS TO AN IDENTIFIER
     This routine applies an immediate access check to the identifier id
     by cid.
 */
-void immediate_access
+void
-    PROTO_N ( ( cid, id ) )
-    PROTO_T ( IDENTIFIER cid X IDENTIFIER id )
+immediate_access(IDENTIFIER cid, IDENTIFIER id)
+{
-    DECL_SPEC acc = DEREF_dspec ( id_storage ( id ) ) ;
+	DECL_SPEC acc = DEREF_dspec(id_storage(id));
-    acc &= dspec_access ;
+	acc &= dspec_access;
-    if ( acc == dspec_none || acc == dspec_public ) return ;
+	if (acc == dspec_none || acc == dspec_public) {
-    if ( do_access_checks ) {
-	NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
-	if ( IS_nspace_ctype ( ns ) ) {
+		return;
-	    int mem = crt_access_list.inherit ;
-	    IGNORE do_member_access ( cid, id, mem ) ;
+	}
+	if (do_access_checks) {
+		NAMESPACE ns = DEREF_nspace(id_parent(id));
+		if (IS_nspace_ctype(ns)) {
+			int mem = crt_access_list.inherit;
+			IGNORE do_member_access(cid, id, mem);
-    }
+		}
+	}
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

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