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

Rev	Author	Line No.	Line
2	7u83	1	`/*`
6	7u83	2	`* Copyright (c) 2002-2005 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`
6	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:-`
6	7u83	42
2	7u83	43	`(1) Its Recipients shall ensure that this Notice is`
		44	`reproduced upon any copies or amended versions of it;`
6	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;`
6	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;`
6	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	`/*** rule.c --- Rule ADT.`
		62	`*`
		63	`** Author: Steve Folkes <smf@hermes.mod.uk>`
		64	`*`
		65	`*** Commentary:`
		66	`*`
		67	`* This file implements the rule manipulation routines specified.`
		68	`*`
		69	`*** Change Log:`
		70	`* $Log: rule.c,v $`
		71	`* Revision 1.1.1.1 1998/01/17 15:57:46 release`
		72	`* First version to be checked into rolling release.`
		73	`*`
		74	`* Revision 1.4 1995/02/10 16:29:44 smf`
		75	`* Fixed bugs "CR95_111.sid-inline-no-var-check" and "CR95_112.sid-lre-var-call".`
		76	`*`
		77	`* Revision 1.3 1994/12/15 09:58:56 smf`
		78	`* Brought into line with OSSG C Coding Standards Document, as per`
		79	`* "CR94_178.sid+tld-update".`
		80	`*`
		81	`* Revision 1.2 1994/08/22 09:37:27 smf`
		82	`* Fixed bug DR114:ids-too-long.`
		83	`*`
		84	`* Revision 1.1.1.1 1994/07/25 16:04:41 smf`
		85	`* Initial import of SID 1.8 non shared files.`
		86	`*`
		87	`**/`
		88
		89	`/****************************************************************************/`
		90
		91	`#include "rule.h"`
		92	`#include "action.h"`
		93	`#include "basic.h"`
		94	`#include "name.h"`
		95	`#include "type.h"`
		96
		97	`/--------------------------------------------------------------------------/`
		98
		99	`typedef struct DFSClosureT {`
		100	`RuleP root;`
		101	`RuleP *list;`
		102	`} DFSClosureT, *DFSClosureP;`
		103
		104	`/--------------------------------------------------------------------------/`
		105
		106	`static void`
6	7u83	107	`rule_compute_minimal_dataflow_1(RuleP rule, AltP alt, TypeTupleP all_used)`
2	7u83	108	`{`
		109	`TypeTupleT used;`
		110
6	7u83	111	`types_copy(&used, rule_result(rule));`
		112	`item_compute_minimal_dataflow(alt_item_head(alt), &used);`
		113	`types_add_new_names(all_used, &used, NIL(EntryP));`
		114	`types_destroy(&used);`
2	7u83	115	`}`
		116
		117	`static void`
6	7u83	118	`rule_compute_reverse_list_1(AltP alt, EntryP entry, CycleTypeT type)`
2	7u83	119	`{`
6	7u83	120	`ItemP item = alt_item_head(alt);`
2	7u83	121	`ItemP initial = item;`
		122	`ItemP next;`
		123
		124	`while (item) {`
6	7u83	125	`next = item_next(item);`
		126	`if (item_is_rule(item)) {`
		127	`RuleP item_rule = entry_get_rule(item_entry(item));`
2	7u83	128
		129	`if (((type == CT_LEFT) && (item == initial)) \|\|`
6	7u83	130	`((type == CT_TAIL) && (next == NIL(ItemP))) \|\|`
		131	`((type == CT_ALL) && (item_is_inlinable(item)) &&`
		132	`(rule_get_call_count(item_rule) <= 1) &&`
		133	`(!item_is_tail_call(item))) \|\| (type == CT_MUTATE)) {`
		134	`entry_list_add_if_missing(rule_reverse_list(item_rule), entry);`
2	7u83	135	`}`
		136	`}`
		137	`item = next;`
		138	`}`
		139	`}`
		140
		141	`static void`
6	7u83	142	`rule_compute_dfs_1(AltP alt, CycleTypeT type, RuleP *list)`
2	7u83	143	`{`
6	7u83	144	`ItemP item = alt_item_head(alt);`
2	7u83	145	`ItemP initial = item;`
		146	`ItemP next;`
		147
6	7u83	148	`ASSERT(type != CT_MUTATE);`
2	7u83	149	`while (item) {`
6	7u83	150	`next = item_next(item);`
		151	`if (item_is_rule(item)) {`
		152	`RuleP item_rule = entry_get_rule(item_entry(item));`
2	7u83	153
		154	`if (((type == CT_LEFT) && (item == initial)) \|\|`
6	7u83	155	`((type == CT_TAIL) && (next == NIL(ItemP))) \|\|`
		156	`((type == CT_ALL) && (item_is_inlinable(item)) &&`
		157	`(rule_get_call_count(item_rule) <= 1) &&`
		158	`(!item_is_tail_call(item)))) {`
		159	`rule_compute_dfs(item_rule, type, list);`
2	7u83	160	`}`
		161	`}`
		162	`item = next;`
		163	`}`
		164	`}`
		165
		166	`static void`
6	7u83	167	`rule_compute_reverse_dfs_1(EntryP entry, GenericP gclosure)`
2	7u83	168	`{`
6	7u83	169	`DFSClosureP closure = (DFSClosureP)gclosure;`
		170	`RuleP rule = entry_get_rule(entry);`
2	7u83	171
6	7u83	172	`rule_compute_reverse_dfs(rule, closure->root, closure->list);`
2	7u83	173	`}`
		174
		175	`static void`
6	7u83	176	`rule_renumber_1(AltP alt, TypeNTransP translator, SaveNTransP state)`
2	7u83	177	`{`
		178	`ItemP item;`
		179
6	7u83	180	`for (item = alt_item_head(alt); item; item = item_next(item)) {`
		181	`types_renumber(item_param(item), translator);`
		182	`types_renumber(item_result(item), translator);`
2	7u83	183	`}`
6	7u83	184	`ntrans_restore_state(translator, state);`
2	7u83	185	`}`
		186
		187	`#ifdef FS_FAST`
		188	`#undef rule_get_dfs_state`
		189	`#endif /* defined (FS_FAST) */`
		190	`static DFSStateT`
6	7u83	191	`rule_get_dfs_state(RuleP rule)`
2	7u83	192	`{`
6	7u83	193	`return(rule->dfs_state);`
2	7u83	194	`}`
		195	`#ifdef FS_FAST`
6	7u83	196	`#define rule_get_dfs_state(r) ((r)->dfs_state)`
2	7u83	197	`#endif /* defined (FS_FAST) */`
		198
		199	`#ifdef FS_FAST`
		200	`#undef rule_next_in_root_list_ref`
		201	`#endif /* defined (FS_FAST) */`
		202	`static RuleP *`
6	7u83	203	`rule_next_in_root_list_ref(RuleP rule)`
2	7u83	204	`{`
6	7u83	205	`return(&(rule->next_in_root_list));`
2	7u83	206	`}`
		207	`#ifdef FS_FAST`
6	7u83	208	`#define rule_next_in_root_list_ref(r) (&((r)->next_in_root_list))`
2	7u83	209	`#endif /* defined (FS_FAST) */`
		210
		211	`#ifdef FS_FAST`
		212	`#undef rule_set_next_in_dfs`
		213	`#endif /* defined (FS_FAST) */`
		214	`static void`
6	7u83	215	`rule_set_next_in_dfs(RuleP rule1, RuleP rule2)`
2	7u83	216	`{`
		217	`rule1->next_in_dfs = rule2;`
		218	`}`
		219	`#ifdef FS_FAST`
6	7u83	220	`#define rule_set_next_in_dfs(r1, r2) ((r1)->next_in_dfs = (r2))`
2	7u83	221	`#endif /* defined (FS_FAST) */`
		222
		223	`#ifdef FS_FAST`
		224	`#undef rule_set_next_in_reverse_dfs`
		225	`#endif /* defined (FS_FAST) */`
		226	`static void`
6	7u83	227	`rule_set_next_in_reverse_dfs(RuleP rule1, RuleP rule2)`
2	7u83	228	`{`
		229	`rule1->next_in_reverse_dfs = rule2;`
		230	`}`
		231	`#ifdef FS_FAST`
6	7u83	232	`#define rule_set_next_in_reverse_dfs(r1, r2) \`
		233	`((r1)->next_in_reverse_dfs = (r2))`
2	7u83	234	`#endif /* defined (FS_FAST) */`
		235
		236	`/--------------------------------------------------------------------------/`
		237
		238	`RuleP`
6	7u83	239	`rule_create(EntryP entry)`
2	7u83	240	`{`
6	7u83	241	`RuleP rule = ALLOCATE(RuleT);`
2	7u83	242
		243	`rule->entry = entry;`
6	7u83	244	`types_init(rule_param(rule));`
		245	`types_init(rule_result(rule));`
		246	`non_local_list_init(rule_non_locals(rule));`
		247	`nstring_init(rule_maximum_scope(rule));`
2	7u83	248	`rule->defined = FALSE;`
		249	`rule->has_empty_alt = FALSE;`
		250	`rule->required = FALSE;`
6	7u83	251	`entry_list_init(rule_reverse_list(rule));`
2	7u83	252	`rule->dfs_state = DFS_UNTRACED;`
6	7u83	253	`rule->next_in_reverse_dfs = NIL(RuleP);`
2	7u83	254	`rule->no_cycles = FALSE;`
		255	`rule->computed_first_set = FALSE;`
		256	`rule->computing_first_set = FALSE;`
6	7u83	257	`bitvec_init(rule_first_set(rule));`
		258	`entry_list_init(rule_predicate_first(rule));`
2	7u83	259	`rule->see_through = FALSE;`
		260	`rule->priority = 0;`
		261	`rule->factored = FALSE;`
6	7u83	262	`rule->tail_group = NIL(RuleP);`
2	7u83	263	`rule->being_inlined = FALSE;`
		264	`rule->checked_for_inlining = FALSE;`
6	7u83	265	`entry_list_init(rule_call_list(rule));`
		266	`bitvec_init(rule_follow_set(rule));`
		267	`entry_list_init(rule_predicate_follow(rule));`
		268	`rule->see_through_alt = NIL(AltP);`
2	7u83	269	`rule->needs_function = FALSE;`
		270	`rule->all_basics = FALSE;`
		271	`rule->being_output = FALSE;`
6	7u83	272	`rule->handler = NIL(AltP);`
		273	`rule->alt_head = NIL(AltP);`
2	7u83	274	`rule->alt_tail = &(rule->alt_head);`
6	7u83	275	`return(rule);`
2	7u83	276	`}`
		277
		278	`void`
6	7u83	279	`rule_reinit(RuleP rule)`
2	7u83	280	`{`
		281	`rule->has_empty_alt = FALSE;`
6	7u83	282	`rule->alt_head = NIL(AltP);`
2	7u83	283	`rule->alt_tail = &(rule->alt_head);`
		284	`}`
		285
		286	`#ifdef FS_FAST`
		287	`#undef rule_table_entry`
		288	`#endif /* defined (FS_FAST) */`
		289	`EntryP`
6	7u83	290	`rule_entry(RuleP rule)`
2	7u83	291	`{`
6	7u83	292	`return(rule->entry);`
2	7u83	293	`}`
		294	`#ifdef FS_FAST`
6	7u83	295	`#define rule_entry(r) ((r)->entry)`
2	7u83	296	`#endif /* defined (FS_FAST) */`
		297
		298	`#ifdef FS_FAST`
		299	`#undef rule_param`
		300	`#endif /* defined (FS_FAST) */`
		301	`TypeTupleP`
6	7u83	302	`rule_param(RuleP rule)`
2	7u83	303	`{`
6	7u83	304	`return(&(rule->param));`
2	7u83	305	`}`
		306	`#ifdef FS_FAST`
6	7u83	307	`#define rule_param(r) (&((r)->param))`
2	7u83	308	`#endif /* defined (FS_FAST) */`
		309
		310	`#ifdef FS_FAST`
		311	`#undef rule_result`
		312	`#endif /* defined (FS_FAST) */`
		313	`TypeTupleP`
6	7u83	314	`rule_result(RuleP rule)`
2	7u83	315	`{`
6	7u83	316	`return(&(rule->result));`
2	7u83	317	`}`
		318	`#ifdef FS_FAST`
6	7u83	319	`#define rule_result(r) (&((r)->result))`
2	7u83	320	`#endif /* defined (FS_FAST) */`
		321
		322	`#ifdef FS_FAST`
		323	`#undef rule_non_locals`
		324	`#endif /* defined (FS_FAST) */`
		325	`NonLocalListP`
6	7u83	326	`rule_non_locals(RuleP rule)`
2	7u83	327	`{`
6	7u83	328	`return(&(rule->non_locals));`
2	7u83	329	`}`
		330	`#ifdef FS_FAST`
6	7u83	331	`#define rule_non_locals(r) (&((r)->non_locals))`
2	7u83	332	`#endif /* defined (FS_FAST) */`
		333
		334	`#ifdef FS_FAST`
		335	`#undef rule_maximum_scope`
		336	`#endif /* defined (FS_FAST) */`
		337	`NStringP`
6	7u83	338	`rule_maximum_scope(RuleP rule)`
2	7u83	339	`{`
6	7u83	340	`return(&(rule->maximum_scope));`
2	7u83	341	`}`
		342	`#ifdef FS_FAST`
6	7u83	343	`#define rule_maximum_scope(r) (&((r)->maximum_scope))`
2	7u83	344	`#endif /* defined (FS_FAST) */`
		345
		346	`#ifdef FS_FAST`
		347	`#undef rule_is_defined`
		348	`#endif /* defined (FS_FAST) */`
		349	`BoolT`
6	7u83	350	`rule_is_defined(RuleP rule)`
2	7u83	351	`{`
6	7u83	352	`return(rule->defined);`
2	7u83	353	`}`
		354	`#ifdef FS_FAST`
6	7u83	355	`#define rule_is_defined(r) ((r)->defined)`
2	7u83	356	`#endif /* defined (FS_FAST) */`
		357
		358	`#ifdef FS_FAST`
		359	`#undef rule_defined`
		360	`#endif /* defined (FS_FAST) */`
		361	`void`
6	7u83	362	`rule_defined(RuleP rule)`
2	7u83	363	`{`
		364	`rule->defined = TRUE;`
		365	`}`
		366	`#ifdef FS_FAST`
6	7u83	367	`#define rule_defined(r) ((r)->defined = TRUE)`
2	7u83	368	`#endif /* defined (FS_FAST) */`
		369
		370	`#ifdef FS_FAST`
		371	`#undef rule_is_required`
		372	`#endif /* defined (FS_FAST) */`
		373	`BoolT`
6	7u83	374	`rule_is_required(RuleP rule)`
2	7u83	375	`{`
6	7u83	376	`return(rule->required);`
2	7u83	377	`}`
		378	`#ifdef FS_FAST`
6	7u83	379	`#define rule_is_required(r) ((r)->required)`
2	7u83	380	`#endif /* defined (FS_FAST) */`
		381
		382	`#ifdef FS_FAST`
		383	`#undef rule_required`
		384	`#endif /* defined (FS_FAST) */`
		385	`void`
6	7u83	386	`rule_required(RuleP rule)`
2	7u83	387	`{`
		388	`rule->required = TRUE;`
		389	`}`
		390	`#ifdef FS_FAST`
6	7u83	391	`#define rule_required(r) ((r)->required = TRUE)`
2	7u83	392	`#endif /* defined (FS_FAST) */`
		393
		394	`void`
6	7u83	395	`rule_add_alt(RuleP rule, AltP alt)`
2	7u83	396	`{`
		397	`*(rule->alt_tail) = alt;`
6	7u83	398	`rule->alt_tail = alt_next_ref(alt);`
2	7u83	399	`}`
		400
		401	`#ifdef FS_FAST`
		402	`#undef rule_has_empty_alt`
		403	`#endif /* defined (FS_FAST) */`
		404	`BoolT`
6	7u83	405	`rule_has_empty_alt(RuleP rule)`
2	7u83	406	`{`
6	7u83	407	`return(rule->has_empty_alt);`
2	7u83	408	`}`
		409	`#ifdef FS_FAST`
6	7u83	410	`#define rule_has_empty_alt(r) ((r)->has_empty_alt)`
2	7u83	411	`#endif /* defined (FS_FAST) */`
		412
		413	`#ifdef FS_FAST`
		414	`#undef rule_add_empty_alt`
		415	`#endif /* defined (FS_FAST) */`
		416	`void`
6	7u83	417	`rule_add_empty_alt(RuleP rule)`
2	7u83	418	`{`
		419	`rule->has_empty_alt = TRUE;`
		420	`}`
		421	`#ifdef FS_FAST`
6	7u83	422	`#define rule_add_empty_alt(r) ((r)->has_empty_alt = TRUE)`
2	7u83	423	`#endif /* defined (FS_FAST) */`
		424
		425	`BoolT`
6	7u83	426	`rule_has_one_alt(RuleP rule)`
2	7u83	427	`{`
6	7u83	428	`return(((rule_has_empty_alt(rule)) && (rule->alt_head == NIL(AltP))) \|\|`
		429	`((!rule_has_empty_alt(rule)) && (rule->alt_head) &&`
		430	`(alt_next(rule->alt_head) == NIL(AltP))));`
2	7u83	431	`}`
		432
		433	`void`
6	7u83	434	`rule_compute_result_intersect(RuleP rule)`
2	7u83	435	`{`
6	7u83	436	`TypeTupleP result = rule_result(rule);`
2	7u83	437	`BoolT inited = FALSE;`
		438	`AltP alt;`
		439
6	7u83	440	`if (rule_has_empty_alt(rule)) {`
		441	`types_init(result);`
2	7u83	442	`} else {`
6	7u83	443	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
		444	`types_copy(result, alt_names(alt));`
2	7u83	445	`inited = TRUE;`
		446	`}`
6	7u83	447	`for (alt = rule_alt_head(rule); alt; alt = alt_next(alt)) {`
2	7u83	448	`if (inited) {`
6	7u83	449	`types_inplace_intersection(result, alt_names(alt));`
2	7u83	450	`} else {`
6	7u83	451	`types_copy(result, alt_names(alt));`
2	7u83	452	`inited = TRUE;`
		453	`}`
		454	`}`
6	7u83	455	`types_unlink_used(result, rule_param(rule));`
2	7u83	456	`}`
		457	`}`
		458
		459	`void`
6	7u83	460	`rule_compute_minimal_dataflow(RuleP rule, TypeTupleP param)`
2	7u83	461	`{`
		462	`TypeTupleT all_used;`
		463	`AltP alt;`
		464
6	7u83	465	`types_init(&all_used);`
		466	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
		467	`rule_compute_minimal_dataflow_1(rule, alt, &all_used);`
2	7u83	468	`}`
6	7u83	469	`for (alt = rule_alt_head(rule); alt; alt = alt_next(alt)) {`
		470	`rule_compute_minimal_dataflow_1(rule, alt, &all_used);`
2	7u83	471	`}`
6	7u83	472	`types_inplace_intersection(rule_param(rule), &all_used);`
		473	`types_inplace_intersection(param, &all_used);`
		474	`types_destroy(&all_used);`
2	7u83	475	`}`
		476
		477	`void`
6	7u83	478	`rule_compute_reverse_list(RuleP rule, CycleTypeT type)`
2	7u83	479	`{`
6	7u83	480	`EntryP entry = rule_entry(rule);`
2	7u83	481	`AltP alt;`
		482
6	7u83	483	`if ((type != CT_LEFT) && (alt = rule_get_handler(rule))) {`
		484	`rule_compute_reverse_list_1(alt, entry, type);`
2	7u83	485	`}`
6	7u83	486	`for (alt = rule_alt_head(rule); alt; alt = alt_next(alt)) {`
		487	`rule_compute_reverse_list_1(alt, entry, type);`
2	7u83	488	`}`
		489	`}`
		490
		491	`void`
6	7u83	492	`rule_reinit_reverse_list(RuleP rule)`
2	7u83	493	`{`
6	7u83	494	`entry_list_destroy(rule_reverse_list(rule));`
		495	`entry_list_init(rule_reverse_list(rule));`
		496	`rule_set_dfs_state(rule, DFS_UNTRACED);`
		497	`rule->next_in_reverse_dfs = NIL(RuleP);`
2	7u83	498	`rule->no_cycles = FALSE;`
		499	`}`
		500
		501	`#ifdef FS_FAST`
		502	`#undef rule_reverse_list`
		503	`#endif /* defined (FS_FAST) */`
		504	`EntryListP`
6	7u83	505	`rule_reverse_list(RuleP rule)`
2	7u83	506	`{`
6	7u83	507	`return(&(rule->reverse_list));`
2	7u83	508	`}`
		509	`#ifdef FS_FAST`
6	7u83	510	`#define rule_reverse_list(r) ((r)->reverse_list)`
2	7u83	511	`#endif /* defined (FS_FAST) */`
		512
		513	`#ifdef FS_FAST`
		514	`#undef rule_set_dfs_state`
		515	`#endif /* defined (FS_FAST) */`
		516	`void`
6	7u83	517	`rule_set_dfs_state(RuleP rule, DFSStateT state)`
2	7u83	518	`{`
		519	`rule->dfs_state = state;`
		520	`}`
		521	`#ifdef FS_FAST`
6	7u83	522	`#define rule_set_dfs_state(r, s) ((r)->dfs_state = (s))`
2	7u83	523	`#endif /* defined (FS_FAST) */`
		524
		525	`#ifdef FS_FAST`
		526	`#undef rule_next_in_root_list`
		527	`#endif /* defined (FS_FAST) */`
		528	`RuleP`
6	7u83	529	`rule_next_in_root_list(RuleP rule)`
2	7u83	530	`{`
6	7u83	531	`return(rule->next_in_root_list);`
2	7u83	532	`}`
		533	`#ifdef FS_FAST`
6	7u83	534	`#define rule_next_in_root_list(r) ((r)->next_in_root_list)`
2	7u83	535	`#endif /* defined (FS_FAST) */`
		536
		537	`void`
6	7u83	538	`rule_build_root_list(EntryP entry, GenericP gclosure)`
2	7u83	539	`{`
6	7u83	540	`if (entry_is_rule(entry)) {`
		541	`RuleListP list = (RuleListP)gclosure;`
		542	`RuleP rule = entry_get_rule(entry);`
2	7u83	543
6	7u83	544	`rule_list_append(list, rule, rule_next_in_root_list_ref(rule));`
2	7u83	545	`}`
		546	`}`
		547
		548	`#ifdef FS_FAST`
		549	`#undef rule_get_next_in_dfs`
		550	`#endif /* defined (FS_FAST) */`
		551	`RuleP`
6	7u83	552	`rule_get_next_in_dfs(RuleP rule)`
2	7u83	553	`{`
6	7u83	554	`return(rule->next_in_dfs);`
2	7u83	555	`}`
		556	`#ifdef FS_FAST`
6	7u83	557	`#define rule_get_next_in_dfs(r) ((r)->next_in_dfs)`
2	7u83	558	`#endif /* defined (FS_FAST) */`
		559
		560	`void`
6	7u83	561	`rule_compute_dfs(RuleP rule, CycleTypeT type, RuleP *list)`
2	7u83	562	`{`
		563	`AltP alt;`
		564
6	7u83	565	`switch (rule_get_dfs_state(rule))EXHAUSTIVE {`
2	7u83	566	`case DFS_UNTRACED:`
6	7u83	567	`rule_set_dfs_state(rule, DFS_TRACING);`
		568	`if ((type != CT_LEFT) && (alt = rule_get_handler(rule))) {`
		569	`rule_compute_dfs_1(alt, type, list);`
2	7u83	570	`}`
6	7u83	571	`for (alt = rule_alt_head(rule); alt; alt = alt_next(alt)) {`
		572	`rule_compute_dfs_1(alt, type, list);`
2	7u83	573	`}`
6	7u83	574	`rule_set_dfs_state(rule, DFS_TRACED);`
		575	`rule_set_next_in_dfs(rule, *list);`
2	7u83	576	`*list = rule;`
		577	`break;`
		578	`case DFS_TRACING:`
		579	`case DFS_TRACED:`
		580	`break;`
		581	`case DFS_CYCLING:`
		582	`UNREACHED;`
		583	`}`
		584	`}`
		585
		586	`#ifdef FS_FAST`
		587	`#undef rule_get_next_in_reverse_dfs`
		588	`#endif /* defined (FS_FAST) */`
		589	`RuleP`
6	7u83	590	`rule_get_next_in_reverse_dfs(RuleP rule)`
2	7u83	591	`{`
6	7u83	592	`return(rule->next_in_reverse_dfs);`
2	7u83	593	`}`
		594	`#ifdef FS_FAST`
6	7u83	595	`#define rule_get_next_in_reverse_dfs(r) ((r)->next_in_reverse_dfs)`
2	7u83	596	`#endif /* defined (FS_FAST) */`
		597
		598	`#ifdef FS_FAST`
		599	`#undef rule_next_in_reverse_dfs_ref`
		600	`#endif /* defined (FS_FAST) */`
		601	`RuleP *`
6	7u83	602	`rule_next_in_reverse_dfs_ref(RuleP rule)`
2	7u83	603	`{`
6	7u83	604	`return(&(rule->next_in_reverse_dfs));`
2	7u83	605	`}`
		606	`#ifdef FS_FAST`
6	7u83	607	`#define rule_next_in_reverse_dfs_ref(r) (&((r)->next_in_reverse_dfs))`
2	7u83	608	`#endif /* defined (FS_FAST) */`
		609
		610	`void`
6	7u83	611	`rule_compute_reverse_dfs(RuleP rule, RuleP root, RuleP *list)`
2	7u83	612	`{`
		613	`DFSClosureT closure;`
		614
6	7u83	615	`switch (rule_get_dfs_state(rule))EXHAUSTIVE {`
2	7u83	616	`case DFS_UNTRACED:`
		617	`closure.root = root;`
		618	`closure.list = list;`
6	7u83	619	`rule_set_dfs_state(rule, DFS_TRACING);`
		620	`entry_list_iter(rule_reverse_list(rule), rule_compute_reverse_dfs_1,`
		621	`(GenericP)&closure);`
		622	`if (((rule == root) && (rule_get_dfs_state(rule) == DFS_CYCLING)) \|\|`
2	7u83	623	`(rule != root)) {`
6	7u83	624	`rule_set_next_in_reverse_dfs(rule, *list);`
2	7u83	625	`*list = rule;`
		626	`}`
6	7u83	627	`rule_set_dfs_state(rule, DFS_TRACED);`
2	7u83	628	`break;`
		629	`case DFS_CYCLING:`
		630	`case DFS_TRACED:`
		631	`break;`
		632	`case DFS_TRACING:`
6	7u83	633	`rule_set_dfs_state(rule, DFS_CYCLING);`
2	7u83	634	`break;`
		635	`}`
		636	`}`
		637
		638	`#ifdef FS_FAST`
		639	`#undef rule_has_no_cycles`
		640	`#endif /* defined (FS_FAST) */`
		641	`BoolT`
6	7u83	642	`rule_has_no_cycles(RuleP rule)`
2	7u83	643	`{`
6	7u83	644	`return(rule->no_cycles);`
2	7u83	645	`}`
		646	`#ifdef FS_FAST`
6	7u83	647	`#define rule_has_no_cycles(r) ((r)->no_cycles)`
2	7u83	648	`#endif /* defined (FS_FAST) */`
		649
		650	`#ifdef FS_FAST`
		651	`#undef rule_no_cycles`
		652	`#endif /* defined (FS_FAST) */`
		653	`void`
6	7u83	654	`rule_no_cycles(RuleP rule)`
2	7u83	655	`{`
		656	`rule->no_cycles = TRUE;`
		657	`}`
		658	`#ifdef FS_FAST`
6	7u83	659	`#define rule_no_cycles(r) ((r)->no_cycles = TRUE)`
2	7u83	660	`#endif /* defined (FS_FAST) */`
		661
		662	`#ifdef FS_FAST`
		663	`#undef rule_get_cycle_index`
		664	`#endif /* defined (FS_FAST) */`
		665	`unsigned`
6	7u83	666	`rule_get_cycle_index(RuleP rule)`
2	7u83	667	`{`
6	7u83	668	`return(rule->cycle_index);`
2	7u83	669	`}`
		670	`#ifdef FS_FAST`
6	7u83	671	`#define rule_get_cycle_index(r) ((r)->cycle_index)`
2	7u83	672	`#endif /* defined (FS_FAST) */`
		673
		674	`#ifdef FS_FAST`
		675	`#undef rule_set_cycle_index`
		676	`#endif /* defined (FS_FAST) */`
		677	`void`
6	7u83	678	`rule_set_cycle_index(RuleP rule, unsigned cycle_index)`
2	7u83	679	`{`
		680	`rule->cycle_index = cycle_index;`
		681	`}`
		682	`#ifdef FS_FAST`
6	7u83	683	`#define rule_set_cycle_index(r, i) ((r)->cycle_index = (i))`
2	7u83	684	`#endif /* defined (FS_FAST) */`
		685
		686	`#ifdef FS_FAST`
		687	`#undef rule_reset_cycle_index`
		688	`#endif /* defined (FS_FAST) */`
		689	`void`
6	7u83	690	`rule_reset_cycle_index(RuleP rule)`
2	7u83	691	`{`
		692	`rule->cycle_index = 0;`
		693	`}`
		694	`#ifdef FS_FAST`
6	7u83	695	`#define rule_reset_cycle_index(r) ((r)->cycle_index = 0)`
2	7u83	696	`#endif /* defined (FS_FAST) */`
		697
		698	`#ifdef FS_FAST`
		699	`#undef rule_has_computed_first_set`
		700	`#endif /* defined (FS_FAST) */`
		701	`BoolT`
6	7u83	702	`rule_has_computed_first_set(RuleP rule)`
2	7u83	703	`{`
6	7u83	704	`return(rule->computed_first_set);`
2	7u83	705	`}`
		706	`#ifdef FS_FAST`
6	7u83	707	`#define rule_has_computed_first_set(r) ((r)->computed_first_set)`
2	7u83	708	`#endif /* defined (FS_FAST) */`
		709
		710	`#ifdef FS_FAST`
		711	`#undef rule_computed_first_set`
		712	`#endif /* defined (FS_FAST) */`
		713	`void`
6	7u83	714	`rule_computed_first_set(RuleP rule)`
2	7u83	715	`{`
		716	`rule->computed_first_set = TRUE;`
		717	`}`
		718	`#ifdef FS_FAST`
6	7u83	719	`#define rule_computed_first_set(r) ((r)->computed_first_set)`
2	7u83	720	`#endif /* defined (FS_FAST) */`
		721
		722	`#ifdef FS_FAST`
		723	`#undef rule_is_computing_first_set`
		724	`#endif /* defined (FS_FAST) */`
		725	`BoolT`
6	7u83	726	`rule_is_computing_first_set(RuleP rule)`
2	7u83	727	`{`
6	7u83	728	`return(rule->computing_first_set);`
2	7u83	729	`}`
		730	`#ifdef FS_FAST`
6	7u83	731	`#define rule_is_computing_first_set(r) ((r)->computing_first_set)`
2	7u83	732	`#endif /* defined (FS_FAST) */`
		733
		734	`#ifdef FS_FAST`
		735	`#undef rule_computing_first_set`
		736	`#endif /* defined (FS_FAST) */`
		737	`void`
6	7u83	738	`rule_computing_first_set(RuleP rule)`
2	7u83	739	`{`
		740	`rule->computing_first_set = TRUE;`
		741	`}`
		742	`#ifdef FS_FAST`
6	7u83	743	`#define rule_computing_first_set(r) ((r)->computing_first_set = TRUE)`
2	7u83	744	`#endif /* defined (FS_FAST) */`
		745
		746	`#ifdef FS_FAST`
		747	`#undef rule_first_set`
		748	`#endif /* defined (FS_FAST) */`
		749	`BitVecP`
6	7u83	750	`rule_first_set(RuleP rule)`
2	7u83	751	`{`
6	7u83	752	`return(&(rule->first_set));`
2	7u83	753	`}`
		754	`#ifdef FS_FAST`
6	7u83	755	`#define rule_first_set(r) (&((r)->first_set))`
2	7u83	756	`#endif /* defined (FS_FAST) */`
		757
		758	`#ifdef FS_FAST`
		759	`#undef rule_predicate_first`
		760	`#endif /* defined (FS_FAST) */`
		761	`EntryListP`
6	7u83	762	`rule_predicate_first(RuleP rule)`
2	7u83	763	`{`
6	7u83	764	`return(&(rule->predicate_first));`
2	7u83	765	`}`
		766	`#ifdef FS_FAST`
6	7u83	767	`#define rule_predicate_first(r) (&((r)->predicate_first))`
2	7u83	768	`#endif /* defined (FS_FAST) */`
		769
		770	`#ifdef FS_FAST`
		771	`#undef rule_is_see_through`
		772	`#endif /* defined (FS_FAST) */`
		773	`BoolT`
6	7u83	774	`rule_is_see_through(RuleP rule)`
2	7u83	775	`{`
6	7u83	776	`return(rule->see_through);`
2	7u83	777	`}`
		778	`#ifdef FS_FAST`
6	7u83	779	`#define rule_is_see_through(r) ((r)->see_through)`
2	7u83	780	`#endif /* defined (FS_FAST) */`
		781
		782	`#ifdef FS_FAST`
		783	`#undef rule_see_through`
		784	`#endif /* defined (FS_FAST) */`
		785	`void`
6	7u83	786	`rule_see_through(RuleP rule)`
2	7u83	787	`{`
		788	`rule->see_through = TRUE;`
		789	`}`
		790	`#ifdef FS_FAST`
6	7u83	791	`#define rule_see_through(r) ((r)->see_through = TRUE)`
2	7u83	792	`#endif /* defined (FS_FAST) */`
		793
		794	`#ifdef FS_FAST`
		795	`#undef rule_get_priority`
		796	`#endif /* defined (FS_FAST) */`
		797	`unsigned`
6	7u83	798	`rule_get_priority(RuleP rule)`
2	7u83	799	`{`
6	7u83	800	`return(rule->priority);`
2	7u83	801	`}`
		802	`#ifdef FS_FAST`
6	7u83	803	`#define rule_get_priority(r) ((r)->priority)`
2	7u83	804	`#endif /* defined (FS_FAST) */`
		805
		806	`#ifdef FS_FAST`
		807	`#undef rule_set_priority`
		808	`#endif /* defined (FS_FAST) */`
		809	`void`
6	7u83	810	`rule_set_priority(RuleP rule, unsigned priority)`
2	7u83	811	`{`
6	7u83	812	`ASSERT(priority > 0);`
2	7u83	813	`rule->priority = priority;`
		814	`}`
		815	`#ifdef FS_FAST`
6	7u83	816	`#define rule_set_priority(r, p) ((r)->priority = (p))`
2	7u83	817	`#endif /* defined (FS_FAST) */`
		818
		819	`#ifdef FS_FAST`
		820	`#undef rule_is_factored`
		821	`#endif /* defined (FS_FAST) */`
		822	`BoolT`
6	7u83	823	`rule_is_factored(RuleP rule)`
2	7u83	824	`{`
6	7u83	825	`return(rule->factored);`
2	7u83	826	`}`
		827	`#ifdef FS_FAST`
6	7u83	828	`#define rule_is_factored(r) ((r)->factored)`
2	7u83	829	`#endif /* defined (FS_FAST) */`
		830
		831	`#ifdef FS_FAST`
		832	`#undef rule_factored`
		833	`#endif /* defined (FS_FAST) */`
		834	`void`
6	7u83	835	`rule_factored(RuleP rule)`
2	7u83	836	`{`
		837	`rule->factored = TRUE;`
		838	`}`
		839	`#ifdef FS_FAST`
6	7u83	840	`#define rule_factored(r) ((r)->factored = TRUE)`
2	7u83	841	`#endif /* defined (FS_FAST) */`
		842
		843	`#ifdef FS_FAST`
		844	`#undef rule_get_tail_group`
		845	`#endif /* defined (FS_FAST) */`
		846	`RuleP`
6	7u83	847	`rule_get_tail_group(RuleP rule)`
2	7u83	848	`{`
6	7u83	849	`return(rule->tail_group);`
2	7u83	850	`}`
		851	`#ifdef FS_FAST`
6	7u83	852	`#define rule_get_tail_group(r) ((r)->tail_group)`
2	7u83	853	`#endif /* defined (FS_FAST) */`
		854
		855	`#ifdef FS_FAST`
		856	`#undef rule_set_tail_group`
		857	`#endif /* defined (FS_FAST) */`
		858	`void`
6	7u83	859	`rule_set_tail_group(RuleP rule1, RuleP rule2)`
2	7u83	860	`{`
		861	`rule1->tail_group = rule2;`
		862	`}`
		863	`#ifdef FS_FAST`
6	7u83	864	`#define rule_set_tail_group(r1, r2) ((r1)->tail_group = (r2))`
2	7u83	865	`#endif /* defined (FS_FAST) */`
		866
		867	`#ifdef FS_FAST`
		868	`#undef rule_is_being_inlined`
		869	`#endif /* defined (FS_FAST) */`
		870	`BoolT`
6	7u83	871	`rule_is_being_inlined(RuleP rule)`
2	7u83	872	`{`
6	7u83	873	`return(rule->being_inlined);`
2	7u83	874	`}`
		875	`#ifdef FS_FAST`
6	7u83	876	`#define rule_is_being_inlined(r) ((r)->being_inlined)`
2	7u83	877	`#endif /* defined (FS_FAST) */`
		878
		879	`#ifdef FS_FAST`
		880	`#undef rule_being_inlined`
		881	`#endif /* defined (FS_FAST) */`
		882	`void`
6	7u83	883	`rule_being_inlined(RuleP rule)`
2	7u83	884	`{`
		885	`rule->being_inlined = TRUE;`
		886	`}`
		887	`#ifdef FS_FAST`
6	7u83	888	`#define rule_being_inlined(r) ((r)->being_inlined = TRUE)`
2	7u83	889	`#endif /* defined (FS_FAST) */`
		890
		891	`#ifdef FS_FAST`
		892	`#undef rule_is_checked_for_inlining`
		893	`#endif /* defined (FS_FAST) */`
		894	`BoolT`
6	7u83	895	`rule_is_checked_for_inlining(RuleP rule)`
2	7u83	896	`{`
6	7u83	897	`return(rule->checked_for_inlining);`
2	7u83	898	`}`
		899	`#ifdef FS_FAST`
6	7u83	900	`#define rule_is_checked_for_inlining(r) ((r)->checked_for_inlining)`
2	7u83	901	`#endif /* defined (FS_FAST) */`
		902
		903	`#ifdef FS_FAST`
		904	`#undef rule_checked_for_inlining`
		905	`#endif /* defined (FS_FAST) */`
		906	`void`
6	7u83	907	`rule_checked_for_inlining(RuleP rule)`
2	7u83	908	`{`
		909	`rule->checked_for_inlining = TRUE;`
		910	`}`
		911	`#ifdef FS_FAST`
6	7u83	912	`#define rule_checked_for_inlining(r) ((r)->checked_for_inlining = TRUE)`
2	7u83	913	`#endif /* defined (FS_FAST) */`
		914
		915	`#ifdef FS_FAST`
		916	`#undef rule_call_list`
		917	`#endif /* defined (FS_FAST) */`
		918	`EntryListP`
6	7u83	919	`rule_call_list(RuleP rule)`
2	7u83	920	`{`
6	7u83	921	`return(&(rule->call_list));`
2	7u83	922	`}`
		923	`#ifdef FS_FAST`
6	7u83	924	`#define rule_call_list(r) (&((r)->call_list))`
2	7u83	925	`#endif /* defined (FS_FAST) */`
		926
		927	`#ifdef FS_FAST`
		928	`#undef rule_get_next_in_table`
		929	`#endif /* defined (FS_FAST) */`
		930	`RuleP`
6	7u83	931	`rule_get_next_in_table(RuleP rule)`
2	7u83	932	`{`
6	7u83	933	`return(rule->next_in_table);`
2	7u83	934	`}`
		935	`#ifdef FS_FAST`
6	7u83	936	`#define rule_get_next_in_table(r) ((r)->next_in_table)`
2	7u83	937	`#endif /* defined (FS_FAST) */`
		938
		939	`#ifdef FS_FAST`
		940	`#undef rule_get_next_in_table_ref`
		941	`#endif /* defined (FS_FAST) */`
		942	`RuleP *`
6	7u83	943	`rule_get_next_in_table_ref(RuleP rule)`
2	7u83	944	`{`
6	7u83	945	`return(&(rule->next_in_table));`
2	7u83	946	`}`
		947	`#ifdef FS_FAST`
6	7u83	948	`#define rule_get_next_in_table_ref(r) (&((r)->next_in_table))`
2	7u83	949	`#endif /* defined (FS_FAST) */`
		950
		951	`#ifdef FS_FAST`
		952	`#undef rule_set_next_in_table`
		953	`#endif /* defined (FS_FAST) */`
		954	`void`
6	7u83	955	`rule_set_next_in_table(RuleP rule1, RuleP rule2)`
2	7u83	956	`{`
		957	`rule1->next_in_table = rule2;`
		958	`}`
		959	`#ifdef FS_FAST`
6	7u83	960	`#define rule_set_next_in_table(r1, r2) ((r1)->next_in_table = (r2))`
2	7u83	961	`#endif /* defined (FS_FAST) */`
		962
		963	`#ifdef FS_FAST`
		964	`#undef rule_follow_set`
		965	`#endif /* defined (FS_FAST) */`
		966	`BitVecP`
6	7u83	967	`rule_follow_set(RuleP rule)`
2	7u83	968	`{`
6	7u83	969	`return(&(rule->follow_set));`
2	7u83	970	`}`
		971	`#ifdef FS_FAST`
6	7u83	972	`#define rule_follow_set(r) (&((r)->follow_set))`
2	7u83	973	`#endif /* defined (FS_FAST) */`
		974
		975	`#ifdef FS_FAST`
		976	`#undef rule_predicate_follow`
		977	`#endif /* defined (FS_FAST) */`
		978	`EntryListP`
6	7u83	979	`rule_predicate_follow(RuleP rule)`
2	7u83	980	`{`
6	7u83	981	`return(&(rule->predicate_follow));`
2	7u83	982	`}`
		983	`#ifdef FS_FAST`
6	7u83	984	`#define rule_predicate_follow(r) (&((r)->predicate_follow))`
2	7u83	985	`#endif /* defined (FS_FAST) */`
		986
		987	`#ifdef FS_FAST`
		988	`#undef rule_has_started_follows`
		989	`#endif /* defined (FS_FAST) */`
		990	`BoolT`
6	7u83	991	`rule_has_started_follows(RuleP rule)`
2	7u83	992	`{`
6	7u83	993	`return(rule->started_follows);`
2	7u83	994	`}`
		995	`#ifdef FS_FAST`
6	7u83	996	`#define rule_has_started_follows(r) ((r)->started_follows)`
2	7u83	997	`#endif /* defined (FS_FAST) */`
		998
		999	`#ifdef FS_FAST`
		1000	`#undef rule_started_follows`
		1001	`#endif /* defined (FS_FAST) */`
		1002	`void`
6	7u83	1003	`rule_started_follows(RuleP rule)`
2	7u83	1004	`{`
		1005	`rule->started_follows = TRUE;`
		1006	`}`
		1007	`#ifdef FS_FAST`
6	7u83	1008	`#define rule_started_follows(r) ((r)->started_follows = TRUE)`
2	7u83	1009	`#endif /* defined (FS_FAST) */`
		1010
		1011	`#ifdef FS_FAST`
		1012	`#undef rule_set_see_through_alt`
		1013	`#endif /* defined (FS_FAST) */`
		1014	`void`
6	7u83	1015	`rule_set_see_through_alt(RuleP rule, AltP alt)`
2	7u83	1016	`{`
		1017	`rule->see_through_alt = alt;`
		1018	`}`
		1019	`#ifdef FS_FAST`
6	7u83	1020	`#define rule_set_see_through_alt(r, a) ((r)->see_through_alt = (a))`
2	7u83	1021	`#endif /* defined (FS_FAST) */`
		1022
		1023	`#ifdef FS_FAST`
		1024	`#undef rule_see_through_alt`
		1025	`#endif /* defined (FS_FAST) */`
		1026	`AltP`
6	7u83	1027	`rule_see_through_alt(RuleP rule)`
2	7u83	1028	`{`
6	7u83	1029	`return(rule->see_through_alt);`
2	7u83	1030	`}`
		1031	`#ifdef FS_FAST`
6	7u83	1032	`#define rule_see_through_alt(r) ((r)->see_through_alt)`
2	7u83	1033	`#endif /* defined (FS_FAST) */`
		1034
		1035	`#ifdef FS_FAST`
		1036	`#undef rule_needs_function`
		1037	`#endif /* defined (FS_FAST) */`
		1038	`BoolT`
6	7u83	1039	`rule_needs_function(RuleP rule)`
2	7u83	1040	`{`
6	7u83	1041	`return(rule->needs_function);`
2	7u83	1042	`}`
		1043	`#ifdef FS_FAST`
6	7u83	1044	`#define rule_needs_function(r) ((r)->needs_function)`
2	7u83	1045	`#endif /* defined (FS_FAST) */`
		1046
		1047	`#ifdef FS_FAST`
		1048	`#undef rule_will_need_function`
		1049	`#endif /* defined (FS_FAST) */`
		1050	`void`
6	7u83	1051	`rule_will_need_function(RuleP rule)`
2	7u83	1052	`{`
		1053	`rule->needs_function = TRUE;`
		1054	`}`
		1055	`#ifdef FS_FAST`
6	7u83	1056	`#define rule_will_need_function(r) ((r)->needs_function = TRUE)`
2	7u83	1057	`#endif /* defined (FS_FAST) */`
		1058
		1059	`#ifdef FS_FAST`
		1060	`#undef rule_is_all_basics`
		1061	`#endif /* defined (FS_FAST) */`
		1062	`BoolT`
6	7u83	1063	`rule_is_all_basics(RuleP rule)`
2	7u83	1064	`{`
6	7u83	1065	`return(rule->all_basics);`
2	7u83	1066	`}`
		1067	`#ifdef FS_FAST`
6	7u83	1068	`#define rule_is_all_basics(r) ((r)->all_basics)`
2	7u83	1069	`#endif /* defined (FS_FAST) */`
		1070
		1071	`#ifdef FS_FAST`
		1072	`#undef rule_all_basics`
		1073	`#endif /* defined (FS_FAST) */`
		1074	`void`
6	7u83	1075	`rule_all_basics(RuleP rule)`
2	7u83	1076	`{`
		1077	`rule->all_basics = TRUE;`
		1078	`}`
		1079	`#ifdef FS_FAST`
6	7u83	1080	`#define rule_all_basics(r) ((r)->all_basics = TRUE)`
2	7u83	1081	`#endif /* defined (FS_FAST) */`
		1082
		1083	`#ifdef FS_FAST`
		1084	`#undef rule_rstack_state`
		1085	`#endif /* defined (FS_FAST) */`
		1086	`SaveRStackP`
6	7u83	1087	`rule_rstack_state(RuleP rule)`
2	7u83	1088	`{`
6	7u83	1089	`return(&(rule->rstack_state));`
2	7u83	1090	`}`
		1091	`#ifdef FS_FAST`
6	7u83	1092	`#define rule_rstack_state(r) (&((r)->rstack_state))`
2	7u83	1093	`#endif /* defined (FS_FAST) */`
		1094
		1095	`#ifdef FS_FAST`
		1096	`#undef rule_non_local_state`
		1097	`#endif /* defined (FS_FAST) */`
		1098	`SaveRStackP`
6	7u83	1099	`rule_non_local_state(RuleP rule)`
2	7u83	1100	`{`
6	7u83	1101	`return(&(rule->non_local_state));`
2	7u83	1102	`}`
		1103	`#ifdef FS_FAST`
6	7u83	1104	`#define rule_non_local_state(r) (&((r)->non_local_state))`
2	7u83	1105	`#endif /* defined (FS_FAST) */`
		1106
		1107	`#ifdef FS_FAST`
		1108	`#undef rule_is_being_output`
		1109	`#endif /* defined (FS_FAST) */`
		1110	`BoolT`
6	7u83	1111	`rule_is_being_output(RuleP rule)`
2	7u83	1112	`{`
6	7u83	1113	`return(rule->being_output);`
2	7u83	1114	`}`
		1115	`#ifdef FS_FAST`
6	7u83	1116	`#define rule_is_being_output(r) ((r)->being_output)`
2	7u83	1117	`#endif /* defined (FS_FAST) */`
		1118
		1119	`#ifdef FS_FAST`
		1120	`#undef rule_being_output`
		1121	`#endif /* defined (FS_FAST) */`
		1122	`void`
6	7u83	1123	`rule_being_output(RuleP rule)`
2	7u83	1124	`{`
		1125	`rule->being_output = TRUE;`
		1126	`}`
		1127	`#ifdef FS_FAST`
6	7u83	1128	`#define rule_being_output(r) ((r)->being_output = TRUE)`
2	7u83	1129	`#endif /* defined (FS_FAST) */`
		1130
		1131	`#ifdef FS_FAST`
		1132	`#undef rule_not_being_output`
		1133	`#endif /* defined (FS_FAST) */`
		1134	`void`
6	7u83	1135	`rule_not_being_output(RuleP rule)`
2	7u83	1136	`{`
		1137	`rule->being_output = FALSE;`
		1138	`}`
		1139	`#ifdef FS_FAST`
6	7u83	1140	`#define rule_not_being_output(r) ((r)->being_output = FALSE)`
2	7u83	1141	`#endif /* defined (FS_FAST) */`
		1142
		1143	`#ifdef FS_FAST`
		1144	`#undef rule_get_start_label`
		1145	`#endif /* defined (FS_FAST) */`
		1146	`unsigned`
6	7u83	1147	`rule_get_start_label(RuleP rule)`
2	7u83	1148	`{`
6	7u83	1149	`return(rule->start_label);`
2	7u83	1150	`}`
		1151	`#ifdef FS_FAST`
6	7u83	1152	`#define rule_get_start_label(r) ((r)->start_label)`
2	7u83	1153	`#endif /* defined (FS_FAST) */`
		1154
		1155	`#ifdef FS_FAST`
		1156	`#undef rule_set_start_label`
		1157	`#endif /* defined (FS_FAST) */`
		1158	`void`
6	7u83	1159	`rule_set_start_label(RuleP rule, unsigned label)`
2	7u83	1160	`{`
		1161	`rule->start_label = label;`
		1162	`}`
		1163	`#ifdef FS_FAST`
6	7u83	1164	`#define rule_set_start_label(r, l) ((r)->start_label = (l))`
2	7u83	1165	`#endif /* defined (FS_FAST) */`
		1166
		1167	`#ifdef FS_FAST`
		1168	`#undef rule_get_call_count`
		1169	`#endif /* defined (FS_FAST) */`
		1170	`unsigned`
6	7u83	1171	`rule_get_call_count(RuleP rule)`
2	7u83	1172	`{`
6	7u83	1173	`return(rule->call_count);`
2	7u83	1174	`}`
		1175	`#ifdef FS_FAST`
6	7u83	1176	`#define rule_get_call_count(r) ((r)->call_count)`
2	7u83	1177	`#endif /* defined (FS_FAST) */`
		1178
		1179	`#ifdef FS_FAST`
		1180	`#undef rule_inc_call_count`
		1181	`#endif /* defined (FS_FAST) */`
		1182	`void`
6	7u83	1183	`rule_inc_call_count(RuleP rule)`
2	7u83	1184	`{`
6	7u83	1185	`rule->call_count++;`
2	7u83	1186	`}`
		1187	`#ifdef FS_FAST`
6	7u83	1188	`#define rule_inc_call_count(r) ((r)->call_count++)`
2	7u83	1189	`#endif /* defined (FS_FAST) */`
		1190
		1191	`unsigned`
6	7u83	1192	`rule_get_end_label(RuleP rule)`
2	7u83	1193	`{`
		1194	`rule->used_end_label = TRUE;`
6	7u83	1195	`return(rule->end_label);`
2	7u83	1196	`}`
		1197
		1198	`void`
6	7u83	1199	`rule_set_end_label(RuleP rule, unsigned label)`
2	7u83	1200	`{`
		1201	`rule->used_end_label = FALSE;`
		1202	`rule->end_label = label;`
		1203	`}`
		1204
		1205	`#ifdef FS_FAST`
		1206	`#undef rule_used_end_label`
		1207	`#endif /* defined (FS_FAST) */`
		1208	`BoolT`
6	7u83	1209	`rule_used_end_label(RuleP rule)`
2	7u83	1210	`{`
6	7u83	1211	`return(rule->used_end_label);`
2	7u83	1212	`}`
		1213	`#ifdef FS_FAST`
6	7u83	1214	`#define rule_used_end_label(r) ((r)->used_end_label)`
2	7u83	1215	`#endif /* defined (FS_FAST) */`
		1216
		1217	`#ifdef FS_FAST`
		1218	`#undef rule_get_next_label`
		1219	`#endif /* defined (FS_FAST) */`
		1220	`unsigned`
6	7u83	1221	`rule_get_next_label(RuleP rule)`
2	7u83	1222	`{`
6	7u83	1223	`return(rule->next_label);`
2	7u83	1224	`}`
		1225	`#ifdef FS_FAST`
6	7u83	1226	`#define rule_get_next_label(r) ((r)->next_label)`
2	7u83	1227	`#endif /* defined (FS_FAST) */`
		1228
		1229	`#ifdef FS_FAST`
		1230	`#undef rule_set_next_label`
		1231	`#endif /* defined (FS_FAST) */`
		1232	`void`
6	7u83	1233	`rule_set_next_label(RuleP rule, unsigned label)`
2	7u83	1234	`{`
		1235	`rule->next_label = label;`
		1236	`}`
		1237	`#ifdef FS_FAST`
6	7u83	1238	`#define rule_set_next_label(r, l) ((r)->next_label = (l))`
2	7u83	1239	`#endif /* defined (FS_FAST) */`
		1240
		1241	`unsigned`
6	7u83	1242	`rule_get_handler_label(RuleP rule)`
2	7u83	1243	`{`
		1244	`rule->used_handler_label = TRUE;`
6	7u83	1245	`return(rule->handler_label);`
2	7u83	1246	`}`
		1247
		1248	`void`
6	7u83	1249	`rule_set_handler_label(RuleP rule, unsigned label)`
2	7u83	1250	`{`
		1251	`rule->used_handler_label = FALSE;`
		1252	`rule->handler_label = label;`
		1253	`}`
		1254
		1255	`#ifdef FS_FAST`
		1256	`#undef rule_used_handler_label`
		1257	`#endif /* defined (FS_FAST) */`
		1258	`BoolT`
6	7u83	1259	`rule_used_handler_label(RuleP rule)`
2	7u83	1260	`{`
6	7u83	1261	`return(rule->used_handler_label);`
2	7u83	1262	`}`
		1263	`#ifdef FS_FAST`
6	7u83	1264	`#define rule_used_handler_label(r) ((r)->used_handler_label)`
2	7u83	1265	`#endif /* defined (FS_FAST) */`
		1266
		1267	`#ifdef FS_FAST`
		1268	`#undef rule_get_handler`
		1269	`#endif /* defined (FS_FAST) */`
		1270	`AltP`
6	7u83	1271	`rule_get_handler(RuleP rule)`
2	7u83	1272	`{`
6	7u83	1273	`return(rule->handler);`
2	7u83	1274	`}`
		1275	`#ifdef FS_FAST`
6	7u83	1276	`#define rule_get_handler(r) ((r)->handler)`
2	7u83	1277	`#endif /* defined (FS_FAST) */`
		1278
		1279	`#ifdef FS_FAST`
		1280	`#undef rule_set_handler`
		1281	`#endif /* defined (FS_FAST) */`
		1282	`void`
6	7u83	1283	`rule_set_handler(RuleP rule, AltP handler)`
2	7u83	1284	`{`
		1285	`rule->handler = handler;`
		1286	`}`
		1287	`#ifdef FS_FAST`
6	7u83	1288	`#define rule_set_handler(r, a) ((r)->handler = (a))`
2	7u83	1289	`#endif /* defined (FS_FAST) */`
		1290
		1291	`#ifdef FS_FAST`
		1292	`#undef rule_alt_head`
		1293	`#endif /* defined (FS_FAST) */`
		1294	`AltP`
6	7u83	1295	`rule_alt_head(RuleP rule)`
2	7u83	1296	`{`
6	7u83	1297	`return(rule->alt_head);`
2	7u83	1298	`}`
		1299	`#ifdef FS_FAST`
6	7u83	1300	`#define rule_alt_head(r) ((r)->alt_head)`
2	7u83	1301	`#endif /* defined (FS_FAST) */`
		1302
		1303	`void`
6	7u83	1304	`rule_renumber(RuleP rule, BoolT do_result, EntryP predicate_id)`
2	7u83	1305	`{`
		1306	`TypeNTransT translator;`
		1307	`SaveNTransT state;`
		1308	`AltP alt;`
		1309
6	7u83	1310	`ntrans_init(&translator);`
		1311	`(void)ntrans_get_translation(&translator, predicate_id);`
		1312	`types_renumber(rule_param(rule), &translator);`
2	7u83	1313	`if (do_result) {`
6	7u83	1314	`types_renumber(rule_result(rule), &translator);`
2	7u83	1315	`}`
6	7u83	1316	`ntrans_save_state(&translator, &state);`
		1317	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
		1318	`rule_renumber_1(alt, &translator, &state);`
2	7u83	1319	`}`
6	7u83	1320	`for (alt = rule->alt_head; alt; alt = alt_next(alt)) {`
		1321	`rule_renumber_1(alt, &translator, &state);`
2	7u83	1322	`}`
6	7u83	1323	`ntrans_destroy(&translator);`
2	7u83	1324	`}`
		1325
		1326	`void`
6	7u83	1327	`rule_iter_for_table(RuleP rule, BoolT full, void (*proc)(EntryP, GenericP),`
		1328	`GenericP closure)`
2	7u83	1329	`{`
		1330	`AltP alt;`
		1331
6	7u83	1332	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
2	7u83	1333	`ItemP item;`
		1334
6	7u83	1335	`for (item = alt_item_head(alt); item; item = item_next(item)) {`
		1336	`entry_iter(item_entry(item), full, proc, closure);`
2	7u83	1337	`if (full) {`
6	7u83	1338	`types_iter_for_table(item_param(item), proc, closure);`
		1339	`types_iter_for_table(item_result(item), proc, closure);`
2	7u83	1340	`}`
		1341	`}`
		1342	`}`
6	7u83	1343	`for (alt = rule->alt_head; alt; alt = alt_next(alt)) {`
2	7u83	1344	`ItemP item;`
		1345
6	7u83	1346	`for (item = alt_item_head(alt); item; item = item_next(item)) {`
		1347	`entry_iter(item_entry(item), full, proc, closure);`
2	7u83	1348	`if (full) {`
6	7u83	1349	`types_iter_for_table(item_param(item), proc, closure);`
		1350	`types_iter_for_table(item_result(item), proc, closure);`
2	7u83	1351	`}`
		1352	`}`
		1353	`}`
		1354	`if (full) {`
6	7u83	1355	`non_local_list_iter_for_table(rule_non_locals(rule), proc, closure);`
		1356	`types_iter_for_table(rule_param(rule), proc, closure);`
		1357	`types_iter_for_table(rule_result(rule), proc, closure);`
2	7u83	1358	`}`
		1359	`}`
		1360
		1361	`void`
6	7u83	1362	`rule_deallocate(RuleP rule)`
2	7u83	1363	`{`
		1364	`AltP alt;`
		1365
6	7u83	1366	`types_destroy(rule_param(rule));`
		1367	`types_destroy(rule_result(rule));`
		1368	`non_local_list_destroy(rule_non_locals(rule));`
		1369	`nstring_destroy(rule_maximum_scope(rule));`
		1370	`entry_list_destroy(rule_reverse_list(rule));`
		1371	`bitvec_destroy(rule_first_set(rule));`
		1372	`entry_list_destroy(rule_predicate_first(rule));`
		1373	`bitvec_destroy(rule_follow_set(rule));`
		1374	`entry_list_destroy(rule_predicate_follow(rule));`
		1375	`entry_list_destroy(rule_call_list(rule));`
		1376	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
		1377	`(void)alt_deallocate(alt);`
2	7u83	1378	`}`
6	7u83	1379	`for (alt = rule_alt_head(rule); alt; alt = alt_deallocate(alt)) {`
2	7u83	1380	`/NOTHING/`
		1381	`}`
		1382	`}`
		1383
		1384	`void`
6	7u83	1385	`write_rule_lhs(OStreamP ostream, RuleP rule)`
2	7u83	1386	`{`
6	7u83	1387	`KeyP key = entry_key(rule_entry(rule));`
2	7u83	1388
6	7u83	1389	`write_key(ostream, key);`
		1390	`write_cstring(ostream, ": ");`
		1391	`write_type_names(ostream, rule_param(rule), FALSE);`
		1392	`write_cstring(ostream, " -> ");`
		1393	`write_type_names(ostream, rule_result(rule), FALSE);`
		1394	`if (!non_local_list_is_empty(rule_non_locals(rule))) {`
		1395	`write_cstring(ostream, " [");`
		1396	`write_newline(ostream);`
		1397	`write_non_locals(ostream, rule_non_locals(rule));`
		1398	`write_char(ostream, ']');`
2	7u83	1399	`}`
6	7u83	1400	`write_cstring(ostream, " = {");`
		1401	`write_newline(ostream);`
2	7u83	1402	`}`
		1403
		1404	`void`
6	7u83	1405	`write_rule(OStreamP ostream, RuleP rule)`
2	7u83	1406	`{`
		1407	`BoolT need_sep = FALSE;`
		1408	`AltP alt;`
		1409
6	7u83	1410	`write_rule_lhs(ostream, rule);`
		1411	`if (rule_has_empty_alt(rule)) {`
		1412	`write_tab(ostream);`
		1413	`write_cstring(ostream, "$;");`
		1414	`write_newline(ostream);`
2	7u83	1415	`need_sep = TRUE;`
		1416	`}`
6	7u83	1417	`for (alt = rule->alt_head; alt; alt = alt_next(alt)) {`
2	7u83	1418	`if (need_sep) {`
6	7u83	1419	`write_cstring(ostream, " \|\|");`
		1420	`write_newline(ostream);`
2	7u83	1421	`}`
6	7u83	1422	`write_alt(ostream, alt);`
2	7u83	1423	`need_sep = TRUE;`
		1424	`}`
6	7u83	1425	`if ((alt = rule_get_handler(rule)) != NIL(AltP)) {`
		1426	`write_cstring(ostream, " ##");`
		1427	`write_newline(ostream);`
		1428	`write_alt(ostream, alt);`
2	7u83	1429	`}`
6	7u83	1430	`write_cstring(ostream, "};");`
		1431	`write_newline(ostream);`
2	7u83	1432	`}`
		1433
		1434	`/--------------------------------------------------------------------------/`
		1435
		1436	`void`
6	7u83	1437	`rule_list_init(RuleListP list)`
2	7u83	1438	`{`
		1439	`list->tail = &(list->head);`
		1440	`}`
		1441
		1442	`void`
6	7u83	1443	`rule_list_append(RuleListP list, RuleP next, RuleP *tail)`
2	7u83	1444	`{`
		1445	`*(list->tail) = next;`
		1446	`list->tail = tail;`
		1447	`}`
		1448
		1449	`#ifdef FS_FAST`
		1450	`#undef rule_list_terminate`
		1451	`#endif /* defined (FS_FAST) */`
		1452	`void`
6	7u83	1453	`rule_list_terminate(RuleListP list)`
2	7u83	1454	`{`
6	7u83	1455	`*(list->tail) = NIL(RuleP);`
2	7u83	1456	`}`
		1457	`#ifdef FS_FAST`
6	7u83	1458	`#define rule_list_terminate(r) ((*((r)->tail)) = NIL(RuleP))`
2	7u83	1459	`#endif /* defined (FS_FAST) */`
		1460
		1461	`#ifdef FS_FAST`
		1462	`#undef rule_list_head`
		1463	`#endif /* defined (FS_FAST) */`
		1464	`RuleP`
6	7u83	1465	`rule_list_head(RuleListP list)`
2	7u83	1466	`{`
6	7u83	1467	`return(list->head);`
2	7u83	1468	`}`
		1469	`#ifdef FS_FAST`
6	7u83	1470	`#define rule_list_head(r) ((r)->head)`
2	7u83	1471	`#endif /* defined (FS_FAST) */`
		1472
		1473	`/*`
		1474	`* Local variables(smf):`
		1475	`* eval: (include::add-path-entry "../os-interface" "../library")`
		1476	`* eval: (include::add-path-entry "../generated")`
		1477	`* end:`
		1478	`**/`

Subversion Repositories tendra.SVN

(root)/branches/tendra5-amd64/src/utilities/sid/rule.c – Rev 123