ugBASIC 1.18
An isomorphic BASIC language compiler for retrocomputers
Loading...
Searching...
No Matches
put_image.c
Go to the documentation of this file.
1/*****************************************************************************
2 * ugBASIC - an isomorphic BASIC language compiler for retrocomputers *
3 *****************************************************************************
4 * Copyright 2021-2024 Marco Spedaletti (asimov@mclink.it)
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *----------------------------------------------------------------------------
18 * Concesso in licenza secondo i termini della Licenza Apache, versione 2.0
19 * (la "Licenza"); è proibito usare questo file se non in conformità alla
20 * Licenza. Una copia della Licenza è disponibile all'indirizzo:
21 *
22 * http://www.apache.org/licenses/LICENSE-2.0
23 *
24 * Se non richiesto dalla legislazione vigente o concordato per iscritto,
25 * il software distribuito nei termini della Licenza è distribuito
26 * "COSÌ COM'È", SENZA GARANZIE O CONDIZIONI DI ALCUN TIPO, esplicite o
27 * implicite. Consultare la Licenza per il testo specifico che regola le
28 * autorizzazioni e le limitazioni previste dalla medesima.
29 ****************************************************************************/
30
31/****************************************************************************
32 * INCLUDE SECTION
33 ****************************************************************************/
34
35#include "../../ugbc.h"
36
37/****************************************************************************
38 * CODE SECTION
39 ****************************************************************************/
40
41extern char DATATYPE_AS_STRING[][16];
42
53
54void put_image_vars_original( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
55
56 if ( _environment->emptyProcedure ) {
57 return;
58 }
59
60 MAKE_LABEL
61
62 Variable * image = variable_retrieve( _environment, _image );
63
64 Resource * resource = build_resource_for_sequence( _environment, _image, _frame, _sequence );
65
66 Variable * x1 = variable_retrieve_or_define( _environment, _x1, VT_POSITION, 0 );
67 Variable * y1 = variable_retrieve_or_define( _environment, _y1, VT_POSITION, 0 );
68
69 Variable * realFrame = NULL;
70 Variable * frame = NULL;
71 if ( _frame) {
72 frame = variable_retrieve_or_define( _environment, _frame, VT_BYTE, 0 );
73 realFrame = frame;
74 }
75 Variable * sequence = NULL;
76 if ( _sequence) {
77 sequence = variable_retrieve_or_define( _environment, _sequence, VT_BYTE, 0 );
78 realFrame = frame;
79 }
80
81 switch( resource->type ) {
82 case VT_SEQUENCE:
83 return;
84 if ( image->bankAssigned != -1 ) {
85
86 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
87 sprintf(alreadyLoadedLabel, "%salready", label );
88
89 char bankWindowId[MAX_TEMPORARY_STORAGE];
90 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
91
92 char bankWindowName[MAX_TEMPORARY_STORAGE];
93 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
94
95 // cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
96 // if ( image->uncompressedSize ) {
97 // bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
98 // } else {
99 // bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
100 // }
101 // cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
102 // cpu_label( _environment, alreadyLoadedLabel );
103
104 Variable * frameSize = variable_temporary( _environment, VT_WORD, "(temporary)");
105 variable_store( _environment, frameSize->name, image->frameSize );
106 Variable * bank = variable_temporary( _environment, VT_BYTE, "(temporary)");
107 variable_store( _environment, bank->name, image->bankAssigned );
108 Variable * offset = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
109
110 if ( !sequence ) {
111 if ( !frame ) {
112 gb_calculate_sequence_frame_offset(_environment, offset->realName, "", "", image->frameSize, image->frameCount );
113 } else {
114 gb_calculate_sequence_frame_offset(_environment, offset->realName, "", frame->realName, image->frameSize, image->frameCount );
115 }
116 } else {
117 if ( !frame ) {
118 gb_calculate_sequence_frame_offset(_environment, offset->realName, sequence->realName, "", image->frameSize, image->frameCount );
119 } else {
120 gb_calculate_sequence_frame_offset(_environment, offset->realName, sequence->realName, frame->realName, image->frameSize, image->frameCount );
121 }
122 }
123
124 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
125 variable_store( _environment, address->name, image->absoluteAddress );
126 variable_add_inplace_vars( _environment, address->name, offset->name );
127 bank_read_vars_direct( _environment, bank->name, address->name, bankWindowName, frameSize->name );
128
129 Resource resource;
130 resource.realName = strdup( bankWindowName );
131 resource.isAddress = 0;
132
133 gb_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, image->frameSize, 0, _flags );
134
135 } else {
136 if ( !sequence ) {
137 if ( !frame ) {
138 gb_put_image( _environment, resource, x1->realName, y1->realName, "", "", image->frameSize, image->frameCount, _flags );
139 } else {
140 gb_put_image( _environment, resource, x1->realName, y1->realName, frame->realName, "", image->frameSize, image->frameCount, _flags );
141 }
142 } else {
143 if ( !frame ) {
144 gb_put_image( _environment, resource, x1->realName, y1->realName, "", sequence->realName, image->frameSize, image->frameCount, _flags );
145 } else {
146 gb_put_image( _environment, resource, x1->realName, y1->realName, frame->realName, sequence->realName, image->frameSize, image->frameCount, _flags );
147 }
148 }
149 }
150 break;
151 case VT_IMAGES:
152 return;
153 if ( image->bankAssigned != -1 ) {
154
155 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
156 sprintf(alreadyLoadedLabel, "%salready", label );
157
158 char bankWindowId[MAX_TEMPORARY_STORAGE];
159 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
160
161 char bankWindowName[MAX_TEMPORARY_STORAGE];
162 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
163
164 // cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
165 // if ( image->uncompressedSize ) {
166 // bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
167 // } else {
168 // bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
169 // }
170 // cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
171 // cpu_label( _environment, alreadyLoadedLabel );
172
173 Variable * frameSize = variable_temporary( _environment, VT_WORD, "(temporary)");
174 variable_store( _environment, frameSize->name, image->frameSize );
175 Variable * bank = variable_temporary( _environment, VT_BYTE, "(temporary)");
176 variable_store( _environment, bank->name, image->bankAssigned );
177 Variable * offset = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
178
179 if ( sequence ) {
180 if ( image->strips ) {
181 realFrame = variable_temporary( _environment, VT_BYTE, "(real frame)" );
182 outline0("PUSH HL");
183 outline0("PUSH AF");
184 outline1("LD HL, %sstrip", image->realName );
185 outline1("LD A, (%s)", sequence->realName );
186 outline0("SLA A" );
187 outline0("LD E, A" );
188 outline0("LD D, 0" );
189 outline0("ADD HL, DE");
190 outline0("LD A, (HL)");
191 outline0("LD E, A");
192 outline0("INC HL");
193 outline0("LD A, (HL)");
194 outline0("LD D, A");
195 outline0("LD HL, (DE)");
196 outline1("LD A, (%s)", frame->realName );
197 outline0("LD E, A" );
198 outline0("LD D, 0" );
199 outline0("ADD HL, DE");
200 outline0("LD A, (HL)");
201 outline1("LD (%s), A", realFrame->realName );
202 outline0("POP AF");
203 outline0("POP HL");
204 } else {
205 CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP( image->name );
206 }
207 }
208
209 if ( !frame ) {
210 gb_calculate_sequence_frame_offset(_environment, offset->realName, NULL, "", image->frameSize, 0 );
211 } else {
212 gb_calculate_sequence_frame_offset(_environment, offset->realName, NULL, realFrame->realName, image->frameSize, 0 );
213 }
214
215 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
216 variable_store( _environment, address->name, image->absoluteAddress );
217 variable_add_inplace_vars( _environment, address->name, offset->name );
218 bank_read_vars_direct( _environment, bank->name, address->name, bankWindowName, frameSize->name );
219
220 Resource resource;
221 resource.realName = strdup( bankWindowName );
222 resource.isAddress = 0;
223
224 gb_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, image->frameSize, 0, _flags );
225
226 } else {
227
228 if ( sequence ) {
229 if ( image->strips ) {
230 realFrame = variable_temporary( _environment, VT_BYTE, "(real frame)" );
231 outline0("PUSH HL");
232 outline0("PUSH AF");
233 outline1("LD HL, %sstrip", image->realName );
234 outline1("LD A, (%s)", sequence->realName );
235 outline0("SLA A" );
236 outline0("LD E, A" );
237 outline0("LD D, 0" );
238 outline0("ADD HL, DE");
239 outline0("LD A, (HL)");
240 outline0("LD E, A");
241 outline0("INC HL");
242 outline0("LD A, (HL)");
243 outline0("LD E, A");
244 outline0("LD HL, (DE)");
245 outline1("LD A, (%s)", frame->realName );
246 outline0("LD E, A" );
247 outline0("LD D, 0" );
248 outline0("ADD HL, DE");
249 outline0("LD A, (HL)");
250 outline1("LD (%s), A", realFrame->realName );
251 outline0("POP AF");
252 outline0("POP HL");
253 } else {
254 CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP( image->name );
255 }
256 }
257
258 if ( !frame ) {
259 gb_put_image( _environment, resource, x1->realName, y1->realName, "", NULL, image->frameSize, 0, _flags );
260 } else {
261 gb_put_image( _environment, resource, x1->realName, y1->realName, realFrame->realName, NULL, image->frameSize, 0, _flags );
262 }
263 }
264 break;
265 case VT_IMAGE:
266 case VT_TARRAY:
267 if ( image->bankAssigned != -1 ) {
268
269 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
270 sprintf(alreadyLoadedLabel, "%salready", label );
271
272 char bankWindowId[MAX_TEMPORARY_STORAGE];
273 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
274
275 char bankWindowName[MAX_TEMPORARY_STORAGE];
276 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
277
278 cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
279 if ( image->uncompressedSize ) {
280 bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
281 } else {
282 bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
283 }
284 cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
285 cpu_label( _environment, alreadyLoadedLabel );
286
287 Resource resource;
288 resource.realName = strdup( bankWindowName );
289 resource.isAddress = 0;
290
291 gb_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, 1, 0, _flags );
292 } else {
293 gb_put_image( _environment, resource, x1->realName, y1->realName, NULL, NULL, 1, 0, _flags );
294 }
295 break;
296 default:
297 CRITICAL_PUT_IMAGE_UNSUPPORTED( _image, DATATYPE_AS_STRING[image->type] );
298 }
299
300
301}
302
303void put_image_vars_imageref( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
304
305 MAKE_LABEL
306
307 Variable * image = variable_retrieve( _environment, _image );
308
309 Variable * x1 = variable_retrieve_or_define( _environment, _x1, VT_POSITION, 0 );
310 Variable * y1 = variable_retrieve_or_define( _environment, _y1, VT_POSITION, 0 );
311 Variable * frame = NULL;
312 if ( _frame) {
313 frame = variable_retrieve_or_define( _environment, _frame, VT_BYTE, 0 );
314 }
315 Variable * sequence = NULL;
316 if ( _sequence) {
317 sequence = variable_retrieve_or_define( _environment, _sequence, VT_BYTE, 0 );
318 }
319
320 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(stub)" );
321
322 if ( !_environment->putImageRefUnsafe ) {
323 outline1("LD A, (%s)", address_displacement( _environment, image->realName, "5") );
324 outline0("CP 0");
325 outline1("JP Z, %sskip", label );
326 }
327
328 // Y = OFFSET
329
330 if ( !_sequence && !_frame ) {
331 outline1("LD HL, (%s)", image->realName );
332 } else {
333 outline1("LD HL, (%s)", image->realName );
334
335 if ( _sequence ) {
336 outline0("LD DE, $0003" );
337 outline0("ADD HL, DE" );
338 if ( strlen(_sequence) == 0 ) {
339
340 } else {
341 outline1("LD A, (%s)", sequence->realName );
342 outline0("LD (IXR), HL" );
343 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "10") );
344 }
345 if ( _frame ) {
346 if ( strlen(_frame) == 0 ) {
347
348 } else {
349 outline1("LD A, (%s)", frame->realName );
350 outline0("LD (IXR), HL" );
351 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "8") );
352 }
353 }
354
355 } else {
356
357 if ( _frame ) {
358 outline0("LD DE, $0003" );
359 outline0("ADD HL, DE" );
360 if ( strlen(_frame) == 0 ) {
361
362 } else {
363 outline0("LD (IXR), HL" );
364 outline1("LD A, (%s)", frame->realName );
365 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "8") );
366 }
367 }
368
369 }
370
371 }
372 outline1("LD (%s), HL", address->realName );
373
374 Resource resource;
375 resource.realName = strdup( address->realName );
376 resource.isAddress = 1;
377
378 gb_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, 0, 0, _flags );
379
380 if ( !_environment->putImageRefUnsafe ) {
381 outhead1("%sskip:", label );
382 }
383
384}
385
386void put_image_vars( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
387
388 if ( _environment->emptyProcedure ) {
389 return;
390 }
391
392 Variable * image = variable_retrieve( _environment, _image );
393
394 switch( image->type ) {
395 case VT_IMAGE:
396 case VT_IMAGES:
397 case VT_SEQUENCE:
398 case VT_ADDRESS:
399 put_image_vars_original( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, _flags );
400 break;
401 case VT_IMAGEREF:
402 put_image_vars_imageref( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, _flags );
403 break;
404 default:
405 CRITICAL_PUT_IMAGE_UNSUPPORTED( _image, DATATYPE_AS_STRING[image->type] );
406 }
407
408}
409
410void put_image_vars_flags( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, int _flags ) {
411
412 char flagsConstantName[MAX_TEMPORARY_STORAGE]; sprintf( flagsConstantName, "PUTIMAGEFLAGS%4.4x", _flags );
413 char flagsConstantParameter[MAX_TEMPORARY_STORAGE]; sprintf( flagsConstantParameter, "PUTIMAGEFLAGS%4.4x", _flags );
414
415 Constant * flagsConstant = constant_find( _environment, flagsConstantName );
416
417 if ( !flagsConstant ) {
418 flagsConstant = malloc( sizeof( Constant ) );
419 memset( flagsConstant, 0, sizeof( Constant ) );
420 flagsConstant->name = strdup( flagsConstantName );
421 flagsConstant->realName = strdup( flagsConstantName );
422 flagsConstant->value = _flags;
423 flagsConstant->type = CT_INTEGER;
424 flagsConstant->next = _environment->constants;
425 _environment->constants = flagsConstant;
426 }
427
428 put_image_vars( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, flagsConstantParameter );
429}
cpu_store_16bit
void cpu_store_16bit(Environment *_environment, char *_destination, int _value)
CPU 6309: emit code to store 16 bit
Definition 6309.c:1503
cpu_compare_and_branch_16bit_const
void cpu_compare_and_branch_16bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
CPU 6309: emit code to compare two 8 bit values and jump if they are equal/different
Definition 6309.c:1578
cpu_label
void cpu_label(Environment *_environment, char *_label)
Definition 6309.c:356
cpu_call_indirect
void cpu_call_indirect(Environment *_environment, char *_value)
Definition 6309.c:3765
variable_retrieve
Variable * variable_retrieve(Environment *_environment, char *_name)
Definition _infrastructure.c:988
variable_retrieve_or_define
Variable * variable_retrieve_or_define(Environment *_environment, char *_name, VariableType _type, int _value)
Definition _infrastructure.c:1040
build_resource_for_sequence
Resource * build_resource_for_sequence(Environment *_environment, char *_image, char *_frame, char *_sequence)
Definition _infrastructure.c:15073
variable_add_inplace_vars
void variable_add_inplace_vars(Environment *_environment, char *_source, char *_destination)
Add two variable and return the sum of them on the first.
Definition _infrastructure.c:4377
variable_temporary
Variable * variable_temporary(Environment *_environment, VariableType _type, char *_meaning)
Define a temporary variable.
Definition _infrastructure.c:1388
variable_store
Variable * variable_store(Environment *_environment, char *_destination, unsigned int _value)
Store a direct value to a variable.
Definition _infrastructure.c:1720
address_displacement
char * address_displacement(Environment *_environment, char *_address, char *_displacement)
Definition _infrastructure.c:14516
constant_find
Constant * constant_find(Environment *_environment, char *_name)
Definition _infrastructure.c:373
offset
int offset
Definition _optimizer.c:681
put_image_vars_original
void put_image_vars_original(Environment *_environment, char *_image, char *_x1, char *_y1, char *_x2, char *_y2, char *_frame, char *_sequence, char *_flags)
Emit ASM code for PUT IMAGE [image] AT [int],[int].
Definition put_image.c:53
put_image_vars_imageref
void put_image_vars_imageref(Environment *_environment, char *_image, char *_x1, char *_y1, char *_x2, char *_y2, char *_frame, char *_sequence, char *_flags)
Definition put_image.c:289
put_image_vars_flags
void put_image_vars_flags(Environment *_environment, char *_image, char *_x1, char *_y1, char *_x2, char *_y2, char *_frame, char *_sequence, int _flags)
Definition put_image.c:430
put_image_vars
void put_image_vars(Environment *_environment, char *_image, char *_x1, char *_y1, char *_x2, char *_y2, char *_frame, char *_sequence, char *_flags)
Definition put_image.c:406
bank_read_semi_var
void bank_read_semi_var(Environment *_environment, int _bank, int _address1, char *_address2, int _size)
Emit ASM code for instruction BANK READ ....
Definition bank_read.c:50
bank_read_vars_direct
void bank_read_vars_direct(Environment *_environment, char *_bank, char *_address1, char *_address2, char *_size)
Definition bank_read.c:138
bank_uncompress_semi_var
void bank_uncompress_semi_var(Environment *_environment, int _bank, int _address1, char *_address2)
Emit ASM code for instruction BANK UNCOMPRESS ....
Definition bank_uncompress.c:49
gb_put_image
void gb_put_image(Environment *_environment, Resource *_image, char *_x, char *_y, char *_frame, char *_sequence, int _frame_size, int _frame_count, char *_flags)
Definition gb.c:1776
gb_calculate_sequence_frame_offset
void gb_calculate_sequence_frame_offset(Environment *_environment, char *_offset, char *_sequence, char *_frame, int _frame_size, int _frame_count)
Definition gb.c:2213
_Constant::name
char * name
Definition ugbc.h:800
_Constant::value
int value
Definition ugbc.h:815
_Constant::type
ConstantType type
Definition ugbc.h:805
_Constant::next
struct _Constant * next
Definition ugbc.h:832
_Constant::realName
char * realName
Definition ugbc.h:803
_Environment::putImageRefUnsafe
int putImageRefUnsafe
Definition ugbc.h:3271
_Environment::constants
Constant * constants
Definition ugbc.h:2611
_Environment::emptyProcedure
int emptyProcedure
Definition ugbc.h:2932
_Resource::isAddress
int isAddress
Definition ugbc.h:557
_Resource::type
VariableType type
Definition ugbc.h:559
_Resource::realName
char * realName
Definition ugbc.h:555
_Variable::name
char * name
Definition ugbc.h:979
_Variable::type
VariableType type
Definition ugbc.h:988
_Variable::realName
char * realName
Definition ugbc.h:982
malloc
void * malloc(YYSIZE_T)
Resource
struct _Resource Resource
MAX_TEMPORARY_STORAGE
#define MAX_TEMPORARY_STORAGE
Definition ugbc.h:563
CT_INTEGER
@ CT_INTEGER
Definition ugbc.h:788
Variable
struct _Variable Variable
Structure of a single variable.
Environment
struct _Environment Environment
Structure of compilation environment.
VT_TARRAY
@ VT_TARRAY
Definition ugbc.h:480
VT_WORD
@ VT_WORD
Definition ugbc.h:455
VT_POSITION
@ VT_POSITION
Definition ugbc.h:468
VT_BYTE
@ VT_BYTE
Definition ugbc.h:450
VT_IMAGEREF
@ VT_IMAGEREF
Definition ugbc.h:537
VT_IMAGES
@ VT_IMAGES
Definition ugbc.h:495
VT_ADDRESS
@ VT_ADDRESS
Definition ugbc.h:465
VT_IMAGE
@ VT_IMAGE
Definition ugbc.h:489
VT_SEQUENCE
@ VT_SEQUENCE
Definition ugbc.h:513
Constant
struct _Constant Constant
Structure of a single constant.
CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP
#define CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP(s)
Definition ugbc.h:3855
outline0
#define outline0(s)
Definition ugbc.h:4252
CRITICAL_PUT_IMAGE_UNSUPPORTED
#define CRITICAL_PUT_IMAGE_UNSUPPORTED(v, t)
Definition ugbc.h:3532
outline1
#define outline1(s, a)
Definition ugbc.h:4253
MAKE_LABEL
#define MAKE_LABEL
Definition ugbc.h:3351
outhead1
#define outhead1(s, a)
Definition ugbc.h:4247
DATATYPE_AS_STRING
char DATATYPE_AS_STRING[][16]
Definition _infrastructure.c:133