WebSVN – tendra.SVN – Blame – /branches/algol60/src/producers/common/construct/operator.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 "etype_ops.h"`
		65	`#include "exp_ops.h"`
		66	`#include "hashid_ops.h"`
		67	`#include "id_ops.h"`
		68	`#include "member_ops.h"`
		69	`#include "nat_ops.h"`
		70	`#include "type_ops.h"`
		71	`#include "error.h"`
		72	`#include "catalog.h"`
		73	`#include "allocate.h"`
		74	`#include "assign.h"`
		75	`#include "basetype.h"`
		76	`#include "cast.h"`
		77	`#include "chktype.h"`
		78	`#include "class.h"`
		79	`#include "constant.h"`
		80	`#include "construct.h"`
		81	`#include "convert.h"`
		82	`#include "copy.h"`
		83	`#include "derive.h"`
		84	`#include "dump.h"`
		85	`#include "exception.h"`
		86	`#include "expression.h"`
		87	`#include "function.h"`
		88	`#include "hash.h"`
		89	`#include "identifier.h"`
		90	`#include "initialise.h"`
		91	`#include "instance.h"`
		92	`#include "inttype.h"`
		93	`#include "member.h"`
		94	`#include "namespace.h"`
		95	`#include "operator.h"`
		96	`#include "overload.h"`
		97	`#include "quality.h"`
		98	`#include "statement.h"`
		99	`#include "syntax.h"`
		100	`#include "template.h"`
		101	`#include "typeid.h"`
		102
		103
		104	`/*`
		105	`FIND AN EXPRESSION RELATION`
		106
		107	`This routine returns the lexical token number of associated with`
		108	`the test ntst. The default value returned is lex.`
		109	`*/`
		110
7	7u83	111	`int`
		112	`ntest_token(NTEST ntst, int lex)`
2	7u83	113	`{`
7	7u83	114	`switch (ntst) {`
		115	`case ntest_eq:`
		116	`lex = lex_eq;`
		117	`break;`
		118	`case ntest_not_eq:`
		119	`lex = lex_not_Heq_H1;`
		120	`break;`
		121	`case ntest_less:`
		122	`lex = lex_less;`
		123	`break;`
		124	`case ntest_less_eq:`
		125	`lex = lex_less_Heq;`
		126	`break;`
		127	`case ntest_greater:`
		128	`lex = lex_greater;`
		129	`break;`
		130	`case ntest_greater_eq:`
		131	`lex = lex_greater_Heq;`
		132	`break;`
		133	`}`
		134	`return (lex);`
2	7u83	135	`}`
		136
		137
		138	`/*`
		139	`FIND THE TOKEN NUMBER FOR AN OPERATION`
		140
		141	`This routine returns the lexical token number associated with the`
		142	`expression e. The default value returned is lex.`
		143	`*/`
		144
7	7u83	145	`int`
		146	`op_token(EXP e, int lex)`
2	7u83	147	`{`
7	7u83	148	`if (!IS_NULL_exp(e)) {`
		149	`switch (TAG_exp(e)) {`
		150	`case exp_negate_tag:`
		151	`lex = lex_minus;`
		152	`break;`
		153	`case exp_compl_tag:`
		154	`lex = lex_compl_H1;`
		155	`break;`
		156	`case exp_not_tag:`
		157	`lex = lex_not_H1;`
		158	`break;`
		159	`case exp_abs_tag:`
		160	`lex = lex_abs;`
		161	`break;`
		162	`case exp_plus_tag:`
		163	`lex = lex_plus;`
		164	`break;`
		165	`case exp_minus_tag:`
		166	`lex = lex_minus;`
		167	`break;`
		168	`case exp_mult_tag:`
		169	`lex = lex_star;`
		170	`break;`
		171	`case exp_div_tag:`
		172	`lex = lex_div;`
		173	`break;`
		174	`case exp_rem_tag:`
		175	`lex = lex_rem;`
		176	`break;`
		177	`case exp_and_tag:`
		178	`lex = lex_and_H1;`
		179	`break;`
		180	`case exp_or_tag:`
		181	`lex = lex_or_H1;`
		182	`break;`
		183	`case exp_xor_tag:`
		184	`lex = lex_xor_H1;`
		185	`break;`
		186	`case exp_log_and_tag:`
		187	`lex = lex_logical_Hand_H1;`
		188	`break;`
		189	`case exp_log_or_tag:`
		190	`lex = lex_logical_Hor_H1;`
		191	`break;`
		192	`case exp_lshift_tag:`
		193	`lex = lex_lshift;`
		194	`break;`
		195	`case exp_rshift_tag:`
		196	`lex = lex_rshift;`
		197	`break;`
		198	`case exp_max_tag:`
		199	`lex = lex_max;`
		200	`break;`
		201	`case exp_min_tag:`
		202	`lex = lex_min;`
		203	`break;`
		204	`case exp_test_tag: {`
		205	`NTEST ntst = DEREF_ntest(exp_test_tst(e));`
		206	`lex = ntest_token(ntst, lex);`
		207	`break;`
		208	`}`
		209	`case exp_compare_tag: {`
		210	`NTEST ntst = DEREF_ntest(exp_compare_tst(e));`
		211	`lex = ntest_token(ntst, lex);`
		212	`break;`
		213	`}`
		214	`case exp_paren_tag: {`
		215	`EXP a = DEREF_exp(exp_paren_arg(e));`
		216	`lex = op_token(a, lex);`
		217	`break;`
		218	`}`
		219	`case exp_copy_tag: {`
		220	`EXP a = DEREF_exp(exp_copy_arg(e));`
		221	`lex = op_token(a, lex);`
		222	`break;`
		223	`}`
		224	`}`
2	7u83	225	`}`
7	7u83	226	`return (lex);`
2	7u83	227	`}`
		228
		229
		230	`/*`
		231	`APPLY A UNARY OPERATOR`
		232
		233	`This routine applies the unary operator op to the argument a. The`
		234	`type t2 gives the destination for any cast operator.`
		235	`*/`
		236
7	7u83	237	`EXP`
		238	`apply_unary(int op, EXP a, TYPE t1, TYPE t2, int cpy)`
2	7u83	239	`{`
7	7u83	240	`EXP e;`
		241	`if (cpy) {`
		242	`/* Copy argument if necessary */`
		243	`switch (op) {`
		244	`case lex_function:`
		245	`a = copy_func_exp(a, t1, t2);`
		246	`break;`
		247	`case lex_sizeof:`
		248	`case lex_alignof:`
		249	`case lex_typeid:`
		250	`case lex_vtable:`
		251	`suppress_usage++;`
		252	`a = copy_exp(a, t1, t2);`
		253	`suppress_usage--;`
		254	`break;`
		255	`default:`
		256	`a = copy_exp(a, t1, t2);`
		257	`break;`
		258	`}`
2	7u83	259	`}`
7	7u83	260	`suppress_quality++;`
		261	`switch (op) {`
		262	`case lex_and_H1:`
		263	`/* Construct '&a' */`
		264	`e = make_ref_exp(a, 0);`
		265	`break;`
		266	`case lex_abs:`
		267	`case lex_plus:`
		268	`case lex_minus:`
		269	`case lex_compl_H1:`
		270	`/* Construct '+a', '-a', '~a' and 'abs a' */`
		271	`e = make_uminus_exp(op, a);`
		272	`break;`
		273	`case lex_not_H1:`
		274	`/* Construct '!a' */`
		275	`e = make_not_exp(a);`
		276	`break;`
		277	`case lex_plus_Hplus:`
		278	`case lex_minus_Hminus:`
		279	`/* Construct '++a' and '--a' */`
		280	`e = make_prefix_exp(op, a);`
		281	`break;`
		282	`case lex_star:`
		283	`/* Construct 'a' /`
		284	`e = make_indir_exp(a);`
		285	`break;`
		286	`case lex_pointer:`
		287	`/* Construct null pointer constant */`
		288	`e = make_null_ptr(a, t2);`
		289	`if (IS_NULL_exp(e)) {`
		290	`/* Force conversion error */`
		291	`e = apply_unary(lex_implicit, a, t1, t2, 0);`
		292	`}`
		293	`break;`
		294	`case lex_sizeof:`
		295	`case lex_alignof: {`
		296	`/* Construct 'sizeof ( a )' */`
		297	`TYPE s;`
		298	`EXP b = a;`
		299	`suppress_usage++;`
		300	`s = typeof_exp(&b, 0, op);`
		301	`e = make_sizeof_exp(s, b, 0, op);`
		302	`suppress_usage--;`
		303	`break;`
2	7u83	304	`}`
7	7u83	305	`case lex_function: {`
		306	`/* Dummy function resolution operator */`
		307	`ERROR err = NULL_err;`
		308	`LIST(IDENTIFIER) pids = NULL_list(IDENTIFIER);`
		309	`a = resolve_cast(t2, a, &err, 1, 1, pids);`
		310	`e = cast_exp(t2, a, &err, CAST_IMPLICIT);`
		311	`if (!IS_NULL_err(err)) {`
		312	`report(crt_loc, err);`
		313	`}`
		314	`break;`
2	7u83	315	`}`
7	7u83	316	`case lex_implicit: {`
		317	`/* Dummy implicit cast operator */`
		318	`ERROR err = NULL_err;`
		319	`if (IS_exp_initialiser(a)) {`
		320	`LIST(EXP) args;`
		321	`args = DEREF_list(exp_initialiser_args(a));`
		322	`e = init_constr(t2, args, &err);`
		323	`} else {`
		324	`a = convert_reference(a, REF_ASSIGN);`
		325	`e = cast_exp(t2, a, &err, CAST_IMPLICIT);`
		326	`}`
		327	`if (!IS_NULL_err(err)) {`
		328	`report(crt_loc, err);`
		329	`}`
		330	`break;`
2	7u83	331	`}`
7	7u83	332	`case lex_cast: {`
		333	`/* Construct '( t2 ) a' */`
		334	`if (IS_NULL_exp(a)) {`
		335	`ERROR err = NULL_err;`
		336	`e = init_empty(t2, cv_none, 1, &err);`
		337	`if (!IS_NULL_err(err))report(crt_loc, err);`
		338	`} else {`
		339	`e = make_cast_exp(t2, a, 0);`
		340	`}`
		341	`break;`
2	7u83	342	`}`
7	7u83	343	`case lex_if:`
		344	`case lex_do:`
		345	`case lex_for:`
		346	`case lex_while:`
		347	`case lex_cond_Hop: {`
		348	`/* Dummy conditional operators */`
		349	`EXP b = NULL_exp;`
		350	`e = check_cond(a, &b, op);`
		351	`break;`
2	7u83	352	`}`
7	7u83	353	`case lex_switch: {`
		354	`/* Dummy control operator */`
		355	`EXP b = NULL_exp;`
		356	`EXP c = NULL_exp;`
		357	`e = check_control(a, &b, &c);`
		358	`break;`
2	7u83	359	`}`
7	7u83	360	`case lex_fall:`
		361	`case lex_return: {`
		362	`/* Dummy return operator */`
		363	`IDENTIFIER lab = NULL_id;`
		364	`e = find_return_exp(a, &lab, op);`
		365	`break;`
2	7u83	366	`}`
7	7u83	367	`case lex_discard:`
		368	`/* Dummy expression statement operator */`
		369	`e = make_exp_stmt(a);`
		370	`break;`
		371	`case lex_void:`
		372	`/* Dummy discard operator */`
		373	`e = make_discard_exp(a);`
		374	`break;`
		375	`case lex_question:`
		376	`/* Dummy identity operator */`
		377	`e = a;`
		378	`break;`
2	7u83	379	`#if LANGUAGE_CPP`
7	7u83	380	`case lex_delete:`
		381	`/* Construct 'delete a' */`
		382	`e = make_delete_exp(lex_delete, 0, a);`
		383	`break;`
		384	`case lex_delete_Hfull:`
		385	`/* Construct '::delete a' */`
		386	`e = make_delete_exp(lex_delete, 1, a);`
		387	`break;`
		388	`case lex_delete_Harray:`
		389	`/* Construct 'delete [] a' */`
		390	`e = make_delete_exp(lex_delete_Harray, 0, a);`
		391	`break;`
		392	`case lex_delete_Harray_Hfull:`
		393	`/* Construct '::delete [] a' */`
		394	`e = make_delete_exp(lex_delete_Harray, 1, a);`
		395	`break;`
		396	`case lex_compute:`
		397	`/* Construct empty new-initialiser */`
		398	`e = make_new_init(t2, NULL_list(EXP), 0);`
		399	`break;`
		400	`case lex_typeid:`
		401	`case lex_vtable:`
		402	`/* Construct 'typeid ( a )' */`
		403	`suppress_usage++;`
		404	`e = make_typeid_exp(op, a, 0);`
		405	`suppress_usage--;`
		406	`break;`
		407	`case lex_static_Hcast:`
		408	`case lex_reinterpret_Hcast:`
		409	`case lex_const_Hcast:`
		410	`case lex_dynamic_Hcast:`
		411	`/* Construct 'op < t2 > ( a )' */`
		412	`e = make_new_cast_exp(op, t2, a, 0);`
		413	`break;`
2	7u83	414	`#endif`
7	7u83	415	`default:`
		416	`/* Illegal operations */`
		417	`FAIL(Unexpected unary operation);`
		418	`e = make_error_exp(0);`
		419	`break;`
2	7u83	420	`}`
7	7u83	421	`suppress_quality--;`
		422	`return (e);`
2	7u83	423	`}`
		424
		425
		426	`/*`
		427	`APPLY A BINARY OPERATOR`
		428
		429	`This routine applies the binary operator op to the arguments a and b.`
		430	`*/`
		431
7	7u83	432	`EXP`
		433	`apply_binary(int op, EXP a, EXP b, TYPE t1, TYPE t2, int cpy)`
2	7u83	434	`{`
7	7u83	435	`EXP e;`
		436	`if (cpy) {`
		437	`/* Copy arguments if necessary */`
		438	`a = copy_exp(a, t1, t2);`
		439	`b = copy_exp(b, t1, t2);`
2	7u83	440	`}`
7	7u83	441	`suppress_quality++;`
		442	`switch (op) {`
		443	`case lex_and_H1:`
		444	`/* Construct 'a & b' */`
		445	`e = make_and_exp(a, b);`
		446	`break;`
		447	`case lex_and_Heq_H1:`
		448	`case lex_div_Heq:`
		449	`case lex_lshift_Heq:`
		450	`case lex_minus_Heq:`
		451	`case lex_or_Heq_H1:`
		452	`case lex_plus_Heq:`
		453	`case lex_rem_Heq:`
		454	`case lex_rshift_Heq:`
		455	`case lex_star_Heq:`
		456	`case lex_xor_Heq_H1:`
		457	`/* Construct 'a &= b', 'a /= b' etc. */`
		458	`e = make_become_exp(op, a, b);`
		459	`break;`
		460	`case lex_array_Hop:`
		461	`/* Construct 'a [b]' */`
		462	`e = make_index_exp(a, b);`
		463	`break;`
		464	`case lex_arrow:`
		465	`case lex_dot:`
		466	`/* Construct 'a->b' and 'a.b' */`
		467	`e = make_field_exp(op, a, b);`
		468	`break;`
		469	`case lex_assign:`
		470	`/* Construct 'a = b' */`
		471	`e = make_assign_exp(a, b, LANGUAGE_C);`
		472	`break;`
		473	`case lex_comma: {`
		474	`/* Construct 'a, b' */`
		475	`LIST(EXP) p = NULL_list(EXP);`
		476	`CONS_exp(b, p, p);`
		477	`CONS_exp(a, p, p);`
		478	`e = make_comma_exp(p);`
		479	`break;`
2	7u83	480	`}`
7	7u83	481	`case lex_eq:`
		482	`case lex_not_Heq_H1:`
		483	`/* Construct 'a == b' and 'a != b' */`
		484	`e = make_equality_exp(op, a, b);`
		485	`break;`
		486	`case lex_greater:`
		487	`case lex_greater_Heq:`
		488	`case lex_less:`
		489	`case lex_less_Heq:`
		490	`/* Construct 'a > b', 'a >= b', 'a < b' and 'a <= b' */`
		491	`e = make_relation_exp(op, a, b);`
		492	`break;`
		493	`case lex_logical_Hand_H1:`
		494	`/* Construct 'a && b' */`
		495	`e = make_log_and_exp(a, b);`
		496	`break;`
		497	`case lex_logical_Hor_H1:`
		498	`/* Construct 'a \|\| b' */`
		499	`e = make_log_or_exp(a, b);`
		500	`break;`
		501	`case lex_lshift:`
		502	`case lex_rshift:`
		503	`/* Construct 'a << b' and 'a >> b' */`
		504	`e = make_shift_exp(op, a, b);`
		505	`break;`
		506	`case lex_minus:`
		507	`/* Construct 'a - b' */`
		508	`e = make_minus_exp(a, b);`
		509	`break;`
		510	`case lex_plus:`
		511	`/* Construct 'a + b' */`
		512	`e = make_plus_exp(a, b);`
		513	`break;`
		514	`case lex_plus_Hplus:`
		515	`case lex_minus_Hminus:`
		516	`/* Construct 'a++' and 'a--' */`
		517	`e = make_postfix_exp(op, a);`
		518	`break;`
		519	`case lex_or_H1:`
		520	`/* Construct 'a \| b' */`
		521	`e = make_or_exp(a, b);`
		522	`break;`
		523	`case lex_rem:`
		524	`/* Construct 'a % b' */`
		525	`e = make_rem_exp(a, b);`
		526	`break;`
		527	`case lex_star:`
		528	`case lex_div:`
		529	`case lex_max:`
		530	`case lex_min:`
		531	`/* Construct 'a * b' and 'a / b' */`
		532	`e = make_mult_exp(op, a, b);`
		533	`break;`
		534	`case lex_xor_H1:`
		535	`/* Construct 'a ^ b' */`
		536	`e = make_xor_exp(a, b);`
		537	`break;`
		538	`case lex_colon:`
		539	`/* Construct 'NULL_exp ? a : b' */`
		540	`e = make_cond_exp(NULL_exp, a, b);`
		541	`break;`
2	7u83	542	`#if LANGUAGE_CPP`
7	7u83	543	`case lex_arrow_Hstar:`
		544	`case lex_dot_Hstar:`
		545	`/* Construct 'a->b' and 'a.b' */`
		546	`e = make_member_exp(op, a, b);`
		547	`break;`
2	7u83	548	`#endif`
7	7u83	549	`default:`
		550	`/* Illegal operations */`
		551	`FAIL(Unexpected binary operation);`
		552	`e = make_error_exp(0);`
		553	`break;`
2	7u83	554	`}`
7	7u83	555	`suppress_quality--;`
		556	`return (e);`
2	7u83	557	`}`
		558
		559
		560	`/*`
		561	`APPLY AN N-ARY OPERATOR`
		562
		563	`This routine applies the n-ary operator op to the arguments p. The`
		564	`type t2 gives the destination for any cast operator.`
		565	`*/`
		566
7	7u83	567	`EXP`
		568	`apply_nary(int op, LIST(EXP)p, TYPE t1, TYPE t2, int cpy)`
2	7u83	569	`{`
7	7u83	570	`EXP e;`
		571	`suppress_quality++;`
		572	`switch (op) {`
		573	`case lex_comma: {`
		574	`/* Construct 'p0, p1, ..., pn' */`
		575	`if (cpy) {`
		576	`p = copy_exp_list(p, t1, t2);`
		577	`}`
		578	`e = make_comma_exp(p);`
		579	`break;`
2	7u83	580	`}`
7	7u83	581	`case lex_cond_Hop: {`
		582	`/* Construct 'p0 ? p1 : p2' */`
		583	`EXP c, a, b;`
		584	`c = DEREF_exp(HEAD_list(p));`
		585	`p = TAIL_list(p);`
		586	`a = DEREF_exp(HEAD_list(p));`
		587	`p = TAIL_list(p);`
		588	`b = DEREF_exp(HEAD_list(p));`
		589	`if (cpy) {`
		590	`c = copy_exp(c, type_bool, type_bool);`
		591	`a = copy_exp(a, t1, t2);`
		592	`b = copy_exp(b, t1, t2);`
		593	`}`
		594	`e = make_cond_exp(c, a, b);`
		595	`break;`
2	7u83	596	`}`
7	7u83	597	`case lex_func_Hop: {`
		598	`/* Construct 'p0 ( p1, ..., pn )' */`
		599	`EXP a = DEREF_exp(HEAD_list(p));`
		600	`p = TAIL_list(p);`
		601	`if (cpy) {`
		602	`a = copy_func_exp(a, t1, t2);`
		603	`p = copy_exp_list(p, t1, t2);`
		604	`}`
		605	`e = make_func_exp(a, p, 1);`
		606	`break;`
2	7u83	607	`}`
7	7u83	608	`case lex_cast:`
		609	`/* Construct 't2 ( p0, ..., pn )' */`
		610	`if (cpy) {`
		611	`p = copy_exp_list(p, t1, t2);`
		612	`}`
		613	`e = make_func_cast_exp(t2, p);`
		614	`break;`
		615	`case lex_static_Hcast: {`
		616	`/* Construct 't2 ( p0, ..., pn )' */`
		617	`ERROR err = NULL_err;`
		618	`if (cpy) {`
		619	`p = copy_exp_list(p, t1, t2);`
		620	`}`
		621	`p = convert_args(p);`
		622	`e = convert_constr(t2, p, &err, CAST_STATIC);`
		623	`if (!IS_NULL_err(err)) {`
		624	`report(crt_loc, err);`
		625	`}`
		626	`break;`
2	7u83	627	`}`
		628	`#if LANGUAGE_CPP`
7	7u83	629	`case lex_new:`
		630	`case lex_new_Hfull: {`
		631	`/* Construct 'new ( p3, ..., pn ) ( t0 [ p1 ] ) ( p2 )' */`
		632	`EXP a;`
		633	`TYPE s;`
		634	`int b = 0;`
		635	`if (op == lex_new_Hfull) {`
		636	`b = 1;`
		637	`}`
		638	`if (cpy) {`
		639	`p = copy_exp_list(p, t1, t2);`
		640	`}`
		641	`a = DEREF_exp(HEAD_list(p));`
		642	`p = TAIL_list(p);`
		643	`s = DEREF_type(exp_type(a));`
		644	`a = DEREF_exp(HEAD_list(p));`
		645	`p = TAIL_list(p);`
		646	`if (!IS_NULL_exp(a)) {`
		647	`/* Array dimension */`
		648	`NAT n;`
		649	`MAKE_nat_calc(a, n);`
		650	`MAKE_type_array(cv_none, s, n, s);`
		651	`}`
		652	`a = DEREF_exp(HEAD_list(p));`
		653	`p = TAIL_list(p);`
		654	`e = make_new_exp(s, 0, b, p, a);`
		655	`break;`
2	7u83	656	`}`
7	7u83	657	`case lex_compute:`
		658	`/* Construct new-initialiser, '( p0, ..., pn )' */`
		659	`if (cpy) {`
		660	`p = copy_exp_list(p, t1, t2);`
		661	`}`
		662	`e = make_new_init(t2, p, 1);`
		663	`break;`
2	7u83	664	`#endif`
7	7u83	665	`default:`
		666	`/* Illegal operations */`
		667	`FAIL(Unexpected nary operation);`
		668	`e = make_error_exp(0);`
		669	`break;`
2	7u83	670	`}`
7	7u83	671	`suppress_quality--;`
		672	`return (e);`
2	7u83	673	`}`
		674
		675
		676	`/*`
		677	`CONVERT AN OPERAND TO A BUILT-IN OPERATOR`
		678
		679	`This routine converts the nth operand a to the built-in operator op`
		680	`to type t.`
		681	`*/`
		682
7	7u83	683	`static EXP`
		684	`convert_builtin(TYPE t, EXP a, int op, unsigned n)`
2	7u83	685	`{`
7	7u83	686	`ERROR err = NULL_err;`
		687	`if (IS_type_compound(t)) {`
		688	`a = convert_class(t, a, &err);`
		689	`} else {`
		690	`a = init_assign(t, cv_none, a, &err);`
		691	`}`
		692	`if (!IS_NULL_err(err)) {`
		693	`err = init_error(err, 0);`
		694	`err = concat_error(err, ERR_expr_convert_op(n, op));`
		695	`report(crt_loc, err);`
		696	`}`
		697	`return (a);`
2	7u83	698	`}`
		699
		700
		701	`/*`
		702	`APPLY A BUILT-IN OPERATOR`
		703
		704	`This routine applies the built-in operator id to the arguments args.`
		705	`*/`
		706
7	7u83	707	`EXP`
		708	`apply_builtin(IDENTIFIER id, LIST(EXP) args)`
2	7u83	709	`{`
7	7u83	710	`EXP e;`
		711	`TYPE t;`
		712	`int op;`
		713	`EXP a, b;`
		714	`HASHID nm = DEREF_hashid(id_name(id));`
		715	`LIST(TYPE) ts = DEREF_list(id_builtin_ptypes(id));`
2	7u83	716
7	7u83	717	`/* Find operator */`
		718	`if (IS_hashid_op(nm)) {`
		719	`op = DEREF_int(hashid_op_lex(nm));`
		720	`} else {`
		721	`op = lex_func_Hop;`
		722	`}`
2	7u83	723
7	7u83	724	`/* Shouldn't have no arguments */`
		725	`if (IS_NULL_list(args)) {`
		726	`e = make_error_exp(0);`
		727	`return (e);`
		728	`}`
2	7u83	729
7	7u83	730	`/* Convert first argument */`
		731	`DESTROY_CONS_exp(destroy, a, args, args);`
		732	`t = DEREF_type(HEAD_list(ts));`
		733	`a = convert_builtin(t, a, op,(unsigned)1);`
2	7u83	734
7	7u83	735	`/* Allow for 'operator ()' */`
		736	`if (op == lex_func_Hop) {`
		737	`overload_depth++;`
		738	`e = make_func_exp(a, args, 0);`
		739	`overload_depth--;`
		740	`return (e);`
		741	`}`
2	7u83	742
7	7u83	743	`/* Allow for unary operators */`
		744	`if (IS_NULL_list(args)) {`
		745	`overload_depth++;`
		746	`e = apply_unary(op, a, NULL_type, NULL_type, 0);`
		747	`overload_depth--;`
		748	`return (e);`
		749	`}`
2	7u83	750
7	7u83	751	`/* Convert second argument */`
		752	`DESTROY_CONS_exp(destroy, b, args, args);`
		753	`t = DEREF_type(HEAD_list(TAIL_list(ts)));`
		754	`b = convert_builtin(t, b, op,(unsigned)1);`
2	7u83	755
7	7u83	756	`/* Allow for binary operators */`
		757	`if (IS_NULL_list(args)) {`
		758	`overload_depth++;`
		759	`e = apply_binary(op, a, b, NULL_type, NULL_type, 0);`
		760	`overload_depth--;`
		761	`return (e);`
		762	`}`
2	7u83	763
7	7u83	764	`/* Shouldn't have more than two arguments */`
		765	`DESTROY_list(args, SIZE_exp);`
		766	`e = make_error_exp(0);`
		767	`return (e);`
2	7u83	768	`}`
		769
		770
		771	`/*`
		772	`OVERLOAD DEPTH FLAG`
		773
		774	`This flag is used to keep track of the depth of overloaded operator`
		775	`resolutions.`
		776	`*/`
		777
7	7u83	778	`int overload_depth = 0;`
		779	`int overload_warn = 1;`
2	7u83	780
		781
		782	`/*`
		783	`OPERATOR OVERLOADING ROUTINES`
		784
		785	`The operator overloading routines are only included in the C++`
		786	`producer.`
		787	`*/`
		788
		789	`#if LANGUAGE_CPP`
		790
		791
		792	`/*`
		793	`CHECK AN OVERLOADED OPERATOR TYPE`
		794
		795	`This routine checks the function type t for the overloaded operator id.`
		796	`The argument mem is true if id represents a non-static member function.`
		797	`Most operators have restrictions on the number and types of their`
		798	`parameters, others must be member functions. Note that this routine`
		799	`only covers genuine overloading operators such as 'operator +', the`
		800	`allocation operators such as 'operator new' are handled by the routine`
		801	`check_allocator and alloc is set accordingly.`
		802	`*/`
		803
7	7u83	804	`TYPE`
		805	`check_operator(TYPE t, IDENTIFIER id, int mem, int *alloc)`
2	7u83	806	`{`
7	7u83	807	`int op;`
		808	`int ell;`
		809	`HASHID nm;`
		810	`int dargs = 0;`
		811	`unsigned n, m;`
		812	`unsigned npars;`
		813	`LIST(TYPE) ptypes;`
2	7u83	814
7	7u83	815	`/* Allow for template types */`
		816	`if (IS_type_templ(t)) {`
		817	`TYPE s = DEREF_type(type_templ_defn(t));`
		818	`s = check_operator(s, id, mem, alloc);`
		819	`COPY_type(type_templ_defn(t), s);`
		820	`return (t);`
		821	`}`
2	7u83	822
7	7u83	823	`/* Find the operator */`
		824	`nm = DEREF_hashid(id_name(id));`
		825	`op = DEREF_int(hashid_op_lex(nm));`
		826	`switch (op) {`
		827	`case lex_new:`
		828	`case lex_new_Harray:`
		829	`/* Check for allocation operators */`
		830	`*alloc = 1;`
		831	`t = check_allocator(t, id, mem, 0);`
		832	`return (t);`
		833	`case lex_delete:`
		834	`case lex_delete_Harray:`
		835	`/* Check for deallocation operators */`
		836	`*alloc = 2;`
		837	`t = check_allocator(t, id, mem, 0);`
		838	`return (t);`
		839	`default:`
		840	`*alloc = 0;`
		841	`break;`
2	7u83	842	`}`
7	7u83	843
		844	`/* Decompose function type */`
		845	`ptypes = DEREF_list(type_func_ptypes(t));`
		846	`npars = LENGTH_list(ptypes);`
		847	`ell = DEREF_int(type_func_ellipsis(t));`
		848	`if (ell) {`
		849	`/* Set number of parameters to dummy large value */`
		850	`npars = 10000;`
2	7u83	851	`}`
		852
7	7u83	853	`/* Check function arguments */`
		854	`if (mem) {`
		855	`/* Member functions have implicit extra parameter */`
		856	`npars++;`
		857	`n = 0;`
		858	`m = 1;`
		859	`} else {`
		860	`/* Should have an overloadable parameter */`
		861	`LIST(TYPE) p = ptypes;`
		862	`while (!IS_NULL_list(p)) {`
		863	`TYPE a = DEREF_type(HEAD_list(p));`
		864	`unsigned ca = type_category(&a);`
		865	`if (IS_TYPE_OVERLOAD(ca)) {`
		866	`break;`
		867	`}`
		868	`p = TAIL_list(p);`
		869	`}`
		870	`if (IS_NULL_list(p)) {`
		871	`report(crt_loc, ERR_over_oper_type(nm));`
		872	`}`
		873	`n = 1;`
		874	`m = 2;`
2	7u83	875	`}`
		876
7	7u83	877	`/* Check number of arguments */`
		878	`switch (op) {`
		879	`case lex_compl_H1:`
		880	`case lex_not_H1:`
		881	`case lex_abs:`
		882	`case lex_alignof:`
		883	`case lex_sizeof:`
		884	`case lex_typeid:`
		885	`case lex_vtable:`
		886	`/* Unary operators */`
		887	`if (npars != 1) {`
		888	`ERROR err = ERR_over_unary_pars(nm, n, n);`
		889	`report(crt_loc, err);`
2	7u83	890	`}`
7	7u83	891	`break;`
		892	`case lex_plus:`
		893	`case lex_minus:`
		894	`case lex_star:`
		895	`case lex_and_H1:`
		896	`/* Either unary or binary operators */`
		897	`if (npars != 1 && npars != 2) {`
		898	`ERROR err = ERR_over_binary_pars_p1(nm, n, m, m);`
		899	`report(crt_loc, err);`
		900	`}`
		901	`break;`
		902	`default:`
		903	`/* Binary operators */`
		904	`if (npars != 2) {`
		905	`ERROR err = ERR_over_binary_pars_p2(nm, m, m);`
		906	`report(crt_loc, err);`
		907	`}`
		908	`break;`
		909	`case lex_assign:`
		910	`/* Assignment */`
		911	`if (!mem) {`
		912	`report(crt_loc, ERR_over_ass_mem(nm));`
		913	`}`
		914	`if (npars != 2) {`
		915	`ERROR err = ERR_over_ass_pars(nm, m, m);`
		916	`report(crt_loc, err);`
		917	`}`
		918	`break;`
		919	`case lex_func_Hop:`
		920	`/* Function call (can have default arguments) */`
		921	`if (!mem) {`
		922	`report(crt_loc, ERR_over_call_mem(nm));`
		923	`}`
		924	`dargs = 1;`
		925	`break;`
		926	`case lex_array_Hop:`
		927	`/* Subscripting */`
		928	`if (!mem) {`
		929	`report(crt_loc, ERR_over_sub_mem(nm));`
		930	`}`
		931	`if (npars != 2) {`
		932	`ERROR err = ERR_over_sub_pars(nm, m, m);`
		933	`report(crt_loc, err);`
		934	`}`
		935	`break;`
		936	`case lex_arrow:`
		937	`/* Class member access */`
		938	`if (!mem) {`
		939	`report(crt_loc, ERR_over_ref_mem(nm));`
		940	`}`
		941	`if (npars != 1) {`
		942	`ERROR err = ERR_over_ref_pars(nm, n, n);`
		943	`report(crt_loc, err);`
		944	`}`
		945	`break;`
		946	`case lex_plus_Hplus:`
		947	`case lex_minus_Hminus:`
		948	`/* Increment and decrement */`
		949	`if (npars == 1) {`
		950	`/* One argument form is fine */`
		951	`/* EMPTY */`
		952	`} else if (npars == 2) {`
		953	`/* Two argument form needs checking */`
		954	`TYPE a;`
		955	`TYPE b = type_sint;`
		956	`LIST(TYPE) p = ptypes;`
		957	`if (!mem) {`
		958	`p = TAIL_list(p);`
		959	`}`
		960	`a = DEREF_type(HEAD_list(p));`
		961	`if (!eq_type_unqual(a, b) && !is_templ_type(a)) {`
		962	`/* Second argument should be 'int' */`
		963	`report(crt_loc, ERR_over_inc_pars_p2(nm, b));`
		964	`}`
		965	`} else {`
		966	`/* Anything else is illegal */`
		967	`ERROR err = ERR_over_inc_pars(nm, n, m, m);`
		968	`report(crt_loc, err);`
		969	`}`
		970	`break;`
		971	`case lex_cond_Hop:`
		972	`/* Tertiary operators */`
		973	`if (npars != 3) {`
		974	`unsigned p = n + 2;`
		975	`ERROR err = ERR_over_binary_pars_p2(nm, p, p);`
		976	`report(crt_loc, err);`
		977	`}`
		978	`break;`
2	7u83	979	`}`
7	7u83	980
		981	`/* Check for default arguments */`
		982	`if (!dargs && check_func_dargs(t, 0, 0)) {`
		983	`report(crt_loc, ERR_over_oper_default(nm));`
2	7u83	984	`}`
7	7u83	985	`return (t);`
2	7u83	986	`}`
		987
		988
		989	`/*`
		990	`LISTS OF BUILT-IN OPERATORS`
		991
		992	`These values are used in the allocation and deallocation of built-in`
		993	`operators.`
		994	`*/`
		995
7	7u83	996	`static IDENTIFIER unary_free = NULL_id;`
		997	`static IDENTIFIER unary_all = NULL_id;`
		998	`static IDENTIFIER binary_free = NULL_id;`
		999	`static IDENTIFIER binary_all = NULL_id;`
		1000	`static IDENTIFIER nary_free = NULL_id;`
		1001	`static IDENTIFIER nary_all = NULL_id;`
2	7u83	1002
		1003
		1004	`/*`
		1005	`CONSTRUCT A BUILT-IN UNARY OPERATOR`
		1006
		1007	`This routine constructs the built-in unary operator 'r nm ( a )'.`
		1008	`*/`
		1009
7	7u83	1010	`static IDENTIFIER`
		1011	`unary_builtin(HASHID nm, TYPE a, TYPE r)`
2	7u83	1012	`{`
7	7u83	1013	`LIST(TYPE) p;`
		1014	`IDENTIFIER id = unary_free;`
		1015	`if (IS_NULL_id(id)) {`
		1016	`/* Allocate new identifier */`
		1017	`NAMESPACE ns = NULL_nspace;`
		1018	`CONS_type(a, NULL_list(TYPE), p);`
		1019	`MAKE_id_builtin(nm, dspec_none, ns, builtin_loc, r, p, id);`
		1020	`COPY_id(id_alias(id), unary_all);`
		1021	`unary_all = id;`
		1022	`} else {`
		1023	`/* Use existing identifier */`
		1024	`COPY_hashid(id_name(id), nm);`
		1025	`COPY_ulong(id_dump(id), LINK_NONE);`
		1026	`COPY_type(id_builtin_ret(id), r);`
		1027	`p = DEREF_list(id_builtin_ptypes(id));`
		1028	`COPY_type(HEAD_list(p), a);`
		1029	`unary_free = DEREF_id(id_alias(id));`
		1030	`}`
		1031	`return (id);`
2	7u83	1032	`}`
		1033
		1034
		1035	`/*`
		1036	`CONSTRUCT A BUILT-IN BINARY OPERATOR`
		1037
		1038	`This routine constructs the built-in binary operator 'r nm ( a, b )'.`
		1039	`*/`
		1040
7	7u83	1041	`static IDENTIFIER`
		1042	`binary_builtin(HASHID nm, TYPE a, TYPE b, TYPE r)`
2	7u83	1043	`{`
7	7u83	1044	`LIST(TYPE) p;`
		1045	`IDENTIFIER id = binary_free;`
		1046	`if (IS_NULL_id(id)) {`
		1047	`/* Allocate new identifier */`
		1048	`NAMESPACE ns = NULL_nspace;`
		1049	`CONS_type(b, NULL_list(TYPE), p);`
		1050	`CONS_type(a, p, p);`
		1051	`MAKE_id_builtin(nm, dspec_none, ns, builtin_loc, r, p, id);`
		1052	`COPY_id(id_alias(id), binary_all);`
		1053	`binary_all = id;`
		1054	`} else {`
		1055	`/* Use existing identifier */`
		1056	`COPY_hashid(id_name(id), nm);`
		1057	`COPY_ulong(id_dump(id), LINK_NONE);`
		1058	`COPY_type(id_builtin_ret(id), r);`
		1059	`p = DEREF_list(id_builtin_ptypes(id));`
		1060	`COPY_type(HEAD_list(p), a);`
		1061	`p = TAIL_list(p);`
		1062	`COPY_type(HEAD_list(p), b);`
		1063	`binary_free = DEREF_id(id_alias(id));`
		1064	`}`
		1065	`return (id);`
2	7u83	1066	`}`
		1067
		1068
		1069	`/*`
		1070	`CONSTRUCT A BUILT-IN N-ARY OPERATOR`
		1071
		1072	`This routine constructs the built-in n-ary operator 'r nm ( a, p )'.`
		1073	`*/`
		1074
7	7u83	1075	`static IDENTIFIER`
		1076	`nary_builtin(HASHID nm, TYPE a, LIST(TYPE) p, TYPE r)`
2	7u83	1077	`{`
7	7u83	1078	`IDENTIFIER id = nary_free;`
		1079	`if (IS_NULL_id(id)) {`
		1080	`/* Allocate new identifier */`
		1081	`NAMESPACE ns = NULL_nspace;`
		1082	`CONS_type(a, p, p);`
		1083	`MAKE_id_builtin(nm, dspec_none, ns, builtin_loc, r, p, id);`
		1084	`COPY_id(id_alias(id), nary_all);`
		1085	`nary_all = id;`
		1086	`} else {`
		1087	`/* Use existing identifier */`
		1088	`LIST(TYPE) q;`
		1089	`COPY_hashid(id_name(id), nm);`
		1090	`COPY_ulong(id_dump(id), LINK_NONE);`
		1091	`COPY_type(id_builtin_ret(id), r);`
		1092	`q = DEREF_list(id_builtin_ptypes(id));`
		1093	`COPY_type(HEAD_list(q), a);`
		1094	`COPY_list(PTR_TAIL_list(q), p);`
		1095	`nary_free = DEREF_id(id_alias(id));`
		1096	`}`
		1097	`return (id);`
2	7u83	1098	`}`
		1099
		1100
		1101	`/*`
		1102	`CONSTRUCT OVERLOADED OPERATION CANDIDATE LIST`
		1103
		1104	`This routine constructs the candidate list for the overloaded n-ary`
		1105	`operation op, adding the result to p. The candidates come from the`
		1106	`current namespace and the type t, if this is a class. The routine`
		1107	`returns the hash table entry for 'operator op'.`
		1108	`*/`
		1109
7	7u83	1110	`static HASHID`
		1111	`overload_candidates(CANDIDATE_LIST *p, int op, TYPE t, TYPE s)`
2	7u83	1112	`{`
7	7u83	1113	`/* Look up 'operator op' (non-standard) */`
		1114	`HASHID nm = lookup_op(op);`
		1115	`switch (op) {`
		1116	`case lex_assign:`
		1117	`case lex_func_Hop:`
		1118	`case lex_array_Hop:`
		1119	`case lex_arrow:`
		1120	`/* These can only be member functions */`
		1121	`break;`
		1122	`default: {`
		1123	`/* These can be non-member functions */`
		1124	`IDENTIFIER id = find_op_id(nm);`
		1125	`if (!IS_NULL_type(s)) {`
		1126	`IGNORE koenig_candidates(p, id, s, KIND_OP);`
		1127	`}`
		1128	`IGNORE koenig_candidates(p, id, t, KIND_OP);`
		1129	`if (!IS_id_dummy(id)) {`
		1130	`/* Function declared */`
		1131	`add_candidates(p, id, 1, KIND_OP);`
		1132	`}`
		1133	`break;`
2	7u83	1134	`}`
		1135	`}`
		1136
7	7u83	1137	`/* Look up 't::operator op' */`
		1138	`if (IS_type_compound(t)) {`
		1139	`CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));`
		1140	`NAMESPACE ns = DEREF_nspace(ctype_member(ct));`
		1141	`IDENTIFIER id = search_field(ns, nm, 0, 0);`
		1142	`if (!IS_NULL_id(id)) {`
		1143	`if (IS_id_ambig(id)) {`
		1144	`/* Ambiguous look-up */`
		1145	`IGNORE report_ambiguous(id, 0, 1, 0);`
		1146	`}`
		1147	`add_candidates(p, id, 1, KIND_MEM_OP);`
		1148	`}`
2	7u83	1149	`}`
7	7u83	1150	`return (nm);`
2	7u83	1151	`}`
		1152
		1153
		1154	`/*`
		1155	`CONSTRUCT LIST OF INTEGRAL TYPES`
		1156
		1157	`This routine adds all the promoted integral types to the list res.`
		1158	`*/`
		1159
7	7u83	1160	`static LIST(TYPE)`
		1161	`add_int_types(LIST(TYPE) res)`
2	7u83	1162	`{`
7	7u83	1163	`if (basetype_info[ntype_sllong].key) {`
		1164	`res = cons_type_set(res, type_ullong);`
		1165	`res = cons_type_set(res, type_sllong);`
		1166	`}`
		1167	`res = cons_type_set(res, type_ulong);`
		1168	`res = cons_type_set(res, type_slong);`
		1169	`res = cons_type_set(res, type_uint);`
		1170	`res = cons_type_set(res, type_sint);`
		1171	`return (res);`
2	7u83	1172	`}`
		1173
		1174
		1175	`/*`
		1176	`CONSTRUCT LIST OF FLOATING POINT TYPES`
		1177
		1178	`This routine adds all the floating point types to the list res.`
		1179	`*/`
		1180
7	7u83	1181	`static LIST(TYPE)`
		1182	`add_float_types(LIST(TYPE) res)`
2	7u83	1183	`{`
7	7u83	1184	`res = cons_type_set(res, type_ldouble);`
		1185	`res = cons_type_set(res, type_double);`
		1186	`res = cons_type_set(res, type_float);`
		1187	`return (res);`
2	7u83	1188	`}`
		1189
		1190
		1191	`/*`
		1192	`CONSTRUCT A LIST OF CONVERSION TYPES`
		1193
		1194	`This routine constructs a list of types consisting of all the types`
		1195	`of a certain kind to which the type t can be converted. Conversions`
		1196	`which are worse that existing conversions are omitted. The type kind`
		1197	`is indicated by the CTYPE macros defined in chktype.h, except that`
		1198	`CTYPE_INTEGER refers to promoted integer types unless qualified using`
		1199	`CTYPE_LVALUE.`
		1200	`*/`
		1201
7	7u83	1202	`static LIST(TYPE)`
		1203	`find_type_convs(TYPE t, EXP a, unsigned kind)`
2	7u83	1204	`{`
7	7u83	1205	`LIST(TYPE) res = NULL_list(TYPE);`
		1206	`unsigned nt = TAG_type(t);`
		1207	`switch (nt) {`
		1208	`case type_compound_tag: {`
		1209	`/* Class types */`
		1210	`LIST(IDENTIFIER) conv;`
		1211	`CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));`
		1212	`complete_class(ct, 1);`
		1213	`conv = DEREF_list(ctype_conv(ct));`
		1214	`for (; !IS_NULL_list(conv); conv = TAIL_list(conv)) {`
		1215	`/* Scan through conversion operations */`
		1216	`TYPE r;`
		1217	`HASHID nm;`
		1218	`unsigned nr;`
		1219	`IDENTIFIER id = DEREF_id(HEAD_list(conv));`
		1220	`DECL_SPEC ds = DEREF_dspec(id_storage(id));`
		1221	`if (ds & dspec_explicit) {`
		1222	`continue;`
		1223	`}`
2	7u83	1224
7	7u83	1225	`/* Check for reference types */`
		1226	`nm = DEREF_hashid(id_name(id));`
		1227	`r = DEREF_type(hashid_conv_type(nm));`
		1228	`if (kind == CTYPE_NONE) {`
		1229	`/* Include all types in this case */`
		1230	`res = cons_type_set(res, r);`
		1231	`continue;`
		1232	`}`
		1233	`nr = TAG_type(r);`
		1234	`if (nr == type_ref_tag) {`
		1235	`/* Allow for reference bindings */`
		1236	`if (IS_TYPE_LVALUE(kind)) {`
		1237	`TYPE s = DEREF_type(type_ref_sub(r));`
		1238	`CV_SPEC cv = find_cv_qual(s);`
		1239	`if (!(cv & cv_const)) {`
		1240	`/* Don't include const`
		1241	`* references */`
		1242	`unsigned ns = TAG_type(s);`
		1243	`switch (ns) {`
		1244	`case type_integer_tag:`
		1245	`case type_bitfield_tag:`
		1246	`case type_enumerate_tag:`
		1247	`if (IS_TYPE_INTEGER(kind)) {`
		1248	`res = cons_type_set(res, r);`
		1249	`}`
		1250	`break;`
		1251	`case type_floating_tag:`
		1252	`if (IS_TYPE_FLOAT(kind)) {`
		1253	`res = cons_type_set(res, r);`
		1254	`}`
		1255	`break;`
		1256	`case type_ptr_tag:`
		1257	`if (IS_TYPE_PTR(kind)) {`
		1258	`res = cons_type_set(res, r);`
		1259	`}`
		1260	`break;`
		1261	`case type_ptr_mem_tag:`
		1262	`if (IS_TYPE_PTR_MEM(kind)) {`
		1263	`res = cons_type_set(res, r);`
		1264	`}`
		1265	`break;`
		1266	`}`
		1267	`}`
		1268	`} else {`
		1269	`/* Allow for reference conversions */`
		1270	`r = DEREF_type(type_ref_sub(r));`
		1271	`nr = TAG_type(r);`
2	7u83	1272	`}`
7	7u83	1273	`}`
		1274
		1275	`/* Check return type */`
		1276	`switch (nr) {`
		1277	`case type_integer_tag:`
		1278	`case type_bitfield_tag:`
		1279	`case type_enumerate_tag:`
		1280	`/* Integral types */`
		1281	`if (IS_TYPE_INTEGER(kind)) {`
		1282	`/* Means promoted integer type */`
		1283	`TYPE s = promote_type(r);`
		1284	`res = cons_type_set(res, s);`
		1285	`} else if (IS_TYPE_FLOAT(kind)) {`
		1286	`/* Can convert to any floating type */`
		1287	`res = add_float_types(res);`
2	7u83	1288	`}`
7	7u83	1289	`break;`
		1290	`case type_floating_tag:`
		1291	`/* Floating point types */`
		1292	`if (IS_TYPE_FLOAT(kind)) {`
		1293	`res = cons_type_set(res, r);`
		1294	`} else if (IS_TYPE_INTEGER(kind)) {`
		1295	`/* Can convert to any promoted integer`
		1296	`* type */`
		1297	`res = add_int_types(res);`
2	7u83	1298	`}`
7	7u83	1299	`break;`
		1300	`case type_ptr_tag:`
		1301	`/* Pointer types */`
		1302	`if (IS_TYPE_PTR(kind)) {`
		1303	`res = cons_type_set(res, r);`
2	7u83	1304	`}`
7	7u83	1305	`break;`
		1306	`case type_ptr_mem_tag:`
		1307	`/* Pointer to member types */`
		1308	`if (IS_TYPE_PTR_MEM(kind)) {`
		1309	`res = cons_type_set(res, r);`
		1310	`}`
		1311	`break;`
2	7u83	1312	`}`
		1313	`}`
7	7u83	1314	`res = REVERSE_list(res);`
		1315	`break;`
		1316	`}`
		1317	`case type_integer_tag:`
		1318	`case type_bitfield_tag:`
		1319	`case type_enumerate_tag:`
		1320	`/* Integral types */`
		1321	`if (IS_TYPE_LVALUE(kind)) {`
		1322	`/* Lvalue of integral type */`
		1323	`if (IS_TYPE_INTEGER(kind)) {`
		1324	`if (nt == type_integer_tag) {`
		1325	`t = lvalue_type(t);`
		1326	`MAKE_type_ref(cv_none, t, t);`
		1327	`CONS_type(t, res, res);`
		1328	`}`
2	7u83	1329	`}`
7	7u83	1330	`} else if (IS_TYPE_INTEGER(kind)) {`
		1331	`/* Means promoted integer type */`
		1332	`TYPE s = promote_type(t);`
		1333	`CONS_type(s, res, res);`
		1334	`} else if (IS_TYPE_FLOAT(kind)) {`
		1335	`/* Can convert to any floating type */`
		1336	`res = add_float_types(res);`
		1337	`}`
		1338	`break;`
		1339	`case type_floating_tag:`
		1340	`/* Floating point types */`
		1341	`if (IS_TYPE_LVALUE(kind)) {`
		1342	`/* Lvalue of floating point type */`
		1343	`if (IS_TYPE_FLOAT(kind)) {`
		1344	`t = lvalue_type(t);`
		1345	`MAKE_type_ref(cv_none, t, t);`
		1346	`CONS_type(t, res, res);`
2	7u83	1347	`}`
7	7u83	1348	`} else if (IS_TYPE_FLOAT(kind)) {`
		1349	`/* Floating point type */`
		1350	`CONS_type(t, res, res);`
		1351	`} else if (IS_TYPE_INTEGER(kind)) {`
		1352	`/* Can convert to any promoted integer type */`
		1353	`if (basetype_info[ntype_sllong].key) {`
		1354	`CONS_type(type_ullong, res, res);`
		1355	`CONS_type(type_sllong, res, res);`
2	7u83	1356	`}`
7	7u83	1357	`CONS_type(type_ulong, res, res);`
		1358	`CONS_type(type_slong, res, res);`
		1359	`CONS_type(type_uint, res, res);`
		1360	`CONS_type(type_sint, res, res);`
		1361	`}`
		1362	`break;`
		1363	`case type_ptr_tag:`
		1364	`/* Pointer types */`
		1365	`if (IS_TYPE_PTR(kind)) {`
		1366	`if (IS_TYPE_LVALUE(kind)) {`
		1367	`t = lvalue_type(t);`
		1368	`MAKE_type_ref(cv_none, t, t);`
2	7u83	1369	`}`
7	7u83	1370	`CONS_type(t, res, res);`
2	7u83	1371	`}`
7	7u83	1372	`break;`
		1373	`case type_ptr_mem_tag:`
		1374	`/* Pointer to member types */`
		1375	`if (IS_TYPE_PTR_MEM(kind)) {`
		1376	`if (IS_TYPE_LVALUE(kind)) {`
		1377	`t = lvalue_type(t);`
		1378	`MAKE_type_ref(cv_none, t, t);`
		1379	`}`
		1380	`CONS_type(t, res, res);`
2	7u83	1381	`}`
7	7u83	1382	`break;`
		1383	`case type_array_tag:`
		1384	`/* Allow for array-to-pointer conversion */`
		1385	`if (IS_TYPE_PTR(kind) && !IS_TYPE_LVALUE(kind)) {`
		1386	`TYPE s = DEREF_type(type_array_sub(t));`
		1387	`MAKE_type_ptr(cv_none, s, s);`
		1388	`CONS_type(s, res, res);`
2	7u83	1389	`}`
7	7u83	1390	`if (kind == CTYPE_NONE) {`
		1391	`TYPE s = DEREF_type(type_array_sub(t));`
		1392	`MAKE_type_ptr(cv_none, s, t);`
2	7u83	1393	`}`
7	7u83	1394	`break;`
		1395	`case type_func_tag:`
		1396	`/* Allow for function-to-pointer conversion */`
		1397	`if (IS_TYPE_PTR(kind) && !IS_TYPE_LVALUE(kind)) {`
		1398	`TYPE s;`
		1399	`MAKE_type_ptr(cv_none, t, s);`
		1400	`CONS_type(s, res, res);`
2	7u83	1401	`}`
7	7u83	1402	`if (kind == CTYPE_NONE) {`
		1403	`MAKE_type_ptr(cv_none, t, t);`
		1404	`}`
		1405	`break;`
2	7u83	1406	`}`
7	7u83	1407	`if (kind == CTYPE_NONE) {`
		1408	`/* Include all types in this case */`
		1409	`CV_SPEC cv = DEREF_cv(type_qual(t));`
		1410	`if (cv & cv_lvalue) {`
		1411	`/* Turn lvalues into references */`
		1412	`MAKE_type_ref(cv_none, t, t);`
2	7u83	1413	`}`
7	7u83	1414	`res = cons_type_set(res, t);`
2	7u83	1415	`}`
7	7u83	1416	`UNUSED(a);`
		1417	`return (res);`
2	7u83	1418	`}`
		1419
		1420
		1421	`/*`
		1422	`FILTER A LIST OF POINTER TYPES`
		1423
		1424	`This routine scans through the list of pointer or pointer to member`
		1425	`types pa replacing any types which are not pointers to complete object`
		1426	`types by the null type. If fn is true pointer to function types are`
		1427	`also allowed.`
		1428	`*/`
		1429
7	7u83	1430	`static void`
		1431	`filter_ptr(LIST(TYPE) pa, int fn)`
2	7u83	1432	`{`
7	7u83	1433	`while (!IS_NULL_list(pa)) {`
		1434	`TYPE ta = DEREF_type(HEAD_list(pa));`
		1435	`TYPE sa = ta;`
		1436	`if (IS_type_ref(sa)) {`
		1437	`sa = DEREF_type(type_ref_sub(sa));`
		1438	`}`
		1439	`if (IS_type_ptr(sa)) {`
		1440	`sa = DEREF_type(type_ptr_sub(sa));`
		1441	`} else {`
		1442	`sa = DEREF_type(type_ptr_mem_sub(sa));`
		1443	`}`
		1444	`switch (TAG_type(sa)) {`
		1445	`case type_array_tag: {`
		1446	`/* Check for incomplete arrays */`
		1447	`NAT n = DEREF_nat(type_array_size(sa));`
		1448	`if (IS_NULL_nat(n)) {`
		1449	`ta = NULL_type;`
		1450	`}`
		1451	`break;`
		1452	`}`
		1453	`case type_compound_tag: {`
		1454	`/* Check for incomplete classes */`
		1455	`CLASS_TYPE cs = DEREF_ctype(type_compound_defn(sa));`
		1456	`CLASS_INFO ci = DEREF_cinfo(ctype_info(cs));`
		1457	`if (!(ci & cinfo_complete)) {`
		1458	`ta = NULL_type;`
		1459	`}`
		1460	`break;`
		1461	`}`
		1462	`case type_enumerate_tag: {`
		1463	`/* Check for incomplete enumerations */`
		1464	`ENUM_TYPE es = DEREF_etype(type_enumerate_defn(sa));`
		1465	`CLASS_INFO ei = DEREF_cinfo(etype_info(es));`
		1466	`if (!(ei & cinfo_complete)) {`
		1467	`ta = NULL_type;`
		1468	`}`
		1469	`break;`
		1470	`}`
		1471	`case type_top_tag:`
		1472	`case type_bottom_tag:`
		1473	`/* These are always incomplete */`
		1474	`ta = NULL_type;`
		1475	`break;`
		1476	`case type_func_tag:`
		1477	`/* Deal with function types */`
		1478	`if (!fn) {`
		1479	`ta = NULL_type;`
		1480	`}`
		1481	`break;`
		1482	`}`
		1483	`COPY_type(HEAD_list(pa), ta);`
		1484	`pa = TAIL_list(pa);`
2	7u83	1485	`}`
7	7u83	1486	`return;`
2	7u83	1487	`}`
		1488
		1489
		1490	`/*`
		1491	`BUILT-IN OPERATOR TYPES`
		1492
		1493	`The following macros are used to describe the return types and the`
		1494	`constraints on the operand types of the built-in operators.`
		1495	`*/`
		1496
		1497	`#define RTYPE_ARG_1 0`
		1498	`#define RTYPE_ARG_2 1`
		1499	`#define RTYPE_CONT_1 2`
		1500	`#define RTYPE_CONT_2 3`
		1501	`#define RTYPE_ARITH 4`
		1502	`#define RTYPE_BOOL 5`
		1503	`#define RTYPE_PTRDIFF 6`
		1504	`#define RTYPE_OP 7`
		1505
		1506	`#define OTYPE_NONE 0`
		1507	`#define OTYPE_PTR 1`
		1508	`#define OTYPE_PTR_MEM 2`
		1509	`#define OTYPE_REF_PTR 3`
		1510	`#define OTYPE_REF_MEM 4`
		1511	`#define OTYPE_SELECT 5`
		1512	`#define OTYPE_COND 6`
		1513
		1514
		1515	`/*`
		1516	`FIND RETURN TYPE OF BUILT-IN OPERATOR`
		1517
		1518	`This routine finds the return type for a built-in operator with`
		1519	`operand types ta and tb and return descriptor rtype. tc gives the`
		1520	`default return type. The return type is not used in overload`
		1521	`resolution but is included for error reporting purposes.`
		1522	`*/`
		1523
7	7u83	1524	`static TYPE`
		1525	`find_builtin_ret(TYPE ta, TYPE tb, int rtype, TYPE tc)`
2	7u83	1526	`{`
7	7u83	1527	`switch (rtype) {`
		1528	`case RTYPE_ARG_1:`
		1529	`tc = ta;`
		1530	`break;`
		1531	`case RTYPE_ARG_2:`
		1532	`tc = tb;`
		1533	`break;`
		1534	`case RTYPE_CONT_1:`
		1535	`if (IS_type_ptr_etc(ta)) {`
		1536	`tc = DEREF_type(type_ptr_etc_sub(ta));`
		1537	`}`
		1538	`break;`
		1539	`case RTYPE_CONT_2:`
		1540	`if (IS_type_ptr_etc(tb)) {`
		1541	`tc = DEREF_type(type_ptr_etc_sub(tb));`
		1542	`}`
		1543	`break;`
		1544	`case RTYPE_ARITH:`
		1545	`tc = arith_type(ta, tb, NULL_exp, NULL_exp);`
		1546	`break;`
		1547	`case RTYPE_BOOL:`
		1548	`tc = type_bool;`
		1549	`break;`
		1550	`case RTYPE_PTRDIFF:`
		1551	`tc = type_ptrdiff_t;`
		1552	`break;`
2	7u83	1553	`}`
7	7u83	1554	`return (tc);`
2	7u83	1555	`}`
		1556
		1557
		1558	`/*`
		1559	`CHECK BUILT-IN OPERAND TYPES`
		1560
		1561	`This routine checks whether the operand types ta and tb are valid for`
		1562	`a built-in operator with operand constraints otype. In some cases`
		1563	`the return type is returned via pt.`
		1564	`*/`
		1565
7	7u83	1566	`static int`
		1567	`check_builtin_args(TYPE ta, TYPE tb, int otype, TYPE *pt)`
2	7u83	1568	`{`
7	7u83	1569	`int ok = 1;`
		1570	`switch (otype) {`
		1571	`case OTYPE_PTR: {`
		1572	`/* Allow equal pointer types */`
		1573	`TYPE sa = DEREF_type(type_ptr_sub(ta));`
		1574	`TYPE sb = DEREF_type(type_ptr_sub(tb));`
		1575	`ok = eq_type_unqual(sa, sb);`
		1576	`break;`
2	7u83	1577	`}`
7	7u83	1578	`case OTYPE_PTR_MEM: {`
		1579	`/* Allow equal pointer member types */`
		1580	`CLASS_TYPE ca = DEREF_ctype(type_ptr_mem_of(ta));`
		1581	`CLASS_TYPE cb = DEREF_ctype(type_ptr_mem_of(tb));`
		1582	`if (eq_ctype(ca, cb)) {`
		1583	`TYPE sa = DEREF_type(type_ptr_mem_sub(ta));`
		1584	`TYPE sb = DEREF_type(type_ptr_mem_sub(tb));`
		1585	`ok = eq_type_unqual(sa, sb);`
		1586	`} else {`
		1587	`ok = 0;`
		1588	`}`
		1589	`break;`
2	7u83	1590	`}`
7	7u83	1591	`case OTYPE_REF_PTR:`
		1592	`/* Allow equal pointer types */`
		1593	`if (IS_type_ref(ta)) {`
		1594	`ta = DEREF_type(type_ref_sub(ta));`
2	7u83	1595	`}`
7	7u83	1596	`return (check_builtin_args(ta, tb, OTYPE_PTR, pt));`
		1597	`case OTYPE_REF_MEM:`
		1598	`/* Allow equal pointer member types */`
		1599	`if (IS_type_ref(ta)) {`
		1600	`ta = DEREF_type(type_ref_sub(ta));`
2	7u83	1601	`}`
7	7u83	1602	`return (check_builtin_args(ta, tb, OTYPE_PTR_MEM, pt));`
		1603	`case OTYPE_SELECT: {`
		1604	`/* Allow pointer member selection */`
		1605	`TYPE sa = DEREF_type(type_ptr_sub(ta));`
		1606	`if (IS_type_compound(sa)) {`
		1607	`CLASS_TYPE ca = DEREF_ctype(type_compound_defn(sa));`
		1608	`CLASS_TYPE cb = DEREF_ctype(type_ptr_mem_of(tb));`
		1609	`GRAPH gr = find_base_class(ca, cb, 0);`
		1610	`if (IS_NULL_graph(gr))ok = 0;`
		1611	`*pt = DEREF_type(type_ptr_mem_sub(tb));`
		1612	`} else {`
		1613	`ok = 0;`
2	7u83	1614	`}`
7	7u83	1615	`break;`
2	7u83	1616	`}`
7	7u83	1617	`case OTYPE_COND: {`
		1618	`/* Allow for conditional expressions */`
		1619	`int suspect = 0;`
		1620	`TYPE r = common_type(ta, tb, &suspect);`
		1621	`if (IS_NULL_type(r)) {`
		1622	`ok = 0;`
		1623	`if (IS_type_ref(ta)) {`
		1624	`ta = DEREF_type(type_ref_sub(ta));`
		1625	`ok = 1;`
		1626	`}`
		1627	`if (IS_type_ref(tb)) {`
		1628	`tb = DEREF_type(type_ref_sub(tb));`
		1629	`ok = 1;`
		1630	`}`
		1631	`if (ok) {`
		1632	`suspect = 0;`
		1633	`r = common_type(ta, tb, &suspect);`
		1634	`if (IS_NULL_type(r)) {`
		1635	`ok = 0;`
		1636	`} else {`
		1637	`*pt = r;`
		1638	`}`
		1639	`}`
		1640	`} else {`
		1641	`*pt = r;`
		1642	`}`
		1643	`break;`
		1644	`}`
		1645	`}`
		1646	`return (ok);`
2	7u83	1647	`}`
		1648
		1649
		1650	`/*`
		1651	`ADD A LIST OF BUILT-IN UNARY CANDIDATES`
		1652
		1653	`This routine adds a series of built-in unary candidates for the`
		1654	`operator nm to the list p. The possible operand types are given by pa.`
		1655	`rtype describes how to form the return type from the operand type.`
		1656	`*/`
		1657
7	7u83	1658	`static void`
		1659	`add_unary_builtin(CANDIDATE_LIST *p, HASHID nm, LIST(TYPE) pa, int rtype)`
2	7u83	1660	`{`
7	7u83	1661	`while (!IS_NULL_list(pa)) {`
		1662	`TYPE ta = DEREF_type(HEAD_list(pa));`
		1663	`if (!IS_NULL_type(ta)) {`
		1664	`TYPE tb = find_builtin_ret(ta, ta, rtype, type_error);`
		1665	`IDENTIFIER id = unary_builtin(nm, ta, tb);`
		1666	`add_candidates(p, id, 1, KIND_BUILTIN);`
		1667	`}`
		1668	`pa = TAIL_list(pa);`
2	7u83	1669	`}`
7	7u83	1670	`DESTROY_list(pa, SIZE_type);`
		1671	`return;`
2	7u83	1672	`}`
		1673
		1674
		1675	`/*`
		1676	`ADD A LIST OF BUILT-IN BINARY CANDIDATES`
		1677
		1678	`This routine adds a series of built-in binary candidates for the`
		1679	`operator nm to the list p. The possible first and second operand types`
		1680	`are given by pa and pb. rtype describes how to form the return type`
		1681	`from the operand types, otype describes any restrictions on the operand`
		1682	`types.`
		1683	`*/`
		1684
7	7u83	1685	`static void`
		1686	`add_binary_builtin(CANDIDATE_LIST *p, HASHID nm, LIST(TYPE) pa, LIST(TYPE) pb,`
		1687	`int rtype, int otype)`
2	7u83	1688	`{`
7	7u83	1689	`while (!IS_NULL_list(pa)) {`
		1690	`TYPE ta = DEREF_type(HEAD_list(pa));`
		1691	`if (!IS_NULL_type(ta)) {`
		1692	`LIST(TYPE) pc = pb;`
		1693	`while (!IS_NULL_list(pc)) {`
		1694	`TYPE tb = DEREF_type(HEAD_list(pc));`
		1695	`if (!IS_NULL_type(tb)) {`
2	7u83	1696	`/* Check operand types */`
7	7u83	1697	`TYPE tc = type_error;`
		1698	`if (check_builtin_args(ta, tb, otype, &tc)) {`
		1699	`IDENTIFIER id;`
		1700	`tc = find_builtin_ret(ta, tb, rtype, tc);`
		1701	`if (otype == OTYPE_COND) {`
		1702	`ta = tc;`
		1703	`tb = tc;`
2	7u83	1704	`}`
7	7u83	1705	`id = binary_builtin(nm, ta, tb, tc);`
		1706	`add_candidates(p, id, 1, KIND_BUILTIN);`
2	7u83	1707	`}`
		1708	`}`
7	7u83	1709	`pc = TAIL_list(pc);`
2	7u83	1710	`}`
		1711	`}`
7	7u83	1712	`pa = TAIL_list(pa);`
2	7u83	1713	`}`
7	7u83	1714	`if (!EQ_list(pa, pb)) {`
		1715	`DESTROY_list(pa, SIZE_type);`
		1716	`}`
		1717	`DESTROY_list(pb, SIZE_type);`
		1718	`return;`
2	7u83	1719	`}`
		1720
		1721
		1722	`/*`
		1723	`OVERLOAD A UNARY OPERATOR`
		1724
		1725	`This routine calculates the unary overload operator 'op a'. This can`
		1726	`be 'a.operator op ()', 'operator op ( a )' or 'op t ( a )' for some`
		1727	`type t. Note that '->' is a special case for op, with 'a->b' being`
		1728	`expanded as '( a.operator -> () )->b'. This expansion is done in`
		1729	`begin_field_exp, this routine returning the null expression to indicate`
		1730	`that '->' is not overloaded.`
		1731	`*/`
		1732
7	7u83	1733	`EXP`
		1734	`unary_overload(int op, EXP a)`
2	7u83	1735	`{`
7	7u83	1736	`EXP e;`
		1737	`HASHID nm;`
		1738	`IDENTIFIER id;`
		1739	`LIST(TYPE) pa;`
		1740	`CANDIDATE_LIST *p = &candidates;`
2	7u83	1741
7	7u83	1742	`/* Check for template parameters */`
		1743	`TYPE t = DEREF_type(exp_type(a));`
		1744	`if (is_templ_type(t)) {`
		1745	`MAKE_exp_op(t, op, a, NULL_exp, e);`
		1746	`return (e);`
		1747	`}`
2	7u83	1748
7	7u83	1749	`/* Construct candidate list */`
		1750	`p->size = 0;`
		1751	`nm = overload_candidates(p, op, t, NULL_type);`
2	7u83	1752
7	7u83	1753	`/* Construct built-in candidates */`
		1754	`switch (op) {`
		1755	`case lex_plus:`
		1756	`/* Built-in candidates for '+a' */`
		1757	`pa = find_type_convs(t, a, CTYPE_SCALAR);`
		1758	`add_unary_builtin(p, nm, pa, RTYPE_ARG_1);`
		1759	`break;`
		1760	`case lex_minus:`
		1761	`case lex_abs:`
		1762	`/* Built-in candidates for '-a' */`
		1763	`pa = find_type_convs(t, a, CTYPE_ARITH);`
		1764	`add_unary_builtin(p, nm, pa, RTYPE_ARG_1);`
		1765	`break;`
		1766	`case lex_compl_H1:`
		1767	`/* Built-in candidates for '~a' */`
		1768	`pa = find_type_convs(t, a, CTYPE_INT);`
		1769	`add_unary_builtin(p, nm, pa, RTYPE_ARG_1);`
		1770	`break;`
		1771	`case lex_not_H1:`
		1772	`/* Built-in candidate for '!a' */`
		1773	`id = unary_builtin(nm, type_bool, type_bool);`
		1774	`add_candidates(p, id, 1, KIND_BUILTIN);`
		1775	`break;`
		1776	`case lex_star:`
		1777	`/* Built-in candidates for 'a' /`
		1778	`pa = find_type_convs(t, a, CTYPE_PTR);`
		1779	`filter_ptr(pa, 1);`
		1780	`add_unary_builtin(p, nm, pa, RTYPE_CONT_1);`
		1781	`break;`
		1782	`case lex_plus_Hplus:`
		1783	`case lex_minus_Hminus:`
		1784	`/* Built-in candidates for '++a' and '--a' */`
		1785	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_PTR));`
		1786	`filter_ptr(pa, 0);`
		1787	`add_unary_builtin(p, nm, pa, RTYPE_ARG_1);`
		1788	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_ARITH));`
		1789	`add_unary_builtin(p, nm, pa, RTYPE_ARG_1);`
		1790	`break;`
		1791	`case lex_and_H1:`
		1792	`/* No built-in candidates for '&a' */`
		1793	`break;`
		1794	`case lex_arrow:`
		1795	`/* No built-in candidates for 'a->' */`
		1796	`break;`
2	7u83	1797	`}`
		1798
7	7u83	1799	`/* Search for overload operator */`
		1800	`if (p->size) {`
		1801	`CANDIDATE *q;`
		1802	`unsigned rank;`
		1803	`LIST(EXP) args;`
		1804	`CONS_exp(a, NULL_list(EXP), args);`
		1805	`q = resolve_overload(p, args, NULL_type, 0);`
		1806	`unary_free = unary_all;`
		1807	`rank = q->rank;`
		1808	`if (rank >= RANK_VIABLE) {`
		1809	`/* Only allow viable resolutions */`
		1810	`int kind = q->kind;`
		1811	`IDENTIFIER qid = q->func;`
		1812	`int ow = overload_warn;`
		1813	`if (rank == RANK_BEST) {`
		1814	`/* Unambiguous resolution */`
		1815	`if (match_no_viable > 1 && ow) {`
		1816	`if (do_dump) {`
		1817	`dump_builtin(qid);`
		1818	`}`
		1819	`report(crt_loc,`
		1820	`ERR_over_match_oper_ok(qid));`
		1821	`}`
		1822	`} else {`
		1823	`/* Ambiguous resolution */`
		1824	`q = resolve_ambiguous(p, args, NULL_type, 0);`
		1825	`qid = q->func;`
		1826	`rank = q->rank;`
		1827	`if (rank == RANK_TARGET) {`
		1828	`ERROR err2 =`
		1829	`ERR_over_match_oper_target(op);`
		1830	`qid = make_ambig_func(p, qid, args,`
		1831	`qual_none,`
		1832	`&err2);`
		1833	`kind = KIND_OP;`
		1834	`if (do_dump) {`
		1835	`dump_builtin(qid);`
		1836	`}`
		1837	`report(crt_loc, err2);`
		1838	`} else if (rank == RANK_VIABLE) {`
		1839	`ERROR err2 =`
		1840	`ERR_over_match_oper_ambig(op);`
		1841	`err2 = list_candidates(err2, p,`
		1842	`RANK_VIABLE);`
		1843	`report(crt_loc, err2);`
		1844	`}`
		1845	`overload_warn = 0;`
		1846	`}`
		1847	`if (kind == KIND_BUILTIN) {`
		1848	`/* Built-in resolution */`
		1849	`if (op == lex_arrow) {`
		1850	`/* For 'a->' return the null`
		1851	`* expression */`
		1852	`DESTROY_list(args, SIZE_exp);`
		1853	`e = NULL_exp;`
		1854	`} else {`
		1855	`e = apply_builtin(qid, args);`
		1856	`}`
		1857	`} else {`
		1858	`/* Function resolution */`
		1859	`use_func_id(qid, 0, suppress_usage);`
		1860	`e = apply_func_id(qid, qual_none, NULL_graph,`
		1861	`args);`
		1862	`}`
		1863	`overload_warn = ow;`
		1864	`return (e);`
2	7u83	1865	`}`
7	7u83	1866	`DESTROY_list(args, SIZE_exp);`
2	7u83	1867	`}`
		1868
7	7u83	1869	`/* Try operation again */`
		1870	`if (op == lex_arrow) {`
		1871	`/* For 'a->' return the null expression */`
		1872	`e = NULL_exp;`
		1873	`} else {`
		1874	`overload_depth++;`
		1875	`e = apply_unary(op, a, NULL_type, NULL_type, 0);`
		1876	`overload_depth--;`
		1877	`}`
		1878	`return (e);`
2	7u83	1879	`}`
		1880
		1881
		1882	`/*`
		1883	`OVERLOAD A BINARY OPERATOR`
		1884
		1885	`This routine calculates the binary overload operator 'a op b'. This can`
		1886	`be 'a.operator op ( b )', 'operator op ( a, b )' or 't ( a ) op s ( b )'`
		1887	`for some types t and s. Note that postfix '++' and '--' are special`
		1888	`cases for op in which b is a dummy zero operand.`
		1889	`*/`
		1890
7	7u83	1891	`EXP`
		1892	`binary_overload(int op, EXP a, EXP b)`
2	7u83	1893	`{`
7	7u83	1894	`EXP e;`
		1895	`HASHID nm;`
		1896	`LIST(TYPE) pa, pb;`
		1897	`CANDIDATE_LIST *p = &candidates;`
2	7u83	1898
7	7u83	1899	`/* Check for template parameters */`
		1900	`TYPE t = DEREF_type(exp_type(a));`
		1901	`TYPE s = DEREF_type(exp_type(b));`
		1902	`if (is_templ_type(t)) {`
		1903	`MAKE_exp_op(t, op, a, b, e);`
		1904	`return (e);`
		1905	`}`
		1906	`if (is_templ_type(s)) {`
		1907	`MAKE_exp_op(s, op, a, b, e);`
		1908	`return (e);`
		1909	`}`
2	7u83	1910
7	7u83	1911	`/* Construct candidate list */`
		1912	`p->size = 0;`
		1913	`nm = overload_candidates(p, op, t, s);`
2	7u83	1914
7	7u83	1915	`/* Construct built-in candidates */`
		1916	`/* QUERY - overloaded function operands */`
		1917	`switch (op) {`
		1918	`case lex_logical_Hand_H1:`
		1919	`case lex_logical_Hor_H1: {`
		1920	`/* Built-in candidates for 'a && b' and 'a \|\| b' */`
		1921	`IDENTIFIER id;`
		1922	`id = binary_builtin(nm, type_bool, type_bool, type_bool);`
		1923	`add_candidates(p, id, 1, KIND_BUILTIN);`
		1924	`break;`
2	7u83	1925	`}`
7	7u83	1926	`case lex_and_H1:`
		1927	`case lex_or_H1:`
		1928	`case lex_rem:`
		1929	`case lex_xor_H1:`
		1930	`/* Built-in candidates for 'a & b' etc. */`
		1931	`pa = find_type_convs(t, a, CTYPE_INT);`
		1932	`pb = find_type_convs(s, b, CTYPE_INT);`
		1933	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARITH, OTYPE_NONE);`
		1934	`break;`
		1935	`case lex_lshift:`
		1936	`case lex_rshift:`
		1937	`/* Built-in candidates for 'a << b' and 'a >> b' */`
		1938	`pa = find_type_convs(t, a, CTYPE_INT);`
		1939	`pb = find_type_convs(s, b, CTYPE_INT);`
		1940	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		1941	`break;`
		1942	`case lex_minus:`
		1943	`/* Built-in candidates for 'a - b' */`
		1944	`pa = find_type_convs(t, a, CTYPE_PTR);`
		1945	`pb = find_type_convs(s, b, CTYPE_PTR);`
		1946	`filter_ptr(pa, 0);`
		1947	`add_binary_builtin(p, nm, pa, pb, RTYPE_PTRDIFF, OTYPE_PTR);`
		1948	`pa = find_type_convs(t, a, CTYPE_PTR);`
		1949	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pb);`
		1950	`filter_ptr(pa, 0);`
		1951	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		1952	`goto arith_op_lab;`
		1953	`case lex_plus:`
		1954	`/* Built-in candidates for 'a + b' */`
		1955	`pa = find_type_convs(t, a, CTYPE_PTR);`
		1956	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pb);`
		1957	`filter_ptr(pa, 0);`
		1958	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		1959	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pa);`
		1960	`pb = find_type_convs(s, b, CTYPE_PTR);`
		1961	`filter_ptr(pb, 0);`
		1962	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_2, OTYPE_NONE);`
		1963	`goto arith_op_lab;`
		1964	`case lex_array_Hop:`
		1965	`/* Built-in candidates for 'a [b]' */`
		1966	`pa = find_type_convs(t, a, CTYPE_PTR);`
		1967	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pb);`
		1968	`filter_ptr(pa, 0);`
		1969	`add_binary_builtin(p, nm, pa, pb, RTYPE_CONT_1, OTYPE_NONE);`
		1970	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pa);`
		1971	`pb = find_type_convs(s, b, CTYPE_PTR);`
		1972	`filter_ptr(pb, 0);`
		1973	`add_binary_builtin(p, nm, pa, pb, RTYPE_CONT_2, OTYPE_NONE);`
		1974	`break;`
		1975	`case lex_star:`
		1976	`case lex_div:`
		1977	`case lex_max:`
		1978	`case lex_min:`
		1979	`arith_op_lab:`
		1980	`/* Built-in candidates for 'a * b' and 'a / b' */`
		1981	`pa = find_type_convs(t, a, CTYPE_ARITH);`
		1982	`pb = find_type_convs(s, b, CTYPE_ARITH);`
		1983	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARITH, OTYPE_NONE);`
		1984	`break;`
		1985	`case lex_eq:`
		1986	`case lex_not_Heq_H1:`
		1987	`/* Built-in candidates for 'a == b' and 'a != b' */`
		1988	`pa = find_type_convs(t, a, CTYPE_PTR_MEM);`
		1989	`pb = find_type_convs(s, b, CTYPE_PTR_MEM);`
		1990	`if (is_zero_exp(a)) {`
		1991	`pa = pb;`
		1992	`}`
		1993	`if (is_zero_exp(b)) {`
		1994	`pb = pa;`
		1995	`}`
		1996	`add_binary_builtin(p, nm, pa, pb, RTYPE_BOOL, OTYPE_PTR_MEM);`
		1997	`goto relation_op_lab;`
		1998	`case lex_greater:`
		1999	`case lex_greater_Heq:`
		2000	`case lex_less:`
		2001	`case lex_less_Heq:`
		2002	`relation_op_lab:`
		2003	`/* Built-in candidates for 'a > b' etc. */`
		2004	`pa = find_type_convs(t, a, CTYPE_PTR);`
		2005	`pb = find_type_convs(s, b, CTYPE_PTR);`
		2006	`if (is_zero_exp(a)) {`
		2007	`pa = pb;`
		2008	`}`
		2009	`if (is_zero_exp(b)) {`
		2010	`pb = pa;`
		2011	`}`
		2012	`add_binary_builtin(p, nm, pa, pb, RTYPE_BOOL, OTYPE_PTR);`
		2013	`pa = find_type_convs(t, a, CTYPE_ARITH);`
		2014	`pb = find_type_convs(s, b, CTYPE_ARITH);`
		2015	`add_binary_builtin(p, nm, pa, pb, RTYPE_BOOL, OTYPE_NONE);`
		2016	`break;`
		2017	`case lex_arrow_Hstar:`
		2018	`/* Built-in candidates for 'a->b' /`
		2019	`pa = find_type_convs(t, a, CTYPE_PTR);`
		2020	`pb = find_type_convs(s, b, CTYPE_PTR_MEM);`
		2021	`filter_ptr(pb, 1);`
		2022	`add_binary_builtin(p, nm, pa, pb, RTYPE_OP, OTYPE_SELECT);`
		2023	`break;`
		2024	`case lex_plus_Hplus:`
		2025	`case lex_minus_Hminus:`
		2026	`/* Built-in candidates for 'a++' and 'a--' */`
		2027	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_PTR));`
		2028	`CONS_type(type_sint, NULL_list(TYPE), pb);`
		2029	`filter_ptr(pa, 0);`
		2030	`add_binary_builtin(p, nm, pa, pb, RTYPE_CONT_1, OTYPE_NONE);`
		2031	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_ARITH));`
		2032	`CONS_type(type_sint, NULL_list(TYPE), pb);`
		2033	`add_binary_builtin(p, nm, pa, pb, RTYPE_CONT_1, OTYPE_NONE);`
		2034	`break;`
		2035	`case lex_and_Heq_H1:`
		2036	`case lex_lshift_Heq:`
		2037	`case lex_or_Heq_H1:`
		2038	`case lex_rem_Heq:`
		2039	`case lex_rshift_Heq:`
		2040	`case lex_xor_Heq_H1:`
		2041	`/* Built-in candidates for 'a &= b' etc. */`
		2042	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_INT));`
		2043	`pb = find_type_convs(s, b, CTYPE_INT);`
		2044	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		2045	`break;`
		2046	`case lex_div_Heq:`
		2047	`case lex_star_Heq:`
		2048	`/* Built-in candidates for 'a /= b' and 'a = b' /`
		2049	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_ARITH));`
		2050	`pb = find_type_convs(s, b, CTYPE_ARITH);`
		2051	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		2052	`break;`
		2053	`case lex_plus_Heq:`
		2054	`case lex_minus_Heq:`
		2055	`/* Built-in candidates for 'a += b' and 'a -= b' */`
		2056	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_PTR));`
		2057	`CONS_type(type_ptrdiff_t, NULL_list(TYPE), pb);`
		2058	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		2059	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_ARITH));`
		2060	`pb = find_type_convs(s, b, CTYPE_ARITH);`
		2061	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		2062	`break;`
		2063	`case lex_assign:`
		2064	`/* Built-in candidates for 'a = b' */`
		2065	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_PTR_MEM));`
		2066	`pb = find_type_convs(s, b, CTYPE_PTR_MEM);`
		2067	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_REF_MEM);`
		2068	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_PTR));`
		2069	`pb = find_type_convs(s, b, CTYPE_PTR);`
		2070	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_REF_PTR);`
		2071	`pa = find_type_convs(t, a,(CTYPE_LVALUE \| CTYPE_ARITH));`
		2072	`pb = find_type_convs(s, b, CTYPE_ARITH);`
		2073	`add_binary_builtin(p, nm, pa, pb, RTYPE_ARG_1, OTYPE_NONE);`
		2074	`break;`
		2075	`case lex_comma:`
		2076	`/* No built-in candidates for 'a, b' */`
		2077	`break;`
		2078	`case lex_colon: {`
		2079	`/* Built-in candidates for '<condition> ? a : b' */`
		2080	`LIST(TYPE) pc;`
		2081	`pa = find_type_convs(t, a, CTYPE_NONE);`
		2082	`pb = find_type_convs(s, b, CTYPE_NONE);`
		2083	`if (is_zero_exp(a)) {`
		2084	`/* Allow for null pointers */`
		2085	`pc = find_type_convs(s, b,(CTYPE_PTR \| CTYPE_PTR_MEM));`
		2086	`pa = APPEND_list(pa, pc);`
		2087	`}`
		2088	`if (is_zero_exp(b)) {`
		2089	`/* Allow for null pointers */`
		2090	`pc = find_type_convs(t, a,(CTYPE_PTR \| CTYPE_PTR_MEM));`
		2091	`pb = APPEND_list(pb, pc);`
		2092	`}`
		2093	`add_binary_builtin(p, nm, pa, pb, RTYPE_OP, OTYPE_COND);`
		2094	`break;`
2	7u83	2095	`}`
		2096	`}`
		2097
7	7u83	2098	`/* Search for overload operator */`
		2099	`if (p->size) {`
		2100	`CANDIDATE *q;`
		2101	`unsigned rank;`
		2102	`LIST(EXP) args;`
		2103	`CONS_exp(b, NULL_list(EXP), args);`
		2104	`CONS_exp(a, args, args);`
		2105	`q = resolve_overload(p, args, NULL_type, 0);`
		2106	`binary_free = binary_all;`
		2107	`rank = q->rank;`
		2108	`if (rank >= RANK_VIABLE) {`
		2109	`/* Only allow viable resolutions */`
		2110	`int kind = q->kind;`
		2111	`IDENTIFIER qid = q->func;`
		2112	`int ow = overload_warn;`
		2113	`if (rank == RANK_BEST) {`
		2114	`/* Unambiguous resolution */`
		2115	`if (match_no_viable > 1 && ow) {`
		2116	`if (do_dump) {`
		2117	`dump_builtin(qid);`
		2118	`}`
		2119	`report(crt_loc,`
		2120	`ERR_over_match_oper_ok(qid));`
		2121	`}`
		2122	`} else {`
		2123	`/* Ambiguous resolution */`
		2124	`q = resolve_ambiguous(p, args, NULL_type, 0);`
		2125	`qid = q->func;`
		2126	`rank = q->rank;`
		2127	`if (rank == RANK_TARGET) {`
		2128	`ERROR err2 =`
		2129	`ERR_over_match_oper_target(op);`
		2130	`qid = make_ambig_func(p, qid, args,`
		2131	`qual_none,`
		2132	`&err2);`
		2133	`kind = KIND_OP;`
		2134	`if (do_dump) {`
		2135	`dump_builtin(qid);`
		2136	`}`
		2137	`report(crt_loc, err2);`
		2138	`} else if (rank == RANK_VIABLE) {`
		2139	`ERROR err2 =`
		2140	`ERR_over_match_oper_ambig(op);`
		2141	`err2 = list_candidates(err2, p,`
		2142	`RANK_VIABLE);`
		2143	`report(crt_loc, err2);`
		2144	`}`
		2145	`overload_warn = 0;`
		2146	`}`
		2147	`if (kind == KIND_BUILTIN) {`
		2148	`/* Built-in resolution */`
		2149	`if (op == lex_comma) {`
		2150	`/* Return null expression for 'a, b' */`
		2151	`DESTROY_list(args, SIZE_exp);`
		2152	`e = NULL_exp;`
		2153	`} else {`
		2154	`e = apply_builtin(qid, args);`
		2155	`}`
		2156	`} else {`
		2157	`/* Function resolution */`
		2158	`use_func_id(qid, 0, suppress_usage);`
		2159	`e = apply_func_id(qid, qual_none, NULL_graph,`
		2160	`args);`
		2161	`}`
		2162	`overload_warn = ow;`
		2163	`return (e);`
2	7u83	2164	`}`
7	7u83	2165	`DESTROY_list(args, SIZE_exp);`
2	7u83	2166	`}`
		2167
7	7u83	2168	`/* Try operation again */`
		2169	`if (op == lex_comma) {`
		2170	`/* Return null expression for 'a, b' */`
		2171	`e = NULL_exp;`
		2172	`} else {`
		2173	`overload_depth++;`
		2174	`e = apply_binary(op, a, b, NULL_type, NULL_type, 0);`
		2175	`overload_depth--;`
		2176	`}`
		2177	`return (e);`
2	7u83	2178	`}`
		2179
		2180
		2181	`/*`
		2182	`OVERLOAD A FUNCTION OPERATOR`
		2183
		2184	`This routine calculates the function overload operator 'a ( args )'.`
		2185	`This is expanded as 'a.operator () ( args )'.`
		2186	`*/`
		2187
7	7u83	2188	`EXP`
		2189	`function_overload(EXP a, LIST(EXP)args)`
2	7u83	2190	`{`
7	7u83	2191	`EXP e;`
		2192	`int op = lex_func_Hop;`
2	7u83	2193
7	7u83	2194	`/* Construct candidate list */`
		2195	`TYPE t = DEREF_type(exp_type(a));`
		2196	`CANDIDATE_LIST *p = &candidates;`
		2197	`p->size = 0;`
		2198	`IGNORE overload_candidates(p, op, t, NULL_type);`
2	7u83	2199
7	7u83	2200	`if (IS_type_compound(t)) {`
		2201	`LIST(IDENTIFIER) conv;`
		2202	`HASHID nm = KEYWORD(lex_zzzz);`
		2203	`CLASS_TYPE ct = DEREF_ctype(type_compound_defn(t));`
		2204	`complete_class(ct, 1);`
		2205	`conv = DEREF_list(ctype_conv(ct));`
		2206	`while (!IS_NULL_list(conv)) {`
		2207	`/* Scan through conversion operations */`
		2208	`IDENTIFIER cid = DEREF_id(HEAD_list(conv));`
		2209	`DECL_SPEC ds = DEREF_dspec(id_storage(cid));`
		2210	`if (!(ds & dspec_explicit)) {`
		2211	`HASHID cnm = DEREF_hashid(id_name(cid));`
		2212	`TYPE r = DEREF_type(hashid_conv_type(cnm));`
		2213	`unsigned nr = TAG_type(r);`
2	7u83	2214
7	7u83	2215	`/* Search for pointer or reference to`
		2216	`* functions */`
		2217	`if (nr == type_ptr_tag \|\| nr == type_ref_tag) {`
		2218	`TYPE s =`
		2219	`DEREF_type(type_ptr_etc_sub(r));`
		2220	`if (IS_type_func(s)) {`
		2221	`LOCATION loc;`
		2222	`LIST(TYPE) ptypes;`
		2223	`TYPE ret = DEREF_type(type_func_ret(s));`
		2224	`ptypes = DEREF_list(type_func_ptypes(s));`
		2225	`DEREF_loc(id_loc(cid), loc);`
		2226	`cid = nary_builtin(nm, r,`
		2227	`ptypes,`
		2228	`ret);`
		2229	`COPY_loc(id_loc(cid), loc);`
		2230	`add_candidates(p, cid, 1,`
		2231	`KIND_BUILTIN);`
		2232	`}`
		2233	`}`
		2234	`}`
		2235	`conv = TAIL_list(conv);`
2	7u83	2236	`}`
		2237	`}`
		2238
7	7u83	2239	`/* Search for overload operator */`
		2240	`if (p->size) {`
		2241	`CANDIDATE *q;`
		2242	`unsigned rank;`
		2243	`CONS_exp(a, args, args);`
		2244	`q = resolve_overload(p, args, NULL_type, 0);`
		2245	`nary_free = nary_all;`
		2246	`rank = q->rank;`
		2247	`if (rank >= RANK_VIABLE) {`
		2248	`/* Only allow viable resolutions */`
		2249	`int kind = q->kind;`
		2250	`IDENTIFIER qid = q->func;`
		2251	`int ow = overload_warn;`
		2252	`if (rank == RANK_BEST) {`
		2253	`/* Unambiguous resolution */`
		2254	`if (match_no_viable > 1 && ow) {`
		2255	`if (do_dump) {`
		2256	`dump_builtin(qid);`
		2257	`}`
		2258	`report(crt_loc,`
		2259	`ERR_over_match_oper_ok(qid));`
		2260	`}`
		2261	`} else {`
		2262	`/* Ambiguous resolution */`
		2263	`q = resolve_ambiguous(p, args, NULL_type, 0);`
		2264	`qid = q->func;`
		2265	`rank = q->rank;`
		2266	`if (rank == RANK_TARGET) {`
		2267	`ERROR err =`
		2268	`ERR_over_match_oper_target(op);`
		2269	`qid = make_ambig_func(p, qid, args,`
		2270	`qual_none, &err);`
		2271	`kind = KIND_OP;`
		2272	`if (do_dump) {`
		2273	`dump_builtin(qid);`
		2274	`}`
		2275	`report(crt_loc, err);`
		2276	`} else if (rank == RANK_VIABLE) {`
		2277	`ERROR err =`
		2278	`ERR_over_match_oper_ambig(op);`
		2279	`err = list_candidates(err, p,`
		2280	`RANK_VIABLE);`
		2281	`report(crt_loc, err);`
		2282	`}`
		2283	`overload_warn = 0;`
		2284	`}`
		2285	`if (kind == KIND_BUILTIN) {`
		2286	`/* Built-in resolution */`
		2287	`e = apply_builtin(qid, args);`
		2288	`} else {`
		2289	`/* Function resolution */`
		2290	`use_func_id(qid, 0, suppress_usage);`
		2291	`e = apply_func_id(qid, qual_none, NULL_graph,`
		2292	`args);`
		2293	`}`
		2294	`overload_warn = ow;`
		2295	`return (e);`
2	7u83	2296	`}`
7	7u83	2297	`DESTROY_CONS_exp(destroy, a, args, args);`
2	7u83	2298	`}`
		2299
7	7u83	2300	`/* Try operation again with increased overload depth */`
		2301	`overload_depth++;`
		2302	`e = make_func_exp(a, args, 0);`
		2303	`overload_depth--;`
		2304	`return (e);`
2	7u83	2305	`}`
		2306
		2307
		2308	`#endif /* LANGUAGE_CPP */`

Subversion Repositories tendra.SVN

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