genie-denotation.c
1 //! @file genie-denotation.c
2 //! @author J. Marcel van der Veer
3
4 //! @section Copyright
5 //!
6 //! This file is part of Algol68G - an Algol 68 interpreter.
7 //! Copyright 2001-2026 J. Marcel van der Veer [algol68g@algol68genie.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 routines for denotations.
25
26 #include "a68g.h"
27 #include "a68g-conversion.h"
28 #include "a68g-genie.h"
29 #include "a68g-frames.h"
30 #include "a68g-prelude.h"
31 #include "a68g-mp.h"
32 #include "a68g-transput.h"
33
34 //! @brief Push routine text.
35
36 PROP_T genie_routine_text (NODE_T *p)
37 {
38 static PROP_T self;
39 A68G_PROCEDURE z = *(A68G_PROCEDURE *) (FRAME_OBJECT (OFFSET (TAX (p))));
40 PUSH_PROCEDURE (p, z);
41 UNIT (&self) = genie_routine_text;
42 SOURCE (&self) = p;
43 return self;
44 }
45
46
47 //! @brief Push format text.
48
49 PROP_T genie_format_text (NODE_T *p)
50 {
51 static PROP_T self;
52 A68G_FORMAT z = *(A68G_FORMAT *) (FRAME_OBJECT (OFFSET (TAX (p))));
53 PUSH_FORMAT (p, z);
54 UNIT (&self) = genie_format_text;
55 SOURCE (&self) = p;
56 return self;
57 }
58
59
60 //! @brief Push NIL.
61
62 PROP_T genie_nihil (NODE_T *p)
63 {
64 PROP_T self;
65 PUSH_REF (p, nil_ref);
66 UNIT (&self) = genie_nihil;
67 SOURCE (&self) = p;
68 return self;
69 }
70
71
72 //! @brief Push constant stored in the tree.
73
74 PROP_T genie_constant (NODE_T *p)
75 {
76 PUSH (p, CONSTANT (GINFO (p)), SIZE (GINFO (p)));
77 return GPROP (p);
78 }
79
80
81 //! @brief Push value of denotation.
82
83 PROP_T genie_denotation (NODE_T *p)
84 {
85 MOID_T *moid = MOID (p);
86 PROP_T self;
87 UNIT (&self) = genie_denotation;
88 SOURCE (&self) = p;
89 if (moid == M_INT) {
90 // INT denotation.
91 A68G_INT z;
92 NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
93 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
94 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
95 exit_genie (p, A68G_RUNTIME_ERROR);
96 }
97 UNIT (&self) = genie_constant;
98 STATUS (&z) = INIT_MASK;
99 CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE (M_INT));
100 SIZE (GINFO (p)) = SIZE (M_INT);
101 COPY (CONSTANT (GINFO (p)), &z, SIZE (M_INT));
102 PUSH_VALUE (p, VALUE ((A68G_INT *) (CONSTANT (GINFO (p)))), A68G_INT);
103 return self;
104 }
105 if (moid == M_REAL) {
106 // REAL denotation.
107 A68G_REAL z;
108 NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
109 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
110 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
111 exit_genie (p, A68G_RUNTIME_ERROR);
112 }
113 STATUS (&z) = INIT_MASK;
114 UNIT (&self) = genie_constant;
115 CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_REAL));
116 SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_REAL);
117 COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_REAL));
118 PUSH_VALUE (p, VALUE ((A68G_REAL *) (CONSTANT (GINFO (p)))), A68G_REAL);
119 return self;
120 }
121 #if (A68G_LEVEL >= 3)
122 if (moid == M_LONG_INT) {
123 // LONG INT denotation.
124 A68G_LONG_INT z;
125 size_t len = SIZE_ALIGNED (A68G_LONG_INT);
126 NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
127 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
128 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
129 exit_genie (p, A68G_RUNTIME_ERROR);
130 }
131 UNIT (&self) = genie_constant;
132 STATUS (&z) = INIT_MASK;
133 CONSTANT (GINFO (p)) = (void *) get_heap_space (len);
134 SIZE (GINFO (p)) = len;
135 COPY (CONSTANT (GINFO (p)), &z, len);
136 PUSH_VALUE (p, VALUE ((A68G_LONG_INT *) (CONSTANT (GINFO (p)))), A68G_LONG_INT);
137 return self;
138 }
139 if (moid == M_LONG_REAL) {
140 // LONG REAL denotation.
141 A68G_LONG_REAL z;
142 NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
143 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
144 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
145 exit_genie (p, A68G_RUNTIME_ERROR);
146 }
147 STATUS (&z) = INIT_MASK;
148 UNIT (&self) = genie_constant;
149 CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_LONG_REAL));
150 SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_LONG_REAL);
151 COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_LONG_REAL));
152 PUSH_VALUE (p, VALUE ((A68G_LONG_REAL *) (CONSTANT (GINFO (p)))), A68G_LONG_REAL);
153 return self;
154 }
155 // LONG BITS denotation.
156 if (moid == M_LONG_BITS) {
157 A68G_LONG_BITS z;
158 NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
159 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
160 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
161 exit_genie (p, A68G_RUNTIME_ERROR);
162 }
163 UNIT (&self) = genie_constant;
164 STATUS (&z) = INIT_MASK;
165 CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_LONG_BITS));
166 SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_LONG_BITS);
167 COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_LONG_BITS));
168 PUSH_VALUE (p, VALUE ((A68G_LONG_BITS *) (CONSTANT (GINFO (p)))), A68G_LONG_BITS);
169 return self;
170 }
171 #endif
172 if (moid == M_LONG_INT || moid == M_LONGER_INT) {
173 // [LONG] LONG INT denotation.
174 int digits = LIMBS (moid);
175 size_t size = SIZE (moid);
176 NODE_T *number;
177 if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
178 number = NEXT_SUB (p);
179 } else {
180 number = SUB (p);
181 }
182 MP_T *z = nil_mp (p, digits);
183 if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
184 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
185 exit_genie (p, A68G_RUNTIME_ERROR);
186 }
187 SET_INIT_MP (z);
188 UNIT (&self) = genie_constant;
189 CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
190 SIZE (GINFO (p)) = size;
191 COPY (CONSTANT (GINFO (p)), z, size);
192 return self;
193 }
194 if (moid == M_LONG_REAL || moid == M_LONGER_REAL) {
195 // [LONG] LONG REAL denotation.
196 int digits = LIMBS (moid);
197 size_t size = SIZE (moid);
198 NODE_T *number;
199 if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
200 number = NEXT_SUB (p);
201 } else {
202 number = SUB (p);
203 }
204 MP_T *z = nil_mp (p, digits);
205 if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
206 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
207 exit_genie (p, A68G_RUNTIME_ERROR);
208 }
209 SET_INIT_MP (z);
210 UNIT (&self) = genie_constant;
211 CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
212 SIZE (GINFO (p)) = size;
213 COPY (CONSTANT (GINFO (p)), z, size);
214 return self;
215 }
216 if (moid == M_BITS) {
217 // BITS denotation.
218 A68G_BITS z;
219 NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
220 if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
221 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
222 exit_genie (p, A68G_RUNTIME_ERROR);
223 }
224 UNIT (&self) = genie_constant;
225 STATUS (&z) = INIT_MASK;
226 CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_BITS));
227 SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_BITS);
228 COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_BITS));
229 PUSH_VALUE (p, VALUE ((A68G_BITS *) (CONSTANT (GINFO (p)))), A68G_BITS);
230 }
231 if (moid == M_LONG_BITS || moid == M_LONGER_BITS) {
232 // [LONG] LONG BITS denotation.
233 int digits = LIMBS (moid);
234 size_t size = SIZE (moid);
235 NODE_T *number;
236 if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
237 number = NEXT_SUB (p);
238 } else {
239 number = SUB (p);
240 }
241 MP_T *z = nil_mp (p, digits);
242 if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
243 diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
244 exit_genie (p, A68G_RUNTIME_ERROR);
245 }
246 SET_INIT_MP (z);
247 UNIT (&self) = genie_constant;
248 CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
249 SIZE (GINFO (p)) = size;
250 COPY (CONSTANT (GINFO (p)), z, size);
251 return self;
252 }
253 if (moid == M_BOOL) {
254 // BOOL denotation.
255 A68G_BOOL z;
256 ASSERT (genie_string_to_value_internal (p, M_BOOL, NSYMBOL (p), (BYTE_T *) & z) == A68G_TRUE);
257 PUSH_VALUE (p, VALUE (&z), A68G_BOOL);
258 return self;
259 } else if (moid == M_CHAR) {
260 // CHAR denotation.
261 PUSH_VALUE (p, TO_UCHAR (NSYMBOL (p)[0]), A68G_CHAR);
262 return self;
263 } else if (moid == M_ROW_CHAR) {
264 // [] CHAR denotation - permanent string in the heap.
265 A68G_REF z;
266 A68G_ARRAY *arr;
267 A68G_TUPLE *tup;
268 z = c_to_a_string (p, NSYMBOL (p), DEFAULT_WIDTH);
269 GET_DESCRIPTOR (arr, tup, &z);
270 BLOCK_GC_HANDLE (&z);
271 BLOCK_GC_HANDLE (&(ARRAY (arr)));
272 UNIT (&self) = genie_constant;
273 CONSTANT (GINFO (p)) = (void *) get_heap_space (A68G_REF_SIZE);
274 SIZE (GINFO (p)) = A68G_REF_SIZE;
275 COPY (CONSTANT (GINFO (p)), &z, A68G_REF_SIZE);
276 PUSH_REF (p, *(A68G_REF *) (CONSTANT (GINFO (p))));
277 (void) tup;
278 return self;
279 }
280 if (moid == M_VOID) {
281 // VOID denotation: EMPTY.
282 return self;
283 }
284 return self;
285 }
286
© J.M. van der Veer • jmvdveer@algol68genie.nl