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 
/*** entry.c --- Identifier table entry ADT.
32 
 *
33 
 ** Author: Steve Folkes <smf@hermes.mod.uk>
34 
 *
35 
 *** Commentary:
36 
 *
37 
 * This file implements the identifier table routines used by SID.
38 
 *
39 
 *** Change Log:
40 
 * $Log: entry.c,v $
41 
 * Revision 1.1.1.1  1998/01/17  15:57:45  release
42 
 * First version to be checked into rolling release.
43 
 *
44 
 * Revision 1.2  1994/12/15  09:58:08  smf
45 
 * Brought into line with OSSG C Coding Standards Document, as per
46 
 * "CR94_178.sid+tld-update".
47 
 *
48 
 * Revision 1.1.1.1  1994/07/25  16:04:33  smf
49 
 * Initial import of SID 1.8 non shared files.
50 
 *
51 
**/
52 
 
53 
/****************************************************************************/
54 
 
55 
#include "entry.h"
56 
#include "action.h"
57 
#include "basic.h"
58 
#include "gen-errors.h"
59 
#include "name.h"
60 
#include "rule.h"
61 
#include "type.h"
62 
 
63 
/*--------------------------------------------------------------------------*/
64 
 
65 
#ifdef FS_FAST
66 
#undef entry_traced
67 
#endif /* defined (FS_FAST) */
68 
static void
69 
entry_traced PROTO_N ((entry))
70 
	     PROTO_T (EntryP entry)
71 
{
72 
    entry->traced = TRUE;
73 
}
74 
#ifdef FS_FAST
75 
#define entry_traced(e) ((e)->traced = TRUE)
76 
#endif /* defined (FS_FAST) */
77 
 
78 
/*--------------------------------------------------------------------------*/
79 
 
80 
EntryP
81 
entry_create_from_string PROTO_N ((key, number, type))
82 
			 PROTO_T (NStringP   key X
83 
				  unsigned   number X
84 
				  EntryTypeT type)
85 
{
86 
    EntryP entry = ALLOCATE (EntryT);
87 
 
88 
    entry->next   = NIL (EntryP);
89 
    key_init_from_string (entry_key (entry), key, number);
90 
    entry->mapped = FALSE;
91 
    nstring_init (&(entry->mapping));
92 
    entry->type   = type;
93 
    entry->name   = name_create ();
94 
    entry->traced = FALSE;
95 
    return (entry);
96 
}
97 
 
98 
EntryP
99 
entry_create_from_number PROTO_N ((key, type, traced, next))
100 
			 PROTO_T (unsigned   key X
101 
				  EntryTypeT type X
102 
				  BoolT      traced X
103 
				  EntryP     next)
104 
{
105 
    EntryP entry = ALLOCATE (EntryT);
106 
 
107 
    entry->next   = next;
108 
    key_init_from_number (entry_key (entry), key);
109 
    entry->mapped = FALSE;
110 
    nstring_init (&(entry->mapping));
111 
    entry->type   = type;
112 
    entry->name   = name_create ();
113 
    entry->traced = traced;
114 
    return (entry);
115 
}
116 
 
117 
#ifdef FS_FAST
118 
#undef entry_set_basic
119 
#endif /* defined (FS_FAST) */
120 
void
121 
entry_set_basic PROTO_N ((entry, basic))
122 
		PROTO_T (EntryP entry X
123 
			 BasicP basic)
124 
{
125 
    ASSERT (entry_is_basic (entry));
126 
    entry->u.basic = basic;
127 
}
128 
#ifdef FS_FAST
129 
#define entry_set_basic(e, b) ((e)->u.basic = (b))
130 
#endif /* defined (FS_FAST) */
131 
 
132 
#ifdef FS_FAST
133 
#undef entry_set_rule
134 
#endif /* defined (FS_FAST) */
135 
void
136 
entry_set_rule PROTO_N ((entry, rule))
137 
	       PROTO_T (EntryP entry X
138 
			RuleP  rule)
139 
{
140 
    ASSERT (entry_is_rule (entry));
141 
    entry->u.rule = rule;
142 
}
143 
#ifdef FS_FAST
144 
#define entry_set_rule(e, r) ((e)->u.rule = (r))
145 
#endif /* defined (FS_FAST) */
146 
 
147 
#ifdef FS_FAST
148 
#undef entry_set_action
149 
#endif /* defined (FS_FAST) */
150 
void
151 
entry_set_action PROTO_N ((entry, action))
152 
		 PROTO_T (EntryP  entry X
153 
			  ActionP action)
154 
{
155 
    ASSERT (entry_is_action (entry));
156 
    entry->u.action = action;
157 
}
158 
#ifdef FS_FAST
159 
#define entry_set_action(e, a) ((e)->u.action = (a))
160 
#endif /* defined (FS_FAST) */
161 
 
162 
#ifdef FS_FAST
163 
#undef entry_set_type
164 
#endif /* defined (FS_FAST) */
165 
void
166 
entry_set_type PROTO_N ((entry, type))
167 
	       PROTO_T (EntryP entry X
168 
			TypeP  type)
169 
{
170 
    ASSERT (entry_is_type (entry));
171 
    entry->u.type = type;
172 
}
173 
#ifdef FS_FAST
174 
#define entry_set_type(e, t) ((e)->u.type = (t))
175 
#endif /* defined (FS_FAST) */
176 
 
177 
#ifdef FS_FAST
178 
#undef entry_set_non_local
179 
#endif /* defined (FS_FAST) */
180 
void
181 
entry_set_non_local PROTO_N ((entry, type))
182 
		    PROTO_T (EntryP entry X
183 
			     EntryP type)
184 
{
185 
    ASSERT (entry_is_non_local (entry));
186 
    entry->u.non_local = type;
187 
}
188 
#ifdef FS_FAST
189 
#define entry_set_non_local(e, t) ((e)->u.non_local = (t))
190 
#endif /* defined (FS_FAST) */
191 
 
192 
#ifdef FS_FAST
193 
#undef entry_next
194 
#endif /* defined (FS_FAST) */
195 
EntryP
196 
entry_next PROTO_N ((entry))
197 
	   PROTO_T (EntryP entry)
198 
{
199 
    return (entry->next);
200 
}
201 
#ifdef FS_FAST
202 
#define entry_next(e) ((e)->next)
203 
#endif /* defined (FS_FAST) */
204 
 
205 
#ifdef FS_FAST
206 
#undef entry_next_ref
207 
#endif /* defined (FS_FAST) */
208 
EntryP *
209 
entry_next_ref PROTO_N ((entry))
210 
	       PROTO_T (EntryP entry)
211 
{
212 
    return (&(entry->next));
213 
}
214 
#ifdef FS_FAST
215 
#define entry_next_ref(e) (&((e)->next))
216 
#endif /* defined (FS_FAST) */
217 
 
218 
#ifdef FS_FAST
219 
#undef entry_key
220 
#endif /* defined (FS_FAST) */
221 
KeyP
222 
entry_key PROTO_N ((entry))
223 
	  PROTO_T (EntryP entry)
224 
{
225 
    return (&(entry->key));
226 
}
227 
#ifdef FS_FAST
228 
#define entry_key(e) (&((e)->key))
229 
#endif /* defined (FS_FAST) */
230 
 
231 
#ifdef FS_FAST
232 
#undef entry_type
233 
#endif /* defined (FS_FAST) */
234 
EntryTypeT
235 
entry_type PROTO_N ((entry))
236 
	   PROTO_T (EntryP entry)
237 
{
238 
    return (entry->type);
239 
}
240 
#ifdef FS_FAST
241 
#define entry_type(e) ((e)->type)
242 
#endif /* defined (FS_FAST) */
243 
 
244 
#ifdef FS_FAST
245 
#undef entry_change_type
246 
#endif /* defined (FS_FAST) */
247 
void
248 
entry_change_type PROTO_N ((entry, type))
249 
		  PROTO_T (EntryP     entry X
250 
			   EntryTypeT type)
251 
{
252 
    entry->type = type;
253 
}
254 
#ifdef FS_FAST
255 
#define entry_change_type(e, t) ((e)->type= (t))
256 
#endif /* defined (FS_FAST) */
257 
 
258 
#ifdef FS_FAST
259 
#undef entry_is_basic
260 
#endif /* defined (FS_FAST) */
261 
BoolT
262 
entry_is_basic PROTO_N ((entry))
263 
	       PROTO_T (EntryP entry)
264 
{
265 
    return (entry->type == ET_BASIC);
266 
}
267 
#ifdef FS_FAST
268 
#define entry_is_basic(e) ((e)->type == ET_BASIC)
269 
#endif /* defined (FS_FAST) */
270 
 
271 
#ifdef FS_FAST
272 
#undef entry_is_action
273 
#endif /* defined (FS_FAST) */
274 
BoolT
275 
entry_is_action PROTO_N ((entry))
276 
		PROTO_T (EntryP entry)
277 
{
278 
    return (entry->type == ET_ACTION);
279 
}
280 
#ifdef FS_FAST
281 
#define entry_is_action(e) ((e)->type == ET_ACTION)
282 
#endif /* defined (FS_FAST) */
283 
 
284 
#ifdef FS_FAST
285 
#undef entry_is_rule
286 
#endif /* defined (FS_FAST) */
287 
BoolT
288 
entry_is_rule PROTO_N ((entry))
289 
	      PROTO_T (EntryP entry)
290 
{
291 
    return (entry->type == ET_RULE);
292 
}
293 
#ifdef FS_FAST
294 
#define entry_is_rule(e) ((e)->type == ET_RULE)
295 
#endif /* defined (FS_FAST) */
296 
 
297 
#ifdef FS_FAST
298 
#undef entry_is_type
299 
#endif /* defined (FS_FAST) */
300 
BoolT
301 
entry_is_type PROTO_N ((entry))
302 
	      PROTO_T (EntryP entry)
303 
{
304 
    return (entry->type == ET_TYPE);
305 
}
306 
#ifdef FS_FAST
307 
#define entry_is_type(e) ((e)->type == ET_TYPE)
308 
#endif /* defined (FS_FAST) */
309 
 
310 
#ifdef FS_FAST
311 
#undef entry_is_non_local
312 
#endif /* defined (FS_FAST) */
313 
BoolT
314 
entry_is_non_local PROTO_N ((entry))
315 
		   PROTO_T (EntryP entry)
316 
{
317 
    return (entry->type == ET_NON_LOCAL);
318 
}
319 
#ifdef FS_FAST
320 
#define entry_is_non_local(e) ((e)->type == ET_NON_LOCAL)
321 
#endif /* defined (FS_FAST) */
322 
 
323 
#ifdef FS_FAST
324 
#undef entry_get_basic
325 
#endif /* defined (FS_FAST) */
326 
BasicP
327 
entry_get_basic PROTO_N ((entry))
328 
		PROTO_T (EntryP entry)
329 
{
330 
    ASSERT (entry_is_basic (entry));
331 
    return (entry->u.basic);
332 
}
333 
#ifdef FS_FAST
334 
#define entry_get_basic(e) ((e)->u.basic)
335 
#endif /* defined (FS_FAST) */
336 
 
337 
#ifdef FS_FAST
338 
#undef entry_get_action
339 
#endif /* defined (FS_FAST) */
340 
ActionP
341 
entry_get_action PROTO_N ((entry))
342 
		 PROTO_T (EntryP entry)
343 
{
344 
    ASSERT (entry_is_action (entry));
345 
    return (entry->u.action);
346 
}
347 
#ifdef FS_FAST
348 
#define entry_get_action(e) ((e)->u.action)
349 
#endif /* defined (FS_FAST) */
350 
 
351 
#ifdef FS_FAST
352 
#undef entry_get_rule
353 
#endif /* defined (FS_FAST) */
354 
RuleP
355 
entry_get_rule PROTO_N ((entry))
356 
	       PROTO_T (EntryP entry)
357 
{
358 
    ASSERT (entry_is_rule (entry));
359 
    return (entry->u.rule);
360 
}
361 
#ifdef FS_FAST
362 
#define entry_get_rule(e) ((e)->u.rule)
363 
#endif /* defined (FS_FAST) */
364 
 
365 
#ifdef FS_FAST
366 
#undef entry_get_name
367 
#endif /* defined (FS_FAST) */
368 
NameP
369 
entry_get_name PROTO_N ((entry))
370 
	       PROTO_T (EntryP entry)
371 
{
372 
    return (entry->name);
373 
}
374 
#ifdef FS_FAST
375 
#define entry_get_name(e) ((e)->name)
376 
#endif /* defined (FS_FAST) */
377 
 
378 
#ifdef FS_FAST
379 
#undef entry_get_type
380 
#endif /* defined (FS_FAST) */
381 
TypeP
382 
entry_get_type PROTO_N ((entry))
383 
	       PROTO_T (EntryP entry)
384 
{
385 
    ASSERT (entry_is_type (entry));
386 
    return (entry->u.type);
387 
}
388 
#ifdef FS_FAST
389 
#define entry_get_type(e) ((e)->u.type)
390 
#endif /* defined (FS_FAST) */
391 
 
392 
#ifdef FS_FAST
393 
#undef entry_get_non_local
394 
#endif /* defined (FS_FAST) */
395 
EntryP
396 
entry_get_non_local PROTO_N ((entry))
397 
		    PROTO_T (EntryP entry)
398 
{
399 
    ASSERT (entry_is_non_local (entry));
400 
    return (entry->u.non_local);
401 
}
402 
#ifdef FS_FAST
403 
#define entry_get_non_local(e) ((e)->u.non_local)
404 
#endif /* defined (FS_FAST) */
405 
 
406 
void
407 
entry_set_mapping PROTO_N ((entry, mapping))
408 
		  PROTO_T (EntryP   entry X
409 
			   NStringP mapping)
410 
{
411 
    if (entry->mapped) {
412 
	nstring_destroy (&(entry->mapping));
413 
    }
414 
    nstring_assign (&(entry->mapping), mapping);
415 
    entry->mapped = TRUE;
416 
}
417 
 
418 
NStringP
419 
entry_get_mapping PROTO_N ((entry))
420 
		  PROTO_T (EntryP entry)
421 
{
422 
    if (entry->mapped) {
423 
	return (&(entry->mapping));
424 
    }
425 
    return (NIL (NStringP));
426 
}
427 
 
428 
void
429 
entry_iter PROTO_N ((entry, full, proc, closure))
430 
	   PROTO_T (EntryP   entry X
431 
		    BoolT    full X
432 
		    void   (*proc) PROTO_S ((EntryP, GenericP)) X
433 
		    GenericP closure)
434 
{
435 
    if (!entry_is_traced (entry)) {
436 
	entry_traced (entry);
437 
	if (proc) {
438 
	    (*proc) (entry, closure);
439 
	}
440 
	switch (entry_type (entry)) EXHAUSTIVE {
441 
	  case ET_RULE: {
442 
	      RuleP rule = entry_get_rule (entry);
443 
 
444 
	      rule_iter_for_table (rule, full, proc, closure);
445 
	  }
446 
	    break;
447 
	  case ET_ACTION: {
448 
	      ActionP action = entry_get_action (entry);
449 
 
450 
	      action_iter_for_table (action, full, proc, closure);
451 
	  }
452 
	    break;
453 
	  case ET_BASIC: {
454 
	      BasicP basic = entry_get_basic (entry);
455 
 
456 
	      basic_iter_for_table (basic, full, proc, closure);
457 
	  }
458 
	    break;
459 
	  case ET_NON_LOCAL:
460 
	    if (full) {
461 
		entry_iter (entry_get_non_local (entry), TRUE, proc, closure);
462 
	    }
463 
	    break;
464 
	  case ET_NAME:
465 
	  case ET_TYPE:
466 
	  case ET_RENAME:
467 
	    /*NOTHING*/
468 
	    break;
469 
	  case ET_PREDICATE:
470 
	    UNREACHED;
471 
	}
472 
    }
473 
}
474 
 
475 
#ifdef FS_FAST
476 
#undef entry_not_traced
477 
#endif /* defined (FS_FAST) */
478 
void
479 
entry_not_traced PROTO_N ((entry))
480 
		 PROTO_T (EntryP entry)
481 
{
482 
    entry->traced = FALSE;
483 
}
484 
#ifdef FS_FAST
485 
#define entry_not_traced(e) ((e)->traced = FALSE)
486 
#endif /* defined (FS_FAST) */
487 
 
488 
#ifdef FS_FAST
489 
#undef entry_is_traced
490 
#endif /* defined (FS_FAST) */
491 
BoolT
492 
entry_is_traced PROTO_N ((entry))
493 
		PROTO_T (EntryP entry)
494 
{
495 
    return (entry->traced);
496 
}
497 
#ifdef FS_FAST
498 
#define entry_is_traced(e) ((e)->traced)
499 
#endif /* defined (FS_FAST) */
500 
 
501 
/*
502 
 * Local variables(smf):
503 
 * eval: (include::add-path-entry "../os-interface" "../library")
504 
 * eval: (include::add-path-entry "../generated")
505 
 * end:
506 
**/