Subversion Repositories tendra.SVN

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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