a68g-genie.h
1 //! @file a68g-genie.h
2 //! @author J. Marcel van der Veer
3
4 //! @section Copyright
5 //!
6 //! This file is part of Algol68G - an Algol 68 compiler-interpreter.
7 //! Copyright 2001-2025 J. Marcel van der Veer [algol68g@xs4all.nl].
8
9 //! @section License
10 //!
11 //! This program is free software; you can redistribute it and/or modify it
12 //! under the terms of the GNU General Public License as published by the
13 //! Free Software Foundation; either version 3 of the License, or
14 //! (at your option) any later version.
15 //!
16 //! This program is distributed in the hope that it will be useful, but
17 //! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 //! or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 //! more details. You should have received a copy of the GNU General Public
20 //! License along with this program. If not, see [http://www.gnu.org/licenses/].
21
22 //! @section Synopsis
23 //!
24 //! Interpreter related definitions.
25
26 #if !defined (__A68G_GENIE_H__)
27 #define __A68G_GENIE_H__
28
29 #include "a68g-frames.h"
30
31 //! @brief PROC VOID gc heap
32
33 // Prelude errors can also occur in the constant folder
34
35 #define CHECK_INT_SHORTEN(p, i)\
36 PRELUDE_ERROR (((i) > INT_MAX || (i) < -INT_MAX), p, ERROR_MATH, M_INT)
37
38 #define CHECK_INT_ADDITION(p, i, j)\
39 PRELUDE_ERROR (\
40 ((j) > 0 && (i) > (A68G_MAX_INT - (j))) || ((j) < 0 && (i) < (-A68G_MAX_INT - (j))),\
41 p, "M overflow", M_INT)
42
43 #define CHECK_INT_MULTIPLICATION(p, i, j)\
44 PRELUDE_ERROR (\
45 (j) != 0 && ABS (i) > A68G_MAX_INT / ABS (j),\
46 p, "M overflow", M_INT)
47
48 #define CHECK_BITS_ADDITION(p, i, j)\
49 if (!MODULAR_MATH (p)) {\
50 PRELUDE_ERROR (((i) > (A68G_MAX_BITS - (j))), p, ERROR_MATH, M_BITS);\
51 }
52
53 #define CHECK_BITS_SUBTRACTION(p, i, j)\
54 if (!MODULAR_MATH (p)) {\
55 PRELUDE_ERROR (((j) > (i)), p, ERROR_MATH, M_BITS);\
56 }
57
58 #define CHECK_BITS_MULTIPLICATION(p, i, j)\
59 if (!MODULAR_MATH (p)) {\
60 PRELUDE_ERROR ((j) != 0 && (i) > A68G_MAX_BITS / (j), p, ERROR_MATH, M_BITS);\
61 }
62
63 #define CHECK_INT_DIVISION(p, i, j)\
64 PRELUDE_ERROR ((j) == 0, p, ERROR_DIVISION_BY_ZERO, M_INT)
65
66 #define PRELUDE_ERROR(cond, p, txt, add)\
67 if (cond) {\
68 if (A68G (in_execution)) {\
69 diagnostic (A68G_RUNTIME_ERROR, p, txt, add);\
70 exit_genie (p, A68G_RUNTIME_ERROR);\
71 } else {\
72 diagnostic (A68G_MATH_ERROR, p, txt, add);\
73 }}
74
75 // Check on a NIL name
76
77 #define CHECK_REF(p, z, m)\
78 if (! INITIALISED (&z)) {\
79 diagnostic (A68G_RUNTIME_ERROR, (p), ERROR_EMPTY_VALUE_FROM, (m));\
80 exit_genie ((p), A68G_RUNTIME_ERROR);\
81 } else if (IS_NIL (z)) {\
82 diagnostic (A68G_RUNTIME_ERROR, (p), ERROR_ACCESSING_NIL, (m));\
83 exit_genie ((p), A68G_RUNTIME_ERROR);\
84 }
85
86 // Macros for row-handling
87
88 // An A68G row is a reference to a descriptor in the heap:
89 // A68G_REF row -> A68G_ARRAY ----+ ARRAY: Description of row, ref to elements.
90 // A68G_TUPLE 1 | TUPLE: Bounds, one for every dimension.
91 // ... |
92 // A68G_TUPLE dim |
93 // ... |
94 // ... |
95 // Element 1 <---+ Sequential row elements in the heap.
96 // ...
97 // Element n
98
99 #define DESCRIPTOR_SIZE(n) (SIZE_ALIGNED (A68G_ARRAY) + (n) * SIZE_ALIGNED (A68G_TUPLE))
100
101 #define NEW_ROW_1D(des, row, arr, tup, row_m, mod, upb)\
102 (des) = heap_generator (p, (row_m), DESCRIPTOR_SIZE (1));\
103 (row) = heap_generator (p, (row_m), (upb) * SIZE (mod));\
104 DIM (&(arr)) = 1;\
105 MOID (&(arr)) = (mod);\
106 ELEM_SIZE (&(arr)) = SIZE (mod);\
107 SLICE_OFFSET (&(arr)) = 0;\
108 FIELD_OFFSET (&(arr)) = 0;\
109 ARRAY (&(arr)) = (row);\
110 LWB (&(tup)) = 1;\
111 UPB (&(tup)) = (upb);\
112 SHIFT (&(tup)) = LWB (&(tup));\
113 SPAN (&(tup)) = 1;\
114 K (&(tup)) = 0;\
115 PUT_DESCRIPTOR ((arr), (tup), &(des));
116
117 #define GET_DESCRIPTOR(arr, tup, p)\
118 arr = (A68G_ARRAY *) ARRAY_ADDRESS (p);\
119 tup = (A68G_TUPLE *) & (((BYTE_T *) (arr)) [SIZE_ALIGNED (A68G_ARRAY)]);
120
121 #define GET_DESCRIPTOR2(arr, tup1, tup2, p)\
122 arr = (A68G_ARRAY *) ARRAY_ADDRESS (p);\
123 tup1 = (A68G_TUPLE *) & (((BYTE_T *) (arr)) [SIZE_ALIGNED (A68G_ARRAY)]);\
124 tup2 = (A68G_TUPLE *) & (((BYTE_T *) (arr)) [SIZE_ALIGNED (A68G_ARRAY) + sizeof (A68G_TUPLE)]);
125
126 #define PUT_DESCRIPTOR(arr, tup, p) {\
127 BYTE_T *a_p = ARRAY_ADDRESS (p);\
128 *(A68G_ARRAY *) a_p = (arr);\
129 *(A68G_TUPLE *) &(((BYTE_T *) (a_p)) [SIZE_ALIGNED (A68G_ARRAY)]) = (tup);\
130 }
131
132 #define PUT_DESCRIPTOR2(arr, tup1, tup2, p) {\
133 BYTE_T *a_p = ARRAY_ADDRESS (p);\
134 *(A68G_ARRAY *) a_p = (arr);\
135 *(A68G_TUPLE *) &(((BYTE_T *) (a_p)) [SIZE_ALIGNED (A68G_ARRAY)]) = (tup1);\
136 *(A68G_TUPLE *) &(((BYTE_T *) (a_p)) [SIZE_ALIGNED (A68G_ARRAY) + sizeof (A68G_TUPLE)]) = (tup2);\
137 }
138
139 #define ROW_SIZE(tup) ((LWB (tup) <= UPB (tup)) ? (UPB (tup) - LWB (tup) + 1) : 0)
140 #define ROW_ELEMENT(arr, k) (((ADDR_T) k + SLICE_OFFSET (arr)) * ELEM_SIZE (arr) + FIELD_OFFSET (arr))
141 #define INDEX_1_DIM(arr, tup, k) ROW_ELEMENT (arr, (SPAN (tup) * (int) (k) - SHIFT (tup)))
142
143 #define VECTOR_OFFSET(arr, tup)\
144 ((LWB (tup) * SPAN (tup) - SHIFT (tup) + SLICE_OFFSET (arr)) * ELEM_SIZE (arr) + FIELD_OFFSET (arr))
145
146 #define MATRIX_OFFSET(arr, tup1, tup2)\
147 ((LWB (tup1) * SPAN (tup1) - SHIFT (tup1) + LWB (tup2) * SPAN (tup2) - SHIFT (tup2) + SLICE_OFFSET (arr)) * ELEM_SIZE (arr) + FIELD_OFFSET (arr))
148
149 // Execution
150
151 #define STORE_GC(p, _sp_) {\
152 A68G_REF _loc_;\
153 STATUS (&_loc_) = (STATUS_MASK_T) (INIT_MASK | IN_FRAME_MASK);\
154 REF_HANDLE (&_loc_) = (A68G_HANDLE *) & nil_handle;\
155 OFFSET (&_loc_) = A68G_FP + FRAME_INFO_SIZE + OFFSET (TAX_GC (p));\
156 REF_SCOPE (&_loc_) = A68G_FP;\
157 COPY_ALIGNED ((BYTE_T *) ADDRESS (&_loc_), STACK_ADDRESS (_sp_), SIZE (MOID (p)));\
158 }
159
160 #define GENIE_UNIT(p) {\
161 PROP_T *_prop_ = &GPROP (p);\
162 if (TAX_GC (p) != NO_TAG) {\
163 ADDR_T _sp_ = A68G_SP;\
164 (void) (*(UNIT (_prop_))) (SOURCE (_prop_));\
165 STORE_GC (p, _sp_);\
166 } else {\
167 (void) (*(UNIT (_prop_))) (SOURCE (_prop_));\
168 }}
169
170 #define GENIE_UNIT_KEEP(p, dest) {\
171 PROP_T *_prop_ = &GPROP (p);\
172 if (TAX_GC (p) != NO_TAG) {\
173 ADDR_T _sp_ = A68G_SP;\
174 dest = (*(UNIT (_prop_))) (SOURCE (_prop_));\
175 STORE_GC (p, _sp_);\
176 } else {\
177 dest = (*(UNIT (_prop_))) (SOURCE (_prop_));\
178 }}
179
180 #define GENIE_UNIT_NO_GC(p) {\
181 A68G_GC (sema) ++;\
182 GENIE_UNIT ((p));\
183 A68G_GC (sema) --;}
184
185 #define GENIE_UNIT_KEEP_NO_GC(p, dest) {\
186 A68G_GC (sema) ++;\
187 GENIE_UNIT_KEEP ((p), (dest));\
188 A68G_GC (sema) --;}
189
190 #define GENIE_UNIT_TRACE(p) {\
191 if (STATUS_TEST (p, (BREAKPOINT_MASK | BREAKPOINT_TEMPORARY_MASK | \
192 BREAKPOINT_INTERRUPT_MASK | BREAKPOINT_WATCH_MASK | BREAKPOINT_TRACE_MASK))) {\
193 single_step ((p), STATUS (p));\
194 }\
195 GENIE_UNIT (p);}
196
197 // Stuff for the garbage collector
198
199 #define PREEMPTIVE_FRACTION 0.9
200
201 // Save a handle from the GC
202
203 #define BLOCK_GC_HANDLE(z) {\
204 if (IS_IN_HEAP (z)) {\
205 STATUS_SET (REF_HANDLE(z), BLOCK_GC_MASK);\
206 }}
207
208 #define UNBLOCK_GC_HANDLE(z) {\
209 if (IS_IN_HEAP (z)) {\
210 STATUS_CLEAR (REF_HANDLE (z), BLOCK_GC_MASK);\
211 }}
212
213 // Tests for objects of mode INT
214
215 #define CHECK_INDEX(p, k, t) {\
216 if (VALUE (k) < LWB (t) || VALUE (k) > UPB (t)) {\
217 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_INDEX_OUT_OF_BOUNDS);\
218 exit_genie (p, A68G_RUNTIME_ERROR);\
219 }}
220
221 // Tests for objects of mode REAL
222
223 #if defined (HAVE_IEEE_754)
224 #define CHECK_REAL(p, u) PRELUDE_ERROR (!a68g_finite_real (u), p, ERROR_INFINITE, M_REAL)
225 #define CHECK_COMPLEX(p, u, v) PRELUDE_ERROR (!a68g_finite_real (u) || !a68g_finite_real (v), p, ERROR_INFINITE, M_COMPLEX)
226 #else
227 #define CHECK_REAL(p, u) {;}
228 #define CHECK_COMPLEX(p, u, v) {;}
229 #endif
230
231 #define MATH_RTE(p, z, m, t) PRELUDE_ERROR (z, (p), (t == NO_TEXT ? ERROR_MATH : t), (m))
232
233 // Macros.
234
235 #define C_FUNCTION(p, f)\
236 A68G_REAL *x;\
237 POP_OPERAND_ADDRESS (p, x, A68G_REAL);\
238 errno = 0;\
239 VALUE (x) = f (VALUE (x));\
240 MATH_RTE (p, errno != 0, M_REAL, NO_TEXT);
241
242 #define OWN_FUNCTION(p, f)\
243 A68G_REAL *x;\
244 POP_OPERAND_ADDRESS (p, x, A68G_REAL);\
245 errno = 0;\
246 VALUE (x) = f (p, VALUE (x));\
247 MATH_RTE (p, errno != 0, M_REAL, NO_TEXT);
248
249 // Macros for standard environ
250
251 #define A68G_ENV_INT(n, k) void n (NODE_T *p) {PUSH_PRIMAL (p, (k), INT);}
252 #define A68G_ENV_REAL(n, z) void n (NODE_T *p) {PUSH_PRIMAL (p, (z), REAL);}
253
254 // Macros for the evaluation stack
255
256 #define INCREMENT_STACK_POINTER(err, i)\
257 {A68G_SP += (ADDR_T) A68G_ALIGN (i); (void) (err);}
258
259 #define DECREMENT_STACK_POINTER(err, i)\
260 {A68G_SP -= A68G_ALIGN (i); (void) (err);}
261
262 #define PUSH(p, addr, size) {\
263 BYTE_T *_sp_ = STACK_TOP;\
264 INCREMENT_STACK_POINTER ((p), (int) (size));\
265 COPY (_sp_, (BYTE_T *) (addr), (int) (size));\
266 }
267
268 #define POP(p, addr, size) {\
269 DECREMENT_STACK_POINTER((p), (int) (size));\
270 COPY ((BYTE_T *) (addr), STACK_TOP, (int) (size));\
271 }
272
273 #define POP_ALIGNED(p, addr, size) {\
274 DECREMENT_STACK_POINTER((p), (int) (size));\
275 COPY_ALIGNED ((BYTE_T *) (addr), STACK_TOP, (int) (size));\
276 }
277
278 #define POP_ADDRESS(p, addr, type) {\
279 DECREMENT_STACK_POINTER((p), (int) SIZE_ALIGNED (type));\
280 (addr) = (type *) STACK_TOP;\
281 }
282
283 #define POP_OPERAND_ADDRESS(p, i, type) {\
284 (void) (p);\
285 (i) = (type *) (STACK_OFFSET (-SIZE_ALIGNED (type)));\
286 }
287
288 #define POP_OPERAND_ADDRESSES(p, i, j, type) {\
289 DECREMENT_STACK_POINTER ((p), (int) SIZE_ALIGNED (type));\
290 (j) = (type *) STACK_TOP;\
291 (i) = (type *) (STACK_OFFSET (-SIZE_ALIGNED (type)));\
292 }
293
294 #define POP_3_OPERAND_ADDRESSES(p, i, j, k, type) {\
295 DECREMENT_STACK_POINTER ((p), (int) (2 * SIZE_ALIGNED (type)));\
296 (k) = (type *) (STACK_OFFSET (SIZE_ALIGNED (type)));\
297 (j) = (type *) STACK_TOP;\
298 (i) = (type *) (STACK_OFFSET (-SIZE_ALIGNED (type)));\
299 }
300
301 #define PUSH_VALUE(p, z, mode) {\
302 mode *_x_ = (mode *) STACK_TOP;\
303 STATUS (_x_) = INIT_MASK;\
304 VALUE (_x_) = (z);\
305 INCREMENT_STACK_POINTER ((p), SIZE_ALIGNED (mode));\
306 }
307
308 #define PUSH_PRIMAL(p, z, m) {\
309 A68G_##m *_x_ = (A68G_##m *) STACK_TOP;\
310 int _size_ = SIZE_ALIGNED (A68G_##m);\
311 STATUS (_x_) = INIT_MASK;\
312 VALUE (_x_) = (z);\
313 INCREMENT_STACK_POINTER ((p), _size_);\
314 }
315
316 #define PUSH_OBJECT(p, z, mode) {\
317 *(mode *) STACK_TOP = (z);\
318 INCREMENT_STACK_POINTER (p, SIZE_ALIGNED (mode));\
319 }
320
321 #define POP_OBJECT(p, z, mode) {\
322 DECREMENT_STACK_POINTER((p), SIZE_ALIGNED (mode));\
323 (*(z)) = *((mode *) STACK_TOP);\
324 }
325
326 #define PUSH_COMPLEX(p, re, im) {\
327 PUSH_PRIMAL (p, re, REAL);\
328 PUSH_PRIMAL (p, im, REAL);\
329 }
330
331 #define POP_COMPLEX(p, re, im) {\
332 POP_OBJECT (p, im, A68G_REAL);\
333 POP_OBJECT (p, re, A68G_REAL);\
334 }
335
336 #define PUSH_BYTES(p, k) {\
337 A68G_BYTES *_z_ = (A68G_BYTES *) STACK_TOP;\
338 STATUS (_z_) = INIT_MASK;\
339 MOVE (VALUE (_z_), k, A68G_BYTES_WIDTH);\
340 INCREMENT_STACK_POINTER((p), SIZE_ALIGNED (A68G_BYTES));\
341 }
342
343 #define PUSH_LONG_BYTES(p, k) {\
344 A68G_LONG_BYTES *_z_ = (A68G_LONG_BYTES *) STACK_TOP;\
345 STATUS (_z_) = INIT_MASK;\
346 MOVE (VALUE (_z_), k, A68G_LONG_BYTES_WIDTH);\
347 INCREMENT_STACK_POINTER((p), SIZE_ALIGNED (A68G_LONG_BYTES));\
348 }
349
350 #define PUSH_REF(p, z) PUSH_OBJECT (p, z, A68G_REF)
351 #define PUSH_PROCEDURE(p, z) PUSH_OBJECT (p, z, A68G_PROCEDURE)
352 #define PUSH_FORMAT(p, z) PUSH_OBJECT (p, z, A68G_FORMAT)
353
354 #define PUSH_STRING(p, z) {\
355 char *_s_ = (z);\
356 PUSH_REF ((p), tmp_to_a68g_string ((p), _s_));\
357 }
358
359 #define POP_REF(p, z) POP_OBJECT (p, z, A68G_REF)
360 #define POP_PROCEDURE(p, z) POP_OBJECT (p, z, A68G_PROCEDURE)
361
362 #define PUSH_UNION(p, z) {\
363 A68G_UNION *_x_ = (A68G_UNION *) STACK_TOP;\
364 STATUS (_x_) = INIT_MASK;\
365 VALUE (_x_) = (z);\
366 INCREMENT_STACK_POINTER ((p), SIZE_ALIGNED (A68G_UNION));\
367 }
368
369 // Interpreter macros
370
371 #define INITIALISED(z) ((BOOL_T) (STATUS (z) & INIT_MASK))
372 #define MODULAR_MATH(z) ((BOOL_T) (STATUS (z) & MODULAR_MASK))
373 #define LHS_MODE(p) (MOID (PACK (MOID (p))))
374 #define RHS_MODE(p) (MOID (NEXT (PACK (MOID (p)))))
375
376 // Transput related macros
377
378 #define IS_NIL_FORMAT(f) ((BOOL_T) (BODY (f) == NO_NODE && ENVIRON (f) == 0))
379
380 // Macros for check on initialisation of values
381
382 #define CHECK_INIT(p, c, q)\
383 if (!(c)) {\
384 diagnostic (A68G_RUNTIME_ERROR, (p), ERROR_EMPTY_VALUE_FROM, (q));\
385 exit_genie ((p), A68G_RUNTIME_ERROR);\
386 }
387
388 #define CHECK_DNS2(p, scope, limit, mode)\
389 if (scope > limit) {\
390 BUFFER txt;\
391 ASSERT (a68g_bufprt (txt, SNPRINTF_SIZE, ERROR_SCOPE_DYNAMIC_1) >= 0);\
392 diagnostic (A68G_RUNTIME_ERROR, p, txt, mode);\
393 exit_genie (p, A68G_RUNTIME_ERROR);\
394 }
395
396 #define CHECK_DNS(p, m, w, limit)\
397 if (NEED_DNS (GINFO (p))) {\
398 ADDR_T _lim = ((limit) < A68G_GLOBALS ? A68G_GLOBALS : (limit));\
399 if (IS ((m), REF_SYMBOL)) {\
400 CHECK_DNS2 (p, (REF_SCOPE ((A68G_REF *) (w))), _lim, (m));\
401 } else if (IS ((m), PROC_SYMBOL)) {\
402 CHECK_DNS2 (p, ENVIRON ((A68G_PROCEDURE *) (w)), _lim, (m));\
403 } else if (IS ((m), FORMAT_SYMBOL)) {\
404 CHECK_DNS2 (p, ENVIRON ((A68G_FORMAT *) w), _lim, (m));\
405 }}
406
407 //
408 // The void * cast in next macro is to stop warnings about dropping a volatile
409 // qualifier to a pointer. This is safe here.
410
411 #define STACK_DNS(p, m, limit)\
412 if (p != NO_NODE && GINFO (p) != NO_GINFO) {\
413 CHECK_DNS ((NODE_T *)(void *)(p), (m),\
414 (STACK_OFFSET (-SIZE (m))), (limit));\
415 }
416
417 // Genie routines.
418
419 PROP_T genie_column_function (NODE_T *);
420 PROP_T genie_diagonal_function (NODE_T *);
421 PROP_T genie_row_function (NODE_T *);
422 PROP_T genie_transpose_function (NODE_T *);
423 PROP_T genie_and_function (NODE_T *);
424 PROP_T genie_assertion (NODE_T *);
425 PROP_T genie_assignation_constant (NODE_T *);
426 PROP_T genie_assignation (NODE_T *);
427 PROP_T genie_assignation_quick (NODE_T * p);
428 PROP_T genie_call (NODE_T *);
429 PROP_T genie_cast (NODE_T *);
430 PROP_T genie_closed (volatile NODE_T *);
431 PROP_T genie_coercion (NODE_T *);
432 PROP_T genie_collateral (NODE_T *);
433 PROP_T genie_conditional (volatile NODE_T *);
434 PROP_T genie_constant (NODE_T *);
435 PROP_T genie_denotation (NODE_T *);
436 PROP_T genie_deproceduring (NODE_T *);
437 PROP_T genie_dereference_frame_identifier (NODE_T *);
438 PROP_T genie_dereference_generic_identifier (NODE_T *);
439 PROP_T genie_dereference_selection_name_quick (NODE_T *);
440 PROP_T genie_dereference_slice_name_quick (NODE_T *);
441 PROP_T genie_dereferencing (NODE_T *);
442 PROP_T genie_dereferencing_quick (NODE_T *);
443 PROP_T genie_dyadic (NODE_T *);
444 PROP_T genie_dyadic_quick (NODE_T *);
445 PROP_T genie_enclosed (volatile NODE_T *);
446 PROP_T genie_field_selection (NODE_T *);
447 PROP_T genie_format_text (NODE_T *);
448 PROP_T genie_formula (NODE_T *);
449 PROP_T genie_frame_identifier (NODE_T *);
450 PROP_T genie_identifier (NODE_T *);
451 PROP_T genie_identifier_standenv (NODE_T *);
452 PROP_T genie_identifier_standenv_proc (NODE_T *);
453 PROP_T genie_identity_relation (NODE_T *);
454 PROP_T genie_int_case (volatile NODE_T *);
455 PROP_T genie_loop (volatile NODE_T *);
456 PROP_T genie_loop (volatile NODE_T *);
457 PROP_T genie_monadic (NODE_T *);
458 PROP_T genie_nihil (NODE_T *);
459 PROP_T genie_or_function (NODE_T *);
460 PROP_T genie_routine_text (NODE_T *);
461 PROP_T genie_rowing (NODE_T *);
462 PROP_T genie_rowing_ref_row_of_row (NODE_T *);
463 PROP_T genie_rowing_ref_row_row (NODE_T *);
464 PROP_T genie_rowing_row_of_row (NODE_T *);
465 PROP_T genie_rowing_row_row (NODE_T *);
466 PROP_T genie_selection_name_quick (NODE_T *);
467 PROP_T genie_selection (NODE_T *);
468 PROP_T genie_selection_value_quick (NODE_T *);
469 PROP_T genie_skip (NODE_T *);
470 PROP_T genie_slice_name_quick (NODE_T *);
471 PROP_T genie_slice (NODE_T *);
472 PROP_T genie_united_case (volatile NODE_T *);
473 PROP_T genie_uniting (NODE_T *);
474 PROP_T genie_unit (NODE_T *);
475 PROP_T genie_voiding_assignation_constant (NODE_T *);
476 PROP_T genie_voiding_assignation (NODE_T *);
477 PROP_T genie_voiding (NODE_T *);
478 PROP_T genie_widen_int_to_real (NODE_T *);
479 PROP_T genie_widen (NODE_T *);
480
481 A68G_REF genie_clone (NODE_T *, MOID_T *, A68G_REF *, A68G_REF *);
482 A68G_REF genie_make_ref_row_of_row (NODE_T *, MOID_T *, MOID_T *, ADDR_T);
483 A68G_REF genie_make_ref_row_row (NODE_T *, MOID_T *, MOID_T *, ADDR_T);
484 A68G_REF genie_make_rowrow (NODE_T *, MOID_T *, int, ADDR_T);
485
486 void genie (void *);
487 void genie_clone_stack (NODE_T *, MOID_T *, A68G_REF *, A68G_REF *);
488 void genie_serial_units_no_label (NODE_T *, ADDR_T, NODE_T **);
489 void genie_jump (NODE_T *);
490
491 #endif
|
© 2002-2025 J.M. van der Veer (jmvdveer@xs4all.nl)
|
