Subversion Repositories tendra.SVN

Rev

Rev 2 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2 Rev 7
Line -... Line 1...
- 
 
 1 
/*
- 
 
 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 
 */
1 
/*
 31 
/*
2 
    		 Crown Copyright (c) 1997
 32 
    		 Crown Copyright (c) 1997
3
33 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 34 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 35 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
 36 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
 37 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
 38 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
 39 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
 40 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
 41 
    shall be deemed to be acceptance of the following conditions:-
12
42 
 
13 
        (1) Its Recipients shall ensure that this Notice is
 43 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
 44 
        reproduced upon any copies or amended versions of it;
15
45 
 
16 
        (2) Any amended version of it shall be clearly marked to
 46 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
 47 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
 48 
        for the relevant amendment or amendments;
19
49 
 
20 
        (3) Its onward transfer from a recipient to another
 50 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
 51 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
 52 
        these conditions;
23
53 
 
24 
        (4) DERA gives no warranty or assurance as to its
 54 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
 55 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
 56 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
 57 
        it may be put.
28 
*/
 58 
*/
Line 64... Line 94...
64 
 
 94 
 
65 
#ifdef FS_FAST
 95 
#ifdef FS_FAST
66 
#undef entry_traced
 96 
#undef entry_traced
67 
#endif /* defined (FS_FAST) */
 97 
#endif /* defined (FS_FAST) */
68 
static void
 98 
static void
69 
entry_traced PROTO_N ((entry))
 99 
entry_traced(EntryP entry)
70 
	     PROTO_T (EntryP entry)
 - 
 
71 
{
 100 
{
72 
    entry->traced = TRUE;
 101 
    entry->traced = TRUE;
73 
}
 102 
}
74 
#ifdef FS_FAST
 103 
#ifdef FS_FAST
75 
#define entry_traced(e) ((e)->traced = TRUE)
 104 
#define entry_traced(e)	((e)->traced = TRUE)
76 
#endif /* defined (FS_FAST) */
 105 
#endif /* defined (FS_FAST) */
77 
 
 106 
 
78 
/*--------------------------------------------------------------------------*/
 107 
/*--------------------------------------------------------------------------*/
79 
 
 108 
 
80 
EntryP
 109 
EntryP
81 
entry_create_from_string PROTO_N ((key, number, type))
 110 
entry_create_from_string(NStringP key, unsigned number, EntryTypeT type)
82 
			 PROTO_T (NStringP   key X
 - 
 
83 
				  unsigned   number X
 - 
 
84 
				  EntryTypeT type)
 - 
 
85 
{
 111 
{
86 
    EntryP entry = ALLOCATE (EntryT);
 112 
    EntryP entry = ALLOCATE(EntryT);
87 
 
 113 
 
88 
    entry->next   = NIL (EntryP);
 114 
    entry->next   = NIL(EntryP);
89 
    key_init_from_string (entry_key (entry), key, number);
 115 
    key_init_from_string(entry_key(entry), key, number);
90 
    entry->mapped = FALSE;
 116 
    entry->mapped = FALSE;
91 
    nstring_init (&(entry->mapping));
 117 
    nstring_init(&(entry->mapping));
92 
    entry->type   = type;
 118 
    entry->type   = type;
93 
    entry->name   = name_create ();
 119 
    entry->name   = name_create();
94 
    entry->traced = FALSE;
 120 
    entry->traced = FALSE;
95 
    return (entry);
 121 
    return(entry);
96 
}
 122 
}
97 
 
 123 
 
98 
EntryP
 124 
EntryP
99 
entry_create_from_number PROTO_N ((key, type, traced, next))
 125 
entry_create_from_number(unsigned key, EntryTypeT type, BoolT traced,
100 
			 PROTO_T (unsigned   key X
 - 
 
101 
				  EntryTypeT type X
 - 
 
102 
				  BoolT      traced X
 - 
 
103 
				  EntryP     next)
 126 
			 EntryP next)
104 
{
 127 
{
105 
    EntryP entry = ALLOCATE (EntryT);
 128 
    EntryP entry = ALLOCATE(EntryT);
106 
 
 129 
 
107 
    entry->next   = next;
 130 
    entry->next   = next;
108 
    key_init_from_number (entry_key (entry), key);
 131 
    key_init_from_number(entry_key(entry), key);
109 
    entry->mapped = FALSE;
 132 
    entry->mapped = FALSE;
110 
    nstring_init (&(entry->mapping));
 133 
    nstring_init(&(entry->mapping));
111 
    entry->type   = type;
 134 
    entry->type   = type;
112 
    entry->name   = name_create ();
 135 
    entry->name   = name_create();
113 
    entry->traced = traced;
 136 
    entry->traced = traced;
114 
    return (entry);
 137 
    return(entry);
115 
}
 138 
}
116 
 
 139 
 
117 
#ifdef FS_FAST
 140 
#ifdef FS_FAST
118 
#undef entry_set_basic
 141 
#undef entry_set_basic
119 
#endif /* defined (FS_FAST) */
 142 
#endif /* defined (FS_FAST) */
120 
void
 143 
void
121 
entry_set_basic PROTO_N ((entry, basic))
 144 
entry_set_basic(EntryP entry, BasicP basic)
122 
		PROTO_T (EntryP entry X
 - 
 
123 
			 BasicP basic)
 - 
 
124 
{
 145 
{
125 
    ASSERT (entry_is_basic (entry));
 146 
    ASSERT(entry_is_basic(entry));
126 
    entry->u.basic = basic;
 147 
    entry->u.basic = basic;
127 
}
 148 
}
128 
#ifdef FS_FAST
 149 
#ifdef FS_FAST
129 
#define entry_set_basic(e, b) ((e)->u.basic = (b))
 150 
#define entry_set_basic(e, b)	((e)->u.basic = (b))
130 
#endif /* defined (FS_FAST) */
 151 
#endif /* defined (FS_FAST) */
131 
 
 152 
 
132 
#ifdef FS_FAST
 153 
#ifdef FS_FAST
133 
#undef entry_set_rule
 154 
#undef entry_set_rule
134 
#endif /* defined (FS_FAST) */
 155 
#endif /* defined (FS_FAST) */
135 
void
 156 
void
136 
entry_set_rule PROTO_N ((entry, rule))
 157 
entry_set_rule(EntryP entry, RuleP rule)
137 
	       PROTO_T (EntryP entry X
 - 
 
138 
			RuleP  rule)
 - 
 
139 
{
 158 
{
140 
    ASSERT (entry_is_rule (entry));
 159 
    ASSERT(entry_is_rule(entry));
141 
    entry->u.rule = rule;
 160 
    entry->u.rule = rule;
142 
}
 161 
}
143 
#ifdef FS_FAST
 162 
#ifdef FS_FAST
144 
#define entry_set_rule(e, r) ((e)->u.rule = (r))
 163 
#define entry_set_rule(e, r)	((e)->u.rule = (r))
145 
#endif /* defined (FS_FAST) */
 164 
#endif /* defined (FS_FAST) */
146 
 
 165 
 
147 
#ifdef FS_FAST
 166 
#ifdef FS_FAST
148 
#undef entry_set_action
 167 
#undef entry_set_action
149 
#endif /* defined (FS_FAST) */
 168 
#endif /* defined (FS_FAST) */
150 
void
 169 
void
151 
entry_set_action PROTO_N ((entry, action))
 170 
entry_set_action(EntryP entry, ActionP action)
152 
		 PROTO_T (EntryP  entry X
 - 
 
153 
			  ActionP action)
 - 
 
154 
{
 171 
{
155 
    ASSERT (entry_is_action (entry));
 172 
    ASSERT(entry_is_action(entry));
156 
    entry->u.action = action;
 173 
    entry->u.action = action;
157 
}
 174 
}
158 
#ifdef FS_FAST
 175 
#ifdef FS_FAST
159 
#define entry_set_action(e, a) ((e)->u.action = (a))
 176 
#define entry_set_action(e, a)	((e)->u.action = (a))
160 
#endif /* defined (FS_FAST) */
 177 
#endif /* defined (FS_FAST) */
161 
 
 178 
 
162 
#ifdef FS_FAST
 179 
#ifdef FS_FAST
163 
#undef entry_set_type
 180 
#undef entry_set_type
164 
#endif /* defined (FS_FAST) */
 181 
#endif /* defined (FS_FAST) */
165 
void
 182 
void
166 
entry_set_type PROTO_N ((entry, type))
 183 
entry_set_type(EntryP entry, TypeP type)
167 
	       PROTO_T (EntryP entry X
 - 
 
168 
			TypeP  type)
 - 
 
169 
{
 184 
{
170 
    ASSERT (entry_is_type (entry));
 185 
    ASSERT(entry_is_type(entry));
171 
    entry->u.type = type;
 186 
    entry->u.type = type;
172 
}
 187 
}
173 
#ifdef FS_FAST
 188 
#ifdef FS_FAST
174 
#define entry_set_type(e, t) ((e)->u.type = (t))
 189 
#define entry_set_type(e, t)	((e)->u.type = (t))
175 
#endif /* defined (FS_FAST) */
 190 
#endif /* defined (FS_FAST) */
176 
 
 191 
 
177 
#ifdef FS_FAST
 192 
#ifdef FS_FAST
178 
#undef entry_set_non_local
 193 
#undef entry_set_non_local
179 
#endif /* defined (FS_FAST) */
 194 
#endif /* defined (FS_FAST) */
180 
void
 195 
void
181 
entry_set_non_local PROTO_N ((entry, type))
 196 
entry_set_non_local(EntryP entry, EntryP type)
182 
		    PROTO_T (EntryP entry X
 - 
 
183 
			     EntryP type)
 - 
 
184 
{
 197 
{
185 
    ASSERT (entry_is_non_local (entry));
 198 
    ASSERT(entry_is_non_local(entry));
186 
    entry->u.non_local = type;
 199 
    entry->u.non_local = type;
187 
}
 200 
}
188 
#ifdef FS_FAST
 201 
#ifdef FS_FAST
189 
#define entry_set_non_local(e, t) ((e)->u.non_local = (t))
 202 
#define entry_set_non_local(e, t)	((e)->u.non_local = (t))
190 
#endif /* defined (FS_FAST) */
 203 
#endif /* defined (FS_FAST) */
191 
 
 204 
 
192 
#ifdef FS_FAST
 205 
#ifdef FS_FAST
193 
#undef entry_next
 206 
#undef entry_next
194 
#endif /* defined (FS_FAST) */
 207 
#endif /* defined (FS_FAST) */
195 
EntryP
 208 
EntryP
196 
entry_next PROTO_N ((entry))
 209 
entry_next(EntryP entry)
197 
	   PROTO_T (EntryP entry)
 - 
 
198 
{
 210 
{
199 
    return (entry->next);
 211 
    return(entry->next);
200 
}
 212 
}
201 
#ifdef FS_FAST
 213 
#ifdef FS_FAST
202 
#define entry_next(e) ((e)->next)
 214 
#define entry_next(e)	((e)->next)
203 
#endif /* defined (FS_FAST) */
 215 
#endif /* defined (FS_FAST) */
204 
 
 216 
 
205 
#ifdef FS_FAST
 217 
#ifdef FS_FAST
206 
#undef entry_next_ref
 218 
#undef entry_next_ref
207 
#endif /* defined (FS_FAST) */
 219 
#endif /* defined (FS_FAST) */
208 
EntryP *
 220 
EntryP *
209 
entry_next_ref PROTO_N ((entry))
 221 
entry_next_ref(EntryP entry)
210 
	       PROTO_T (EntryP entry)
 - 
 
211 
{
 222 
{
212 
    return (&(entry->next));
 223 
    return(&(entry->next));
213 
}
 224 
}
214 
#ifdef FS_FAST
 225 
#ifdef FS_FAST
215 
#define entry_next_ref(e) (&((e)->next))
 226 
#define entry_next_ref(e)	(&((e)->next))
216 
#endif /* defined (FS_FAST) */
 227 
#endif /* defined (FS_FAST) */
217 
 
 228 
 
218 
#ifdef FS_FAST
 229 
#ifdef FS_FAST
219 
#undef entry_key
 230 
#undef entry_key
220 
#endif /* defined (FS_FAST) */
 231 
#endif /* defined (FS_FAST) */
221 
KeyP
 232 
KeyP
222 
entry_key PROTO_N ((entry))
 233 
entry_key(EntryP entry)
223 
	  PROTO_T (EntryP entry)
 - 
 
224 
{
 234 
{
225 
    return (&(entry->key));
 235 
    return(&(entry->key));
226 
}
 236 
}
227 
#ifdef FS_FAST
 237 
#ifdef FS_FAST
228 
#define entry_key(e) (&((e)->key))
 238 
#define entry_key(e)	(&((e)->key))
229 
#endif /* defined (FS_FAST) */
 239 
#endif /* defined (FS_FAST) */
230 
 
 240 
 
231 
#ifdef FS_FAST
 241 
#ifdef FS_FAST
232 
#undef entry_type
 242 
#undef entry_type
233 
#endif /* defined (FS_FAST) */
 243 
#endif /* defined (FS_FAST) */
234 
EntryTypeT
 244 
EntryTypeT
235 
entry_type PROTO_N ((entry))
 245 
entry_type(EntryP entry)
236 
	   PROTO_T (EntryP entry)
 - 
 
237 
{
 246 
{
238 
    return (entry->type);
 247 
    return(entry->type);
239 
}
 248 
}
240 
#ifdef FS_FAST
 249 
#ifdef FS_FAST
241 
#define entry_type(e) ((e)->type)
 250 
#define entry_type(e)	((e)->type)
242 
#endif /* defined (FS_FAST) */
 251 
#endif /* defined (FS_FAST) */
243 
 
 252 
 
244 
#ifdef FS_FAST
 253 
#ifdef FS_FAST
245 
#undef entry_change_type
 254 
#undef entry_change_type
246 
#endif /* defined (FS_FAST) */
 255 
#endif /* defined (FS_FAST) */
247 
void
 256 
void
248 
entry_change_type PROTO_N ((entry, type))
 257 
entry_change_type(EntryP entry, EntryTypeT type)
249 
		  PROTO_T (EntryP     entry X
 - 
 
250 
			   EntryTypeT type)
 - 
 
251 
{
 258 
{
252 
    entry->type = type;
 259 
    entry->type = type;
253 
}
 260 
}
254 
#ifdef FS_FAST
 261 
#ifdef FS_FAST
255 
#define entry_change_type(e, t) ((e)->type= (t))
 262 
#define entry_change_type(e, t)	((e)->type = (t))
256 
#endif /* defined (FS_FAST) */
 263 
#endif /* defined (FS_FAST) */
257 
 
 264 
 
258 
#ifdef FS_FAST
 265 
#ifdef FS_FAST
259 
#undef entry_is_basic
 266 
#undef entry_is_basic
260 
#endif /* defined (FS_FAST) */
 267 
#endif /* defined (FS_FAST) */
261 
BoolT
 268 
BoolT
262 
entry_is_basic PROTO_N ((entry))
 269 
entry_is_basic(EntryP entry)
263 
	       PROTO_T (EntryP entry)
 - 
 
264 
{
 270 
{
265 
    return (entry->type == ET_BASIC);
 271 
    return(entry->type == ET_BASIC);
266 
}
 272 
}
267 
#ifdef FS_FAST
 273 
#ifdef FS_FAST
268 
#define entry_is_basic(e) ((e)->type == ET_BASIC)
 274 
#define entry_is_basic(e)	((e)->type == ET_BASIC)
269 
#endif /* defined (FS_FAST) */
 275 
#endif /* defined (FS_FAST) */
270 
 
 276 
 
271 
#ifdef FS_FAST
 277 
#ifdef FS_FAST
272 
#undef entry_is_action
 278 
#undef entry_is_action
273 
#endif /* defined (FS_FAST) */
 279 
#endif /* defined (FS_FAST) */
274 
BoolT
 280 
BoolT
275 
entry_is_action PROTO_N ((entry))
 281 
entry_is_action(EntryP entry)
276 
		PROTO_T (EntryP entry)
 - 
 
277 
{
 282 
{
278 
    return (entry->type == ET_ACTION);
 283 
    return(entry->type == ET_ACTION);
279 
}
 284 
}
280 
#ifdef FS_FAST
 285 
#ifdef FS_FAST
281 
#define entry_is_action(e) ((e)->type == ET_ACTION)
 286 
#define entry_is_action(e)	((e)->type == ET_ACTION)
282 
#endif /* defined (FS_FAST) */
 287 
#endif /* defined (FS_FAST) */
283 
 
 288 
 
284 
#ifdef FS_FAST
 289 
#ifdef FS_FAST
285 
#undef entry_is_rule
 290 
#undef entry_is_rule
286 
#endif /* defined (FS_FAST) */
 291 
#endif /* defined (FS_FAST) */
287 
BoolT
 292 
BoolT
288 
entry_is_rule PROTO_N ((entry))
 293 
entry_is_rule(EntryP entry)
289 
	      PROTO_T (EntryP entry)
 - 
 
290 
{
 294 
{
291 
    return (entry->type == ET_RULE);
 295 
    return(entry->type == ET_RULE);
292 
}
 296 
}
293 
#ifdef FS_FAST
 297 
#ifdef FS_FAST
294 
#define entry_is_rule(e) ((e)->type == ET_RULE)
 298 
#define entry_is_rule(e)	((e)->type == ET_RULE)
295 
#endif /* defined (FS_FAST) */
 299 
#endif /* defined (FS_FAST) */
296 
 
 300 
 
297 
#ifdef FS_FAST
 301 
#ifdef FS_FAST
298 
#undef entry_is_type
 302 
#undef entry_is_type
299 
#endif /* defined (FS_FAST) */
 303 
#endif /* defined (FS_FAST) */
300 
BoolT
 304 
BoolT
301 
entry_is_type PROTO_N ((entry))
 305 
entry_is_type(EntryP entry)
302 
	      PROTO_T (EntryP entry)
 - 
 
303 
{
 306 
{
304 
    return (entry->type == ET_TYPE);
 307 
    return(entry->type == ET_TYPE);
305 
}
 308 
}
306 
#ifdef FS_FAST
 309 
#ifdef FS_FAST
307 
#define entry_is_type(e) ((e)->type == ET_TYPE)
 310 
#define entry_is_type(e)	((e)->type == ET_TYPE)
308 
#endif /* defined (FS_FAST) */
 311 
#endif /* defined (FS_FAST) */
309 
 
 312 
 
310 
#ifdef FS_FAST
 313 
#ifdef FS_FAST
311 
#undef entry_is_non_local
 314 
#undef entry_is_non_local
312 
#endif /* defined (FS_FAST) */
 315 
#endif /* defined (FS_FAST) */
313 
BoolT
 316 
BoolT
314 
entry_is_non_local PROTO_N ((entry))
 317 
entry_is_non_local(EntryP entry)
315 
		   PROTO_T (EntryP entry)
 - 
 
316 
{
 318 
{
317 
    return (entry->type == ET_NON_LOCAL);
 319 
    return(entry->type == ET_NON_LOCAL);
318 
}
 320 
}
319 
#ifdef FS_FAST
 321 
#ifdef FS_FAST
320 
#define entry_is_non_local(e) ((e)->type == ET_NON_LOCAL)
 322 
#define entry_is_non_local(e)	((e)->type == ET_NON_LOCAL)
321 
#endif /* defined (FS_FAST) */
 323 
#endif /* defined (FS_FAST) */
322 
 
 324 
 
323 
#ifdef FS_FAST
 325 
#ifdef FS_FAST
324 
#undef entry_get_basic
 326 
#undef entry_get_basic
325 
#endif /* defined (FS_FAST) */
 327 
#endif /* defined (FS_FAST) */
326 
BasicP
 328 
BasicP
327 
entry_get_basic PROTO_N ((entry))
 329 
entry_get_basic(EntryP entry)
328 
		PROTO_T (EntryP entry)
 - 
 
329 
{
 330 
{
330 
    ASSERT (entry_is_basic (entry));
 331 
    ASSERT(entry_is_basic(entry));
331 
    return (entry->u.basic);
 332 
    return(entry->u.basic);
332 
}
 333 
}
333 
#ifdef FS_FAST
 334 
#ifdef FS_FAST
334 
#define entry_get_basic(e) ((e)->u.basic)
 335 
#define entry_get_basic(e)	((e)->u.basic)
335 
#endif /* defined (FS_FAST) */
 336 
#endif /* defined (FS_FAST) */
336 
 
 337 
 
337 
#ifdef FS_FAST
 338 
#ifdef FS_FAST
338 
#undef entry_get_action
 339 
#undef entry_get_action
339 
#endif /* defined (FS_FAST) */
 340 
#endif /* defined (FS_FAST) */
340 
ActionP
 341 
ActionP
341 
entry_get_action PROTO_N ((entry))
 342 
entry_get_action(EntryP entry)
342 
		 PROTO_T (EntryP entry)
 - 
 
343 
{
 343 
{
344 
    ASSERT (entry_is_action (entry));
 344 
    ASSERT(entry_is_action(entry));
345 
    return (entry->u.action);
 345 
    return(entry->u.action);
346 
}
 346 
}
347 
#ifdef FS_FAST
 347 
#ifdef FS_FAST
348 
#define entry_get_action(e) ((e)->u.action)
 348 
#define entry_get_action(e)	((e)->u.action)
349 
#endif /* defined (FS_FAST) */
 349 
#endif /* defined (FS_FAST) */
350 
 
 350 
 
351 
#ifdef FS_FAST
 351 
#ifdef FS_FAST
352 
#undef entry_get_rule
 352 
#undef entry_get_rule
353 
#endif /* defined (FS_FAST) */
 353 
#endif /* defined (FS_FAST) */
354 
RuleP
 354 
RuleP
355 
entry_get_rule PROTO_N ((entry))
 355 
entry_get_rule(EntryP entry)
356 
	       PROTO_T (EntryP entry)
 - 
 
357 
{
 356 
{
358 
    ASSERT (entry_is_rule (entry));
 357 
    ASSERT(entry_is_rule(entry));
359 
    return (entry->u.rule);
 358 
    return(entry->u.rule);
360 
}
 359 
}
361 
#ifdef FS_FAST
 360 
#ifdef FS_FAST
362 
#define entry_get_rule(e) ((e)->u.rule)
 361 
#define entry_get_rule(e)	((e)->u.rule)
363 
#endif /* defined (FS_FAST) */
 362 
#endif /* defined (FS_FAST) */
364 
 
 363 
 
365 
#ifdef FS_FAST
 364 
#ifdef FS_FAST
366 
#undef entry_get_name
 365 
#undef entry_get_name
367 
#endif /* defined (FS_FAST) */
 366 
#endif /* defined (FS_FAST) */
368 
NameP
 367 
NameP
369 
entry_get_name PROTO_N ((entry))
 368 
entry_get_name(EntryP entry)
370 
	       PROTO_T (EntryP entry)
 - 
 
371 
{
 369 
{
372 
    return (entry->name);
 370 
    return(entry->name);
373 
}
 371 
}
374 
#ifdef FS_FAST
 372 
#ifdef FS_FAST
375 
#define entry_get_name(e) ((e)->name)
 373 
#define entry_get_name(e)	((e)->name)
376 
#endif /* defined (FS_FAST) */
 374 
#endif /* defined (FS_FAST) */
377 
 
 375 
 
378 
#ifdef FS_FAST
 376 
#ifdef FS_FAST
379 
#undef entry_get_type
 377 
#undef entry_get_type
380 
#endif /* defined (FS_FAST) */
 378 
#endif /* defined (FS_FAST) */
381 
TypeP
 379 
TypeP
382 
entry_get_type PROTO_N ((entry))
 380 
entry_get_type(EntryP entry)
383 
	       PROTO_T (EntryP entry)
 - 
 
384 
{
 381 
{
385 
    ASSERT (entry_is_type (entry));
 382 
    ASSERT(entry_is_type(entry));
386 
    return (entry->u.type);
 383 
    return(entry->u.type);
387 
}
 384 
}
388 
#ifdef FS_FAST
 385 
#ifdef FS_FAST
389 
#define entry_get_type(e) ((e)->u.type)
 386 
#define entry_get_type(e)	((e)->u.type)
390 
#endif /* defined (FS_FAST) */
 387 
#endif /* defined (FS_FAST) */
391 
 
 388 
 
392 
#ifdef FS_FAST
 389 
#ifdef FS_FAST
393 
#undef entry_get_non_local
 390 
#undef entry_get_non_local
394 
#endif /* defined (FS_FAST) */
 391 
#endif /* defined (FS_FAST) */
395 
EntryP
 392 
EntryP
396 
entry_get_non_local PROTO_N ((entry))
 393 
entry_get_non_local(EntryP entry)
397 
		    PROTO_T (EntryP entry)
 - 
 
398 
{
 394 
{
399 
    ASSERT (entry_is_non_local (entry));
 395 
    ASSERT(entry_is_non_local(entry));
400 
    return (entry->u.non_local);
 396 
    return(entry->u.non_local);
401 
}
 397 
}
402 
#ifdef FS_FAST
 398 
#ifdef FS_FAST
403 
#define entry_get_non_local(e) ((e)->u.non_local)
 399 
#define entry_get_non_local(e)	((e)->u.non_local)
404 
#endif /* defined (FS_FAST) */
 400 
#endif /* defined (FS_FAST) */
405 
 
 401 
 
406 
void
 402 
void
407 
entry_set_mapping PROTO_N ((entry, mapping))
 403 
entry_set_mapping(EntryP entry, NStringP mapping)
408 
		  PROTO_T (EntryP   entry X
 - 
 
409 
			   NStringP mapping)
 - 
 
410 
{
 404 
{
411 
    if (entry->mapped) {
 405 
    if (entry->mapped) {
412 
	nstring_destroy (&(entry->mapping));
 406 
	nstring_destroy(&(entry->mapping));
413 
    }
 407 
    }
414 
    nstring_assign (&(entry->mapping), mapping);
 408 
    nstring_assign(&(entry->mapping), mapping);
415 
    entry->mapped = TRUE;
 409 
    entry->mapped = TRUE;
416 
}
 410 
}
417 
 
 411 
 
418 
NStringP
 412 
NStringP
419 
entry_get_mapping PROTO_N ((entry))
 413 
entry_get_mapping(EntryP entry)
420 
		  PROTO_T (EntryP entry)
 - 
 
421 
{
 414 
{
422 
    if (entry->mapped) {
 415 
    if (entry->mapped) {
423 
	return (&(entry->mapping));
 416 
	return(&(entry->mapping));
424 
    }
 417 
    }
425 
    return (NIL (NStringP));
 418 
    return(NIL(NStringP));
426 
}
 419 
}
427 
 
 420 
 
428 
void
 421 
void
429 
entry_iter PROTO_N ((entry, full, proc, closure))
 422 
entry_iter(EntryP entry, BoolT full, void (*proc)(EntryP, GenericP),
430 
	   PROTO_T (EntryP   entry X
 - 
 
431 
		    BoolT    full X
 - 
 
432 
		    void   (*proc) PROTO_S ((EntryP, GenericP)) X
 - 
 
433 
		    GenericP closure)
 423 
	   GenericP closure)
434 
{
 424 
{
435 
    if (!entry_is_traced (entry)) {
 425 
    if (!entry_is_traced(entry)) {
436 
	entry_traced (entry);
 426 
	entry_traced(entry);
437 
	if (proc) {
 427 
	if (proc) {
438 
	    (*proc) (entry, closure);
 428 
	   (*proc)(entry, closure);
439 
	}
 429 
	}
440 
	switch (entry_type (entry)) EXHAUSTIVE {
 430 
	switch (entry_type(entry))EXHAUSTIVE {
441 
	  case ET_RULE: {
 431 
	  case ET_RULE: {
442 
	      RuleP rule = entry_get_rule (entry);
 432 
	      RuleP rule = entry_get_rule(entry);
443 
 
 433 
 
444 
	      rule_iter_for_table (rule, full, proc, closure);
 434 
	      rule_iter_for_table(rule, full, proc, closure);
445 
	  }
 435 
	  }
446 
	    break;
 436 
	    break;
447 
	  case ET_ACTION: {
 437 
	  case ET_ACTION: {
448 
	      ActionP action = entry_get_action (entry);
 438 
	      ActionP action = entry_get_action(entry);
449 
 
 439 
 
450 
	      action_iter_for_table (action, full, proc, closure);
 440 
	      action_iter_for_table(action, full, proc, closure);
451 
	  }
 441 
	  }
452 
	    break;
 442 
	    break;
453 
	  case ET_BASIC: {
 443 
	  case ET_BASIC: {
454 
	      BasicP basic = entry_get_basic (entry);
 444 
	      BasicP basic = entry_get_basic(entry);
455 
 
 445 
 
456 
	      basic_iter_for_table (basic, full, proc, closure);
 446 
	      basic_iter_for_table(basic, full, proc, closure);
457 
	  }
 447 
	  }
458 
	    break;
 448 
	    break;
459 
	  case ET_NON_LOCAL:
 449 
	  case ET_NON_LOCAL:
460 
	    if (full) {
 450 
	    if (full) {
461 
		entry_iter (entry_get_non_local (entry), TRUE, proc, closure);
 451 
		entry_iter(entry_get_non_local(entry), TRUE, proc, closure);
462 
	    }
 452 
	    }
463 
	    break;
 453 
	    break;
464 
	  case ET_NAME:
 454 
	  case ET_NAME:
465 
	  case ET_TYPE:
 455 
	  case ET_TYPE:
466 
	  case ET_RENAME:
 456 
	  case ET_RENAME:
Line 474... Line 464...
474 
 
 464 
 
475 
#ifdef FS_FAST
 465 
#ifdef FS_FAST
476 
#undef entry_not_traced
 466 
#undef entry_not_traced
477 
#endif /* defined (FS_FAST) */
 467 
#endif /* defined (FS_FAST) */
478 
void
 468 
void
479 
entry_not_traced PROTO_N ((entry))
 469 
entry_not_traced(EntryP entry)
480 
		 PROTO_T (EntryP entry)
 - 
 
481 
{
 470 
{
482 
    entry->traced = FALSE;
 471 
    entry->traced = FALSE;
483 
}
 472 
}
484 
#ifdef FS_FAST
 473 
#ifdef FS_FAST
485 
#define entry_not_traced(e) ((e)->traced = FALSE)
 474 
#define entry_not_traced(e)	((e)->traced = FALSE)
486 
#endif /* defined (FS_FAST) */
 475 
#endif /* defined (FS_FAST) */
487 
 
 476 
 
488 
#ifdef FS_FAST
 477 
#ifdef FS_FAST
489 
#undef entry_is_traced
 478 
#undef entry_is_traced
490 
#endif /* defined (FS_FAST) */
 479 
#endif /* defined (FS_FAST) */
491 
BoolT
 480 
BoolT
492 
entry_is_traced PROTO_N ((entry))
 481 
entry_is_traced(EntryP entry)
493 
		PROTO_T (EntryP entry)
 - 
 
494 
{
 482 
{
495 
    return (entry->traced);
 483 
    return(entry->traced);
496 
}
 484 
}
497 
#ifdef FS_FAST
 485 
#ifdef FS_FAST
498 
#define entry_is_traced(e) ((e)->traced)
 486 
#define entry_is_traced(e)	((e)->traced)
499 
#endif /* defined (FS_FAST) */
 487 
#endif /* defined (FS_FAST) */
500
488
501 
/*
 489 
/*
502 
 * Local variables(smf):
 490 
 * Local variables(smf):
503 
 * eval: (include::add-path-entry "../os-interface" "../library")
 491 
 * eval: (include::add-path-entry "../os-interface" "../library")