WebSVN – tendra.SVN – Blame – /branches/algol60/src/producers/common/construct/redeclare.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
7	7u83	2	`* Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.`
		3	`* All rights reserved.`
		4	`*`
		5	`* Redistribution and use in source and binary forms, with or without`
		6	`* modification, are permitted provided that the following conditions are met:`
		7	`*`
		8	`* 1. Redistributions of source code must retain the above copyright notice,`
		9	`* this list of conditions and the following disclaimer.`
		10	`* 2. Redistributions in binary form must reproduce the above copyright notice,`
		11	`* this list of conditions and the following disclaimer in the documentation`
		12	`* and/or other materials provided with the distribution.`
		13	`* 3. Neither the name of The TenDRA Project nor the names of its contributors`
		14	`* may be used to endorse or promote products derived from this software`
		15	`* without specific, prior written permission.`
		16	`*`
		17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
		18	`* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,`
		19	`* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR`
		20	`* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR`
		21	`* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,`
		22	`* EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,`
		23	`* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;`
		24	`* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,`
		25	`* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR`
		26	`* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF`
		27	`* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
		28	`*`
		29	`* $Id$`
		30	`*/`
		31	`/*`
2	7u83	32	`Crown Copyright (c) 1997`
7	7u83	33
2	7u83	34	`This TenDRA(r) Computer Program is subject to Copyright`
		35	`owned by the United Kingdom Secretary of State for Defence`
		36	`acting through the Defence Evaluation and Research Agency`
		37	`(DERA). It is made available to Recipients with a`
		38	`royalty-free licence for its use, reproduction, transfer`
		39	`to other parties and amendment for any purpose not excluding`
		40	`product development provided that any such use et cetera`
		41	`shall be deemed to be acceptance of the following conditions:-`
7	7u83	42
2	7u83	43	`(1) Its Recipients shall ensure that this Notice is`
		44	`reproduced upon any copies or amended versions of it;`
7	7u83	45
2	7u83	46	`(2) Any amended version of it shall be clearly marked to`
		47	`show both the nature of and the organisation responsible`
		48	`for the relevant amendment or amendments;`
7	7u83	49
2	7u83	50	`(3) Its onward transfer from a recipient to another`
		51	`party shall be deemed to be that party's acceptance of`
		52	`these conditions;`
7	7u83	53
2	7u83	54	`(4) DERA gives no warranty or assurance as to its`
		55	`quality or suitability for any purpose and DERA accepts`
		56	`no liability whatsoever in relation to any use to which`
		57	`it may be put.`
		58	`*/`
		59
		60
		61	`#include "config.h"`
		62	`#include "c_types.h"`
		63	`#include "ctype_ops.h"`
		64	`#include "err_ops.h"`
		65	`#include "exp_ops.h"`
		66	`#include "graph_ops.h"`
		67	`#include "hashid_ops.h"`
		68	`#include "id_ops.h"`
		69	`#include "member_ops.h"`
		70	`#include "off_ops.h"`
		71	`#include "nspace_ops.h"`
		72	`#include "str_ops.h"`
		73	`#include "tok_ops.h"`
		74	`#include "type_ops.h"`
		75	`#include "error.h"`
		76	`#include "catalog.h"`
		77	`#include "access.h"`
		78	`#include "basetype.h"`
		79	`#include "char.h"`
		80	`#include "check.h"`
		81	`#include "chktype.h"`
		82	`#include "class.h"`
		83	`#include "compile.h"`
		84	`#include "constant.h"`
		85	`#include "copy.h"`
		86	`#include "declare.h"`
		87	`#include "derive.h"`
		88	`#include "dump.h"`
		89	`#include "file.h"`
		90	`#include "function.h"`
		91	`#include "identifier.h"`
		92	`#include "instance.h"`
		93	`#include "literal.h"`
		94	`#include "namespace.h"`
		95	`#include "option.h"`
		96	`#include "overload.h"`
		97	`#include "predict.h"`
		98	`#include "redeclare.h"`
		99	`#include "syntax.h"`
		100	`#include "template.h"`
		101	`#include "tokdef.h"`
		102	`#include "token.h"`
		103	`#include "ustring.h"`
		104
		105
		106	`/*`
		107	`CURRENT LINKAGE SPECIFIER`
		108
		109	`The current linkage specifier is handled by means of this global`
		110	`variable. The default, of no linkage being given, is interpreted`
		111	`according to the source language.`
		112	`*/`
		113
7	7u83	114	`DECL_SPEC crt_linkage = dspec_none;`
		115	`DECL_SPEC new_linkage = dspec_none;`
2	7u83	116
		117
		118	`/*`
		119	`FIND A LINKAGE SPECIFIER`
		120
		121	`This routine translates the string literal expression e into a linkage`
		122	`specifier. The only recognised strings are "C" and "C++".`
		123	`*/`
		124
7	7u83	125	`DECL_SPEC`
		126	`find_linkage(EXP e)`
2	7u83	127	`{`
7	7u83	128	`STRING s = DEREF_str(exp_string_lit_str(e));`
		129	`unsigned kind = DEREF_unsigned(str_simple_kind(s));`
2	7u83	130
7	7u83	131	`/* Can only occur in namespace scope */`
		132	`if (in_function_defn \|\| in_class_defn) {`
		133	`report(crt_loc, ERR_dcl_link_scope());`
		134	`}`
2	7u83	135
7	7u83	136	`/* Check the linkage string */`
		137	`if (kind == STRING_NONE) {`
		138	`char *t = strlit(DEREF_string(str_simple_text(s)));`
		139	`unsigned long len = DEREF_ulong(str_simple_len(s));`
		140	`if (len == 1 && streq(t, "C")) {`
		141	`return (dspec_c);`
		142	`}`
		143	`if (len == 3 && streq(t, "C++")) {`
		144	`return (dspec_cpp);`
		145	`}`
2	7u83	146	`}`
		147
7	7u83	148	`/* Report unknown strings */`
		149	`report(crt_loc, ERR_dcl_link_unknown(s));`
		150	`return (crt_linkage);`
2	7u83	151	`}`
		152
		153
		154	`/*`
		155	`FIND A LINKAGE STRING`
		156
		157	`This routine returns the string corresponding to the linkage specifiers`
		158	`given by ds and cv.`
		159	`*/`
		160
7	7u83	161	`string`
		162	`linkage_string(DECL_SPEC ds, CV_SPEC cv)`
2	7u83	163	`{`
7	7u83	164	`CONST char *str;`
		165	`if ((ds & dspec_c) \|\| (cv & cv_c)) {`
		166	`str = "C";`
		167	`} else {`
		168	`str = "C++";`
		169	`}`
		170	`return (ustrlit(str));`
2	7u83	171	`}`
		172
		173
		174	`/*`
		175	`ADJUST DECLARATION SPECIFIER FOR LANGUAGE`
		176
		177	`This routine adds the current language specifier to the declaration`
		178	`specifier ds. mem is true for a member declaration (which always`
		179	`has C++ linkage). ds may contain a language specifier from a`
		180	`previous declaration, otherwise it is deduced from crt_linkage.`
		181	`*/`
		182
7	7u83	183	`DECL_SPEC`
		184	`adjust_linkage(DECL_SPEC ds, int mem)`
2	7u83	185	`{`
7	7u83	186	`DECL_SPEC rs = (ds & ~dspec_language);`
		187	`if (mem) {`
		188	`/* Members have C++ linkage */`
		189	`rs \|= dspec_cpp;`
		190	`} else if (rs & dspec_linkage) {`
		191	`/* Only applies to objects with linkage */`
		192	`DECL_SPEC ln = (ds \| crt_linkage);`
		193	`if (ln & dspec_c) {`
		194	`rs \|= dspec_c;`
		195	`} else {`
		196	`rs \|= dspec_cpp;`
		197	`}`
2	7u83	198	`}`
7	7u83	199	`return (rs);`
2	7u83	200	`}`
		201
		202
		203	`/*`
		204	`CHECK C LINKAGE DECLARATIONS`
		205
		206	`This routine checks the identifier id declared with C linkage. Objects`
		207	`with C linkage in different namespaces are actually the same.`
		208	`*/`
		209
7	7u83	210	`void`
		211	`c_linkage(IDENTIFIER id, int def)`
2	7u83	212	`{`
7	7u83	213	`TYPE t = NULL_type;`
		214	`unsigned tag = TAG_id(id);`
		215	`if (tag == id_function_tag) {`
2	7u83	216	`/* Template functions can't have C linkage */`
7	7u83	217	`t = DEREF_type(id_function_type(id));`
		218	`if (IS_type_templ(t)) {`
		219	`report(decl_loc, ERR_temp_decl_linkage());`
2	7u83	220	`}`
7	7u83	221	`} else if (tag == id_variable_tag) {`
		222	`t = DEREF_type(id_variable_type(id));`
2	7u83	223	`}`
7	7u83	224	`if (!IS_NULL_type(t)) {`
		225	`NAMESPACE ns = c_namespace;`
		226	`if (!IS_NULL_nspace(ns)) {`
		227	`HASHID nm = DEREF_hashid(id_name(id));`
		228	`MEMBER mem = search_member(ns, nm, 1);`
		229	`IDENTIFIER pid = DEREF_id(member_id(mem));`
		230	`if (!IS_NULL_id(pid) && !EQ_id(id, pid)) {`
		231	`NAMESPACE cns = DEREF_nspace(id_parent(id));`
		232	`NAMESPACE pns = DEREF_nspace(id_parent(pid));`
		233	`if (!EQ_nspace(cns, pns)) {`
		234	`DECL_SPEC cl = crt_linkage;`
		235	`QUALIFIER cq = crt_id_qualifier;`
		236	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		237	`crt_linkage = (ds & dspec_language);`
		238	`crt_id_qualifier = qual_none;`
		239	`pid = redecl_id(ds, t, pid, 3, -1);`
		240	`if (!IS_NULL_id(pid)) {`
2	7u83	241	`/* Set up alias */`
7	7u83	242	`if (IS_id_function(pid)) {`
		243	`TYPE s = DEREF_type(id_function_type(pid));`
		244	`s = redecl_func_type(pid, s, t, def, 0);`
		245	`COPY_type(id_function_type(pid), s);`
2	7u83	246	`}`
7	7u83	247	`ds \|= dspec_alias;`
		248	`COPY_dspec(id_storage(id), ds);`
		249	`pid = DEREF_id(id_alias(pid));`
		250	`COPY_id(id_alias(id), pid);`
		251	`if (do_dump) {`
		252	`dump_alias(id, pid, &decl_loc);`
		253	`}`
		254	`id = pid;`
2	7u83	255	`}`
7	7u83	256	`crt_id_qualifier = cq;`
		257	`crt_linkage = cl;`
2	7u83	258	`}`
		259	`}`
7	7u83	260	`COPY_id(member_id(mem), id);`
2	7u83	261	`}`
		262	`}`
7	7u83	263	`return;`
2	7u83	264	`}`
		265
		266
		267	`/*`
		268	`FIND A PREVIOUS DECLARATION`
		269
		270	`If a declaration in block scope is declared extern then it has external`
		271	`linkage unless the declaration matches a visible declaration of namespace`
		272	`scope. This routine finds such a declaration for the identifier id`
		273	`of type t.`
		274	`*/`
		275
7	7u83	276	`IDENTIFIER`
		277	`find_previous(TYPE t, IDENTIFIER id)`
2	7u83	278	`{`
7	7u83	279	`if (crt_id_qualifier == qual_none) {`
		280	`NAMESPACE ns = nonblock_namespace;`
		281	`HASHID nm = DEREF_hashid(id_name(id));`
		282	`IDENTIFIER pid = find_extern_id(nm, ns, 0);`
		283	`if (!IS_NULL_id(pid)) {`
		284	`TYPE s;`
		285	`DECL_SPEC st;`
		286	`switch (TAG_id(pid)) {`
		287	`case id_variable_tag:`
		288	`/* Variables may be redeclared */`
		289	`s = DEREF_type(id_variable_type(pid));`
		290	`break;`
		291	`case id_function_tag: {`
		292	`/* Functions may be redeclared */`
2	7u83	293	`#if LANGUAGE_CPP`
7	7u83	294	`int eq = 0;`
		295	`LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);`
		296	`pid = resolve_func(pid, t, 0, 0, pids, &eq);`
		297	`if (IS_NULL_id(pid)) {`
		298	`return (NULL_id);`
		299	`}`
		300	`if (!IS_id_function(pid)) {`
		301	`return (NULL_id);`
		302	`}`
2	7u83	303	`#endif`
7	7u83	304	`s = DEREF_type(id_function_type(pid));`
		305	`break;`
		306	`}`
		307	`default:`
		308	`/* Nothing else can be redeclared */`
		309	`return (NULL_id);`
		310	`}`
		311	`st = DEREF_dspec(id_storage(pid));`
		312	`if (st & dspec_linkage) {`
		313	`/* Previous declaration must have linkage */`
		314	`s = type_composite(s, t, 0, 0, KILL_err, 0);`
		315	`if (!IS_NULL_type(s)) {`
		316	`return (pid);`
		317	`}`
		318	`}`
2	7u83	319	`}`
		320	`}`
7	7u83	321	`return (NULL_id);`
2	7u83	322	`}`
		323
		324
		325	`/*`
		326	`UNIFY AN EXTERNAL IDENTIFIER`
		327
		328	`This routine checks the identifier id, which is a variable declared`
		329	`extern in a block, against conflicts with the namespace ns into`
		330	`which it is injected. p gives all the other extern block identifiers`
		331	`declared before id. The routine returns any previous identifier.`
		332	`*/`
		333
7	7u83	334	`IDENTIFIER`
		335	`unify_extern(IDENTIFIER id, TYPE t, NAMESPACE ns, LIST(IDENTIFIER) p)`
2	7u83	336	`{`
7	7u83	337	`IDENTIFIER pid = NULL_id;`
		338	`HASHID nm = DEREF_hashid(id_name(id));`
		339	`LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);`
		340	`while (!IS_NULL_list(p)) {`
		341	`/* Check other block externs */`
		342	`IDENTIFIER bid = DEREF_id(HEAD_list(p));`
		343	`HASHID bnm = DEREF_hashid(id_name(bid));`
		344	`if (EQ_hashid(bnm, nm)) {`
		345	`bid = DEREF_id(id_alias(bid));`
		346	`CONS_id(bid, pids, pids);`
		347	`}`
		348	`p = TAIL_list(p);`
2	7u83	349	`}`
7	7u83	350	`if (!IS_NULL_nspace(ns)) {`
		351	`/* Check actual namespace */`
		352	`MEMBER mem = search_member(ns, nm, 0);`
		353	`if (!IS_NULL_member(mem)) {`
		354	`IDENTIFIER bid = DEREF_id(member_id(mem));`
		355	`if (!IS_NULL_id(bid)) {`
		356	`bid = DEREF_id(id_alias(bid));`
		357	`CONS_id(bid, pids, pids);`
		358	`}`
		359	`}`
2	7u83	360	`}`
7	7u83	361	`if (!IS_NULL_list(pids)) {`
		362	`/* Match found */`
		363	`if (IS_NULL_type(t)) {`
		364	`if (IS_NULL_list(TAIL_list(pids))) {`
		365	`pid = DEREF_id(HEAD_list(pids));`
		366	`DESTROY_list(pids, SIZE_id);`
		367	`} else {`
		368	`DECL_SPEC ds;`
		369	`pids = REVERSE_list(pids);`
		370	`ds = find_ambig_dspec(pids);`
		371	`MAKE_id_ambig(nm, ds, ns, crt_loc, pids, 1,`
		372	`pid);`
		373	`}`
2	7u83	374	`} else {`
7	7u83	375	`LIST(IDENTIFIER) qids;`
		376	`DECL_SPEC cl = crt_linkage;`
		377	`QUALIFIER cq = crt_id_qualifier;`
		378	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		379	`crt_linkage = (ds & dspec_language);`
		380	`crt_id_qualifier = qual_none;`
		381	`DEREF_loc(id_loc(id), decl_loc);`
		382	`pids = REVERSE_list(pids);`
		383	`qids = pids;`
		384	`while (!IS_NULL_list(qids)) {`
		385	`IDENTIFIER qid = DEREF_id(HEAD_list(qids));`
		386	`qid = DEREF_id(id_alias(qid));`
		387	`if (IS_type_func(t)) {`
		388	`/* Check function redeclaration */`
		389	`IDENTIFIER over = NULL_id;`
		390	`unsigned tag = TAG_id(id);`
		391	`qid = redecl_func(ds, t, qid, tag,`
		392	`&over, -1);`
		393	`} else {`
		394	`/* Check variable redeclaration */`
		395	`qid = redecl_id(ds, t, qid, 0, -1);`
		396	`}`
		397	`if (!IS_NULL_id(qid)) {`
		398	`pid = qid;`
		399	`}`
		400	`qids = TAIL_list(qids);`
		401	`}`
		402	`DESTROY_list(pids, SIZE_id);`
		403	`crt_id_qualifier = cq;`
		404	`crt_linkage = cl;`
2	7u83	405	`}`
		406	`}`
7	7u83	407	`return (pid);`
2	7u83	408	`}`
		409
		410
		411	`/*`
		412	`UNIFY A BLOCK DECLARATION WITH A PREVIOUS DECLARATION`
		413
		414	`This routine is used to unify the external block declaration id of`
		415	`type t with its previous declaration pid (as returned by find_previous).`
		416	`def is true is id is a function definition. The routine returns id.`
		417	`If there is no previous declaration then one is created and added to`
		418	`the extra identifier list of the enclosing non-block namespace.`
		419	`*/`
		420
7	7u83	421	`IDENTIFIER`
		422	`unify_previous(IDENTIFIER id, TYPE t, IDENTIFIER pid, int def)`
2	7u83	423	`{`
7	7u83	424	`/* Unify external linkage */`
		425	`if (IS_NULL_id(pid)) {`
		426	`LIST(IDENTIFIER) p;`
		427	`NAMESPACE ns = nonblock_namespace;`
		428	`p = DEREF_list(nspace_named_etc_extra(ns));`
		429	`pid = unify_extern(id, t, ns, p);`
		430	`if (IS_NULL_id(pid)) {`
		431	`if (!is_templ_depend(t)) {`
		432	`/* Declare new external object */`
		433	`DECL_SPEC ds;`
		434	`pid = copy_id(id, 0);`
		435	`ds = DEREF_dspec(id_storage(pid));`
		436	`if (!(ds & dspec_linkage)) {`
		437	`ds \|= dspec_extern;`
		438	`}`
		439	`ds &= ~dspec_alias;`
		440	`COPY_dspec(id_storage(pid), ds);`
		441	`COPY_nspace(id_parent(pid), ns);`
		442	`COPY_id(id_alias(pid), pid);`
		443	`CONS_id(pid, p, p);`
		444	`COPY_list(nspace_named_etc_extra(ns), p);`
		445	`}`
2	7u83	446
7	7u83	447	`/* Check object type */`
		448	`if (!is_global_type(t)) {`
		449	`report(crt_loc, ERR_basic_link_none(t, id));`
		450	`}`
		451	`}`
2	7u83	452	`}`
		453
7	7u83	454	`/* Alias id to be pid */`
		455	`if (!IS_NULL_id(pid)) {`
		456	`if (IS_id_function_etc(pid)) {`
		457	`TYPE s = DEREF_type(id_function_etc_type(pid));`
		458	`s = redecl_func_type(pid, s, t, def, 0);`
		459	`COPY_type(id_function_etc_type(pid), s);`
		460	`}`
		461	`pid = DEREF_id(id_alias(pid));`
		462	`COPY_id(id_alias(id), pid);`
2	7u83	463	`}`
7	7u83	464	`return (id);`
2	7u83	465	`}`
		466
		467
		468	`/*`
		469	`UNIFY A DECLARATION WITH A PREVIOUS BLOCK DECLARATION`
		470
		471	`This routine is used to unify the external declaration id of type`
		472	`t with any previous external block declaration of the same object.`
		473	`def is true if id is a function definition. The routine returns id.`
		474	`*/`
		475
7	7u83	476	`IDENTIFIER`
		477	`unify_subsequent(IDENTIFIER id, TYPE t, int def)`
2	7u83	478	`{`
7	7u83	479	`NAMESPACE ns = DEREF_nspace(id_parent(id));`
		480	`if (IS_nspace_named_etc(ns)) {`
		481	`LIST(IDENTIFIER) p;`
		482	`p = DEREF_list(nspace_named_etc_extra(ns));`
		483	`if (!IS_NULL_list(p)) {`
		484	`IDENTIFIER pid = unify_extern(id, t, NULL_nspace, p);`
		485	`if (!IS_NULL_id(pid)) {`
		486	`/* Alias id to be pid */`
		487	`if (IS_id_function_etc(pid)) {`
		488	`TYPE s = DEREF_type(id_function_etc_type(pid));`
		489	`s = redecl_func_type(pid, s, t, def, 0);`
		490	`COPY_type(id_function_etc_type(pid), s);`
		491	`}`
		492	`pid = DEREF_id(id_alias(pid));`
		493	`COPY_id(id_alias(id), pid);`
		494	`}`
2	7u83	495	`}`
		496	`}`
7	7u83	497	`return (id);`
2	7u83	498	`}`
		499
		500
		501	`/*`
		502	`CHECK FOR CLASS-LIKE TYPEDEF NAMES`
		503
		504	`This routine checks whether the typedef name id behaves like a class`
		505	`or an object with respect to name hiding. It is not entirely clear`
		506	`whether it is just original class and enumeration names or all class`
		507	`and enumeration names (including those introduced using typedef)`
		508	`which behave in this way.`
		509	`*/`
		510
7	7u83	511	`int`
		512	`is_tagged_type(IDENTIFIER id)`
2	7u83	513	`{`
7	7u83	514	`switch (TAG_id(id)) {`
		515	`case id_class_name_tag:`
		516	`case id_enum_name_tag:`
		517	`/* Original class and enumeration names */`
		518	`return (1);`
		519	`case id_class_alias_tag:`
		520	`case id_enum_alias_tag:`
		521	`case id_type_alias_tag:`
		522	`/* Type aliases */`
		523	`return (0);`
2	7u83	524	`}`
7	7u83	525	`return (0);`
2	7u83	526	`}`
		527
		528
		529	`/*`
		530	`REPORT AN OVERLOADIN ERROR`
		531
		532	`This routine reports the overloading error err for the function id`
		533	`which cannot be overloaded for the reason corresponding to reason.`
		534	`It returns the severity of the error.`
		535	`*/`
		536
7	7u83	537	`static int`
		538	`overload_error(IDENTIFIER id, ERROR err, int reason)`
2	7u83	539	`{`
7	7u83	540	`int sev = ERROR_NONE;`
		541	`switch (reason) {`
		542	`case 1:`
		543	`/* Two functions with C linkage */`
		544	`err = concat_error(err, ERR_dcl_link_over());`
		545	`break;`
		546	`case 2:`
		547	`/* Two functions with indistinguishable parameters */`
		548	`err = concat_error(err, ERR_over_load_pars());`
		549	`break;`
		550	`case 3: {`
		551	`/* Two objects with C linkage */`
		552	`PTR(LOCATION)loc = id_loc(id);`
		553	`HASHID nm = DEREF_hashid(id_name(id));`
		554	`err = concat_error(err, ERR_dcl_link_redecl(nm, loc));`
		555	`break;`
2	7u83	556	`}`
		557	`}`
7	7u83	558
		559	`if (!IS_NULL_err(err)) {`
		560	`sev = DEREF_int(err_severity(err));`
		561	`report(decl_loc, err);`
2	7u83	562	`}`
7	7u83	563	`return (sev);`
2	7u83	564	`}`
		565
		566
		567	`/*`
		568	`REDECLARE AN OBJECT IDENTIFIER`
		569
		570	`This routine checks the redeclaration of the identifier id as an object`
		571	`with declaration specifiers ds and type t. It returns id for a valid`
		572	`redeclaration and the null identifier otherwise, reporting any errors`
		573	`if necessary. Note that it is possible to reserve an identifier using`
		574	`the reserve declaration specifier. At present this is only done for`
		575	`the fields of an anonymous union and enumerators. Also a class or`
		576	`enumeration name can be hidden by an object in the same scope. A`
		577	`redeclared identifier will be marked as defined according to whether`
		578	`the redeclaration is a definition. Whether the initial declaration`
		579	`was a definition may be determined from the initialiser expression.`
		580	`*/`
		581
7	7u83	582	`IDENTIFIER`
		583	`redecl_id(DECL_SPEC ds, TYPE t, IDENTIFIER id, int reason, int def)`
2	7u83	584	`{`
7	7u83	585	`TYPE s;`
		586	`DECL_SPEC ln;`
		587	`PTR(TYPE) pt;`
		588	`int changed = 0;`
		589	`int is_member = 0;`
		590	`int is_function = 0;`
		591	`ERROR err = NULL_err;`
		592	`DECL_SPEC ds_old, ln_old;`
2	7u83	593
7	7u83	594	`/* Check previous definition */`
		595	`switch (TAG_id(id)) {`
		596	`case id_variable_tag:`
		597	`/* Variables may be redeclared */`
		598	`pt = id_variable_type(id);`
		599	`break;`
		600	`case id_function_tag:`
		601	`/* Functions may be redeclared */`
		602	`is_function = 1;`
		603	`pt = id_function_type(id);`
		604	`break;`
		605	`case id_class_name_tag:`
		606	`case id_enum_name_tag:`
		607	`case id_class_alias_tag:`
		608	`case id_enum_alias_tag:`
		609	`case id_type_alias_tag: {`
		610	`/* Unqualified class and enumeration names can be hidden */`
		611	`PTR(LOCATION)loc;`
		612	`if (!is_tagged_type(id)) {`
		613	`loc = id_loc(id);`
		614	`report(decl_loc, ERR_basic_odr_diff(id, loc));`
		615	`return (NULL_id);`
		616	`}`
		617	`if (crt_id_qualifier == qual_none) {`
		618	`/* Check for templates */`
		619	`ds_old = DEREF_dspec(id_storage(id));`
		620	`if (!(ds_old & dspec_template)) {`
		621	`return (NULL_id);`
		622	`}`
		623	`}`
		624	`loc = id_loc(id);`
		625	`report(decl_loc, ERR_basic_odr_diff(id, loc));`
		626	`return (NULL_id);`
2	7u83	627	`}`
7	7u83	628	`case id_stat_member_tag:`
		629	`/* Members may be defined outside their class */`
		630	`is_member = 1;`
		631	`if (crt_id_qualifier == qual_none) {`
		632	`goto error_lab;`
		633	`}`
		634	`pt = id_stat_member_type(id);`
		635	`break;`
		636	`case id_mem_func_tag:`
		637	`case id_stat_mem_func_tag:`
		638	`/* Members may be defined outside their class */`
		639	`is_member = 1;`
		640	`is_function = 1;`
		641	`if (crt_id_qualifier == qual_none) {`
		642	`goto error_lab;`
		643	`}`
		644	`pt = id_function_etc_type(id);`
		645	`break;`
		646	`case id_member_tag:`
		647	`/* Non-static members cannot be redeclared */`
		648	`is_member = 1;`
		649	`if (crt_id_qualifier == qual_none) {`
		650	`goto error_lab;`
		651	`}`
		652	`report(decl_loc, ERR_class_mem_def(id));`
		653	`return (NULL_id);`
		654	`case id_token_tag:`
		655	`/* Allow for token definitions */`
		656	`return (NULL_id);`
		657	`case id_undef_tag:`
		658	`case id_ambig_tag:`
		659	`/* Allow for error propagation */`
		660	`return (NULL_id);`
		661	`default:`
		662	`error_lab:`
		663	`/* No other identifiers can be redeclared */`
		664	`if (is_member) {`
		665	`/* Member redeclaration */`
		666	`err = ERR_class_mem_redecl(id, id_loc(id));`
		667	`} else {`
		668	`/* Object redeclaration */`
		669	`err = ERR_basic_odr_decl(id, id_loc(id));`
		670	`}`
		671	`IGNORE overload_error(id, err, reason);`
		672	`return (NULL_id);`
2	7u83	673	`}`
7	7u83	674
		675	`/* Check declaration specifiers */`
		676	`ds_old = DEREF_dspec(id_storage(id));`
		677	`if ((ds \| ds_old) & dspec_reserve) {`
		678	`/* Reserved names can't be redeclared */`
		679	`reason = 0;`
		680	`goto error_lab;`
2	7u83	681	`}`
7	7u83	682
		683	`/* Check for objects with no linkage */`
		684	`ln = (ds & dspec_linkage);`
		685	`ln_old = (ds_old & dspec_linkage);`
		686	`if (ln == dspec_none \|\| ln_old == dspec_none) {`
		687	`/* Can't redeclare objects with no linkage */`
		688	`if (!is_function) {`
		689	`reason = 0;`
		690	`goto error_lab;`
		691	`}`
2	7u83	692	`}`
7	7u83	693
		694	`/* Check previous type */`
		695	`s = DEREF_type(pt);`
		696	`s = check_compatible(s, t, 0, &err, 1);`
		697	`if (!IS_NULL_err(err)) {`
		698	`/* Incompatible declaration */`
		699	`PTR(LOCATION) loc = id_loc(id);`
		700	`err = concat_error(err, ERR_basic_link_decl_type(id, loc));`
		701	`if ((ds \| ds_old) & dspec_token) {`
		702	`/* Allow for interface declarations */`
		703	`err = set_severity(err, OPT_interf_incompat, -1);`
		704	`}`
		705	`if (overload_error(id, err, reason) == ERROR_SERIOUS) {`
		706	`return (NULL_id);`
		707	`}`
2	7u83	708	`}`
7	7u83	709	`if (is_function) {`
		710	`/* Sanity check for error types */`
		711	`if (type_tag(s) != type_func_tag) {`
		712	`return (NULL_id);`
		713	`}`
		714	`} else {`
		715	`if (type_tag(s) == type_func_tag) {`
		716	`return (NULL_id);`
		717	`}`
2	7u83	718	`}`
7	7u83	719	`if (def >= 0) {`
		720	`COPY_type(pt, s);`
2	7u83	721	`}`
7	7u83	722
		723	`/* Check for redeclaration of aliases */`
		724	`if ((ds \| ds_old) & dspec_alias) {`
		725	`PTR(LOCATION) loc = id_loc(id);`
		726	`report(decl_loc, ERR_dcl_nspace_udecl_redecl(id, loc));`
2	7u83	727	`}`
		728
7	7u83	729	`/* Check for inconsistent linkage */`
		730	`if (ln != ln_old) {`
		731	`ERROR err1;`
		732	`DECL_SPEC ln_new;`
		733	`PTR(LOCATION) loc = id_loc(id);`
		734	`if (ln_old == dspec_static) {`
		735	`err1 = ERR_dcl_stc_internal(id, loc);`
		736	`} else {`
		737	`err1 = ERR_dcl_stc_external(id, loc);`
		738	`if (is_member) {`
		739	`/* Members have external linkage */`
		740	`ERROR err2 = ERR_basic_link_mem_extern(id);`
		741	`err1 = concat_error(err2, err1);`
		742	`}`
		743	`}`
		744	`if (reason == 3) {`
		745	`/* Identification of objects with C linkage */`
		746	`HASHID nm = DEREF_hashid(id_name(id));`
		747	`ERROR err2 = ERR_dcl_link_redecl(nm, loc);`
		748	`err1 = concat_error(err1, err2);`
		749	`}`
		750	`if (def == -1 && option(OPT_link_internal) == OPTION_OFF) {`
		751	`ln_new = dspec_extern;`
		752	`} else {`
		753	`ln_new = dspec_static;`
		754	`}`
		755	`ds_old = (ln_new \| (ds_old & ~dspec_linkage));`
		756	`report(decl_loc, err1);`
		757	`changed = 1;`
2	7u83	758	`}`
		759
7	7u83	760	`/* Check language specifier */`
		761	`ln = crt_linkage;`
		762	`if (ln != dspec_none) {`
		763	`/* Check against the current language */`
		764	`ln_old = (ds_old & dspec_language);`
		765	`if ((ds_old & dspec_extern) && ln != ln_old) {`
		766	`/* Report inconsistent linkage */`
		767	`if (!is_member) {`
		768	`/* Should this only apply to functions? */`
		769	`PTR(LOCATION) loc = id_loc(id);`
		770	`string lang = linkage_string(ln_old, cv_none);`
		771	`report(decl_loc,`
		772	`ERR_dcl_link_lang(id, lang, loc));`
		773	`ds_old = adjust_linkage(ds_old, is_member);`
		774	`changed = 1;`
		775	`}`
		776	`}`
2	7u83	777	`}`
		778
7	7u83	779	`/* Check for inline specifier */`
		780	`if (ds & dspec_inline) {`
		781	`ds_old \|= dspec_inline;`
		782	`changed = 1;`
2	7u83	783	`}`
		784
7	7u83	785	`/* Mark whether this declaration is a definition */`
		786	`if (def >= 0) {`
		787	`if (ds & dspec_defn) {`
		788	`ds_old \|= dspec_defn;`
		789	`} else {`
		790	`ds_old &= ~dspec_defn;`
		791	`}`
2	7u83	792	`}`
		793
7	7u83	794	`/* Compatible redeclaration */`
		795	`COPY_dspec(id_storage(id), ds_old);`
		796	`if (changed) {`
		797	`update_tag(id, 0);`
2	7u83	798	`}`
7	7u83	799	`return (id);`
2	7u83	800	`}`
		801
		802
		803	`/*`
		804	`REDECLARE A FUNCTION IDENTIFIER`
		805
		806	`This routine is similar to redecl_id except that it allows for function`
		807	`overloading. As before it returns id if this is a redeclaration of an`
		808	`existing function, and the null identifier otherwise. However in the`
		809	`latter case any functions overloaded by the declaration are returned`
		810	`via over.`
		811	`*/`
		812
7	7u83	813	`IDENTIFIER`
		814	`redecl_func(DECL_SPEC ds, TYPE t, IDENTIFIER id, unsigned tag,`
		815	`IDENTIFIER *over, int def)`
2	7u83	816	`{`
7	7u83	817	`int reason = 0;`
		818	`IDENTIFIER fid = id;`
2	7u83	819	`#if LANGUAGE_CPP`
7	7u83	820	`if (IS_id_function_etc(fid)) {`
		821	`DECL_SPEC ds_old;`
		822	`*over = fid;`
2	7u83	823
7	7u83	824	`/* Scan through overloaded functions for a match */`
		825	`while (!IS_NULL_id(fid)) {`
		826	`int m;`
		827	`TYPE s;`
		828	`int mq = 1;`
		829	`if ((ds & dspec_extern) && crt_linkage == dspec_c) {`
		830	`/* Two functions with C linkage are the same */`
		831	`ds_old = DEREF_dspec(id_storage(fid));`
		832	`if ((ds_old & dspec_c) && IS_id_function(fid)) {`
		833	`reason = 1;`
		834	`break;`
		835	`}`
		836	`}`
		837
		838	`/* Two functions with the same parameters are the`
		839	`* same */`
		840	`s = DEREF_type(id_function_etc_type(fid));`
		841	`if (tag == id_stat_mem_func_tag) {`
		842	`mq = 0;`
		843	`}`
		844	`if (IS_id_stat_mem_func(fid)) {`
		845	`mq = 0;`
		846	`}`
		847	`m = eq_func_type(t, s, mq, 0);`
		848	`if (m) {`
		849	`/* Function types basically match */`
		850	`if (m == 1) {`
		851	`/* Return types don't match */`
		852	`reason = 2;`
		853	`}`
		854	`break;`
		855	`}`
		856	`fid = DEREF_id(id_function_etc_over(fid));`
2	7u83	857	`}`
		858
7	7u83	859	`if (IS_NULL_id(fid)) {`
		860	`/* No match found */`
		861	`IDENTIFIER tid = find_template(id, 0);`
		862	`if (!IS_NULL_id(tid)) {`
		863	`/* Must have match with template`
		864	`* specialisation */`
		865	`report(decl_loc, ERR_temp_spec_type(t, id));`
		866	`return (NULL_id);`
		867	`}`
		868	`if (crt_id_qualifier != qual_none) {`
		869	`/* Must have match with qualified identifier */`
		870	`if (def == -2 && tag == id_function_tag) {`
		871	`/* Allow for name injection */`
		872	`/* EMPTY */`
		873	`} else {`
		874	`report(decl_loc,`
		875	`ERR_basic_link_unmatch(t, id));`
		876	`}`
		877	`return (NULL_id);`
		878	`}`
		879	`if (reason == 0) {`
		880	`return (NULL_id);`
		881	`}`
		882	`fid = id;`
2	7u83	883	`}`
		884
7	7u83	885	`/* Match found */`
		886	`ds_old = DEREF_dspec(id_storage(fid));`
		887	`if ((ds_old & dspec_implicit) && !(ds & dspec_implicit)) {`
		888	`if (IS_id_mem_func(fid)) {`
		889	`/* Matches implicitly declared member`
		890	`* function */`
		891	`report(decl_loc, ERR_class_special_decl(fid));`
		892	`return (NULL_id);`
		893	`}`
2	7u83	894	`}`
7	7u83	895	`if (ds_old & dspec_inherit) {`
		896	`/* Inherited functions (including aliases) are hidden */`
		897	`return (NULL_id);`
		898	`}`
		899	`/* over = NULL_id ; /`
2	7u83	900	`}`
		901	`#else`
7	7u83	902	`/* Don't check overloading in C */`
		903	`*over = NULL_id;`
		904	`UNUSED(tag);`
2	7u83	905	`#endif`
		906
7	7u83	907	`/* Redeclare id */`
		908	`fid = redecl_id(ds, t, fid, reason, def);`
		909	`if (!IS_NULL_id(fid)) {`
		910	`TYPE form = DEREF_type(id_function_etc_form(id));`
		911	`if (def >= 0) {`
		912	`/* Allow for default arguments etc. */`
		913	`TYPE s = DEREF_type(id_function_etc_type(fid));`
		914	`s = redecl_func_type(fid, s, t, def, 1);`
		915	`COPY_type(id_function_etc_type(fid), s);`
2	7u83	916	`}`
7	7u83	917	`if (!IS_NULL_type(form) && IS_type_token(form)) {`
		918	`IDENTIFIER ext = DEREF_id(type_token_tok(form));`
		919	`if (!IS_NULL_id(ext) && IS_id_token(ext)) {`
		920	`/* Check for tokenised functions */`
		921	`ds = DEREF_dspec(id_storage(ext));`
		922	`ds \|= dspec_explicit;`
		923	`COPY_dspec(id_storage(ext), ds);`
		924	`if (def) {`
		925	`/* Check for token definitions */`
		926	`IGNORE define_func_token(ext, fid);`
		927	`if (ds & dspec_pure) {`
		928	`report(decl_loc,`
		929	`ERR_token_def_not(ext));`
		930	`}`
		931	`}`
		932	`}`
		933	`}`
2	7u83	934	`}`
7	7u83	935	`return (fid);`
2	7u83	936	`}`
		937
		938
		939	`/*`
		940	`REDECLARE AN INHERITED OR ALIASED MEMBER`
		941
		942	`This routine is used to allow for declarations of class members to`
		943	`override any inherited value of the member. id gives the inherited`
		944	`value, mem is true for a member declaration, fn is true for a function`
		945	`declaration or a declaration which can't coexist with a function`
		946	`declaration. The null identifier is returned to indicate that id is`
		947	`to be overridden.`
		948	`*/`
		949
7	7u83	950	`IDENTIFIER`
		951	`redecl_inherit(IDENTIFIER id, QUALIFIER qual, int mem, int fn)`
2	7u83	952	`{`
7	7u83	953	`if (!IS_NULL_id(id)) {`
		954	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		955	`if (ds & dspec_alias) {`
		956	`if (fn && IS_id_function_etc(id)) {`
		957	`/* Everything is a function */`
		958	`return (id);`
		959	`}`
		960	`if (mem && IS_id_class_name(id)) {`
		961	`/* Allow for injected type names */`
		962	`if (ds & dspec_implicit) {`
		963	`return (id);`
		964	`}`
		965	`}`
		966	`if (qual == qual_none) {`
		967	`/* New declaration */`
		968	`PTR(LOCATION) loc = id_loc(id);`
		969	`report(decl_loc,`
		970	`ERR_dcl_nspace_udecl_multi(id, loc));`
		971	`return (NULL_id);`
		972	`}`
		973	`}`
		974	`if (ds & dspec_inherit) {`
		975	`NAMESPACE ns;`
		976	`if (mem) {`
		977	`return (NULL_id);`
		978	`}`
		979	`ns = DEREF_nspace(id_parent(id));`
		980	`id = DEREF_id(id_alias(id));`
		981	`report(decl_loc, ERR_lookup_qual_decl(id, ns));`
		982	`}`
2	7u83	983	`}`
7	7u83	984	`return (id);`
2	7u83	985	`}`
		986
		987
		988	`/*`
		989	`COPY AN IDENTIFIER`
		990
		991	`This routine creates a copy of the identifier id. If type is 1`
		992	`then any type components in id are copied using copy_typedef, if it`
		993	`is 2 they are further expanded using expand_type.`
		994	`*/`
		995
7	7u83	996	`IDENTIFIER`
		997	`copy_id(IDENTIFIER id, int type)`
2	7u83	998	`{`
7	7u83	999	`TYPE t;`
		1000	`ulong no;`
		1001	`ulong dno;`
		1002	`HASHID nm;`
		1003	`unsigned tag;`
		1004	`LOCATION loc;`
		1005	`NAMESPACE ns;`
		1006	`DECL_SPEC ds;`
		1007	`IDENTIFIER lid;`
		1008	`IDENTIFIER cid = id;`
2	7u83	1009
7	7u83	1010	`/* Examine various cases */`
		1011	`if (IS_NULL_id(cid)) {`
		1012	`return (NULL_id);`
		1013	`}`
		1014	`tag = TAG_id(cid);`
		1015	`switch (tag) {`
		1016	`case id_class_name_tag:`
		1017	`case id_class_alias_tag:`
		1018	`case id_enum_name_tag:`
		1019	`case id_enum_alias_tag:`
		1020	`case id_type_alias_tag: {`
		1021	`/* Types */`
		1022	`BASE_TYPE bt;`
		1023	`DECONS_id_class_name_etc(nm, ds, ns, loc, lid, no, dno, t, bt,`
		1024	`cid);`
		1025	`if (type) {`
		1026	`t = copy_typedef(cid, t, cv_none);`
		1027	`if (type == 2) {`
		1028	`t = expand_type(t, 1);`
		1029	`if (tag == id_class_name_tag) {`
		1030	`/* Name already copied by copy_class */`
		1031	`CLASS_TYPE ct;`
		1032	`while (IS_type_templ(t)) {`
		1033	`t = DEREF_type(type_templ_defn(t));`
		1034	`}`
		1035	`ct = DEREF_ctype(type_compound_defn(t));`
		1036	`cid = DEREF_id(ctype_name(ct));`
		1037	`if (!EQ_id(cid, id)) {`
		1038	`COPY_hashid(id_name(cid), nm);`
		1039	`COPY_dspec(id_storage(cid), ds);`
		1040	`COPY_nspace(id_parent(cid), ns);`
		1041	`COPY_loc(id_loc(cid), loc);`
		1042	`break;`
		1043	`}`
		1044	`}`
		1045	`if (tag != id_enum_name_tag) {`
		1046	`/* Find type alias tag */`
		1047	`unsigned ta = type_tag(t);`
		1048	`if (ta == type_compound_tag) {`
		1049	`tag = id_class_alias_tag;`
		1050	`} else if (ta == type_enumerate_tag) {`
		1051	`tag = id_enum_alias_tag;`
		1052	`} else {`
		1053	`tag = id_type_alias_tag;`
		1054	`}`
		1055	`}`
2	7u83	1056	`}`
7	7u83	1057	`}`
		1058	`MAKE_id_class_name_etc(tag, nm, ds, ns, loc, t, cid);`
		1059	`COPY_btype(id_class_name_etc_rep(cid), bt);`
		1060	`break;`
		1061	`}`
		1062	`case id_variable_tag:`
		1063	`case id_parameter_tag:`
		1064	`case id_stat_member_tag: {`
		1065	`/* Objects */`
		1066	`EXP a, b;`
		1067	`DECONS_id_variable_etc(nm, ds, ns, loc, lid, no, dno, t,`
		1068	`a, b, cid);`
		1069	`if (type) {`
		1070	`t = copy_typedef(cid, t, cv_none);`
		1071	`if (type == 2) {`
		1072	`t = expand_type(t, 1);`
2	7u83	1073	`}`
7	7u83	1074	`}`
		1075	`MAKE_id_variable_etc(tag, nm, ds, ns, loc, t, cid);`
		1076	`COPY_exp(id_variable_etc_init(cid), a);`
		1077	`COPY_exp(id_variable_etc_term(cid), b);`
		1078	`break;`
		1079	`}`
		1080	`case id_function_tag:`
		1081	`case id_mem_func_tag:`
		1082	`case id_stat_mem_func_tag: {`
		1083	`/* Functions */`
		1084	`EXP a;`
		1085	`TYPE form;`
		1086	`IDENTIFIER over;`
		1087	`LIST(CLASS_TYPE)fr;`
		1088	`DECONS_id_function_etc(nm, ds, ns, loc, lid, no, dno, t,`
		1089	`over, form, fr, a, cid);`
		1090	`if (type) {`
		1091	`t = copy_typedef(cid, t, cv_none);`
		1092	`if (type == 2) {`
		1093	`t = expand_type(t, 1);`
2	7u83	1094	`}`
		1095	`}`
7	7u83	1096	`MAKE_id_function_etc(tag, nm, ds, ns, loc, t, over, cid);`
		1097	`COPY_type(id_function_etc_form(cid), form);`
		1098	`COPY_exp(id_function_etc_defn(cid), a);`
		1099	`if (type == 2) {`
		1100	`/* Copy friend classes */`
		1101	`while (!IS_NULL_list(fr)) {`
		1102	`TYPE r = NULL_type;`
		1103	`CLASS_TYPE cr = DEREF_ctype(HEAD_list(fr));`
		1104	`cr = expand_ctype(cr, 2, &r);`
		1105	`friend_function(cr, cid, 0);`
		1106	`fr = TAIL_list(fr);`
		1107	`}`
		1108	`} else {`
		1109	`COPY_list(id_function_etc_chums(cid), fr);`
		1110	`}`
		1111	`break;`
2	7u83	1112	`}`
7	7u83	1113	`case id_member_tag: {`
		1114	`/* Members */`
		1115	`GRAPH gr;`
		1116	`OFFSET off;`
		1117	`DECONS_id_member(nm, ds, ns, loc, lid, no, dno, t, off, gr,`
		1118	`cid);`
		1119	`if (type) {`
		1120	`t = copy_typedef(cid, t, cv_none);`
		1121	`if (type == 2) {`
		1122	`if (IS_hashid_anon(nm)) {`
		1123	`/* Allow for anonymous bitfields */`
		1124	`expand_anon_bitfield = 1;`
		1125	`}`
		1126	`t = expand_type(t, 1);`
		1127	`expand_anon_bitfield = 0;`
		1128	`}`
		1129	`}`
		1130	`MAKE_id_member(nm, ds, ns, loc, t, cid);`
		1131	`COPY_graph(id_member_base(cid), gr);`
		1132	`COPY_off(id_member_off(cid), off);`
		1133	`break;`
2	7u83	1134	`}`
7	7u83	1135	`case id_enumerator_tag: {`
		1136	`/* Enumerators */`
		1137	`EXP a;`
		1138	`ERROR err = NULL_err;`
		1139	`DECONS_id_enumerator(nm, ds, ns, loc, lid, no, dno, t, a, cid);`
		1140	`if (type == 2) {`
		1141	`/* Copy enumerator value */`
		1142	`TYPE s = expand_type(t, 1);`
		1143	`a = copy_exp(a, t, s);`
		1144	`IGNORE make_nat_exp(a, &err);`
		1145	`t = s;`
2	7u83	1146	`}`
7	7u83	1147	`MAKE_id_enumerator(nm, ds, ns, loc, t, a, cid);`
		1148	`if (!IS_NULL_err(err)) {`
		1149	`err = concat_error(err, ERR_dcl_enum_const(cid));`
		1150	`report(crt_loc, err);`
		1151	`}`
		1152	`break;`
2	7u83	1153	`}`
7	7u83	1154	`case id_token_tag: {`
		1155	`/* Tokens */`
		1156	`TOKEN sort;`
		1157	`IDENTIFIER alt;`
		1158	`DECONS_id_token(nm, ds, ns, loc, lid, no, dno, sort, alt, cid);`
		1159	`if (type == 2) {`
		1160	`/* Expand token sort */`
		1161	`sort = expand_sort(sort, 1, 1);`
2	7u83	1162	`}`
7	7u83	1163	`MAKE_id_token(nm, ds, ns, loc, sort, alt, cid);`
		1164	`break;`
2	7u83	1165	`}`
7	7u83	1166	`default:`
		1167	`/* Don't copy other identifiers */`
		1168	`return (cid);`
2	7u83	1169	`}`
		1170
7	7u83	1171	`if (type != 2) {`
		1172	`COPY_id(id_alias(cid), lid);`
		1173	`COPY_ulong(id_no(cid), no);`
		1174	`COPY_ulong(id_dump(cid), dno);`
2	7u83	1175	`}`
7	7u83	1176	`return (cid);`
2	7u83	1177	`}`
		1178
		1179
		1180	`/*`
		1181	`CREATE AN IDENTIFIER ALIAS`
		1182
		1183	`This routine creates an alias for the identifier id in the namespace`
		1184	`ns. fn gives a list of function which the alias will overload if`
		1185	`it is a function.`
		1186	`*/`
		1187
7	7u83	1188	`IDENTIFIER`
		1189	`alias_id(IDENTIFIER id, NAMESPACE ns, IDENTIFIER fn, int rec)`
2	7u83	1190	`{`
7	7u83	1191	`IDENTIFIER cid = copy_id(id, 1);`
		1192	`if (!EQ_id(cid, id)) {`
		1193	`DECL_SPEC ds = DEREF_dspec(id_storage(cid));`
		1194	`DECL_SPEC acc = (ds & dspec_access);`
		1195	`if (acc) {`
		1196	`IDENTIFIER sid = DEREF_id(nspace_name(ns));`
		1197	`immediate_access(sid, cid);`
2	7u83	1198	`}`
7	7u83	1199	`ds = ((ds & ~dspec_access) \| dspec_alias \| crt_access);`
		1200	`COPY_dspec(id_storage(cid), ds);`
		1201	`COPY_nspace(id_parent(cid), ns);`
		1202	`if (do_dump) {`
		1203	`dump_alias(cid, id, &crt_loc);`
		1204	`}`
		1205	`if (IS_id_function_etc(cid)) {`
		1206	`/* Deal with overloaded functions */`
		1207	`IDENTIFIER over;`
		1208	`if (rec) {`
		1209	`over = DEREF_id(id_function_etc_over(cid));`
		1210	`if (IS_NULL_id(over)) {`
		1211	`over = fn;`
		1212	`} else {`
		1213	`over = alias_id(over, ns, fn, rec);`
		1214	`}`
		1215	`} else {`
		1216	`over = fn;`
		1217	`}`
		1218	`COPY_id(id_function_etc_over(cid), over);`
		1219	`}`
2	7u83	1220	`}`
7	7u83	1221	`return (cid);`
2	7u83	1222	`}`
		1223
		1224
		1225	`/*`
		1226	`DUMMY DECLARATION SPECIFIER`
		1227
		1228	`This value is used as a dummy declaration specifier in the adjusting`
		1229	`of overloaded functions.`
		1230	`*/`
		1231
7	7u83	1232	`#define dspec_mark ((DECL_SPEC)0x7fffffff)`
2	7u83	1233
		1234
		1235	`/*`
		1236	`REMOVE HIDDEN FUNCTIONS`
		1237
		1238	`This routine adjusts the set of overloaded functions id by removing`
		1239	`any with storage field equal to dspec_mark.`
		1240	`*/`
		1241
7	7u83	1242	`static IDENTIFIER`
		1243	`remove_functions(IDENTIFIER id)`
2	7u83	1244	`{`
7	7u83	1245	`if (!IS_NULL_id(id)) {`
		1246	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1247	`IDENTIFIER over = DEREF_id(id_function_etc_over(id));`
		1248	`over = remove_functions(over);`
		1249	`if (ds == dspec_mark) {`
		1250	`id = over;`
		1251	`} else {`
		1252	`COPY_id(id_function_etc_over(id), over);`
		1253	`}`
2	7u83	1254	`}`
7	7u83	1255	`return (id);`
2	7u83	1256	`}`
		1257
		1258
		1259	`/*`
		1260	`COMPARE HIDING FUNCTIONS`
		1261
		1262	`This routine compares two functions id and over, one declared in the`
		1263	`normal fashion and the other by a using-declaration. It returns`
		1264	`true if the former overrides the latter.`
		1265	`*/`
		1266
7	7u83	1267	`static int`
		1268	`compare_functions(IDENTIFIER id, IDENTIFIER over, int mem)`
2	7u83	1269	`{`
7	7u83	1270	`TYPE t = DEREF_type(id_function_etc_type(id));`
		1271	`TYPE s = DEREF_type(id_function_etc_type(over));`
		1272	`int eq = eq_func_type(t, s, 1, 0);`
		1273	`if (eq) {`
		1274	`/* Equal parameter types */`
		1275	`if (mem) {`
		1276	`return (1);`
		1277	`}`
		1278	`}`
		1279	`if (eq >= 2) {`
		1280	`/* Equal types */`
		1281	`PTR(LOCATION)loc = id_loc(over);`
		1282	`report(crt_loc, ERR_dcl_nspace_udecl_multi(over, loc));`
		1283	`return (1);`
		1284	`}`
		1285	`return (0);`
2	7u83	1286	`}`
		1287
		1288
		1289	`/*`
		1290	`MARK HIDDEN FUNCTIONS`
		1291
		1292	`This routine marks any functions which hide, or are hidden by, id in`
		1293	`its set of overloaded functions. mem is true for member functions.`
		1294	`Any hidden function is marked by setting its storage field to the`
		1295	`value dspec_mark.`
		1296	`*/`
		1297
7	7u83	1298	`static int`
		1299	`mark_functions(IDENTIFIER id, int mem)`
2	7u83	1300	`{`
7	7u83	1301	`int ret = 0;`
		1302	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1303	`if (ds != dspec_mark) {`
		1304	`IDENTIFIER over = DEREF_id(id_function_etc_over(id));`
		1305	`while (!IS_NULL_id(over)) {`
		1306	`DECL_SPEC pds = DEREF_dspec(id_storage(over));`
		1307	`if (pds != dspec_mark) {`
		1308	`if (ds & dspec_alias) {`
		1309	`if (pds & dspec_alias) {`
2	7u83	1310	`/* Both are using declarations */`
7	7u83	1311	`IDENTIFIER a = DEREF_id(id_alias(id));`
		1312	`IDENTIFIER b = DEREF_id(id_alias(over));`
		1313	`if (EQ_id(a, b)) {`
2	7u83	1314	`/* Duplicate declarations */`
7	7u83	1315	`if (mem) {`
		1316	`ERROR err;`
		1317	`PTR(LOCATION) loc = id_loc(over);`
		1318	`err = ERR_class_mem_redecl(over, loc);`
		1319	`report(crt_loc, err);`
2	7u83	1320	`}`
7	7u83	1321	`COPY_dspec(id_storage(over), dspec_mark);`
		1322	`ret++;`
2	7u83	1323	`}`
		1324	`} else {`
		1325	`/* The first is a using declaration */`
7	7u83	1326	`if (compare_functions(id, over, mem)) {`
		1327	`COPY_dspec(id_storage(id), dspec_mark);`
		1328	`ret++;`
2	7u83	1329	`}`
		1330	`}`
7	7u83	1331	`} else if (pds & dspec_alias) {`
2	7u83	1332	`/* The second is a using declaration */`
7	7u83	1333	`if (compare_functions(id, over, mem)) {`
		1334	`COPY_dspec(id_storage(over), dspec_mark);`
		1335	`ret++;`
		1336	`break;`
2	7u83	1337	`}`
		1338	`}`
		1339	`}`
7	7u83	1340	`over = DEREF_id(id_function_etc_over(over));`
2	7u83	1341	`}`
		1342	`}`
7	7u83	1343	`return (ret);`
2	7u83	1344	`}`
		1345
		1346
		1347	`/*`
		1348	`HANDLE HIDDEN FUNCTIONS WITH USING DECLARATIONS`
		1349
		1350	`The interaction of using declarations with the hiding and overriding`
		1351	`of member functions is somewhat complex. It is implemented by this`
		1352	`routine which adjusts the declarations of the overloaded functions id`
		1353	`up to the existing declarations over. mem is true for member functions.`
		1354	`*/`
		1355
7	7u83	1356	`IDENTIFIER`
		1357	`hide_functions(IDENTIFIER id, IDENTIFIER over, int mem)`
2	7u83	1358	`{`
7	7u83	1359	`if (!IS_NULL_id(over)) {`
		1360	`int marked = 0;`
		1361	`IDENTIFIER pid = id;`
		1362	`while (!EQ_id(pid, over)) {`
		1363	`marked += mark_functions(pid, mem);`
		1364	`pid = DEREF_id(id_function_etc_over(pid));`
		1365	`}`
		1366	`if (marked) {`
		1367	`id = remove_functions(id);`
		1368	`}`
		1369	`pid = id;`
		1370	`while (!IS_NULL_id(pid)) {`
		1371	`/* Mark template functions */`
		1372	`DECL_SPEC ds = DEREF_dspec(id_storage(pid));`
		1373	`if (ds & dspec_template) {`
		1374	`templ_func_decl(id);`
		1375	`break;`
		1376	`}`
		1377	`pid = DEREF_id(id_function_etc_over(pid));`
		1378	`}`
2	7u83	1379	`}`
7	7u83	1380	`return (id);`
2	7u83	1381	`}`
		1382
		1383
		1384	`/*`
		1385	`CHECK THE VISIBILITY OF AN IDENTIFIER`
		1386
		1387	`A member name in a using declaration should be visible from a direct`
		1388	`base class. This routine checks whether the member id meets this`
		1389	`criterion by comparing it with its look-up in the direct base`
		1390	`classes, pid.`
		1391	`*/`
		1392
7	7u83	1393	`static int`
		1394	`using_visible(IDENTIFIER id, IDENTIFIER pid)`
2	7u83	1395	`{`
7	7u83	1396	`while (!IS_NULL_id(pid)) {`
		1397	`IDENTIFIER qid = DEREF_id(id_alias(pid));`
		1398	`if (EQ_id(qid, id)) {`
		1399	`return (1);`
2	7u83	1400	`}`
7	7u83	1401	`switch (TAG_id(pid)) {`
		1402	`case id_function_tag:`
		1403	`case id_mem_func_tag:`
		1404	`case id_stat_mem_func_tag:`
		1405	`/* Check overloaded functions */`
		1406	`pid = DEREF_id(id_function_etc_over(pid));`
		1407	`break;`
		1408	`case id_ambig_tag: {`
		1409	`/* Check ambiguous identifiers */`
		1410	`LIST(IDENTIFIER)pids;`
		1411	`pids = DEREF_list(id_ambig_ids(pid));`
		1412	`while (!IS_NULL_list(pids)) {`
		1413	`pid = DEREF_id(HEAD_list(pids));`
		1414	`if (using_visible(id, pid)) {`
		1415	`return (1);`
		1416	`}`
		1417	`pids = TAIL_list(pids);`
		1418	`}`
		1419	`return (0);`
		1420	`}`
		1421	`default:`
		1422	`/* Other identifiers */`
		1423	`return (0);`
		1424	`}`
2	7u83	1425	`}`
7	7u83	1426	`return (0);`
2	7u83	1427	`}`
		1428
		1429
		1430	`/*`
		1431	`PROCESS A CLASS USING DECLARATION`
		1432
		1433	`This routine processes a using-declaration of the identifier id in`
		1434	`the case when this declaration is a member-declaration.`
		1435	`*/`
		1436
7	7u83	1437	`static IDENTIFIER`
		1438	`using_member(IDENTIFIER id, int type)`
2	7u83	1439	`{`
7	7u83	1440	`MEMBER mem;`
		1441	`IDENTIFIER aid;`
		1442	`IDENTIFIER pid;`
2	7u83	1443
7	7u83	1444	`/* Check the identifier */`
		1445	`NAMESPACE cns = crt_namespace;`
		1446	`HASHID nm = DEREF_hashid(id_name(id));`
		1447	`GRAPH gr = is_subfield(cns, id);`
		1448	`if (IS_NULL_graph(gr)) {`
		1449	`/* id is not a member of a base class */`
		1450	`CLASS_TYPE ct = crt_class;`
		1451	`report(crt_loc, ERR_dcl_nspace_udecl_base(id, ct));`
		1452	`return (NULL_id);`
		1453	`} else {`
		1454	`GRAPH gu = DEREF_graph(graph_up(gr));`
		1455	`GRAPH gt = DEREF_graph(graph_top(gr));`
		1456	`if (EQ_graph(gt, gr)) {`
		1457	`/* id is a member of the current class */`
		1458	`report(crt_loc, ERR_dcl_nspace_udecl_mem(id));`
		1459	`return (id);`
2	7u83	1460	`}`
7	7u83	1461	`if (!EQ_graph(gt, gu)) {`
		1462	`/* Not a member of a direct base class */`
		1463	`IDENTIFIER bid = search_base_field(cns, nm, type, 0);`
		1464	`aid = id;`
		1465	`while (!IS_NULL_id(aid)) {`
		1466	`IDENTIFIER qid = find_template(aid, 1);`
		1467	`if (IS_NULL_id(qid)) {`
		1468	`qid = aid;`
		1469	`}`
		1470	`qid = DEREF_id(id_alias(qid));`
		1471	`if (!using_visible(qid, bid)) {`
		1472	`CLASS_TYPE ct = crt_class;`
		1473	`report(crt_loc, ERR_dcl_nspace_udecl_vis(aid, ct));`
		1474	`break;`
		1475	`}`
		1476	`if (!IS_id_function_etc(aid)) {`
		1477	`break;`
		1478	`}`
		1479	`aid = DEREF_id(id_function_etc_over(aid));`
		1480	`}`
		1481	`}`
2	7u83	1482	`}`
		1483
7	7u83	1484	`/* Check declarations */`
		1485	`mem = search_member(cns, nm, 1);`
		1486	`if (type) {`
		1487	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1488	`if (ds & dspec_template) {`
		1489	`pid = DEREF_id(member_id(mem));`
		1490	`} else {`
		1491	`pid = type_member(mem, 3);`
		1492	`}`
2	7u83	1493	`} else {`
7	7u83	1494	`pid = DEREF_id(member_id(mem));`
		1495	`if (!IS_NULL_id(pid) && is_tagged_type(pid)) {`
		1496	`/* Allow hiding of non-template classes */`
		1497	`DECL_SPEC ds = DEREF_dspec(id_storage(pid));`
		1498	`if (!(ds & dspec_template)) {`
		1499	`pid = NULL_id;`
		1500	`}`
		1501	`}`
2	7u83	1502	`}`
7	7u83	1503	`if (!IS_NULL_id(pid)) {`
		1504	`DECL_SPEC ds = DEREF_dspec(id_storage(pid));`
		1505	`if ((ds & dspec_inherit) && !(ds & dspec_alias)) {`
		1506	`/* Ignore inherited members */`
		1507	`pid = NULL_id;`
		1508	`} else {`
		1509	`IDENTIFIER rid = DEREF_id(id_alias(id));`
		1510	`IDENTIFIER qid = DEREF_id(id_alias(pid));`
		1511	`if (EQ_id(rid, qid)) {`
		1512	`/* Redeclaration of existing meaning */`
		1513	`if (!type) {`
		1514	`PTR(LOCATION)loc = id_loc(pid);`
		1515	`ERROR err =`
		1516	`ERR_class_mem_redecl(pid, loc);`
		1517	`report(crt_loc, err);`
		1518	`}`
		1519	`adjust_access(pid, crt_access, 1);`
		1520	`return (pid);`
		1521	`}`
		1522	`if (IS_id_function_etc(id) && IS_id_function_etc(pid)) {`
		1523	`/* Both new and old meanings are functions */`
		1524	`/* EMPTY */`
		1525	`} else {`
		1526	`/* One meaning is not a function */`
		1527	`PTR(LOCATION) loc = id_loc(pid);`
		1528	`ERROR err =`
		1529	`ERR_dcl_nspace_udecl_multi(pid, loc);`
		1530	`report(crt_loc, err);`
		1531	`return (NULL_id);`
		1532	`}`
		1533	`}`
2	7u83	1534	`}`
7	7u83	1535
		1536	`/* Find inherited member */`
		1537	`id = search_subfield(cns, gr, id);`
		1538	`aid = alias_id(id, cns, pid, 1);`
		1539	`if (!IS_NULL_id(pid)) {`
		1540	`/* Deal with function hiding */`
		1541	`aid = hide_functions(aid, pid, 1);`
		1542	`}`
		1543	`adjust_access(id, crt_access, 1);`
		1544	`if (type) {`
		1545	`set_type_member(mem, aid);`
2	7u83	1546	`} else {`
7	7u83	1547	`set_member(mem, aid);`
2	7u83	1548	`}`
7	7u83	1549	`return (aid);`
2	7u83	1550	`}`
		1551
		1552
		1553	`/*`
		1554	`PROCESS A NAMESPACE USING DECLARATION`
		1555
		1556	`This routine processes a using-declaration of the identifier id in`
		1557	`the case when this declaration is not a member-declaration.`
		1558	`*/`
		1559
7	7u83	1560	`static IDENTIFIER`
		1561	`using_name(IDENTIFIER id)`
2	7u83	1562	`{`
7	7u83	1563	`int type;`
		1564	`HASHID nm;`
		1565	`MEMBER mem;`
		1566	`IDENTIFIER pid;`
2	7u83	1567
7	7u83	1568	`/* Check the identifier */`
		1569	`NAMESPACE cns = crt_namespace;`
		1570	`NAMESPACE ns = DEREF_nspace(id_parent(id));`
		1571	`if (IS_nspace_ctype(ns)) {`
		1572	`/* id denotes a class member */`
		1573	`report(crt_loc, ERR_dcl_nspace_udecl_id(id));`
		1574	`switch (TAG_id(id)) {`
		1575	`case id_member_tag:`
		1576	`case id_stat_member_tag:`
		1577	`case id_mem_func_tag:`
		1578	`case id_stat_mem_func_tag:`
		1579	`/* Don't even try in these cases */`
		1580	`return (NULL_id);`
		1581	`}`
2	7u83	1582	`}`
		1583
7	7u83	1584	`/* Check declarations */`
		1585	`nm = DEREF_hashid(id_name(id));`
		1586	`mem = search_member(cns, nm, 1);`
		1587	`type = is_tagged_type(id);`
		1588	`if (type) {`
		1589	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1590	`if (ds & dspec_template) {`
		1591	`pid = DEREF_id(member_id(mem));`
		1592	`} else {`
		1593	`pid = type_member(mem, 3);`
		1594	`}`
2	7u83	1595	`} else {`
7	7u83	1596	`pid = DEREF_id(member_id(mem));`
		1597	`if (!IS_id_nspace_name_etc(id)) {`
		1598	`if (!IS_NULL_id(pid) && is_tagged_type(pid)) {`
		1599	`/* Allow hiding of non-template classes */`
		1600	`DECL_SPEC ds = DEREF_dspec(id_storage(pid));`
		1601	`if (!(ds & dspec_template)) {`
		1602	`pid = NULL_id;`
		1603	`}`
		1604	`}`
		1605	`}`
2	7u83	1606	`}`
7	7u83	1607	`if (!IS_NULL_id(pid)) {`
		1608	`IDENTIFIER qid = DEREF_id(id_alias(pid));`
		1609	`if (EQ_id(id, qid)) {`
		1610	`/* Redeclaration of existing meaning */`
		1611	`if (EQ_id(id, pid)) {`
		1612	`report(crt_loc, ERR_dcl_nspace_udecl_mem(id));`
		1613	`}`
		1614	`return (pid);`
		1615	`}`
		1616	`if (IS_id_function_etc(id) && IS_id_function_etc(pid)) {`
		1617	`/* Both new and old meanings are functions */`
		1618	`/* EMPTY */`
		1619	`} else {`
		1620	`/* Invalid redeclaration */`
		1621	`PTR(LOCATION) loc = id_loc(pid);`
		1622	`ERROR err = ERR_dcl_nspace_udecl_multi(pid, loc);`
		1623	`report(crt_loc, err);`
		1624	`pid = NULL_id;`
		1625	`}`
2	7u83	1626	`}`
7	7u83	1627
		1628	`/* Create the alias */`
		1629	`id = alias_id(id, cns, pid, 1);`
		1630	`if (!IS_NULL_id(pid)) {`
		1631	`/* Deal with function hiding */`
		1632	`id = hide_functions(id, pid, 0);`
2	7u83	1633	`}`
7	7u83	1634	`if (type) {`
		1635	`set_type_member(mem, id);`
2	7u83	1636	`} else {`
7	7u83	1637	`set_member(mem, id);`
2	7u83	1638	`}`
7	7u83	1639	`return (id);`
2	7u83	1640	`}`
		1641
		1642
		1643	`/*`
		1644	`PROCESS A USING DECLARATION`
		1645
		1646	`This routine processes a using-declaration of the identifier id. Note`
		1647	`that this includes the access declarations used to modify access to`
		1648	`class members.`
		1649	`*/`
		1650
7	7u83	1651	`IDENTIFIER`
		1652	`using_identifier(IDENTIFIER id)`
2	7u83	1653	`{`
7	7u83	1654	`/* Identifier must be qualified */`
		1655	`MEMBER mem;`
		1656	`HASHID unm;`
		1657	`IDENTIFIER cid;`
		1658	`IDENTIFIER uid = id;`
		1659	`NAMESPACE uns = DEREF_nspace(id_parent(uid));`
		1660	`uid = constr_name(uns, uid);`
		1661	`unm = DEREF_hashid(id_name(uid));`
		1662	`if (crt_id_qualifier == qual_none) {`
		1663	`report(crt_loc, ERR_dcl_nspace_udecl_unqual());`
		1664	`return (uid);`
		1665	`}`
2	7u83	1666
7	7u83	1667	`/* Report undefined and ambiguous identifiers */`
		1668	`switch (TAG_id(uid)) {`
		1669	`case id_ambig_tag: {`
		1670	`/* Introduce all the ambiguous meanings */`
		1671	`LIST(IDENTIFIER) pids = DEREF_list(id_ambig_ids(uid));`
		1672	`while (!IS_NULL_list(pids)) {`
		1673	`IDENTIFIER pid = DEREF_id(HEAD_list(pids));`
		1674	`IGNORE using_identifier(pid);`
		1675	`pids = TAIL_list(pids);`
		1676	`}`
		1677	`uid = find_qual_id(crt_namespace, unm, 0, 0);`
		1678	`return (uid);`
2	7u83	1679	`}`
7	7u83	1680	`case id_undef_tag:`
		1681	`/* Report undeclared identifiers */`
		1682	`report(crt_loc, ERR_lookup_qual_undef(unm, uns));`
		1683	`return (uid);`
2	7u83	1684	`}`
		1685
7	7u83	1686	`/* Can have constructors or destructors */`
		1687	`switch (TAG_hashid(unm)) {`
		1688	`case hashid_constr_tag:`
		1689	`case hashid_destr_tag:`
		1690	`report(crt_loc, ERR_dcl_nspace_udecl_constr(uid));`
		1691	`return (uid);`
2	7u83	1692	`}`
		1693
7	7u83	1694	`/* Check for hidden type names */`
		1695	`mem = search_member(uns, unm, 0);`
		1696	`cid = type_member(mem, 1);`
		1697	`if (EQ_id(cid, uid)) {`
		1698	`cid = NULL_id;`
		1699	`}`
2	7u83	1700
7	7u83	1701	`/* Process the declaration */`
		1702	`if (in_class_defn) {`
		1703	`if (!IS_NULL_id(cid)) {`
		1704	`IGNORE using_member(cid, 1);`
		1705	`}`
		1706	`uid = using_member(uid, 0);`
		1707	`} else {`
		1708	`if (!IS_NULL_id(cid)) {`
		1709	`cid = DEREF_id(id_alias(cid));`
		1710	`IGNORE using_name(cid);`
		1711	`}`
		1712	`uid = DEREF_id(id_alias(uid));`
		1713	`uid = using_name(uid);`
2	7u83	1714	`}`
7	7u83	1715	`if (IS_NULL_id(uid)) {`
		1716	`uid = id;`
		1717	`} else {`
		1718	`/* Check for hiding */`
		1719	`if (option(OPT_decl_hide)) {`
		1720	`switch (TAG_id(id)) {`
		1721	`case id_variable_tag:`
		1722	`case id_function_tag:`
		1723	`check_hiding(uid);`
		1724	`break;`
		1725	`}`
2	7u83	1726	`}`
		1727	`}`
7	7u83	1728	`return (uid);`
2	7u83	1729	`}`
		1730
		1731
		1732	`/*`
		1733	`PROCESS A USING TYPENAME DECLARATION`
		1734
		1735	`This routine processes a using-declaration involving the type t`
		1736	`declared using typename.`
		1737	`*/`
		1738
7	7u83	1739	`void`
		1740	`using_typename(TYPE t)`
2	7u83	1741	`{`
7	7u83	1742	`UNUSED(t);`
		1743	`return;`
2	7u83	1744	`}`
		1745
		1746
		1747	`/*`
		1748	`REDECLARE AN IDENTIFIER`
		1749
		1750	`This routine redeclares the identifier id in the namespace ns.`
		1751	`*/`
		1752
7	7u83	1753	`IDENTIFIER`
		1754	`redeclare_id(NAMESPACE ns, IDENTIFIER id)`
2	7u83	1755	`{`
7	7u83	1756	`IDENTIFIER old_id;`
		1757	`int cl = is_tagged_type(id);`
		1758	`HASHID nm = DEREF_hashid(id_name(id));`
		1759	`MEMBER mem = search_member(ns, nm, 1);`
		1760	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1761	`if (cl) {`
		1762	`old_id = type_member(mem, 3);`
		1763	`} else {`
		1764	`old_id = DEREF_id(member_id(mem));`
		1765	`}`
		1766	`if (!IS_NULL_id(old_id)) {`
		1767	`PTR(LOCATION) loc = id_loc(old_id);`
		1768	`report(crt_loc, ERR_basic_odr_decl(old_id, loc));`
		1769	`}`
		1770	`if (cl) {`
		1771	`set_type_member(mem, id);`
		1772	`} else {`
		1773	`set_member(mem, id);`
		1774	`}`
		1775	`ds \|= dspec_reserve;`
		1776	`COPY_dspec(id_storage(id), ds);`
		1777	`COPY_nspace(id_parent(id), ns);`
		1778	`return (id);`
2	7u83	1779	`}`
		1780
		1781
		1782	`/*`
		1783	`CHECK ANONYMOUS UNION MEMBER`
		1784
		1785	`This routine checks whether the identifier id is member of an`
		1786	`anonymous union.`
		1787	`*/`
		1788
7	7u83	1789	`int`
		1790	`is_anon_member(IDENTIFIER id)`
2	7u83	1791	`{`
7	7u83	1792	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1793	`if (ds & dspec_reserve) {`
		1794	`IDENTIFIER pid = DEREF_id(id_alias(id));`
		1795	`if (!EQ_id(pid, id)) {`
		1796	`TYPE s = DEREF_type(id_variable_etc_type(pid));`
		1797	`if (IS_type_compound(s)) {`
		1798	`TYPE t = DEREF_type(id_variable_etc_type(id));`
		1799	`if (!eq_type(s, t)) {`
		1800	`return (1);`
		1801	`}`
		1802	`}`
		1803	`}`
2	7u83	1804	`}`
7	7u83	1805	`return (0);`
2	7u83	1806	`}`
		1807
		1808
		1809	`/*`
		1810	`REDECLARE A MEMBER OF AN ANONYMOUS UNION`
		1811
		1812	`This routine redeclares the member id of an anonymous union. The`
		1813	`remaining arguments are as in redecl_anon_union.`
		1814	`*/`
		1815
7	7u83	1816	`static IDENTIFIER`
		1817	`redecl_anon_member(IDENTIFIER id, CLASS_TYPE ct, DECL_SPEC ds, IDENTIFIER obj)`
2	7u83	1818	`{`
7	7u83	1819	`IDENTIFIER pid = NULL_id;`
		1820	`HASHID nm = DEREF_hashid(id_name(id));`
		1821	`if (!IS_hashid_anon(nm)) {`
		1822	`switch (TAG_id(id)) {`
		1823	`case id_member_tag: {`
		1824	`/* Redeclare a type member */`
		1825	`TYPE t = DEREF_type(id_member_type(id));`
		1826	`DEREF_loc(id_loc(id), crt_loc);`
		1827	`if (IS_id_member(obj)) {`
		1828	`NAMESPACE cns = crt_namespace;`
		1829	`OFFSET off1 = DEREF_off(id_member_off(id));`
		1830	`OFFSET off2 = DEREF_off(id_member_off(obj));`
		1831	`id = find_id(nm);`
		1832	`id = constr_name(cns, id);`
		1833	`id = make_member_decl(ds, t, id, 0);`
		1834	`MAKE_off_plus(off2, off1, off1);`
		1835	`COPY_off(id_member_off(id), off1);`
		1836	`} else {`
		1837	`id = make_object_decl(ds, t, id, 0);`
		1838	`obj = DEREF_id(id_alias(obj));`
		1839	`COPY_id(id_alias(id), obj);`
		1840	`}`
		1841	`pid = id;`
		1842	`break;`
2	7u83	1843	`}`
7	7u83	1844	`case id_class_name_tag: {`
		1845	`/* Redeclare a class name */`
		1846	`int templ = 0;`
		1847	`CLASS_TYPE cs;`
		1848	`TYPE t = DEREF_type(id_class_name_defn(id));`
		1849	`while (IS_type_templ(t)) {`
		1850	`templ = 1;`
		1851	`t = DEREF_type(type_templ_defn(t));`
		1852	`}`
		1853	`cs = DEREF_ctype(type_compound_defn(t));`
		1854	`if (!eq_ctype(ct, cs)) {`
		1855	`NAMESPACE cns = crt_namespace;`
		1856	`if (templ) {`
		1857	`/* Shouldn't be a template class */`
		1858	`LOCATION loc;`
		1859	`DEREF_loc(id_loc(id), loc);`
		1860	`report(loc, ERR_temp_decl_bad());`
		1861	`}`
		1862	`pid = redeclare_id(cns, id);`
		1863	`}`
		1864	`break;`
2	7u83	1865	`}`
7	7u83	1866	`case id_enum_name_tag:`
		1867	`case id_class_alias_tag:`
		1868	`case id_enum_alias_tag:`
		1869	`case id_type_alias_tag:`
		1870	`case id_enumerator_tag: {`
		1871	`/* Redeclare other identifiers */`
		1872	`NAMESPACE cns = crt_namespace;`
		1873	`pid = redeclare_id(cns, id);`
		1874	`break;`
2	7u83	1875	`}`
7	7u83	1876	`}`
2	7u83	1877	`}`
7	7u83	1878	`return (pid);`
2	7u83	1879	`}`
		1880
		1881
		1882	`/*`
		1883	`REDECLARE AN ANONYMOUS UNION`
		1884
		1885	`This routine redeclares all the members of the anonymous union obj of`
		1886	`type ct in the current namespace using the declaration specifiers ds.`
		1887	`The routine returns false if there are no members to redeclare. The`
		1888	`redeclared members are added to the extra field of the namespace given`
		1889	`by ct.`
		1890	`*/`
		1891
7	7u83	1892	`int`
		1893	`redecl_anon_union(CLASS_TYPE ct, DECL_SPEC ds, IDENTIFIER obj)`
2	7u83	1894	`{`
7	7u83	1895	`int ok = 0;`
		1896	`MEMBER mem;`
		1897	`NAMESPACE ns;`
		1898	`LOCATION old_loc;`
		1899	`bad_crt_loc++;`
		1900	`old_loc = crt_loc;`
		1901	`ds \|= dspec_reserve;`
		1902	`crt_id_qualifier = qual_none;`
		1903	`crt_templ_qualifier = 0;`
		1904	`ns = DEREF_nspace(ctype_member(ct));`
		1905	`mem = DEREF_member(nspace_ctype_first(ns));`
		1906	`while (!IS_NULL_member(mem)) {`
		1907	`IDENTIFIER id = DEREF_id(member_id(mem));`
		1908	`IDENTIFIER aid = DEREF_id(member_alt(mem));`
		1909	`if (!IS_NULL_id(aid) && !EQ_id(aid, id)) {`
		1910	`aid = redecl_anon_member(aid, ct, ds, obj);`
		1911	`if (!IS_NULL_id(aid)) {`
		1912	`ok = 1;`
		1913	`}`
		1914	`}`
		1915	`if (!IS_NULL_id(id)) {`
		1916	`id = redecl_anon_member(id, ct, ds, obj);`
		1917	`if (!IS_NULL_id(id)) {`
		1918	`ok = 1;`
		1919	`}`
		1920	`}`
		1921	`mem = DEREF_member(member_next(mem));`
2	7u83	1922	`}`
7	7u83	1923	`crt_loc = old_loc;`
		1924	`bad_crt_loc--;`
		1925	`return (ok);`
2	7u83	1926	`}`

Subversion Repositories tendra.SVN

(root)/branches/algol60/src/producers/common/construct/redeclare.c – Rev 7