Subversion Repositories tendra.SVN

Rev

Rev 2 | Go to most recent revision | Details | Compare with Previous | 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 
/*** item.c --- Item ADT.
32 
 *
33 
 ** Author: Steve Folkes <smf@hermes.mod.uk>
34 
 *
35 
 *** Commentary:
36 
 *
37 
 * This file implements the item manipulation routines.  These are specified
38 
 * in the file "rule.h".
39 
 *
40 
 *** Change Log:
41 
 * $Log: item.c,v $
42 
 * Revision 1.1.1.1  1998/01/17  15:57:46  release
43 
 * First version to be checked into rolling release.
44 
 *
45 
 * Revision 1.2  1994/12/15  09:58:17  smf
46 
 * Brought into line with OSSG C Coding Standards Document, as per
47 
 * "CR94_178.sid+tld-update".
48 
 *
49 
 * Revision 1.1.1.1  1994/07/25  16:04:34  smf
50 
 * Initial import of SID 1.8 non shared files.
51 
 *
52 
**/
53 
 
54 
/****************************************************************************/
55 
 
56 
#include "rule.h"
57 
#include "action.h"
58 
#include "basic.h"
59 
#include "name.h"
60 
#include "type.h"
61 
 
62 
/*--------------------------------------------------------------------------*/
63 
 
64 
ItemP
65 
item_create PROTO_N ((entry))
66 
	    PROTO_T (EntryP entry)
67 
{
68 
    ItemP item = ALLOCATE (ItemT);
69 
 
70 
    item->next         = NIL (ItemP);
71 
    types_init (item_param (item));
72 
    types_init (item_result (item));
73 
    item->type         = entry_type (entry);
74 
    item->entry        = entry;
75 
    item->inlinable    = FALSE;
76 
    item->tail_call    = FALSE;
77 
    return (item);
78 
}
79 
 
80 
ItemP
81 
item_duplicate PROTO_N ((item))
82 
	       PROTO_T (ItemP item)
83 
{
84 
    ItemP new_item = ALLOCATE (ItemT);
85 
 
86 
    new_item->next         = NIL (ItemP);
87 
    types_copy (item_param (new_item), item_param (item));
88 
    types_copy (item_result (new_item), item_result (item));
89 
    new_item->type         = item->type;
90 
    new_item->entry        = item->entry;
91 
    new_item->inlinable    = item->inlinable;
92 
    new_item->tail_call    = item->tail_call;
93 
    return (new_item);
94 
}
95 
 
96 
ItemP
97 
item_duplicate_and_translate PROTO_N ((item, translator, table))
98 
			     PROTO_T (ItemP      item X
99 
				      TypeTransP translator X
100 
				      TableP     table)
101 
{
102 
    ItemP new_item = ALLOCATE (ItemT);
103 
 
104 
    new_item->next         = NIL (ItemP);
105 
    types_copy_and_translate (item_param (new_item), item_param (item),
106 
			      translator, table);
107 
    types_copy_and_translate (item_result (new_item), item_result (item),
108 
			      translator, table);
109 
    new_item->type         = item->type;
110 
    new_item->entry        = item->entry;
111 
    new_item->inlinable    = item->inlinable;
112 
    new_item->tail_call    = item->tail_call;
113 
    return (new_item);
114 
}
115 
 
116 
void
117 
item_translate_list PROTO_N ((item, translator))
118 
		    PROTO_T (ItemP       item X
119 
			     TypeBTransP translator)
120 
{
121 
    for (; item; item = item_next (item)) {
122 
	types_translate (item_param (item), translator);
123 
	types_translate (item_result (item), translator);
124 
    }
125 
}
126 
 
127 
void
128 
item_to_predicate PROTO_N ((item))
129 
		  PROTO_T (ItemP item)
130 
{
131 
    ASSERT (item_is_action (item));
132 
    item->type = ET_PREDICATE;
133 
}
134 
 
135 
#ifdef FS_FAST
136 
#undef item_next
137 
#endif /* defined (FS_FAST) */
138 
ItemP
139 
item_next PROTO_N ((item))
140 
	  PROTO_T (ItemP item)
141 
{
142 
    return (item->next);
143 
}
144 
#ifdef FS_FAST
145 
#define item_next(i) ((i)->next)
146 
#endif /* defined (FS_FAST) */
147 
 
148 
#ifdef FS_FAST
149 
#undef item_next_ref
150 
#endif /* defined (FS_FAST) */
151 
ItemP *
152 
item_next_ref PROTO_N ((item))
153 
	      PROTO_T (ItemP item)
154 
{
155 
    return (&(item->next));
156 
}
157 
#ifdef FS_FAST
158 
#define item_next_ref(i) (&((i)->next))
159 
#endif /* defined (FS_FAST) */
160 
 
161 
#ifdef FS_FAST
162 
#undef item_set_next
163 
#endif /* defined (FS_FAST) */
164 
void
165 
item_set_next PROTO_N ((item1, item2))
166 
	      PROTO_T (ItemP item1 X
167 
		       ItemP item2)
168 
{
169 
    item1->next = item2;
170 
}
171 
#ifdef FS_FAST
172 
#define item_set_next(i1, i2) ((i1)->next = (i2))
173 
#endif /* defined (FS_FAST) */
174 
 
175 
#ifdef FS_FAST
176 
#undef item_entry
177 
#endif /* defined (FS_FAST) */
178 
EntryP
179 
item_entry PROTO_N ((item))
180 
	   PROTO_T (ItemP item)
181 
{
182 
    return (item->entry);
183 
}
184 
#ifdef FS_FAST
185 
#define item_entry(i) ((i)->entry)
186 
#endif /* defined (FS_FAST) */
187 
 
188 
#ifdef FS_FAST
189 
#undef item_set_entry
190 
#endif /* defined (FS_FAST) */
191 
void
192 
item_set_entry PROTO_N ((item, entry))
193 
	       PROTO_T (ItemP  item X
194 
			EntryP entry)
195 
{
196 
    item->entry = entry;
197 
}
198 
#ifdef FS_FAST
199 
#define item_set_entry(i, e) ((i)->entry = (e))
200 
#endif /* defined (FS_FAST) */
201 
 
202 
#ifdef FS_FAST
203 
#undef item_type
204 
#endif /* defined (FS_FAST) */
205 
EntryTypeT
206 
item_type PROTO_N ((item))
207 
	  PROTO_T (ItemP item)
208 
{
209 
    return (item->type);
210 
}
211 
#ifdef FS_FAST
212 
#define item_type(i) ((i)->type)
213 
#endif /* defined (FS_FAST) */
214 
 
215 
#ifdef FS_FAST
216 
#undef item_is_rule
217 
#endif /* defined (FS_FAST) */
218 
BoolT
219 
item_is_rule PROTO_N ((item))
220 
	     PROTO_T (ItemP item)
221 
{
222 
    return (item->type == ET_RULE);
223 
}
224 
#ifdef FS_FAST
225 
#define item_is_rule(i) ((i)->type == ET_RULE)
226 
#endif /* defined (FS_FAST) */
227 
 
228 
#ifdef FS_FAST
229 
#undef item_is_action
230 
#endif /* defined (FS_FAST) */
231 
BoolT
232 
item_is_action PROTO_N ((item))
233 
	       PROTO_T (ItemP item)
234 
{
235 
    return (item->type == ET_ACTION);
236 
}
237 
#ifdef FS_FAST
238 
#define item_is_action(i) ((i)->type == ET_ACTION)
239 
#endif /* defined (FS_FAST) */
240 
 
241 
#ifdef FS_FAST
242 
#undef item_is_predicate
243 
#endif /* defined (FS_FAST) */
244 
BoolT
245 
item_is_predicate PROTO_N ((item))
246 
		  PROTO_T (ItemP item)
247 
{
248 
    return (item->type == ET_PREDICATE);
249 
}
250 
#ifdef FS_FAST
251 
#define item_is_predicate(i) ((i)->type == ET_PREDICATE)
252 
#endif /* defined (FS_FAST) */
253 
 
254 
#ifdef FS_FAST
255 
#undef item_is_basic
256 
#endif /* defined (FS_FAST) */
257 
BoolT
258 
item_is_basic PROTO_N ((item))
259 
	      PROTO_T (ItemP item)
260 
{
261 
    return (item->type == ET_BASIC);
262 
}
263 
#ifdef FS_FAST
264 
#define item_is_basic(i) ((i)->type == ET_BASIC)
265 
#endif /* defined (FS_FAST) */
266 
 
267 
#ifdef FS_FAST
268 
#undef item_is_rename
269 
#endif /* defined (FS_FAST) */
270 
BoolT
271 
item_is_rename PROTO_N ((item))
272 
	       PROTO_T (ItemP item)
273 
{
274 
    return (item->type == ET_RENAME);
275 
}
276 
#ifdef FS_FAST
277 
#define item_is_rename(i) ((i)->type == ET_RENAME)
278 
#endif /* defined (FS_FAST) */
279 
 
280 
#ifdef FS_FAST
281 
#undef item_param
282 
#endif /* defined (FS_FAST) */
283 
TypeTupleP
284 
item_param PROTO_N ((item))
285 
	   PROTO_T (ItemP item)
286 
{
287 
    return (&(item->param));
288 
}
289 
#ifdef FS_FAST
290 
#define item_param(i) (&((i)->param))
291 
#endif /* defined (FS_FAST) */
292 
 
293 
#ifdef FS_FAST
294 
#undef item_add_param
295 
#endif /* defined (FS_FAST) */
296 
void
297 
item_add_param PROTO_N ((item, param))
298 
	       PROTO_T (ItemP      item X
299 
			TypeTupleP param)
300 
{
301 
    types_assign (item_param (item), param);
302 
}
303 
#ifdef FS_FAST
304 
#define item_add_param(i, t) (types_assign (&((i)->param), (t)))
305 
#endif /* defined (FS_FAST) */
306 
 
307 
#ifdef FS_FAST
308 
#undef item_result
309 
#endif /* defined (FS_FAST) */
310 
TypeTupleP
311 
item_result PROTO_N ((item))
312 
	    PROTO_T (ItemP item)
313 
{
314 
    return (&(item->result));
315 
}
316 
#ifdef FS_FAST
317 
#define item_result(i) (&((i)->result))
318 
#endif /* defined (FS_FAST) */
319 
 
320 
#ifdef FS_FAST
321 
#undef item_add_result
322 
#endif /* defined (FS_FAST) */
323 
void
324 
item_add_result PROTO_N ((item, result))
325 
		PROTO_T (ItemP      item X
326 
			 TypeTupleP result)
327 
{
328 
    types_assign (item_result (item), result);
329 
}
330 
#ifdef FS_FAST
331 
#define item_add_result(i, t) (types_assign (&((i)->result), (t)))
332 
#endif /* defined (FS_FAST) */
333 
 
334 
#ifdef FS_FAST
335 
#undef item_is_inlinable
336 
#endif /* defined (FS_FAST) */
337 
BoolT
338 
item_is_inlinable PROTO_N ((item))
339 
		  PROTO_T (ItemP item)
340 
{
341 
    return (item->inlinable);
342 
}
343 
#ifdef FS_FAST
344 
#define item_is_inlinable(i) ((i)->inlinable)
345 
#endif /* defined (FS_FAST) */
346 
 
347 
#ifdef FS_FAST
348 
#undef item_inlinable
349 
#endif /* defined (FS_FAST) */
350 
void
351 
item_inlinable PROTO_N ((item))
352 
	       PROTO_T (ItemP item)
353 
{
354 
    item->inlinable = TRUE;
355 
}
356 
#ifdef FS_FAST
357 
#define item_inlinable(i) ((i)->inlinable = TRUE)
358 
#endif /* defined (FS_FAST) */
359 
 
360 
#ifdef FS_FAST
361 
#undef item_is_tail_call
362 
#endif /* defined (FS_FAST) */
363 
BoolT
364 
item_is_tail_call PROTO_N ((item))
365 
		  PROTO_T (ItemP item)
366 
{
367 
    return (item->tail_call);
368 
}
369 
#ifdef FS_FAST
370 
#define item_is_tail_call(i) ((i)->tail_call)
371 
#endif /* defined (FS_FAST) */
372 
 
373 
#ifdef FS_FAST
374 
#undef item_tail_call
375 
#endif /* defined (FS_FAST) */
376 
void
377 
item_tail_call PROTO_N ((item))
378 
	       PROTO_T (ItemP item)
379 
{
380 
    item->tail_call = TRUE;
381 
}
382 
#ifdef FS_FAST
383 
#define item_tail_call(i) ((i)->tail_call = TRUE)
384 
#endif /* defined (FS_FAST) */
385 
 
386 
BoolT
387 
item_names_used_in_list PROTO_N ((item, names))
388 
			PROTO_T (ItemP      item X
389 
				 TypeTupleP names)
390 
{
391 
    while (item) {
392 
	if ((types_intersect (item_param (item), names)) ||
393 
	    (types_intersect (item_result (item), names))) {
394 
	    return (TRUE);
395 
	}
396 
	item = item_next (item);
397 
    }
398 
    return (FALSE);
399 
}
400 
 
401 
void
402 
item_compute_minimal_dataflow PROTO_N ((item, used))
403 
			      PROTO_T (ItemP      item X
404 
				       TypeTupleP used)
405 
{
406 
    if (item) {
407 
	ItemP next = item_next (item);
408 
 
409 
	if (next) {
410 
	    item_compute_minimal_dataflow (next, used);
411 
	}
412 
	if (item_is_inlinable (item)) {
413 
	    RuleP rule = entry_get_rule (item_entry (item));
414 
 
415 
	    types_inplace_intersection (item_result (item), used);
416 
	    types_inplace_intersection (rule_result (rule), used);
417 
	    rule_compute_minimal_dataflow (rule, item_param (item));
418 
	}
419 
	types_add_new_names (used, item_param (item), NIL (EntryP));
420 
    }
421 
}
422 
 
423 
ItemP
424 
item_deallocate PROTO_N ((item))
425 
		PROTO_T (ItemP item)
426 
{
427 
    ItemP next = item_next (item);
428 
 
429 
    types_destroy (item_param (item));
430 
    types_destroy (item_result (item));
431 
    DEALLOCATE (item);
432 
    return (next);
433 
}
434 
 
435 
void
436 
write_item PROTO_N ((ostream, item))
437 
	   PROTO_T (OStreamP ostream X
438 
		    ItemP    item)
439 
{
440 
    EntryP entry = item_entry (item);
441 
 
442 
    write_type_names (ostream, item_result (item), TRUE);
443 
    if (item_is_predicate (item)) {
444 
	write_cstring (ostream, " ?");
445 
    }
446 
    write_cstring (ostream, " = ");
447 
    switch (item_type (item)) EXHAUSTIVE {
448 
      case ET_ACTION:
449 
      case ET_PREDICATE:
450 
	write_char (ostream, '<');
451 
	write_key (ostream, entry_key (entry));
452 
	write_cstring (ostream, "> ");
453 
	break;
454 
      case ET_RULE:
455 
	if (item_is_inlinable (item)) {
456 
	    if (item_is_tail_call (item)) {
457 
		write_char (ostream, '*');
458 
	    } else {
459 
		write_char (ostream, '+');
460 
	    }
461 
	}
462 
	FALL_THROUGH;
463 
      case ET_BASIC:
464 
	write_key (ostream, entry_key (item_entry (item)));
465 
	write_char (ostream, ' ');
466 
	break;
467 
      case ET_RENAME:
468 
	break;
469 
      case ET_NON_LOCAL:
470 
      case ET_NAME:
471 
      case ET_TYPE:
472 
	UNREACHED;
473 
    }
474 
    write_type_names (ostream, item_param (item), TRUE);
475 
    write_char (ostream, ';');
476 
}
477 
 
478 
/*
479 
 * Local variables(smf):
480 
 * eval: (include::add-path-entry "../os-interface" "../library")
481 
 * eval: (include::add-path-entry "../generated")
482 
 * end:
483 
**/