Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of The TenDRA Project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific, prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS

 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $Id$

 */

/*

    		 Crown Copyright (c) 1997, 1998

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

#include "config.h"

#include "c_types.h"

#include "ctype_ops.h"

#include "graph_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "member_ops.h"

#include "nspace_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "access.h"

#include "class.h"

#include "declare.h"

#include "derive.h"

#include "dump.h"

#include "hash.h"

#include "identifier.h"

#include "instance.h"

#include "label.h"

#include "namespace.h"

#include "parse.h"

#include "predict.h"

#include "print.h"

#include "redeclare.h"

#include "syntax.h"

#include "tokdef.h"

#include "ustring.h"

#include "variable.h"

/*

    CURRENT NAMESPACE LISTS

    These variables give the current namespace (the one which is currently

    being defined) and the stack of all enclosing namespaces.  Another stack

    of namespaces, which will be a superset of the first, gives the list

    of locations to be searched during name look-up.

*/

NAMESPACE crt_namespace = NULL_nspace;

NAMESPACE last_namespace = NULL_nspace;

NAMESPACE qual_namespace = NULL_nspace;

STACK(NAMESPACE) namespace_stack = NULL_stack(NAMESPACE);

STACK(NAMESPACE) crt_nspace_stack = NULL_stack(NAMESPACE);

STACK(NAMESPACE) local_nspace_stack = NULL_stack(NAMESPACE);

/*

    STANDARD NAMESPACES

    These variables give the various standard namespaces, including the

    global namespace and the external token namespace.  In addition a

    dynamic record of the smallest named namespace enclosing the current

    namespace and the smallest named or block namespace (or, if the

    proto_scope option is true, function prototype namespace) enclosing

    the current namespace are maintained in nonblock_namespace and

    nonclass_namespace respectively.

*/

NAMESPACE global_namespace = NULL_nspace;

NAMESPACE token_namespace = NULL_nspace;

NAMESPACE c_namespace = NULL_nspace;

NAMESPACE nonblock_namespace = NULL_nspace;

NAMESPACE nonclass_namespace = NULL_nspace;

static NAMESPACE scope_namespace = NULL_nspace;

/*

    STANDARD NAMESPACE IDENTIFIERS

    The identifier local_namespace_id is used as the name for all unnamed

    namespaces defined within the current translation unit.

*/

static IDENTIFIER local_namespace_id = NULL_id;

/*

    NAME LOOK-UP CACHE FLAG

    This flag is set to indicate that name look-up should be cached

    whenever possible.  It is switched off temporarily in field selectors

    as an optimisation.

*/

int cache_lookup = 1;

int old_cache_lookup = 1;

/*

    CREATE A STANDARD NAMESPACE

    This routine creates a global namespace of size sz with a dummy name

    given by s.

*/

NAMESPACE

make_global_nspace(CONST char *s, int sz)

{

	IDENTIFIER id;

	string u = ustrlit(s);

	NAMESPACE ns = NULL_nspace;

	DECL_SPEC ds = (dspec_defn | dspec_extern);

	HASHID nm = lookup_name(u, hash(u), 1, lex_identifier);

	MAKE_id_nspace_name(nm, ds, NULL_nspace, crt_loc, ns, id);

	ns = make_namespace(id, nspace_global_tag, sz);

	COPY_nspace(id_nspace_name_defn(id), ns);

	return (ns);

}

/*

    INITIALISE STANDARD NAMESPACES

    This routine initialises the standard namespaces above.

*/

void

init_namespace(void)

{

	string s = ustrlit("<local>");

	HASHID nm = lookup_name(s, hash(s), 1, lex_identifier);

	local_namespace_id = DEREF_id(hashid_id(nm));

	global_namespace = make_global_nspace("<global>", 50);

#if LANGUAGE_CPP

	c_namespace = make_global_nspace("<c>", 50);

#endif

	token_namespace = make_global_nspace("<token>", 50);

	scope_namespace = make_global_nspace("<scope>", 50);

	last_namespace = global_namespace;

	old_cache_lookup = cache_lookup;

	return;

}

/*

    DOES ONE NAMESPACE CONTAIN ANOTHER?

    This routine checks whether the namespace ns contains the definition

    of the namespace pns.

*/

int

is_subnspace(NAMESPACE ns, NAMESPACE pns)

{

	if (EQ_nspace(ns, pns)) {

		return (1);

	}

	while (!IS_NULL_nspace(pns)) {

		pns = DEREF_nspace(nspace_parent(pns));

		if (EQ_nspace(ns, pns)) {

			return (1);

		}

	}

	return (0);

}

/*

    FIND THE JOIN OF TWO NAMESPACES

    This routine finds the join of the namespaces ns and nt, that is to

    say the smallest namespace which contains both ns and nt.  A using

    directive for nt in ns causes the members of nt to be treated as

    members of the join namespace for the purposes of unqualified name

    look-up.

*/

static NAMESPACE

join_namespace(NAMESPACE ns, NAMESPACE nt)

{

	while (!EQ_nspace(ns, nt)) {

		if (IS_NULL_nspace(ns)) {

			return (NULL_nspace);

		}

		if (IS_NULL_nspace(nt)) {

			return (NULL_nspace);

		}

		if (is_subnspace(ns, nt)) {

			return (ns);

		}

		if (is_subnspace(nt, ns)) {

			return (nt);

		}

		ns = DEREF_nspace(nspace_parent(ns));

		nt = DEREF_nspace(nspace_parent(nt));

	}

	return (ns);

}

/*

    UNCACHE A NAMESPACE

    This routine clears the cached name look-ups for all the names

    accessible from the namespace ns.

*/

void

uncache_namespace(NAMESPACE ns, int add)

{

	if (!IS_NULL_nspace(ns) && cache_lookup) {

		MEMBER mem;

		LIST(NAMESPACE) uns;

		/* Clear cache fields for all members */

		if (IS_nspace_named_etc(ns)) {

			mem = DEREF_member(nspace_named_etc_first(ns));

		} else {

			mem = DEREF_member(nspace_last(ns));

		}

		while (!IS_NULL_member(mem)) {

			IDENTIFIER id = DEREF_id(member_id(mem));

			if (!IS_NULL_id(id)) {

				HASHID nm = DEREF_hashid(id_name(id));

				if (!add) {

					id = NULL_id;

				}

				COPY_id(hashid_cache(nm), id);

			}

			mem = DEREF_member(member_next(mem));

		}

		/* Recursively clear all used namespaces */

		uns = DEREF_list(nspace_use(ns));

		if (!IS_NULL_list(uns)) {

			LIST(NAMESPACE) lns = uns;

			COPY_list(nspace_use(ns), NULL_list(NAMESPACE));

			while (!IS_NULL_list(lns)) {

				NAMESPACE pns = DEREF_nspace(HEAD_list(lns));

				uncache_namespace(pns, 0);

				lns = TAIL_list(lns);

			}

			COPY_list(nspace_use(ns), uns);

		}

	}

	return;

}

/*

    ADD A NAMESPACE TO THE LOOK-UP LIST

    This routine adds the namespace ns to the look-up namespace list.  Note

    that this is automatically called by push_namespace.

*/

void

add_namespace(NAMESPACE ns)

{

	PUSH_nspace(ns, namespace_stack);

	uncache_namespace(ns, 1);

	return;

}

/*

    REMOVE A NAMESPACE FROM THE LOOK-UP LIST

    This routine removes the top namespace from the look-up namespace list.

    Note that this is automatically called by pop_namespace.

*/

void

remove_namespace(void)

{

	NAMESPACE ns;

	POP_nspace(ns, namespace_stack);

	uncache_namespace(ns, 0);

	return;

}

/*

    PUSH A NAMESPACE

    This routine pushes the namespace ns onto the namespace stack.

*/

void

store_namespace(NAMESPACE ns)

{

	NAMESPACE cns = crt_namespace;

	switch (TAG_nspace(ns)) {

	case nspace_named_tag:

	case nspace_unnamed_tag:

	case nspace_global_tag:

		/* Record named namespaces */

		nonblock_namespace = ns;

		nonclass_namespace = ns;

		break;

	case nspace_param_tag:

		/* Deal with function prototype scopes */

		if (option(OPT_proto_scope)) {

			nonclass_namespace = ns;

		}

		break;

	case nspace_block_tag:

		/* A block is a non-class namespace */

		nonclass_namespace = ns;

		break;

	}

	COPY_nspace(nspace_parent(ns), cns);

	PUSH_nspace(cns, crt_nspace_stack);

	crt_namespace = ns;

	return;

}

/*

    POP A NAMESPACE

    This routine removes a namespace from the namespace stack.

*/

NAMESPACE

restore_namespace(void)

{

	NAMESPACE ns = crt_namespace;

	int fb = EQ_nspace(ns, nonblock_namespace);

	int fc = EQ_nspace(ns, nonclass_namespace);

	int fa = (fb || fc);

	if (fa) {

		/* Check for enclosing namespaces */

		LIST(NAMESPACE) lns = LIST_stack(crt_nspace_stack);

		while (fa && !IS_NULL_list(lns)) {

			NAMESPACE pns = DEREF_nspace(HEAD_list(lns));

			switch (TAG_nspace(pns)) {

			case nspace_named_tag:

			case nspace_unnamed_tag:

			case nspace_global_tag:

				if (fb) {

					/* Non-block namespace found */

					nonblock_namespace = pns;

					fa = fc;

					fb = 0;

				}

				goto nonclass_namespace_lab;

			case nspace_param_tag:

				/* Deal with function prototype scopes */

				if (!option(OPT_proto_scope)) {

					break;

				}

				goto nonclass_namespace_lab;

			case nspace_block_tag:

nonclass_namespace_lab:

				if (fc) {

					/* Non-class namespace found */

					nonclass_namespace = pns;

					fa = fb;

					fc = 0;

				}

				break;

			}

			lns = TAIL_list(lns);

		}

	}

	POP_nspace(crt_namespace, crt_nspace_stack);

	return (ns);

}

/*

    SET CURRENT NAMESPACE

    This routine makes the namespace ns into the current namespace, pushing

    the previous namespace onto the stack.

*/

void

push_namespace(NAMESPACE ns)

{

	store_namespace(ns);

	add_namespace(ns);

	return;

}

/*

    RESTORE PREVIOUS NAMESPACE

    This routine restores the current namespace to its previous value by

    popping it from the stack.  It returns the removed namespace.

*/

NAMESPACE

pop_namespace(void)

{

	NAMESPACE ns = restore_namespace();

	remove_namespace();

	return (ns);

}

/*

    RECALCULATE NAMESPACES

    This routine forces the recalculation of nonblock_namespace and

    nonclass_namespace by pushing and immediately popping the global

    namespace.

*/

void

update_namespace(void)

{

	NAMESPACE ns = global_namespace;

	if (!IS_NULL_nspace(ns)) {

		store_namespace(ns);

		IGNORE restore_namespace();

	}

	return;

}

/*

    CREATE A NAMESPACE

    This routine creates a namespace named id of type tag.  If tag is

    indicates a small namespace then sz will be zero.  Otherwise sz gives

    the size of hash table to be created.

*/

NAMESPACE

make_namespace(IDENTIFIER id, unsigned tag, int sz)

{

	NAMESPACE ns;

	NAMESPACE pns;

	if (!IS_NULL_id(id)) {

		pns = DEREF_nspace(id_parent(id));

	} else {

		pns = crt_namespace;

	}

	if (sz == 0) {

		/* Small namespace */

		MAKE_nspace_block_etc(tag, id, pns, ns);

	} else {

		/* Large namespace */

		PTR(MEMBER) ptr;

		SIZE(MEMBER) psz;

		unsigned long i, n = (unsigned long)sz;

		/* Allocate namespace hash table */

		psz = SCALE(SIZE_member, n);

		ptr = MAKE_ptr(psz);

		MAKE_nspace_named_etc(tag, id, pns, n, ptr, ns);

		/* Initialise hash table entries */

		for (i = 0; i < n; i++) {

			COPY_member(ptr, NULL_member);

			ptr = STEP_ptr(ptr, SIZE_member);

		}

	}

	return (ns);

}

/*

    USE A NAMESPACE

    This routine creates a using directive for the namespace ns in

    the namespace cns.  nt gives the join of cns and ns.  The routine

    returns zero to indicate that ns has already been used from cns.

*/

int

use_namespace(NAMESPACE ns, NAMESPACE cns, NAMESPACE nt)

{

	if (!EQ_nspace(cns, ns)) {

		LIST(NAMESPACE) p = DEREF_list(nspace_use(cns));

		LIST(NAMESPACE) r = DEREF_list(nspace_join(cns));

		LIST(NAMESPACE) q = p;

		while (!IS_NULL_list(q)) {

			NAMESPACE qns = DEREF_nspace(HEAD_list(q));

			if (EQ_nspace(qns, ns)) {

				return (0);

			}

			q = TAIL_list(q);

		}

		CONS_nspace(nt, r, r);

		COPY_list(nspace_join(cns), r);

		CONS_nspace(ns, p, p);

		COPY_list(nspace_use(cns), p);

		return (1);

	}

	return (0);

}

/*

    LIST OF JOIN NAMESPACES

    During unqualified name look-up any using-directives are treated as

    injecting the names from the used namespace into the join on the

    used and the using namespaces.  This is implemented by injecting a

    dummy using-directive into the join namespace.  This list is used

    to keep track of all the join namespaces which have using-directives

    injected in this way.

*/

static LIST(NAMESPACE) join_nspaces = NULL_list(NAMESPACE);

/*

    CLEAR LIST OF JOIN NAMESPACES

    This routine removes any dummy using-directives from the list of join

    namespaces above.

*/

static void

clear_join_nspaces(void)

{

	LIST(NAMESPACE) lns = join_nspaces;

	while (!IS_NULL_list(lns)) {

		NAMESPACE ns;

		NAMESPACE dns;

		LIST(NAMESPACE) p;

		DESTROY_CONS_nspace(destroy, ns, lns, lns);

		p = DEREF_list(nspace_use(ns));

		if (!IS_NULL_list(p)) {

			DESTROY_CONS_nspace(destroy, dns, p, p);

			UNUSED(dns);

			COPY_list(nspace_use(ns), p);

		}

		p = DEREF_list(nspace_join(ns));

		if (!IS_NULL_list(p)) {

			DESTROY_CONS_nspace(destroy, dns, p, p);

			UNUSED(dns);

			COPY_list(nspace_join(ns), p);

		}

	}

	join_nspaces = NULL_list(NAMESPACE);

	return;

}

/*

    BEGIN A NAMESPACE DEFINITION

    This routine begins the definition of a namespace named id (or an

    anonymous namespace if anon is true).  Note that there may be multiple

    definitions of a namespace, the effect of the later definitions being

    to add elements to the existing namespace.  Only original namespace

    names, and not namespace aliases, can be used in these namespace

    extensions.

*/

void

begin_namespace(IDENTIFIER id, int anon)

{

	HASHID nm;

	MEMBER mem;

	IDENTIFIER old_id;

	NAMESPACE ns = NULL_nspace;

	NAMESPACE cns = crt_namespace;

	unsigned tag = nspace_named_tag;

	/* Find name for anonymous namespaces */

	if (anon) {

		id = local_namespace_id;

		tag = nspace_unnamed_tag;

	}

	nm = DEREF_hashid(id_name(id));

	/* Can only occur in namespace scope */

	if (in_function_defn || in_class_defn) {

		report(crt_loc, ERR_dcl_nspace_scope());

	}

	/* Look up namespace name */

	mem = search_member(cns, nm, 1);

	old_id = DEREF_id(member_id(mem));

	if (!IS_NULL_id(old_id)) {

		/* Check for redeclarations */

		old_id = redecl_inherit(old_id, qual_none, in_class_defn, 2);

		switch (TAG_id(old_id)) {

		case id_nspace_name_tag:

			/* Previously defined namespace */

			ns = DEREF_nspace(id_nspace_name_defn(old_id));

			break;

		case id_nspace_alias_tag: {

			/* Previously defined namespace alias */

			IDENTIFIER ns_id;

			ns = DEREF_nspace(id_nspace_alias_defn(old_id));

			ns_id = DEREF_id(nspace_name(ns));

			if (!IS_id_nspace_name(ns_id)) {

				/* Alias for class namespace */

				ns = NULL_nspace;

				goto default_lab;

			}

			report(crt_loc, ERR_dcl_nspace_def_orig(ns_id, old_id));

			break;

		}

		default:

default_lab: {

		     /* Other previously defined identifier */

		     PTR(LOCATION) loc = id_loc(old_id);

		     report(crt_loc, ERR_basic_odr_decl(old_id, loc));

		     break;

	     }

		}

	}

	/* Construct the namespace if necessary */

	if (IS_NULL_nspace(ns)) {

		DECL_SPEC ds = (dspec_defn | dspec_extern);

		MAKE_id_nspace_name(nm, ds, cns, decl_loc, ns, id);

		ns = make_namespace(id, tag, 50);

		COPY_nspace(id_nspace_name_defn(id), ns);

		set_member(mem, id);

		if (anon) {

			/* Anonymous namespaces are implicitly used */

			IGNORE use_namespace(ns, cns, cns);

			if (do_dump) {

				dump_using(ns, cns, &decl_loc);

			}

		}

	}

	/* Adjust the current namespace */

	if (do_dump) {

		dump_declare(id, &decl_loc, 1);

	}

	push_namespace(ns);

	cns = DEREF_nspace(id_parent(id));

	COPY_nspace(nspace_parent(ns), cns);

	return;

}

/*

    END A NAMESPACE DEFINITION

    This routine ends the definition of the current namespace.

*/

void

end_namespace(int anon)

{

	NAMESPACE ns;

	clear_decl_blocks();

	ns = pop_namespace();

	if (do_dump) {

		IDENTIFIER id = DEREF_id(nspace_name(ns));

		dump_undefine(id, &crt_loc, 0);

	}

	UNUSED(anon);

	return;

}

/*

    PROCESS A TARGET DEPENDENT DECLARATION SEQUENCE

    This routine is called in the processing of target dependent

    preprocessing directives within declaration sequences.  The directive

    involved is given by dir, while c gives the associated condition for

    '#if' and '#elif'.

*/

void

target_decl(int dir, EXP c)

{

	if (!IS_NULL_exp(c)) {

		report(crt_loc, ERR_cpp_cond_if_ti_decl(dir));

	}

	return;

}

/*

    BEGIN A DECLARATION BLOCK

    A declaration block is a technique for partitioning the external

    declarations into subsets.  These subsets have no significance within

    the language, but are useful for indicating, for example, those

    identifiers which form part of a certain API.  This routine starts

    a declaration block named id.

*/

void

begin_decl_block(IDENTIFIER id)

{

	NAMESPACE cns = nonblock_namespace;

	NAMESPACE sns = scope_namespace;

	HASHID nm = DEREF_hashid(id_name(id));

	MEMBER mem = search_member(sns, nm, 1);

	id = DEREF_id(member_id(mem));

	if (IS_NULL_id(id)) {

		/* Create dummy namespace identifier */

		NAMESPACE bns = NULL_nspace;

		DECL_SPEC ds = (dspec_defn | dspec_extern);

		MAKE_id_nspace_name(nm, ds, cns, crt_loc, bns, id);

		bns = make_namespace(id, nspace_block_tag, 0);

		COPY_nspace(id_nspace_name_defn(id), bns);

		COPY_id(member_id(mem), id);

	}

	if (do_dump) {

		/* Output scope to dump file */

		NAMESPACE bns = DEREF_nspace(id_nspace_name_defn(id));

		dump_begin_scope(id, bns, cns, &crt_loc);

	}

	if (!IS_NULL_nspace(cns)) {

		/* Add to current namespace */

		STACK(IDENTIFIER)pids = DEREF_stack(nspace_set(cns));

		PUSH_id(id, pids);

		COPY_stack(nspace_set(cns), pids);

	}

	return;

}

/*

    END A DECLARATION BLOCK

    This routine ends a declaration block named id or the current

    declaration block if id is the null identifier.  If there is no

    current declaration block and force is true then an error is

    raised.  The routine returns true if a declaration block is ended.

*/

int

end_decl_block(IDENTIFIER id, int force)

{

	int res = 0;

	NAMESPACE cns = nonblock_namespace;

	if (!IS_NULL_nspace(cns)) {

		/* Add to current namespace */

		STACK(IDENTIFIER) pids = DEREF_stack(nspace_set(cns));

		if (IS_NULL_stack(pids)) {

			if (force) {

				/* Stack shouldn't be empty */

				report(crt_loc, ERR_pragma_dblock_end());

			}

		} else {

			IDENTIFIER pid;

			POP_id(pid, pids);

			COPY_stack(nspace_set(cns), pids);

			if (!IS_NULL_id(id)) {

				/* Check block name if given */

				HASHID nm = DEREF_hashid(id_name(id));

				HASHID pnm = DEREF_hashid(id_name(pid));

				if (!EQ_hashid(nm, pnm)) {

					report(crt_loc,

					       ERR_pragma_dblock_name(pnm));

				}

			}

			if (do_dump) {

				/* Output scope to dump file */

				NAMESPACE bns =

				    DEREF_nspace(id_nspace_name_defn(pid));

				dump_end_scope(pid, bns, &crt_loc);

			}

			res = 1;

		}

	}

	return (res);

}

/*

    END ALL DECLARATION BLOCKS

    This routine ends all the declaration blocks associated with the

    current namespace.  This is called at the end of a namespace definition

    and at the end of the input file.

*/

void

clear_decl_blocks(void)

{

	while (end_decl_block(NULL_id, 0));

	return;

}

/*

    FIND A NAMESPACE

    This routine finds the namespace corresponding to the identifier id,

    returning the null namespace if id does not represent a class or a

    namespace.

*/

NAMESPACE

find_namespace(IDENTIFIER id)

{

	NAMESPACE ns = NULL_nspace;

	if (!IS_NULL_id(id)) {

		switch (TAG_id(id)) {

		case id_nspace_name_tag:

		case id_nspace_alias_tag: