WebSVN – tendra.SVN – Blame – /branches/tendra5/src/utilities/sid/c-parser.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
		2	`* Automatically generated from the files:`
		3	`* /u/g/release/Source/src/utilities/sid/c-parser.sid`
		4	`* and`
		5	`* /u/g/release/Source/src/utilities/sid/c-parser.act`
		6	`* by:`
		7	`* sid`
		8	`*/`
		9
		10	`/* BEGINNING OF HEADER */`
		11
		12
		13	`/*`
		14	`Crown Copyright (c) 1997`
		15
		16	`This TenDRA(r) Computer Program is subject to Copyright`
		17	`owned by the United Kingdom Secretary of State for Defence`
		18	`acting through the Defence Evaluation and Research Agency`
		19	`(DERA). It is made available to Recipients with a`
		20	`royalty-free licence for its use, reproduction, transfer`
		21	`to other parties and amendment for any purpose not excluding`
		22	`product development provided that any such use et cetera`
		23	`shall be deemed to be acceptance of the following conditions:-`
		24
		25	`(1) Its Recipients shall ensure that this Notice is`
		26	`reproduced upon any copies or amended versions of it;`
		27
		28	`(2) Any amended version of it shall be clearly marked to`
		29	`show both the nature of and the organisation responsible`
		30	`for the relevant amendment or amendments;`
		31
		32	`(3) Its onward transfer from a recipient to another`
		33	`party shall be deemed to be that party's acceptance of`
		34	`these conditions;`
		35
		36	`(4) DERA gives no warranty or assurance as to its`
		37	`quality or suitability for any purpose and DERA accepts`
		38	`no liability whatsoever in relation to any use to which`
		39	`it may be put.`
		40	`*/`
		41
		42
		43	`#include "c-parser.h"`
		44	`#include "action.h"`
		45	`#include "c-code.h"`
		46	`#include "c-out-info.h"`
		47	`#include "basic.h"`
		48	`#include "entry.h"`
		49	`#include "gen-errors.h"`
		50	`#include "type.h"`
		51	`#include "types.h"`
		52
		53	`/--------------------------------------------------------------------------/`
		54
		55	`#define CURRENT_TERMINAL c_lexer_get_terminal (c_current_stream)`
		56	`#define ADVANCE_LEXER c_lexer_next_token (c_current_stream)`
		57	`#define SAVE_LEXER(x) (c_lexer_save_terminal (c_current_stream, (CTokenT) (x)))`
		58	`#define RESTORE_LEXER (c_lexer_restore_terminal (c_current_stream))`
		59
		60	`/--------------------------------------------------------------------------/`
		61
		62	`static NStringT c_prefix_names [CPFX_NUM_PREFIXES];`
		63	`static BoolT c_inited_prefix_names = FALSE;`
		64	`static CPrefixT c_current_prefix;`
		65	`static EntryP c_current_entry;`
		66	`static TypeTupleT c_saved_type;`
		67	`static TypeTupleT c_current_type;`
		68	`static BoolT c_propagating_error = FALSE;`
		69
		70	`/--------------------------------------------------------------------------/`
		71
		72	`CLexerStreamP c_current_stream;`
		73	`COutputInfoP c_current_out_info;`
		74	`TableP c_current_table;`
		75
		76	`/* BEGINNING OF FUNCTION DECLARATIONS */`
		77
		78	`static void ZR132 PROTO_S ((void));`
		79	`static void ZR139 PROTO_S ((void));`
		80	`static void ZR92 PROTO_S ((void));`
		81	`static void ZR119 PROTO_S ((void));`
		82	`static void ZR148 PROTO_S ((void));`
		83	`static void ZR107 PROTO_S ((void));`
		84	`static void ZR172 PROTO_S ((void));`
		85	`static void ZR146 PROTO_S ((void));`
		86	`static void ZR127 PROTO_S ((void));`
		87	`static void ZR82 PROTO_S ((void));`
		88	`static void ZR84 PROTO_S ((void));`
		89	`extern void c_parse_grammar PROTO_S ((void));`
		90	`static void ZR110 PROTO_S ((void));`
		91	`static void ZR112 PROTO_S ((void));`
		92	`static void ZR134 PROTO_S ((void));`
		93	`static void ZR101 PROTO_S ((void));`
		94	`static void ZR141 PROTO_S ((void));`
		95	`static void ZR90 PROTO_S ((void));`
		96	`static void ZR99 PROTO_S ((void));`
		97	`static void ZR117 PROTO_S ((void));`
		98	`static void ZR116 PROTO_S ((void));`
		99	`static void ZR125 PROTO_S ((void));`
		100	`static void ZR121 PROTO_S ((void));`
		101	`static void ZR124 PROTO_S ((void));`
		102
		103	`/* BEGINNING OF STATIC VARIABLES */`
		104
		105	`static BoolT ZI0;`
		106
		107	`/* BEGINNING OF FUNCTION DEFINITIONS */`
		108
		109	`static void`
		110	`ZR132 PROTO_Z ()`
		111	`{`
		112	`ZL2_132:;`
		113	`switch (CURRENT_TERMINAL) {`
		114	`case 8: case 9:`
		115	`{`
		116	`ZR134 ();`
		117	`if ((CURRENT_TERMINAL) == 23) {`
		118	`RESTORE_LEXER;`
		119	`goto ZL1;`
		120	`}`
		121	`{`
		122
		123	`c_propagating_error = FALSE;`
		124	`}`
		125	`goto ZL2_132;`
		126	`}`
		127	`/UNREACHED/`
		128	`case 23:`
		129	`return;`
		130	`default:`
		131	`break;`
		132	`}`
		133	`return;`
		134	`ZL1:;`
		135	`SAVE_LEXER (23);`
		136	`return;`
		137	`}`
		138
		139	`static void`
		140	`ZR139 PROTO_Z ()`
		141	`{`
		142	`ZL2_139:;`
		143	`switch (CURRENT_TERMINAL) {`
		144	`case 8: case 9:`
		145	`{`
		146	`ZR141 ();`
		147	`if ((CURRENT_TERMINAL) == 23) {`
		148	`RESTORE_LEXER;`
		149	`goto ZL1;`
		150	`}`
		151	`{`
		152
		153	`c_propagating_error = FALSE;`
		154	`}`
		155	`goto ZL2_139;`
		156	`}`
		157	`/UNREACHED/`
		158	`case 23:`
		159	`return;`
		160	`default:`
		161	`break;`
		162	`}`
		163	`return;`
		164	`ZL1:;`
		165	`SAVE_LEXER (23);`
		166	`return;`
		167	`}`
		168
		169	`static void`
		170	`ZR92 PROTO_Z ()`
		171	`{`
		172	`if ((CURRENT_TERMINAL) == 23) {`
		173	`return;`
		174	`}`
		175	`{`
		176	`NStringT ZI94;`
		177
		178	`{`
		179	`switch (CURRENT_TERMINAL) {`
		180	`case 9:`
		181	`{`
		182	`{`
		183
		184	`nstring_assign (&ZI94, c_lexer_string_value (c_current_stream));`
		185	`}`
		186	`ADVANCE_LEXER;`
		187	`}`
		188	`break;`
		189	`case 8:`
		190	`{`
		191	`{`
		192
		193	`nstring_assign (&ZI94, c_lexer_string_value (c_current_stream));`
		194	`}`
		195	`ADVANCE_LEXER;`
		196	`}`
		197	`break;`
		198	`default:`
		199	`goto ZL1;`
		200	`}`
		201	`}`
		202	`{`
		203
		204	`if ((c_current_entry = table_get_entry (c_current_table, (&ZI94))) ==`
		205	`NIL (EntryP)) {`
		206	`E_c_unknown_identifier ((&ZI94));`
		207	`} else if (entry_get_mapping (c_current_entry)) {`
		208	`E_c_remapped_identifier ((&ZI94));`
		209	`c_current_entry = NIL (EntryP);`
		210	`} else {`
		211	`switch (entry_type (c_current_entry)) EXHAUSTIVE {`
		212	`case ET_NAME:`
		213	`case ET_ACTION:`
		214	`case ET_NON_LOCAL:`
		215	`E_c_illegal_map ((&ZI94));`
		216	`c_current_entry = NIL (EntryP);`
		217	`break;`
		218	`case ET_RENAME:`
		219	`case ET_PREDICATE:`
		220	`/* UNREACHED */`
		221	`break;`
		222	`case ET_TYPE:`
		223	`case ET_RULE:`
		224	`case ET_BASIC:`
		225	`break;`
		226	`}`
		227	`}`
		228	`nstring_destroy (&(ZI94));`
		229	`}`
		230	`ZR116 ();`
		231	`{`
		232	`if ((CURRENT_TERMINAL) == 23) {`
		233	`RESTORE_LEXER;`
		234	`goto ZL1;`
		235	`}`
		236	`{`
		237	`NStringT ZI97;`
		238
		239	`switch (CURRENT_TERMINAL) {`
		240	`case 9:`
		241	`{`
		242
		243	`nstring_assign (&ZI97, c_lexer_string_value (c_current_stream));`
		244	`}`
		245	`break;`
		246	`default:`
		247	`goto ZL4;`
		248	`}`
		249	`ADVANCE_LEXER;`
		250	`{`
		251
		252	`if (c_current_entry) {`
		253	`entry_set_mapping (c_current_entry, &(ZI97));`
		254	`} else {`
		255	`nstring_destroy (&(ZI97));`
		256	`}`
		257	`}`
		258	`ZR124 ();`
		259	`if ((CURRENT_TERMINAL) == 23) {`
		260	`RESTORE_LEXER;`
		261	`goto ZL4;`
		262	`}`
		263	`}`
		264	`goto ZL3;`
		265	`ZL4:;`
		266	`{`
		267	`{`
		268
		269	`if (!c_propagating_error) {`
		270	`E_c_expected_c_identifier ();`
		271	`}`
		272	`}`
		273	`{`
		274
		275	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		276	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		277	`(CURRENT_TERMINAL != C_TOK_BLT_ASSIGNMENTS) &&`
		278	`(CURRENT_TERMINAL != C_TOK_BLT_PARAM_ASSIGN) &&`
		279	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		280	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		281	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		282	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		283	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		284	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		285	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		286	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		287	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		288	`}`
		289	`ADVANCE_LEXER;`
		290	`}`
		291	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		292	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		293	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		294	`}`
		295	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		296	`ADVANCE_LEXER;`
		297	`}`
		298	`c_propagating_error = TRUE;`
		299	`}`
		300	`}`
		301	`ZL3:;`
		302	`}`
		303	`}`
		304	`return;`
		305	`ZL1:;`
		306	`SAVE_LEXER (23);`
		307	`return;`
		308	`}`
		309
		310	`static void`
		311	`ZR119 PROTO_Z ()`
		312	`{`
		313	`if ((CURRENT_TERMINAL) == 23) {`
		314	`return;`
		315	`}`
		316	`{`
		317	`NStringT ZI79;`
		318
		319	`{`
		320	`switch (CURRENT_TERMINAL) {`
		321	`case 9:`
		322	`{`
		323	`{`
		324
		325	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		326	`}`
		327	`ADVANCE_LEXER;`
		328	`}`
		329	`break;`
		330	`case 8:`
		331	`{`
		332	`{`
		333
		334	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		335	`}`
		336	`ADVANCE_LEXER;`
		337	`}`
		338	`break;`
		339	`default:`
		340	`goto ZL1;`
		341	`}`
		342	`}`
		343	`{`
		344
		345	`if ((c_current_entry = table_get_type (c_current_table, (&ZI79))) ==`
		346	`NIL (EntryP)) {`
		347	`E_c_unknown_assign ((&ZI79));`
		348	`} else if (type_get_assign_code (entry_get_type (c_current_entry))) {`
		349	`E_c_assign_mult_def ((&ZI79));`
		350	`c_current_entry = NIL (EntryP);`
		351	`}`
		352	`nstring_destroy (&(ZI79));`
		353	`}`
		354	`ZR99 ();`
		355	`ZR121 ();`
		356	`{`
		357	`if ((CURRENT_TERMINAL) == 23) {`
		358	`RESTORE_LEXER;`
		359	`goto ZL1;`
		360	`}`
		361	`{`
		362	`CCodeP ZI123;`
		363
		364	`switch (CURRENT_TERMINAL) {`
		365	`case 16:`
		366	`{`
		367
		368	`ZI123 = c_lexer_code_value (c_current_stream);`
		369	`}`
		370	`break;`
		371	`default:`
		372	`goto ZL4;`
		373	`}`
		374	`ADVANCE_LEXER;`
		375	`{`
		376
		377	`if (c_current_entry) {`
		378	`BoolT errored = FALSE;`
		379	`KeyP key = entry_key (c_current_entry);`
		380	`TypeTupleT tmp;`
		381
		382	`types_init (&tmp);`
		383	`types_add_type_entry (&tmp, c_current_entry, FALSE);`
		384	`if (!types_disjoint_names (&c_saved_type)) {`
		385	`E_c_assign_param_clash (key, &c_saved_type);`
		386	`errored = TRUE;`
		387	`}`
		388	`if (!types_fillin_types (&c_saved_type, &tmp)) {`
		389	`E_c_assign_param_mismatch (key, &tmp, &c_saved_type);`
		390	`errored = TRUE;`
		391	`}`
		392	`if (!types_disjoint_names (&c_current_type)) {`
		393	`E_c_assign_result_clash (key, &c_current_type);`
		394	`errored = TRUE;`
		395	`}`
		396	`if (!types_fillin_types (&c_current_type, &tmp)) {`
		397	`E_c_assign_result_mismatch (key, &tmp, &c_current_type);`
		398	`errored = TRUE;`
		399	`}`
		400	`if (types_intersect (&c_saved_type, &c_current_type)) {`
		401	`E_c_assign_formal_clash (key, &c_saved_type, &c_current_type);`
		402	`errored = TRUE;`
		403	`}`
		404	`types_destroy (&tmp);`
		405	`if (errored) {`
		406	`types_destroy (&c_saved_type);`
		407	`types_destroy (&c_current_type);`
		408	`c_code_deallocate ((ZI123));`
		409	`c_current_entry = NIL (EntryP);`
		410	`} else {`
		411	`TypeP type = entry_get_type (c_current_entry);`
		412
		413	`c_code_check ((ZI123), FALSE, FALSE, &c_saved_type, &c_current_type,`
		414	`c_current_table);`
		415	`type_set_assign_code (type, (GenericP) (ZI123));`
		416	`}`
		417	`} else {`
		418	`types_destroy (&c_saved_type);`
		419	`types_destroy (&c_current_type);`
		420	`c_code_deallocate ((ZI123));`
		421	`}`
		422	`}`
		423	`ZR124 ();`
		424	`if ((CURRENT_TERMINAL) == 23) {`
		425	`RESTORE_LEXER;`
		426	`goto ZL4;`
		427	`}`
		428	`}`
		429	`goto ZL3;`
		430	`ZL4:;`
		431	`{`
		432	`{`
		433
		434	`if (!c_propagating_error) {`
		435	`E_c_expected_code ();`
		436	`}`
		437	`}`
		438	`{`
		439
		440	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		441	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		442	`(CURRENT_TERMINAL != C_TOK_BLT_PARAM_ASSIGN) &&`
		443	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		444	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		445	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		446	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		447	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		448	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		449	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		450	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		451	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		452	`}`
		453	`ADVANCE_LEXER;`
		454	`}`
		455	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		456	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		457	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		458	`}`
		459	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		460	`ADVANCE_LEXER;`
		461	`}`
		462	`c_propagating_error = TRUE;`
		463	`}`
		464	`}`
		465	`ZL3:;`
		466	`}`
		467	`}`
		468	`return;`
		469	`ZL1:;`
		470	`SAVE_LEXER (23);`
		471	`return;`
		472	`}`
		473
		474	`static void`
		475	`ZR148 PROTO_Z ()`
		476	`{`
		477	`if ((CURRENT_TERMINAL) == 23) {`
		478	`return;`
		479	`}`
		480	`{`
		481	`switch (CURRENT_TERMINAL) {`
		482	`case 13:`
		483	`break;`
		484	`default:`
		485	`goto ZL1;`
		486	`}`
		487	`ADVANCE_LEXER;`
		488	`{`
		489	`{`
		490	`NStringT ZI79;`
		491
		492	`{`
		493	`switch (CURRENT_TERMINAL) {`
		494	`case 9:`
		495	`{`
		496	`{`
		497
		498	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		499	`}`
		500	`ADVANCE_LEXER;`
		501	`}`
		502	`break;`
		503	`case 8:`
		504	`{`
		505	`{`
		506
		507	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		508	`}`
		509	`ADVANCE_LEXER;`
		510	`}`
		511	`break;`
		512	`default:`
		513	`goto ZL3;`
		514	`}`
		515	`}`
		516	`{`
		517
		518	`if ((c_current_entry = table_get_action (c_current_table, (&ZI79))) ==`
		519	`NIL (EntryP)) {`
		520	`E_c_unknown_action ((&ZI79));`
		521	`} else {`
		522	`ActionP action = entry_get_action (c_current_entry);`
		523
		524	`if (action_get_code (action)) {`
		525	`E_c_action_mult_def ((&ZI79));`
		526	`c_current_entry = NIL (EntryP);`
		527	`}`
		528	`}`
		529	`nstring_destroy (&(ZI79));`
		530	`}`
		531	`{`
		532	`{`
		533	`switch (CURRENT_TERMINAL) {`
		534	`case 15:`
		535	`break;`
		536	`default:`
		537	`goto ZL6;`
		538	`}`
		539	`ADVANCE_LEXER;`
		540	`}`
		541	`goto ZL5;`
		542	`ZL6:;`
		543	`{`
		544	`{`
		545
		546	`if (!c_propagating_error) {`
		547	`E_c_expected_end_action ();`
		548	`}`
		549	`}`
		550	`}`
		551	`ZL5:;`
		552	`}`
		553	`ZR99 ();`
		554	`ZR121 ();`
		555	`{`
		556	`if ((CURRENT_TERMINAL) == 23) {`
		557	`RESTORE_LEXER;`
		558	`goto ZL3;`
		559	`}`
		560	`{`
		561	`CCodeP ZI123;`
		562
		563	`switch (CURRENT_TERMINAL) {`
		564	`case 16:`
		565	`{`
		566
		567	`ZI123 = c_lexer_code_value (c_current_stream);`
		568	`}`
		569	`break;`
		570	`default:`
		571	`goto ZL8;`
		572	`}`
		573	`ADVANCE_LEXER;`
		574	`{`
		575
		576	`if (c_current_entry) {`
		577	`ActionP action = entry_get_action (c_current_entry);`
		578	`TypeTupleP param = action_param (action);`
		579	`TypeTupleP result = action_result (action);`
		580	`BoolT errored = FALSE;`
		581	`KeyP key = entry_key (c_current_entry);`
		582
		583	`if (!types_disjoint_names (&c_saved_type)) {`
		584	`E_c_action_param_clash (key, &c_saved_type);`
		585	`errored = TRUE;`
		586	`}`
		587	`if (!types_fillin_types (&c_saved_type, param)) {`
		588	`E_c_action_param_mismatch (key, param, &c_saved_type);`
		589	`errored = TRUE;`
		590	`}`
		591	`if (!types_disjoint_names (&c_current_type)) {`
		592	`E_c_action_result_clash (key, &c_current_type);`
		593	`errored = TRUE;`
		594	`}`
		595	`if (!types_fillin_types (&c_current_type, result)) {`
		596	`E_c_action_result_mismatch (key, result, &c_current_type);`
		597	`errored = TRUE;`
		598	`}`
		599	`if (types_intersect (&c_saved_type, &c_current_type)) {`
		600	`E_c_action_formal_clash (key, &c_saved_type, &c_current_type);`
		601	`errored = TRUE;`
		602	`}`
		603	`if (errored) {`
		604	`types_destroy (&c_saved_type);`
		605	`types_destroy (&c_current_type);`
		606	`c_code_deallocate ((ZI123));`
		607	`c_current_entry = NIL (EntryP);`
		608	`} else {`
		609	`c_code_check ((ZI123), TRUE, FALSE, &c_saved_type, &c_current_type,`
		610	`c_current_table);`
		611	`types_propogate_mutations (param, &c_saved_type);`
		612	`action_set_code (action, (GenericP) (ZI123));`
		613	`}`
		614	`} else {`
		615	`types_destroy (&c_saved_type);`
		616	`types_destroy (&c_current_type);`
		617	`c_code_deallocate ((ZI123));`
		618	`}`
		619	`}`
		620	`ZR124 ();`
		621	`if ((CURRENT_TERMINAL) == 23) {`
		622	`RESTORE_LEXER;`
		623	`goto ZL8;`
		624	`}`
		625	`}`
		626	`goto ZL7;`
		627	`ZL8:;`
		628	`{`
		629	`{`
		630
		631	`if (!c_propagating_error) {`
		632	`E_c_expected_code ();`
		633	`}`
		634	`}`
		635	`{`
		636
		637	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		638	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		639	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		640	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		641	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		642	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		643	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		644	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		645	`}`
		646	`ADVANCE_LEXER;`
		647	`}`
		648	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		649	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		650	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		651	`}`
		652	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		653	`ADVANCE_LEXER;`
		654	`}`
		655	`c_propagating_error = TRUE;`
		656	`}`
		657	`}`
		658	`ZL7:;`
		659	`}`
		660	`}`
		661	`goto ZL2;`
		662	`ZL3:;`
		663	`{`
		664	`{`
		665
		666	`if (!c_propagating_error) {`
		667	`E_c_expected_identifier ();`
		668	`}`
		669	`}`
		670	`{`
		671
		672	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		673	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		674	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		675	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		676	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		677	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		678	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		679	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		680	`}`
		681	`ADVANCE_LEXER;`
		682	`}`
		683	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		684	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		685	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		686	`}`
		687	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		688	`ADVANCE_LEXER;`
		689	`}`
		690	`c_propagating_error = TRUE;`
		691	`}`
		692	`}`
		693	`ZL2:;`
		694	`}`
		695	`}`
		696	`return;`
		697	`ZL1:;`
		698	`SAVE_LEXER (23);`
		699	`return;`
		700	`}`
		701
		702	`static void`
		703	`ZR107 PROTO_Z ()`
		704	`{`
		705	`if ((CURRENT_TERMINAL) == 23) {`
		706	`return;`
		707	`}`
		708	`ZL2_107:;`
		709	`{`
		710	`ZR101 ();`
		711	`{`
		712	`if ((CURRENT_TERMINAL) == 23) {`
		713	`RESTORE_LEXER;`
		714	`goto ZL1;`
		715	`}`
		716	`{`
		717	`{`
		718
		719	`(ZI0) = ((CURRENT_TERMINAL == C_TOK_CLOSE_TUPLE) \|\|`
		720	`(CURRENT_TERMINAL == C_TOK_EOF) \|\|`
		721	`(c_propagating_error));`
		722	`}`
		723	`if (!ZI0)`
		724	`goto ZL5;`
		725	`goto ZL3;`
		726	`}`
		727	`/UNREACHED/`
		728	`ZL5:;`
		729	`switch (CURRENT_TERMINAL) {`
		730	`case 10:`
		731	`{`
		732	`ADVANCE_LEXER;`
		733	`goto ZL2_107;`
		734	`}`
		735	`/UNREACHED/`
		736	`default:`
		737	`goto ZL4;`
		738	`}`
		739	`/UNREACHED/`
		740	`ZL4:;`
		741	`{`
		742	`{`
		743
		744	`if (!c_propagating_error) {`
		745	`E_c_expected_separator ();`
		746	`}`
		747	`}`
		748	`goto ZL2_107;`
		749	`}`
		750	`/UNREACHED/`
		751	`ZL3:;`
		752	`}`
		753	`}`
		754	`return;`
		755	`ZL1:;`
		756	`SAVE_LEXER (23);`
		757	`return;`
		758	`}`
		759
		760	`static void`
		761	`ZR172 PROTO_Z ()`
		762	`{`
		763	`if ((CURRENT_TERMINAL) == 23) {`
		764	`return;`
		765	`}`
		766	`{`
		767	`switch (CURRENT_TERMINAL) {`
		768	`case 10:`
		769	`break;`
		770	`default:`
		771	`goto ZL1;`
		772	`}`
		773	`ADVANCE_LEXER;`
		774	`}`
		775	`return;`
		776	`ZL1:;`
		777	`{`
		778	`{`
		779
		780	`if (!c_propagating_error) {`
		781	`E_c_expected_separator ();`
		782	`}`
		783	`}`
		784	`}`
		785	`}`
		786
		787	`static void`
		788	`ZR146 PROTO_Z ()`
		789	`{`
		790	`ZL2_146:;`
		791	`switch (CURRENT_TERMINAL) {`
		792	`case 13:`
		793	`{`
		794	`ZR148 ();`
		795	`if ((CURRENT_TERMINAL) == 23) {`
		796	`RESTORE_LEXER;`
		797	`goto ZL1;`
		798	`}`
		799	`{`
		800
		801	`c_propagating_error = FALSE;`
		802	`}`
		803	`goto ZL2_146;`
		804	`}`
		805	`/UNREACHED/`
		806	`case 23:`
		807	`return;`
		808	`default:`
		809	`break;`
		810	`}`
		811	`return;`
		812	`ZL1:;`
		813	`SAVE_LEXER (23);`
		814	`return;`
		815	`}`
		816
		817	`static void`
		818	`ZR127 PROTO_Z ()`
		819	`{`
		820	`if ((CURRENT_TERMINAL) == 23) {`
		821	`return;`
		822	`}`
		823	`{`
		824	`NStringT ZI79;`
		825
		826	`{`
		827	`switch (CURRENT_TERMINAL) {`
		828	`case 9:`
		829	`{`
		830	`{`
		831
		832	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		833	`}`
		834	`ADVANCE_LEXER;`
		835	`}`
		836	`break;`
		837	`case 8:`
		838	`{`
		839	`{`
		840
		841	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		842	`}`
		843	`ADVANCE_LEXER;`
		844	`}`
		845	`break;`
		846	`default:`
		847	`goto ZL1;`
		848	`}`
		849	`}`
		850	`{`
		851
		852	`if ((c_current_entry = table_get_type (c_current_table, (&ZI79))) ==`
		853	`NIL (EntryP)) {`
		854	`E_c_unknown_param_assign ((&ZI79));`
		855	`} else if (type_get_param_assign_code (entry_get_type (c_current_entry))) {`
		856	`E_c_param_assign_mult_def ((&ZI79));`
		857	`c_current_entry = NIL (EntryP);`
		858	`}`
		859	`nstring_destroy (&(ZI79));`
		860	`}`
		861	`ZR99 ();`
		862	`ZR121 ();`
		863	`{`
		864	`if ((CURRENT_TERMINAL) == 23) {`
		865	`RESTORE_LEXER;`
		866	`goto ZL1;`
		867	`}`
		868	`{`
		869	`CCodeP ZI123;`
		870
		871	`switch (CURRENT_TERMINAL) {`
		872	`case 16:`
		873	`{`
		874
		875	`ZI123 = c_lexer_code_value (c_current_stream);`
		876	`}`
		877	`break;`
		878	`default:`
		879	`goto ZL4;`
		880	`}`
		881	`ADVANCE_LEXER;`
		882	`{`
		883
		884	`if (c_current_entry) {`
		885	`BoolT errored = FALSE;`
		886	`KeyP key = entry_key (c_current_entry);`
		887	`TypeTupleT tmp;`
		888
		889	`types_init (&tmp);`
		890	`types_add_type_entry (&tmp, c_current_entry, FALSE);`
		891	`if (!types_disjoint_names (&c_saved_type)) {`
		892	`E_c_param_assign_param_clash (key, &c_saved_type);`
		893	`errored = TRUE;`
		894	`}`
		895	`if (!types_fillin_types (&c_saved_type, &tmp)) {`
		896	`E_c_param_assign_param_mismatch (key, &tmp, &c_saved_type);`
		897	`errored = TRUE;`
		898	`}`
		899	`if (!types_disjoint_names (&c_current_type)) {`
		900	`E_c_param_assign_result_clash (key, &c_current_type);`
		901	`errored = TRUE;`
		902	`}`
		903	`if (!types_fillin_types (&c_current_type, &tmp)) {`
		904	`E_c_param_assign_res_mismatch (key, &tmp, &c_current_type);`
		905	`errored = TRUE;`
		906	`}`
		907	`if (types_intersect (&c_saved_type, &c_current_type)) {`
		908	`E_c_param_assign_formal_clash (key, &c_saved_type,`
		909	`&c_current_type);`
		910	`errored = TRUE;`
		911	`}`
		912	`types_destroy (&tmp);`
		913	`if (errored) {`
		914	`types_destroy (&c_saved_type);`
		915	`types_destroy (&c_current_type);`
		916	`c_code_deallocate ((ZI123));`
		917	`c_current_entry = NIL (EntryP);`
		918	`} else {`
		919	`TypeP type = entry_get_type (c_current_entry);`
		920
		921	`c_code_check ((ZI123), FALSE, TRUE, &c_saved_type, &c_current_type,`
		922	`c_current_table);`
		923	`type_set_param_assign_code (type, (GenericP) (ZI123));`
		924	`}`
		925	`} else {`
		926	`types_destroy (&c_saved_type);`
		927	`types_destroy (&c_current_type);`
		928	`c_code_deallocate ((ZI123));`
		929	`}`
		930	`}`
		931	`ZR124 ();`
		932	`if ((CURRENT_TERMINAL) == 23) {`
		933	`RESTORE_LEXER;`
		934	`goto ZL4;`
		935	`}`
		936	`}`
		937	`goto ZL3;`
		938	`ZL4:;`
		939	`{`
		940	`{`
		941
		942	`if (!c_propagating_error) {`
		943	`E_c_expected_code ();`
		944	`}`
		945	`}`
		946	`{`
		947
		948	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		949	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		950	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		951	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		952	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		953	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		954	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		955	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		956	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		957	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		958	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		959	`}`
		960	`ADVANCE_LEXER;`
		961	`}`
		962	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		963	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		964	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		965	`}`
		966	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		967	`ADVANCE_LEXER;`
		968	`}`
		969	`c_propagating_error = TRUE;`
		970	`}`
		971	`}`
		972	`ZL3:;`
		973	`}`
		974	`}`
		975	`return;`
		976	`ZL1:;`
		977	`SAVE_LEXER (23);`
		978	`return;`
		979	`}`
		980
		981	`static void`
		982	`ZR82 PROTO_Z ()`
		983	`{`
		984	`ZL2_82:;`
		985	`switch (CURRENT_TERMINAL) {`
		986	`case 8: case 9:`
		987	`{`
		988	`ZR84 ();`
		989	`if ((CURRENT_TERMINAL) == 23) {`
		990	`RESTORE_LEXER;`
		991	`goto ZL1;`
		992	`}`
		993	`{`
		994
		995	`c_propagating_error = FALSE;`
		996	`}`
		997	`goto ZL2_82;`
		998	`}`
		999	`/UNREACHED/`
		1000	`case 23:`
		1001	`return;`
		1002	`default:`
		1003	`break;`
		1004	`}`
		1005	`return;`
		1006	`ZL1:;`
		1007	`SAVE_LEXER (23);`
		1008	`return;`
		1009	`}`
		1010
		1011	`static void`
		1012	`ZR84 PROTO_Z ()`
		1013	`{`
		1014	`if ((CURRENT_TERMINAL) == 23) {`
		1015	`return;`
		1016	`}`
		1017	`{`
		1018	`NStringT ZI85;`
		1019
		1020	`{`
		1021	`switch (CURRENT_TERMINAL) {`
		1022	`case 9:`
		1023	`{`
		1024	`{`
		1025
		1026	`nstring_assign (&ZI85, c_lexer_string_value (c_current_stream));`
		1027	`}`
		1028	`ADVANCE_LEXER;`
		1029	`}`
		1030	`break;`
		1031	`case 8:`
		1032	`{`
		1033	`{`
		1034
		1035	`nstring_assign (&ZI85, c_lexer_string_value (c_current_stream));`
		1036	`}`
		1037	`ADVANCE_LEXER;`
		1038	`}`
		1039	`break;`
		1040	`default:`
		1041	`goto ZL1;`
		1042	`}`
		1043	`}`
		1044	`{`
		1045
		1046	`int prefix;`
		1047
		1048	`if (!c_inited_prefix_names) {`
		1049	`nstring_copy_cstring (&(c_prefix_names [CPFX_TYPE]), "type");`
		1050	`nstring_copy_cstring (&(c_prefix_names [CPFX_FN]), "function");`
		1051	`nstring_copy_cstring (&(c_prefix_names [CPFX_IN]), "input");`
		1052	`nstring_copy_cstring (&(c_prefix_names [CPFX_OUT]), "output");`
		1053	`nstring_copy_cstring (&(c_prefix_names [CPFX_LABEL]), "label");`
		1054	`nstring_copy_cstring (&(c_prefix_names [CPFX_TERMINAL]), "terminal");`
		1055	`c_inited_prefix_names = TRUE;`
		1056	`}`
		1057	`for (prefix = 0; prefix < CPFX_NUM_PREFIXES; prefix ++) {`
		1058	`if (nstring_ci_equal ((&ZI85), &(c_prefix_names [prefix]))) {`
		1059	`break;`
		1060	`}`
		1061	`}`
		1062	`if ((c_current_prefix = (CPrefixT) prefix) == CPFX_NUM_PREFIXES) {`
		1063	`E_c_unknown_prefix ((&ZI85));`
		1064	`}`
		1065	`nstring_destroy (&(ZI85));`
		1066	`}`
		1067	`ZR121 ();`
		1068	`{`
		1069	`if ((CURRENT_TERMINAL) == 23) {`
		1070	`RESTORE_LEXER;`
		1071	`goto ZL1;`
		1072	`}`
		1073	`{`
		1074	`NStringT ZI88;`
		1075
		1076	`switch (CURRENT_TERMINAL) {`
		1077	`case 9:`
		1078	`{`
		1079
		1080	`nstring_assign (&ZI88, c_lexer_string_value (c_current_stream));`
		1081	`}`
		1082	`break;`
		1083	`default:`
		1084	`goto ZL4;`
		1085	`}`
		1086	`ADVANCE_LEXER;`
		1087	`{`
		1088
		1089	`if (c_current_prefix == CPFX_NUM_PREFIXES) {`
		1090	`nstring_destroy (&(ZI88));`
		1091	`} else {`
		1092	`NStringP prefix = c_out_info_prefix (c_current_out_info,`
		1093	`c_current_prefix);`
		1094
		1095	`nstring_destroy (prefix);`
		1096	`nstring_assign (prefix, &(ZI88));`
		1097	`}`
		1098	`}`
		1099	`ZR124 ();`
		1100	`if ((CURRENT_TERMINAL) == 23) {`
		1101	`RESTORE_LEXER;`
		1102	`goto ZL4;`
		1103	`}`
		1104	`}`
		1105	`goto ZL3;`
		1106	`ZL4:;`
		1107	`{`
		1108	`{`
		1109
		1110	`if (!c_propagating_error) {`
		1111	`E_c_expected_c_identifier ();`
		1112	`}`
		1113	`}`
		1114	`{`
		1115
		1116	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		1117	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		1118	`(CURRENT_TERMINAL != C_TOK_BLT_MAPS) &&`
		1119	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		1120	`(CURRENT_TERMINAL != C_TOK_BLT_ASSIGNMENTS) &&`
		1121	`(CURRENT_TERMINAL != C_TOK_BLT_PARAM_ASSIGN) &&`
		1122	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		1123	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		1124	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		1125	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1126	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1127	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1128	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		1129	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		1130	`}`
		1131	`ADVANCE_LEXER;`
		1132	`}`
		1133	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1134	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1135	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1136	`}`
		1137	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		1138	`ADVANCE_LEXER;`
		1139	`}`
		1140	`c_propagating_error = TRUE;`
		1141	`}`
		1142	`}`
		1143	`ZL3:;`
		1144	`}`
		1145	`}`
		1146	`return;`
		1147	`ZL1:;`
		1148	`SAVE_LEXER (23);`
		1149	`return;`
		1150	`}`
		1151
		1152	`void`
		1153	`c_parse_grammar PROTO_Z ()`
		1154	`{`
		1155	`if ((CURRENT_TERMINAL) == 23) {`
		1156	`return;`
		1157	`}`
		1158	`{`
		1159	`{`
		1160	`switch (CURRENT_TERMINAL) {`
		1161	`case 0:`
		1162	`{`
		1163	`ADVANCE_LEXER;`
		1164	`ZR82 ();`
		1165	`if ((CURRENT_TERMINAL) == 23) {`
		1166	`RESTORE_LEXER;`
		1167	`goto ZL1;`
		1168	`}`
		1169	`}`
		1170	`break;`
		1171	`default:`
		1172	`break;`
		1173	`}`
		1174	`}`
		1175	`{`
		1176	`switch (CURRENT_TERMINAL) {`
		1177	`case 1:`
		1178	`{`
		1179	`ADVANCE_LEXER;`
		1180	`ZR90 ();`
		1181	`if ((CURRENT_TERMINAL) == 23) {`
		1182	`RESTORE_LEXER;`
		1183	`goto ZL1;`
		1184	`}`
		1185	`}`
		1186	`break;`
		1187	`default:`
		1188	`break;`
		1189	`}`
		1190	`}`
		1191	`{`
		1192	`{`
		1193	`switch (CURRENT_TERMINAL) {`
		1194	`case 4:`
		1195	`break;`
		1196	`default:`
		1197	`goto ZL5;`
		1198	`}`
		1199	`ADVANCE_LEXER;`
		1200	`}`
		1201	`goto ZL4;`
		1202	`ZL5:;`
		1203	`{`
		1204	`{`
		1205
		1206	`if (!c_propagating_error) {`
		1207	`E_c_expected_blt_header ();`
		1208	`}`
		1209	`}`
		1210	`}`
		1211	`ZL4:;`
		1212	`}`
		1213	`{`
		1214	`{`
		1215	`CCodeP ZI159;`
		1216
		1217	`switch (CURRENT_TERMINAL) {`
		1218	`case 16:`
		1219	`{`
		1220
		1221	`ZI159 = c_lexer_code_value (c_current_stream);`
		1222	`}`
		1223	`break;`
		1224	`default:`
		1225	`goto ZL7;`
		1226	`}`
		1227	`ADVANCE_LEXER;`
		1228	`{`
		1229
		1230	`c_code_check ((ZI159), FALSE, FALSE, NIL (TypeTupleP), NIL (TypeTupleP),`
		1231	`c_current_table);`
		1232	`c_out_info_set_header1 (c_current_out_info, (ZI159));`
		1233	`}`
		1234	`}`
		1235	`goto ZL6;`
		1236	`ZL7:;`
		1237	`{`
		1238	`{`
		1239
		1240	`if (!c_propagating_error) {`
		1241	`E_c_expected_code ();`
		1242	`}`
		1243	`}`
		1244	`}`
		1245	`ZL6:;`
		1246	`}`
		1247	`ZR172 ();`
		1248	`{`
		1249	`if ((CURRENT_TERMINAL) == 23) {`
		1250	`RESTORE_LEXER;`
		1251	`goto ZL1;`
		1252	`}`
		1253	`{`
		1254	`CCodeP ZI162;`
		1255
		1256	`switch (CURRENT_TERMINAL) {`
		1257	`case 16:`
		1258	`{`
		1259
		1260	`ZI162 = c_lexer_code_value (c_current_stream);`
		1261	`}`
		1262	`break;`
		1263	`default:`
		1264	`goto ZL9;`
		1265	`}`
		1266	`ADVANCE_LEXER;`
		1267	`{`
		1268
		1269	`c_code_check ((ZI162), FALSE, FALSE, NIL (TypeTupleP), NIL (TypeTupleP),`
		1270	`c_current_table);`
		1271	`c_out_info_set_header2 (c_current_out_info, (ZI162));`
		1272	`}`
		1273	`}`
		1274	`goto ZL8;`
		1275	`ZL9:;`
		1276	`{`
		1277	`{`
		1278
		1279	`if (!c_propagating_error) {`
		1280	`E_c_expected_code ();`
		1281	`}`
		1282	`}`
		1283	`}`
		1284	`ZL8:;`
		1285	`}`
		1286	`ZR124 ();`
		1287	`{`
		1288	`switch (CURRENT_TERMINAL) {`
		1289	`case 2:`
		1290	`{`
		1291	`ADVANCE_LEXER;`
		1292	`ZR117 ();`
		1293	`if ((CURRENT_TERMINAL) == 23) {`
		1294	`RESTORE_LEXER;`
		1295	`goto ZL1;`
		1296	`}`
		1297	`}`
		1298	`break;`
		1299	`case 23:`
		1300	`RESTORE_LEXER;`
		1301	`goto ZL1;`
		1302	`default:`
		1303	`break;`
		1304	`}`
		1305	`}`
		1306	`{`
		1307	`switch (CURRENT_TERMINAL) {`
		1308	`case 20:`
		1309	`{`
		1310	`ADVANCE_LEXER;`
		1311	`ZR125 ();`
		1312	`if ((CURRENT_TERMINAL) == 23) {`
		1313	`RESTORE_LEXER;`
		1314	`goto ZL1;`
		1315	`}`
		1316	`}`
		1317	`break;`
		1318	`default:`
		1319	`break;`
		1320	`}`
		1321	`}`
		1322	`{`
		1323	`switch (CURRENT_TERMINAL) {`
		1324	`case 7:`
		1325	`{`
		1326	`ADVANCE_LEXER;`
		1327	`ZR132 ();`
		1328	`if ((CURRENT_TERMINAL) == 23) {`
		1329	`RESTORE_LEXER;`
		1330	`goto ZL1;`
		1331	`}`
		1332	`}`
		1333	`break;`
		1334	`default:`
		1335	`break;`
		1336	`}`
		1337	`}`
		1338	`{`
		1339	`{`
		1340	`switch (CURRENT_TERMINAL) {`
		1341	`case 3:`
		1342	`break;`
		1343	`default:`
		1344	`goto ZL14;`
		1345	`}`
		1346	`ADVANCE_LEXER;`
		1347	`}`
		1348	`goto ZL13;`
		1349	`ZL14:;`
		1350	`{`
		1351	`{`
		1352
		1353	`if (!c_propagating_error) {`
		1354	`E_c_expected_blt_terminals ();`
		1355	`}`
		1356	`}`
		1357	`}`
		1358	`ZL13:;`
		1359	`}`
		1360	`ZR139 ();`
		1361	`{`
		1362	`if ((CURRENT_TERMINAL) == 23) {`
		1363	`RESTORE_LEXER;`
		1364	`goto ZL1;`
		1365	`}`
		1366	`{`
		1367	`switch (CURRENT_TERMINAL) {`
		1368	`case 5:`
		1369	`break;`
		1370	`default:`
		1371	`goto ZL16;`
		1372	`}`
		1373	`ADVANCE_LEXER;`
		1374	`}`
		1375	`goto ZL15;`
		1376	`ZL16:;`
		1377	`{`
		1378	`{`
		1379
		1380	`if (!c_propagating_error) {`
		1381	`E_c_expected_blt_actions ();`
		1382	`}`
		1383	`}`
		1384	`}`
		1385	`ZL15:;`
		1386	`}`
		1387	`ZR146 ();`
		1388	`{`
		1389	`if ((CURRENT_TERMINAL) == 23) {`
		1390	`RESTORE_LEXER;`
		1391	`goto ZL1;`
		1392	`}`
		1393	`{`
		1394	`switch (CURRENT_TERMINAL) {`
		1395	`case 6:`
		1396	`break;`
		1397	`default:`
		1398	`goto ZL18;`
		1399	`}`
		1400	`ADVANCE_LEXER;`
		1401	`}`
		1402	`goto ZL17;`
		1403	`ZL18:;`
		1404	`{`
		1405	`{`
		1406
		1407	`if (!c_propagating_error) {`
		1408	`E_c_expected_blt_trailer ();`
		1409	`}`
		1410	`}`
		1411	`}`
		1412	`ZL17:;`
		1413	`}`
		1414	`{`
		1415	`{`
		1416	`CCodeP ZI171;`
		1417
		1418	`switch (CURRENT_TERMINAL) {`
		1419	`case 16:`
		1420	`{`
		1421
		1422	`ZI171 = c_lexer_code_value (c_current_stream);`
		1423	`}`
		1424	`break;`
		1425	`default:`
		1426	`goto ZL20;`
		1427	`}`
		1428	`ADVANCE_LEXER;`
		1429	`{`
		1430
		1431	`c_code_check ((ZI171), FALSE, FALSE, NIL (TypeTupleP), NIL (TypeTupleP),`
		1432	`c_current_table);`
		1433	`c_out_info_set_trailer1 (c_current_out_info, (ZI171));`
		1434	`}`
		1435	`}`
		1436	`goto ZL19;`
		1437	`ZL20:;`
		1438	`{`
		1439	`{`
		1440
		1441	`if (!c_propagating_error) {`
		1442	`E_c_expected_code ();`
		1443	`}`
		1444	`}`
		1445	`}`
		1446	`ZL19:;`
		1447	`}`
		1448	`ZR172 ();`
		1449	`{`
		1450	`if ((CURRENT_TERMINAL) == 23) {`
		1451	`RESTORE_LEXER;`
		1452	`goto ZL1;`
		1453	`}`
		1454	`{`
		1455	`CCodeP ZI174;`
		1456
		1457	`switch (CURRENT_TERMINAL) {`
		1458	`case 16:`
		1459	`{`
		1460
		1461	`ZI174 = c_lexer_code_value (c_current_stream);`
		1462	`}`
		1463	`break;`
		1464	`default:`
		1465	`goto ZL22;`
		1466	`}`
		1467	`ADVANCE_LEXER;`
		1468	`{`
		1469
		1470	`c_code_check ((ZI174), FALSE, FALSE, NIL (TypeTupleP), NIL (TypeTupleP),`
		1471	`c_current_table);`
		1472	`c_out_info_set_trailer2 (c_current_out_info, (ZI174));`
		1473	`}`
		1474	`}`
		1475	`goto ZL21;`
		1476	`ZL22:;`
		1477	`{`
		1478	`{`
		1479
		1480	`if (!c_propagating_error) {`
		1481	`E_c_expected_code ();`
		1482	`}`
		1483	`}`
		1484	`}`
		1485	`ZL21:;`
		1486	`}`
		1487	`ZR124 ();`
		1488	`{`
		1489	`if ((CURRENT_TERMINAL) == 23) {`
		1490	`RESTORE_LEXER;`
		1491	`goto ZL1;`
		1492	`}`
		1493	`{`
		1494	`switch (CURRENT_TERMINAL) {`
		1495	`case 22:`
		1496	`break;`
		1497	`default:`
		1498	`goto ZL24;`
		1499	`}`
		1500	`ADVANCE_LEXER;`
		1501	`}`
		1502	`goto ZL23;`
		1503	`ZL24:;`
		1504	`{`
		1505	`{`
		1506
		1507	`if (!c_propagating_error) {`
		1508	`E_c_expected_eof ();`
		1509	`}`
		1510	`}`
		1511	`}`
		1512	`ZL23:;`
		1513	`}`
		1514	`}`
		1515	`return;`
		1516	`ZL1:;`
		1517	`{`
		1518	`{`
		1519
		1520	`UNREACHED;`
		1521	`}`
		1522	`}`
		1523	`}`
		1524
		1525	`static void`
		1526	`ZR110 PROTO_Z ()`
		1527	`{`
		1528	`switch (CURRENT_TERMINAL) {`
		1529	`case 9:`
		1530	`{`
		1531	`ZR107 ();`
		1532	`if ((CURRENT_TERMINAL) == 23) {`
		1533	`RESTORE_LEXER;`
		1534	`goto ZL1;`
		1535	`}`
		1536	`}`
		1537	`break;`
		1538	`case 23:`
		1539	`return;`
		1540	`default:`
		1541	`break;`
		1542	`}`
		1543	`return;`
		1544	`ZL1:;`
		1545	`SAVE_LEXER (23);`
		1546	`return;`
		1547	`}`
		1548
		1549	`static void`
		1550	`ZR112 PROTO_Z ()`
		1551	`{`
		1552	`if ((CURRENT_TERMINAL) == 23) {`
		1553	`return;`
		1554	`}`
		1555	`{`
		1556	`{`
		1557
		1558	`types_init (&c_current_type);`
		1559	`}`
		1560	`{`
		1561	`{`
		1562	`switch (CURRENT_TERMINAL) {`
		1563	`case 18:`
		1564	`break;`
		1565	`default:`
		1566	`goto ZL3;`
		1567	`}`
		1568	`ADVANCE_LEXER;`
		1569	`}`
		1570	`goto ZL2;`
		1571	`ZL3:;`
		1572	`{`
		1573	`{`
		1574
		1575	`if (!c_propagating_error) {`
		1576	`E_c_expected_open_tuple ();`
		1577	`}`
		1578	`}`
		1579	`}`
		1580	`ZL2:;`
		1581	`}`
		1582	`ZR110 ();`
		1583	`if ((CURRENT_TERMINAL) == 23) {`
		1584	`RESTORE_LEXER;`
		1585	`goto ZL1;`
		1586	`}`
		1587	`{`
		1588
		1589	`c_propagating_error = FALSE;`
		1590	`}`
		1591	`{`
		1592	`{`
		1593	`switch (CURRENT_TERMINAL) {`
		1594	`case 19:`
		1595	`break;`
		1596	`default:`
		1597	`goto ZL5;`
		1598	`}`
		1599	`ADVANCE_LEXER;`
		1600	`}`
		1601	`goto ZL4;`
		1602	`ZL5:;`
		1603	`{`
		1604	`{`
		1605
		1606	`if (!c_propagating_error) {`
		1607	`E_c_expected_close_tuple ();`
		1608	`}`
		1609	`}`
		1610	`}`
		1611	`ZL4:;`
		1612	`}`
		1613	`}`
		1614	`return;`
		1615	`ZL1:;`
		1616	`SAVE_LEXER (23);`
		1617	`return;`
		1618	`}`
		1619
		1620	`static void`
		1621	`ZR134 PROTO_Z ()`
		1622	`{`
		1623	`if ((CURRENT_TERMINAL) == 23) {`
		1624	`return;`
		1625	`}`
		1626	`{`
		1627	`NStringT ZI79;`
		1628
		1629	`{`
		1630	`switch (CURRENT_TERMINAL) {`
		1631	`case 9:`
		1632	`{`
		1633	`{`
		1634
		1635	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		1636	`}`
		1637	`ADVANCE_LEXER;`
		1638	`}`
		1639	`break;`
		1640	`case 8:`
		1641	`{`
		1642	`{`
		1643
		1644	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		1645	`}`
		1646	`ADVANCE_LEXER;`
		1647	`}`
		1648	`break;`
		1649	`default:`
		1650	`goto ZL1;`
		1651	`}`
		1652	`}`
		1653	`{`
		1654
		1655	`if ((c_current_entry = table_get_type (c_current_table, (&ZI79))) ==`
		1656	`NIL (EntryP)) {`
		1657	`E_c_unknown_result_assign ((&ZI79));`
		1658	`} else if (type_get_result_assign_code (entry_get_type (c_current_entry))) {`
		1659	`E_c_result_assign_mult_def ((&ZI79));`
		1660	`c_current_entry = NIL (EntryP);`
		1661	`}`
		1662	`nstring_destroy (&(ZI79));`
		1663	`}`
		1664	`ZR99 ();`
		1665	`ZR121 ();`
		1666	`{`
		1667	`if ((CURRENT_TERMINAL) == 23) {`
		1668	`RESTORE_LEXER;`
		1669	`goto ZL1;`
		1670	`}`
		1671	`{`
		1672	`CCodeP ZI123;`
		1673
		1674	`switch (CURRENT_TERMINAL) {`
		1675	`case 16:`
		1676	`{`
		1677
		1678	`ZI123 = c_lexer_code_value (c_current_stream);`
		1679	`}`
		1680	`break;`
		1681	`default:`
		1682	`goto ZL4;`
		1683	`}`
		1684	`ADVANCE_LEXER;`
		1685	`{`
		1686
		1687	`if (c_current_entry) {`
		1688	`BoolT errored = FALSE;`
		1689	`KeyP key = entry_key (c_current_entry);`
		1690	`TypeTupleT tmp;`
		1691
		1692	`types_init (&tmp);`
		1693	`types_add_type_entry (&tmp, c_current_entry, FALSE);`
		1694	`if (!types_disjoint_names (&c_saved_type)) {`
		1695	`E_c_result_assign_param_clash (key, &c_saved_type);`
		1696	`errored = TRUE;`
		1697	`}`
		1698	`if (!types_fillin_types (&c_saved_type, &tmp)) {`
		1699	`E_c_res_assign_param_mismatch (key, &tmp, &c_saved_type);`
		1700	`errored = TRUE;`
		1701	`}`
		1702	`if (!types_disjoint_names (&c_current_type)) {`
		1703	`E_c_result_assign_result_clash (key, &c_current_type);`
		1704	`errored = TRUE;`
		1705	`}`
		1706	`if (!types_fillin_types (&c_current_type, &tmp)) {`
		1707	`E_c_res_assign_result_mismatch (key, &tmp, &c_current_type);`
		1708	`errored = TRUE;`
		1709	`}`
		1710	`if (types_intersect (&c_saved_type, &c_current_type)) {`
		1711	`E_c_result_assign_formal_clash (key, &c_saved_type,`
		1712	`&c_current_type);`
		1713	`errored = TRUE;`
		1714	`}`
		1715	`types_destroy (&tmp);`
		1716	`if (errored) {`
		1717	`types_destroy (&c_saved_type);`
		1718	`types_destroy (&c_current_type);`
		1719	`c_code_deallocate ((ZI123));`
		1720	`c_current_entry = NIL (EntryP);`
		1721	`} else {`
		1722	`TypeP type = entry_get_type (c_current_entry);`
		1723
		1724	`c_code_check ((ZI123), FALSE, FALSE, &c_saved_type, &c_current_type,`
		1725	`c_current_table);`
		1726	`type_set_result_assign_code (type, (GenericP) (ZI123));`
		1727	`}`
		1728	`} else {`
		1729	`types_destroy (&c_saved_type);`
		1730	`types_destroy (&c_current_type);`
		1731	`c_code_deallocate ((ZI123));`
		1732	`}`
		1733	`}`
		1734	`ZR124 ();`
		1735	`if ((CURRENT_TERMINAL) == 23) {`
		1736	`RESTORE_LEXER;`
		1737	`goto ZL4;`
		1738	`}`
		1739	`}`
		1740	`goto ZL3;`
		1741	`ZL4:;`
		1742	`{`
		1743	`{`
		1744
		1745	`if (!c_propagating_error) {`
		1746	`E_c_expected_code ();`
		1747	`}`
		1748	`}`
		1749	`{`
		1750
		1751	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		1752	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		1753	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		1754	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		1755	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		1756	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1757	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1758	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1759	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		1760	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		1761	`}`
		1762	`ADVANCE_LEXER;`
		1763	`}`
		1764	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1765	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1766	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1767	`}`
		1768	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		1769	`ADVANCE_LEXER;`
		1770	`}`
		1771	`c_propagating_error = TRUE;`
		1772	`}`
		1773	`}`
		1774	`ZL3:;`
		1775	`}`
		1776	`}`
		1777	`return;`
		1778	`ZL1:;`
		1779	`SAVE_LEXER (23);`
		1780	`return;`
		1781	`}`
		1782
		1783	`static void`
		1784	`ZR101 PROTO_Z ()`
		1785	`{`
		1786	`if ((CURRENT_TERMINAL) == 23) {`
		1787	`return;`
		1788	`}`
		1789	`{`
		1790	`NStringT ZI88;`
		1791
		1792	`switch (CURRENT_TERMINAL) {`
		1793	`case 9:`
		1794	`{`
		1795
		1796	`nstring_assign (&ZI88, c_lexer_string_value (c_current_stream));`
		1797	`}`
		1798	`break;`
		1799	`default:`
		1800	`goto ZL1;`
		1801	`}`
		1802	`ADVANCE_LEXER;`
		1803	`{`
		1804	`switch (CURRENT_TERMINAL) {`
		1805	`case 11:`
		1806	`{`
		1807	`ADVANCE_LEXER;`
		1808	`{`
		1809	`{`
		1810	`NStringT ZI105;`
		1811
		1812	`{`
		1813	`switch (CURRENT_TERMINAL) {`
		1814	`case 9:`
		1815	`{`
		1816	`{`
		1817
		1818	`nstring_assign (&ZI105, c_lexer_string_value (c_current_stream));`
		1819	`}`
		1820	`ADVANCE_LEXER;`
		1821	`}`
		1822	`break;`
		1823	`case 8:`
		1824	`{`
		1825	`{`
		1826
		1827	`nstring_assign (&ZI105, c_lexer_string_value (c_current_stream));`
		1828	`}`
		1829	`ADVANCE_LEXER;`
		1830	`}`
		1831	`break;`
		1832	`default:`
		1833	`goto ZL4;`
		1834	`}`
		1835	`}`
		1836	`{`
		1837	`switch (CURRENT_TERMINAL) {`
		1838	`case 21:`
		1839	`{`
		1840	`ADVANCE_LEXER;`
		1841	`{`
		1842
		1843	`if (!types_add_typed_name (&c_current_type, c_current_table, &(ZI88),`
		1844	`(&ZI105), TRUE)) {`
		1845	`E_c_unknown_type ((&ZI105));`
		1846	`}`
		1847	`nstring_destroy (&(ZI105));`
		1848	`}`
		1849	`}`
		1850	`break;`
		1851	`default:`
		1852	`{`
		1853	`{`
		1854
		1855	`if (!types_add_typed_name (&c_current_type, c_current_table, &(ZI88),`
		1856	`(&ZI105), FALSE)) {`
		1857	`E_c_unknown_type ((&ZI105));`
		1858	`}`
		1859	`nstring_destroy (&(ZI105));`
		1860	`}`
		1861	`}`
		1862	`break;`
		1863	`}`
		1864	`}`
		1865	`}`
		1866	`goto ZL3;`
		1867	`ZL4:;`
		1868	`{`
		1869	`{`
		1870
		1871	`if (!c_propagating_error) {`
		1872	`E_c_expected_identifier ();`
		1873	`}`
		1874	`}`
		1875	`{`
		1876
		1877	`nstring_destroy (&(ZI88));`
		1878	`}`
		1879	`{`
		1880
		1881	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		1882	`(CURRENT_TERMINAL != C_TOK_DEFINE) &&`
		1883	`(CURRENT_TERMINAL != C_TOK_CODE) &&`
		1884	`(CURRENT_TERMINAL != C_TOK_SEPARATOR) &&`
		1885	`(CURRENT_TERMINAL != C_TOK_CLOSE_TUPLE) &&`
		1886	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		1887	`(CURRENT_TERMINAL != C_TOK_BLT_PARAM_ASSIGN) &&`
		1888	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		1889	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		1890	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		1891	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		1892	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1893	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1894	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1895	`}`
		1896	`ADVANCE_LEXER;`
		1897	`}`
		1898	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1899	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1900	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1901	`}`
		1902	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		1903	`ADVANCE_LEXER;`
		1904	`}`
		1905	`c_propagating_error = TRUE;`
		1906	`}`
		1907	`}`
		1908	`ZL3:;`
		1909	`}`
		1910	`}`
		1911	`break;`
		1912	`default:`
		1913	`{`
		1914	`{`
		1915
		1916	`types_add_name (&c_current_type, c_current_table, &(ZI88), FALSE);`
		1917	`}`
		1918	`}`
		1919	`break;`
		1920	`}`
		1921	`}`
		1922	`}`
		1923	`return;`
		1924	`ZL1:;`
		1925	`{`
		1926	`{`
		1927
		1928	`if (!c_propagating_error) {`
		1929	`E_c_expected_identifier ();`
		1930	`}`
		1931	`}`
		1932	`{`
		1933
		1934	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		1935	`(CURRENT_TERMINAL != C_TOK_DEFINE) &&`
		1936	`(CURRENT_TERMINAL != C_TOK_CODE) &&`
		1937	`(CURRENT_TERMINAL != C_TOK_SEPARATOR) &&`
		1938	`(CURRENT_TERMINAL != C_TOK_CLOSE_TUPLE) &&`
		1939	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		1940	`(CURRENT_TERMINAL != C_TOK_BLT_PARAM_ASSIGN) &&`
		1941	`(CURRENT_TERMINAL != C_TOK_BLT_RESULT_ASSIGN) &&`
		1942	`(CURRENT_TERMINAL != C_TOK_BLT_TERMINALS) &&`
		1943	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		1944	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		1945	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1946	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1947	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1948	`}`
		1949	`ADVANCE_LEXER;`
		1950	`}`
		1951	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		1952	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		1953	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		1954	`}`
		1955	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		1956	`ADVANCE_LEXER;`
		1957	`}`
		1958	`c_propagating_error = TRUE;`
		1959	`}`
		1960	`}`
		1961	`}`
		1962
		1963	`static void`
		1964	`ZR141 PROTO_Z ()`
		1965	`{`
		1966	`if ((CURRENT_TERMINAL) == 23) {`
		1967	`return;`
		1968	`}`
		1969	`{`
		1970	`NStringT ZI79;`
		1971
		1972	`{`
		1973	`switch (CURRENT_TERMINAL) {`
		1974	`case 9:`
		1975	`{`
		1976	`{`
		1977
		1978	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		1979	`}`
		1980	`ADVANCE_LEXER;`
		1981	`}`
		1982	`break;`
		1983	`case 8:`
		1984	`{`
		1985	`{`
		1986
		1987	`nstring_assign (&ZI79, c_lexer_string_value (c_current_stream));`
		1988	`}`
		1989	`ADVANCE_LEXER;`
		1990	`}`
		1991	`break;`
		1992	`default:`
		1993	`goto ZL1;`
		1994	`}`
		1995	`}`
		1996	`{`
		1997
		1998	`if ((c_current_entry = table_get_basic (c_current_table, (&ZI79))) ==`
		1999	`NIL (EntryP)) {`
		2000	`E_c_unknown_basic ((&ZI79));`
		2001	`} else {`
		2002	`BasicP basic = entry_get_basic (c_current_entry);`
		2003
		2004	`if (basic_get_result_code (basic)) {`
		2005	`E_c_basic_mult_def ((&ZI79));`
		2006	`c_current_entry = NIL (EntryP);`
		2007	`} else if (types_equal_zero_tuple (basic_result (basic))) {`
		2008	`E_c_basic_has_no_result ((&ZI79));`
		2009	`c_current_entry = NIL (EntryP);`
		2010	`}`
		2011	`}`
		2012	`nstring_destroy (&(ZI79));`
		2013	`}`
		2014	`ZR99 ();`
		2015	`ZR121 ();`
		2016	`{`
		2017	`if ((CURRENT_TERMINAL) == 23) {`
		2018	`RESTORE_LEXER;`
		2019	`goto ZL1;`
		2020	`}`
		2021	`{`
		2022	`CCodeP ZI123;`
		2023
		2024	`switch (CURRENT_TERMINAL) {`
		2025	`case 16:`
		2026	`{`
		2027
		2028	`ZI123 = c_lexer_code_value (c_current_stream);`
		2029	`}`
		2030	`break;`
		2031	`default:`
		2032	`goto ZL4;`
		2033	`}`
		2034	`ADVANCE_LEXER;`
		2035	`{`
		2036
		2037	`if (c_current_entry) {`
		2038	`BasicP basic = entry_get_basic (c_current_entry);`
		2039	`TypeTupleP result = basic_result (basic);`
		2040	`BoolT errored = FALSE;`
		2041	`KeyP key = entry_key (c_current_entry);`
		2042
		2043	`if (!types_disjoint_names (&c_saved_type)) {`
		2044	`E_c_basic_param_clash (key, &c_saved_type);`
		2045	`errored = TRUE;`
		2046	`}`
		2047	`if (!types_equal_zero_tuple (&c_saved_type)) {`
		2048	`E_c_basic_param_mismatch (key, &c_saved_type);`
		2049	`errored = TRUE;`
		2050	`}`
		2051	`if (!types_disjoint_names (&c_current_type)) {`
		2052	`E_c_basic_result_clash (key, &c_current_type);`
		2053	`errored = TRUE;`
		2054	`}`
		2055	`if (!types_fillin_types (&c_current_type, result)) {`
		2056	`E_c_basic_result_mismatch (key, result, &c_current_type);`
		2057	`errored = TRUE;`
		2058	`}`
		2059	`if (types_intersect (&c_saved_type, &c_current_type)) {`
		2060	`E_c_basic_formal_clash (key, &c_saved_type, &c_current_type);`
		2061	`errored = TRUE;`
		2062	`}`
		2063	`if (errored) {`
		2064	`types_destroy (&c_saved_type);`
		2065	`types_destroy (&c_current_type);`
		2066	`c_code_deallocate ((ZI123));`
		2067	`c_current_entry = NIL (EntryP);`
		2068	`} else {`
		2069	`types_destroy (&c_saved_type);`
		2070	`c_code_check ((ZI123), FALSE, FALSE, NIL (TypeTupleP),`
		2071	`&c_current_type, c_current_table);`
		2072	`basic_set_result_code (basic, (GenericP) (ZI123));`
		2073	`}`
		2074	`} else {`
		2075	`types_destroy (&c_saved_type);`
		2076	`types_destroy (&c_current_type);`
		2077	`c_code_deallocate ((ZI123));`
		2078	`}`
		2079	`}`
		2080	`ZR124 ();`
		2081	`if ((CURRENT_TERMINAL) == 23) {`
		2082	`RESTORE_LEXER;`
		2083	`goto ZL4;`
		2084	`}`
		2085	`}`
		2086	`goto ZL3;`
		2087	`ZL4:;`
		2088	`{`
		2089	`{`
		2090
		2091	`if (!c_propagating_error) {`
		2092	`E_c_expected_code ();`
		2093	`}`
		2094	`}`
		2095	`{`
		2096
		2097	`while ((CURRENT_TERMINAL != C_TOK_EOF) &&`
		2098	`(CURRENT_TERMINAL != C_TOK_TERMINATOR) &&`
		2099	`(CURRENT_TERMINAL != C_TOK_BLT_ACTIONS) &&`
		2100	`(CURRENT_TERMINAL != C_TOK_BLT_TRAILER)) {`
		2101	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		2102	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		2103	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		2104	`} else if (CURRENT_TERMINAL == C_TOK_CODE) {`
		2105	`c_code_deallocate (c_lexer_code_value (c_current_stream));`
		2106	`}`
		2107	`ADVANCE_LEXER;`
		2108	`}`
		2109	`if ((CURRENT_TERMINAL == C_TOK_SID_IDENTIFIER) \|\|`
		2110	`(CURRENT_TERMINAL == C_TOK_C_IDENTIFIER)) {`
		2111	`nstring_destroy (c_lexer_string_value (c_current_stream));`
		2112	`}`
		2113	`if (CURRENT_TERMINAL != C_TOK_EOF) {`
		2114	`ADVANCE_LEXER;`
		2115	`}`
		2116	`c_propagating_error = TRUE;`
		2117	`}`
		2118	`}`
		2119	`ZL3:;`
		2120	`}`
		2121	`}`
		2122	`return;`
		2123	`ZL1:;`
		2124	`SAVE_LEXER (23);`
		2125	`return;`
		2126	`}`
		2127
		2128	`static void`
		2129	`ZR90 PROTO_Z ()`
		2130	`{`
		2131	`ZL2_90:;`
		2132	`switch (CURRENT_TERMINAL) {`
		2133	`case 8: case 9:`
		2134	`{`
		2135	`ZR92 ();`
		2136	`if ((CURRENT_TERMINAL) == 23) {`
		2137	`RESTORE_LEXER;`
		2138	`goto ZL1;`
		2139	`}`
		2140	`{`
		2141
		2142	`c_propagating_error = FALSE;`
		2143	`}`
		2144	`goto ZL2_90;`
		2145	`}`
		2146	`/UNREACHED/`
		2147	`case 23:`
		2148	`return;`
		2149	`default:`
		2150	`break;`
		2151	`}`
		2152	`return;`
		2153	`ZL1:;`
		2154	`SAVE_LEXER (23);`
		2155	`return;`
		2156	`}`
		2157
		2158	`static void`
		2159	`ZR99 PROTO_Z ()`
		2160	`{`
		2161	`switch (CURRENT_TERMINAL) {`
		2162	`case 11:`
		2163	`{`
		2164	`ADVANCE_LEXER;`
		2165	`ZR112 ();`
		2166	`if ((CURRENT_TERMINAL) == 23) {`
		2167	`RESTORE_LEXER;`
		2168	`goto ZL1;`
		2169	`}`
		2170	`{`
		2171
		2172	`types_assign (&c_saved_type, &c_current_type);`
		2173	`}`
		2174	`ZR116 ();`
		2175	`ZR112 ();`
		2176	`if ((CURRENT_TERMINAL) == 23) {`
		2177	`RESTORE_LEXER;`
		2178	`goto ZL1;`
		2179	`}`
		2180	`}`
		2181	`break;`
		2182	`default:`
		2183	`{`
		2184	`{`
		2185
		2186	`types_init (&c_saved_type);`
		2187	`types_init (&c_current_type);`
		2188	`}`
		2189	`}`
		2190	`break;`
		2191	`case 23:`
		2192	`return;`
		2193	`}`
		2194	`return;`
		2195	`ZL1:;`
		2196	`SAVE_LEXER (23);`
		2197	`return;`
		2198	`}`
		2199
		2200	`static void`
		2201	`ZR117 PROTO_Z ()`
		2202	`{`
		2203	`ZL2_117:;`
		2204	`switch (CURRENT_TERMINAL) {`
		2205	`case 8: case 9:`
		2206	`{`
		2207	`ZR119 ();`
		2208	`if ((CURRENT_TERMINAL) == 23) {`
		2209	`RESTORE_LEXER;`
		2210	`goto ZL1;`
		2211	`}`
		2212	`{`
		2213
		2214	`c_propagating_error = FALSE;`
		2215	`}`
		2216	`goto ZL2_117;`
		2217	`}`
		2218	`/UNREACHED/`
		2219	`case 23:`
		2220	`return;`
		2221	`default:`
		2222	`break;`
		2223	`}`
		2224	`return;`
		2225	`ZL1:;`
		2226	`SAVE_LEXER (23);`
		2227	`return;`
		2228	`}`
		2229
		2230	`static void`
		2231	`ZR116 PROTO_Z ()`
		2232	`{`
		2233	`if ((CURRENT_TERMINAL) == 23) {`
		2234	`return;`
		2235	`}`
		2236	`{`
		2237	`switch (CURRENT_TERMINAL) {`
		2238	`case 17:`
		2239	`break;`
		2240	`default:`
		2241	`goto ZL1;`
		2242	`}`
		2243	`ADVANCE_LEXER;`
		2244	`}`
		2245	`return;`
		2246	`ZL1:;`
		2247	`{`
		2248	`{`
		2249
		2250	`if (!c_propagating_error) {`
		2251	`E_c_expected_arrow ();`
		2252	`}`
		2253	`}`
		2254	`}`
		2255	`}`
		2256
		2257	`static void`
		2258	`ZR125 PROTO_Z ()`
		2259	`{`
		2260	`ZL2_125:;`
		2261	`switch (CURRENT_TERMINAL) {`
		2262	`case 8: case 9:`
		2263	`{`
		2264	`ZR127 ();`
		2265	`if ((CURRENT_TERMINAL) == 23) {`
		2266	`RESTORE_LEXER;`
		2267	`goto ZL1;`
		2268	`}`
		2269	`{`
		2270
		2271	`c_propagating_error = FALSE;`
		2272	`}`
		2273	`goto ZL2_125;`
		2274	`}`
		2275	`/UNREACHED/`
		2276	`case 23:`
		2277	`return;`
		2278	`default:`
		2279	`break;`
		2280	`}`
		2281	`return;`
		2282	`ZL1:;`
		2283	`SAVE_LEXER (23);`
		2284	`return;`
		2285	`}`
		2286
		2287	`static void`
		2288	`ZR121 PROTO_Z ()`
		2289	`{`
		2290	`if ((CURRENT_TERMINAL) == 23) {`
		2291	`return;`
		2292	`}`
		2293	`{`
		2294	`switch (CURRENT_TERMINAL) {`
		2295	`case 14:`
		2296	`break;`
		2297	`default:`
		2298	`goto ZL1;`
		2299	`}`
		2300	`ADVANCE_LEXER;`
		2301	`}`
		2302	`return;`
		2303	`ZL1:;`
		2304	`{`
		2305	`{`
		2306
		2307	`if (!c_propagating_error) {`
		2308	`E_c_expected_define ();`
		2309	`}`
		2310	`}`
		2311	`}`
		2312	`}`
		2313
		2314	`static void`
		2315	`ZR124 PROTO_Z ()`
		2316	`{`
		2317	`if ((CURRENT_TERMINAL) == 23) {`
		2318	`return;`
		2319	`}`
		2320	`{`
		2321	`switch (CURRENT_TERMINAL) {`
		2322	`case 12:`
		2323	`break;`
		2324	`default:`
		2325	`goto ZL1;`
		2326	`}`
		2327	`ADVANCE_LEXER;`
		2328	`}`
		2329	`return;`
		2330	`ZL1:;`
		2331	`{`
		2332	`{`
		2333
		2334	`if (!c_propagating_error) {`
		2335	`E_c_expected_terminator ();`
		2336	`}`
		2337	`}`
		2338	`}`
		2339	`}`
		2340
		2341	`/* BEGINNING OF TRAILER */`
		2342
		2343
		2344
		2345	`/* END OF FILE */`

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/utilities/sid/c-parser.c – Rev 2