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-2026 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
53void put_image_vars_original( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
54
55 if ( _environment->emptyProcedure ) {
56 return;
57 }
58
59 MAKE_LABEL
60
61 Variable * image = variable_retrieve( _environment, _image );
62
63 image->usedImage = 1;
64
65 Resource * resource = build_resource_for_sequence( _environment, _image, _frame, _sequence );
66
67 Variable * x1 = variable_retrieve_or_define( _environment, _x1, VT_POSITION, 0 );
68 Variable * y1 = variable_retrieve_or_define( _environment, _y1, VT_POSITION, 0 );
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 }
79
80 switch( resource->type ) {
81 case VT_SEQUENCE:
82 if ( image->bankAssigned != -1 ) {
83
84 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
85 sprintf(alreadyLoadedLabel, "%salready", label );
86
87 char bankWindowId[MAX_TEMPORARY_STORAGE];
88 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
89
90 char bankWindowName[MAX_TEMPORARY_STORAGE];
91 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
92
93 // cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
94 // if ( image->uncompressedSize ) {
95 // bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
96 // } else {
97 // bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
98 // }
99 // cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
100 // cpu_label( _environment, alreadyLoadedLabel );
101
102 Variable * frameSize = variable_temporary( _environment, VT_WORD, "(temporary)");
103 variable_store( _environment, frameSize->name, image->frameSize );
104 Variable * bank = variable_temporary( _environment, VT_BYTE, "(temporary)");
105 variable_store( _environment, bank->name, image->bankAssigned );
106 Variable * offset = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
107
108 if ( !sequence ) {
109 if ( !frame ) {
110 gtia_calculate_sequence_frame_offset(_environment, offset->realName, "", "", image->frameSize, image->frameCount );
111 } else {
112 gtia_calculate_sequence_frame_offset(_environment, offset->realName, "", frame->realName, image->frameSize, image->frameCount );
113 }
114 } else {
115 if ( !frame ) {
116 gtia_calculate_sequence_frame_offset(_environment, offset->realName, sequence->realName, "", image->frameSize, image->frameCount );
117 } else {
118 gtia_calculate_sequence_frame_offset(_environment, offset->realName, sequence->realName, frame->realName, image->frameSize, image->frameCount );
119 }
120 }
121
122 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
123 variable_store( _environment, address->name, image->absoluteAddress );
124 variable_add_inplace_vars( _environment, address->name, offset->name );
125 bank_read_vars_direct( _environment, bank->name, address->name, bankWindowName, frameSize->name );
126
127 Resource resource;
128 resource.realName = strdup( bankWindowName );
129 resource.isAddress = 0;
130
131 gtia_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, image->frameSize, 0, _flags );
132
133 } else {
134 if ( !sequence ) {
135 if ( !frame ) {
136 gtia_put_image( _environment, resource, x1->realName, y1->realName, "", "", image->frameSize, image->frameCount, _flags );
137 } else {
138 gtia_put_image( _environment, resource, x1->realName, y1->realName, frame->realName, "", image->frameSize, image->frameCount, _flags );
139 }
140 } else {
141 if ( !frame ) {
142 gtia_put_image( _environment, resource, x1->realName, y1->realName, "", sequence->realName, image->frameSize, image->frameCount, _flags );
143 } else {
144 gtia_put_image( _environment, resource, x1->realName, y1->realName, frame->realName, sequence->realName, image->frameSize, image->frameCount, _flags );
145 }
146 }
147 }
148 break;
149 case VT_IMAGES:
150 if ( image->bankAssigned != -1 ) {
151
152 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
153 sprintf(alreadyLoadedLabel, "%salready", label );
154
155 char bankWindowId[MAX_TEMPORARY_STORAGE];
156 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
157
158 char bankWindowName[MAX_TEMPORARY_STORAGE];
159 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
160
161 // cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
162 // if ( image->uncompressedSize ) {
163 // bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
164 // } else {
165 // bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
166 // }
167 // cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
168 // cpu_label( _environment, alreadyLoadedLabel );
169
170 Variable * frameSize = variable_temporary( _environment, VT_WORD, "(temporary)");
171 variable_store( _environment, frameSize->name, image->frameSize );
172 Variable * bank = variable_temporary( _environment, VT_BYTE, "(temporary)");
173 variable_store( _environment, bank->name, image->bankAssigned );
174 Variable * offset = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
175
176 if ( sequence ) {
177 if ( image->strips ) {
178 realFrame = variable_temporary( _environment, VT_BYTE, "(real frame)" );
179 outline1("LDA %s", sequence->realName);
180 outline0("ASL");
181 outline0("TAY");
182 outline1("LDA #<%sstrip", image->realName);
183 outline0("STA TMPPTR");
184 outline1("LDA #>%sstrip", image->realName);
185 outline0("STA TMPPTR+1");
186 outline0("LDA (TMPPTR),Y" );
187 outline0("STA TMPPTR2");
188 outline0("INY" );
189 outline0("LDA (TMPPTR),Y" );
190 outline0("STA TMPPTR2+1");
191 outline1("LDA %s", frame->realName );
192 outline0("TAY" );
193 outline0("LDA (TMPPTR2),Y" );
194 outline1("STA %s", realFrame->realName );
195 } else {
196 CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP( image->name );
197 }
198 }
199
200 if ( !frame ) {
201 gtia_calculate_sequence_frame_offset(_environment, offset->realName, NULL, "", image->frameSize, 0 );
202 } else {
203 gtia_calculate_sequence_frame_offset(_environment, offset->realName, NULL, realFrame->realName, image->frameSize, 0 );
204 }
205
206 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(temporary)");
207 variable_store( _environment, address->name, image->absoluteAddress );
208 variable_add_inplace_vars( _environment, address->name, offset->name );
209 bank_read_vars_direct( _environment, bank->name, address->name, bankWindowName, frameSize->name );
210
211 Resource resource;
212 resource.realName = strdup( bankWindowName );
213 resource.isAddress = 0;
214
215 gtia_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, image->frameSize, 0, _flags );
216
217 } else {
218
219
220 if ( sequence ) {
221 if ( image->strips ) {
222 realFrame = variable_temporary( _environment, VT_BYTE, "(real frame)" );
223 outline1("LDA %s", sequence->realName);
224 outline0("ASL");
225 outline0("TAY");
226 outline1("LDA #<%sstrip", image->realName);
227 outline0("STA TMPPTR");
228 outline1("LDA #>%sstrip", image->realName);
229 outline0("STA TMPPTR+1");
230 outline0("LDA (TMPPTR),Y" );
231 outline0("STA TMPPTR2");
232 outline0("INY" );
233 outline0("LDA (TMPPTR),Y" );
234 outline0("STA TMPPTR2+1");
235 outline1("LDA %s", frame->realName );
236 outline0("TAY" );
237 outline0("LDA (TMPPTR2),Y" );
238 outline1("STA %s", realFrame->realName );
239 } else {
240 CRITICAL_CANNOT_PUT_IMAGE_WITHOUT_STRIP( image->name );
241 }
242 }
243
244 if ( !frame ) {
245 gtia_put_image( _environment, resource, x1->realName, y1->realName, "", NULL, image->frameSize, 0, _flags );
246 } else {
247 gtia_put_image( _environment, resource, x1->realName, y1->realName, realFrame->realName, NULL, image->frameSize, 0, _flags );
248 }
249 }
250 break;
251 case VT_IMAGE:
252 case VT_TARRAY:
253 if ( image->bankAssigned != -1 ) {
254
255 char alreadyLoadedLabel[MAX_TEMPORARY_STORAGE];
256 sprintf(alreadyLoadedLabel, "%salready", label );
257
258 char bankWindowId[MAX_TEMPORARY_STORAGE];
259 sprintf( bankWindowId, "BANKWINDOWID%2.2x", image->residentAssigned );
260
261 char bankWindowName[MAX_TEMPORARY_STORAGE];
262 sprintf( bankWindowName, "BANKWINDOW%2.2x", image->residentAssigned );
263
264 cpu_compare_and_branch_16bit_const( _environment, bankWindowId, image->variableUniqueId, alreadyLoadedLabel, 1 );
265 if ( image->uncompressedSize ) {
266 bank_uncompress_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName );
267 } else {
268 bank_read_semi_var( _environment, image->bankAssigned, image->absoluteAddress, bankWindowName, image->size );
269 }
270 cpu_store_16bit(_environment, bankWindowId, image->variableUniqueId );
271 cpu_label( _environment, alreadyLoadedLabel );
272
273 Resource resource;
274 resource.realName = strdup( bankWindowName );
275 resource.isAddress = 0;
276
277 gtia_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, 1, 0, _flags );
278 } else {
279 gtia_put_image( _environment, resource, x1->realName, y1->realName, NULL, NULL, 1, 0, _flags );
280 }
281 break;
282 default:
283 CRITICAL_PUT_IMAGE_UNSUPPORTED( _image, DATATYPE_AS_STRING[image->type] );
284 }
285
286
287}
288
289void put_image_vars_imageref( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
290
291 MAKE_LABEL
292
293 Variable * image = variable_retrieve( _environment, _image );
294
295 Variable * x1 = variable_retrieve_or_define( _environment, _x1, VT_POSITION, 0 );
296 Variable * y1 = variable_retrieve_or_define( _environment, _y1, VT_POSITION, 0 );
297 Variable * frame = NULL;
298 if ( _frame) {
299 frame = variable_retrieve_or_define( _environment, _frame, VT_BYTE, 0 );
300 }
301 Variable * sequence = NULL;
302 if ( _sequence) {
303 sequence = variable_retrieve_or_define( _environment, _sequence, VT_BYTE, 0 );
304 }
305
306 Variable * address = variable_temporary( _environment, VT_ADDRESS, "(stub)" );
307
308 if ( !_environment->putImageRefUnsafe ) {
309 outline1("LDA %s", address_displacement( _environment, image->realName, "5") );
310 outline1("BNE %sskipx", label );
311 outline1("JMP %sskip", label );
312 outhead1("%sskipx:", label );
313 }
314
315 // Y = OFFSET
316
317 if ( _sequence ) {
318
319 outline1("LDA %s", image->realName );
320 outline0("STA TMPPTR" );
321 outline1("LDA %s", address_displacement( _environment, image->realName, "1") );
322 outline0("STA TMPPTR+1" );
323
324 outline0("CLC" );
325 outline0("LDA TMPPTR" );
326 outline0("ADC #3" );
327 outline0("STA TMPPTR" );
328 outline0("LDA TMPPTR+1" );
329 outline0("ADC #0" );
330 outline0("STA TMPPTR+1" );
331
332 if ( strlen(_sequence) == 0 ) {
333
334 } else {
335 outline1("LDA %s", sequence->realName );
336 outline0("STA MATHPTR0" );
337 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "10") );
338 }
339 if ( _frame ) {
340 if ( strlen(_frame) == 0 ) {
341
342 } else {
343 outline1("LDA %s", _frame );
344 outline0("STA MATHPTR0" );
345 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "8") );
346 }
347 }
348
349 outline0("LDA TMPPTR" );
350 outline1("STA %s", address->realName );
351 outline0("LDA TMPPTR+1" );
352 outline1("STA %s", address_displacement(_environment, address->realName, "1") );
353
354 } else {
355
356 if ( _frame ) {
357
358 outline1("LDA %s", image->realName );
359 outline0("STA TMPPTR" );
360 outline1("LDA %s", address_displacement( _environment, image->realName, "1") );
361 outline0("STA TMPPTR+1" );
362
363 outline0("CLC" );
364 outline0("LDA TMPPTR" );
365 outline0("ADC #3" );
366 outline0("STA TMPPTR" );
367 outline0("LDA TMPPTR+1" );
368 outline0("ADC #0" );
369 outline0("STA TMPPTR+1" );
370 if ( strlen(_frame) == 0 ) {
371
372 } else {
373 outline1("LDA %s", frame->realName );
374 outline0("STA MATHPTR0" );
375 cpu_call_indirect( _environment, address_displacement( _environment, image->realName, "8") );
376 }
377
378 outline0("LDA TMPPTR" );
379 outline1("STA %s", address->realName );
380 outline0("LDA TMPPTR+1" );
381 outline1("STA %s", address_displacement(_environment, address->realName, "1") );
382
383 } else {
384
385 outline1("LDA %s", image->realName );
386 outline1("STA %s", address->realName );
387 outline1("LDA %s", address_displacement( _environment, image->realName, "1") );
388 outline1("STA %s", address_displacement(_environment, address->realName, "1") );
389
390 }
391
392 }
393
394 Resource resource;
395 resource.realName = strdup( address->realName );
396 resource.isAddress = 1;
397
398 gtia_put_image( _environment, &resource, x1->realName, y1->realName, NULL, NULL, 1, 0, _flags );
399
400 if ( !_environment->putImageRefUnsafe ) {
401 outhead1("%sskip:", label );
402 }
403
404}
405
406void put_image_vars( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, char * _flags ) {
407
408 if ( _environment->emptyProcedure ) {
409 return;
410 }
411
412 Variable * image = variable_retrieve( _environment, _image );
413
414 switch( image->type ) {
415 case VT_IMAGE:
416 case VT_IMAGES:
417 case VT_SEQUENCE:
418 case VT_ADDRESS:
419 put_image_vars_original( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, _flags );
420 break;
421 case VT_IMAGEREF:
422 put_image_vars_imageref( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, _flags );
423 break;
424 default:
425 CRITICAL_PUT_IMAGE_UNSUPPORTED( _image, DATATYPE_AS_STRING[image->type] );
426 }
427
428}
429
430void put_image_vars_flags( Environment * _environment, char * _image, char * _x1, char * _y1, char * _x2, char * _y2, char * _frame, char * _sequence, int _flags ) {
431
432 char flagsConstantName[MAX_TEMPORARY_STORAGE]; sprintf( flagsConstantName, "PUTIMAGEFLAGS%4.4x", _flags );
433 char flagsConstantParameter[MAX_TEMPORARY_STORAGE]; sprintf( flagsConstantParameter, "#PUTIMAGEFLAGS%4.4x", _flags );
434
435 Constant * flagsConstant = constant_find( _environment, flagsConstantName );
436
437 if ( !flagsConstant ) {
438 flagsConstant = malloc( sizeof( Constant ) );
439 memset( flagsConstant, 0, sizeof( Constant ) );
440 flagsConstant->name = strdup( flagsConstantName );
441 flagsConstant->realName = strdup( flagsConstantName );
442 flagsConstant->value = _flags;
443 flagsConstant->type = CT_INTEGER;
444 flagsConstant->next = _environment->constants;
445 _environment->constants = flagsConstant;
446 }
447
448 put_image_vars( _environment, _image, _x1, _y1, _x2, _y2, _frame, _sequence, flagsConstantParameter );
449
450}
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
gtia_put_image
void gtia_put_image(Environment *_environment, Resource *_image, char *_x, char *_y, char *_frame, char *_sequence, int _frame_size, int _frame_count, char *_flags)
Definition gtia.c:3364
gtia_calculate_sequence_frame_offset
void gtia_calculate_sequence_frame_offset(Environment *_environment, char *_offset, char *_sequence, char *_frame, int _frame_size, int _frame_count)
Definition gtia.c:3464
_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