ugBASIC 1.18
An isomorphic BASIC language compiler for retrocomputers
Loading...
Searching...
No Matches
sm83.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 "cpu.h"
36
37#include <math.h>
38
39/****************************************************************************
40 * CODE SECTION
41 ****************************************************************************/
42
43#if defined(__gb__)
44
45void cpu_init( Environment * _environment ) {
46
47 // char duffDevice[38] = {
48 // // +00
49 // 0x18, 0x00, 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0,
50 // // +08
51 // 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0,
52 // // +16
53 // 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0,
54 // // +24
55 // 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0, 0xED, 0xA0,
56 // // +32
57 // 0xED, 0xA0, 0xEA, 0x00, 0x00, 0xC9
58 // };
59
60 // variable_import( _environment, "DUFFDEVICEL0", VT_BUFFER, 36 );
61 // variable_global( _environment, "DUFFDEVICEL0" );
62 // variable_import( _environment, "DUFFDEVICEL1", VT_ADDRESS, 0 );
63 // variable_global( _environment, "DUFFDEVICEL1" );
64
65 // variable_retrieve( _environment, "DUFFDEVICEL0" )->readonly = 0;
66
67 // variable_store_buffer( _environment, "DUFFDEVICEL0", duffDevice, sizeof( duffDevice ), 0 );
68
69 // outline0( "LD HL, DUFFDEVICEL0");
70 // outline0( "LD DE, 35");
71 // outline0( "ADD HL, DE");
72 // outline0( "LD DE, DUFFDEVICEL0");
73 // outline0( "INC DE");
74 // outline0( "INC DE");
75 // outline0( "LD (HL), DE");
76
77 variable_import( _environment, "IXR", VT_WORD, 0 );
78 variable_global( _environment, "IXR" );
79 variable_import( _environment, "IYR", VT_WORD, 0 );
80 variable_global( _environment, "IYR" );
81
82 variable_import( _environment, "IXLR", VT_BYTE, 0 );
83 variable_global( _environment, "IXLR" );
84 variable_import( _environment, "IXHR", VT_BYTE, 0 );
85 variable_global( _environment, "IXHR" );
86 variable_import( _environment, "IYLR", VT_BYTE, 0 );
87 variable_global( _environment, "IYLR" );
88 variable_import( _environment, "IYHR", VT_BYTE, 0 );
89 variable_global( _environment, "IYHR" );
90
91 variable_import( _environment, "HLS", VT_WORD, 0 );
92 variable_global( _environment, "HLS" );
93 variable_import( _environment, "FLAGS", VT_BYTE, 0 );
94 variable_global( _environment, "FLAGS" );
95
96 variable_import( _environment, "CALLINDIRECTSAVEHL", VT_ADDRESS, 0 );
97 variable_global( _environment, "CALLINDIRECTSAVEHL" );
98
99 char callIndirect[3] = {
100 // +00
101 0xc3, 0x00, 0x00
102 };
103
104 variable_import( _environment, "CALLINDIRECT", VT_BUFFER, 3 );
105 variable_global( _environment, "CALLINDIRECT" );
106
107 variable_store_buffer( _environment, "CALLINDIRECT", callIndirect, sizeof( callIndirect ), 0 );
108 variable_retrieve( _environment, "CALLINDIRECT" )->readonly = 0;
109
110 variable_import( _environment, "BCP", VT_WORD, 0 );
111 variable_global( _environment, "BCP" );
112 variable_import( _environment, "DEP", VT_WORD, 0 );
113 variable_global( _environment, "DEP" );
114 variable_import( _environment, "HLP", VT_WORD, 0 );
115 variable_global( _environment, "HLP" );
116
117 _environment->stackSize = 0xfffe - 0xff80;
118 _environment->stackStartAddress = 0xfffe;
119
120}
121
122void cpu_nop( Environment * _environment ) {
123
124 outline0("NOP");
125
126}
127
128void cpu_ztoa( Environment * _environment ) {
129
130 inline( cpu_ztoa )
131
132 MAKE_LABEL
133
134 outline1("JR Z, %syes", label );
135 outline0("LD A, 0");
136 outline1("JP %s", label );
137 outhead1("%syes:", label );
138 outline0("LD A, $ff");
139 outhead1("%s:", label );
140
141 no_embedded( cpu_ztoa )
142
143}
144
145void cpu_ctoa( Environment * _environment ) {
146
147 inline( cpu_ctoa )
148
149 MAKE_LABEL
150
151 outline1("JR C, %syes", label );
152 outline0("LD A, 0");
153 outline1("JP %s", label );
154 outhead1("%syes:", label );
155 outline0("LD A, $ff");
156 outhead1("%s:", label );
157
158 no_embedded( cpu_ctoa )
159
160}
161
176void cpu_beq( Environment * _environment, char * _label ) {
177
178 inline( cpu_beq )
179
180 outline1("JP Z, %s", _label);
181
182 no_embedded( cpu_beq )
183
184}
185
192void cpu_bneq( Environment * _environment, char * _label ) {
193
194 inline( cpu_bneq )
195
196 outline1("JP NZ, %s", _label);
197
198 no_embedded( cpu_bneq )
199
200}
201
202void cpu_bveq( Environment * _environment, char * _value, char * _label ) {
203
204 inline( cpu_bveq )
205
206 outline1("LD A, (%s)", _value);
207 outline0("CP 0");
208 cpu_beq( _environment, _label );
209
210 no_embedded( cpu_bneq )
211
212}
213
214void cpu_bvneq( Environment * _environment, char * _value, char * _label ) {
215
216 inline( cpu_bvneq )
217
218 outline1("LD A, (%s)", _value);
219 outline0("CP 0");
220 cpu_bneq( _environment, _label );
221
222 no_embedded( cpu_bvneq )
223
224}
225
226void cpu_label( Environment * _environment, char * _label ) {
227 outhead1("%s:", _label);
228}
229
230void cpu_peek( Environment * _environment, char * _address, char * _target ) {
231
232 inline( cpu_peek )
233
234 outline1("LD HL, (%s)", _address);
235 outline0("LD A, (HL)");
236 outline1("LD (%s), A", _target);
237
238 no_embedded( cpu_peek )
239
240}
241
242void cpu_poke( Environment * _environment, char * _address, char * _source ) {
243
244 inline( cpu_poke )
245
246 outline1("LD A, (%s)", _source);
247 outline1("LD HL, (%s)", _address);
248 outline0("LD (HL), A");
249
250 no_embedded( cpu_poke )
251
252}
253
254void cpu_poke_const( Environment * _environment, char * _address, int _source ) {
255
256 // inline( cpu_poke )
257
258 outline1("LD A, $%2.2x", _source);
259 outline1("LD HL, (%s)", _address);
260 outline0("LD (HL), A");
261
262 // no_embedded( cpu_poke )
263
264}
265
266void cpu_peekw( Environment * _environment, char * _address, char * _target ) {
267
268 inline( cpu_peek )
269
270 outline1("LD HL, (%s)", _address);
271 outline0("LD A, (HL)");
272 outline1("LD (%s), A", _target);
273 outline0("INC HL");
274 outline0("LD A, (HL)");
275 outline1("LD (%s), A", address_displacement( _environment, _target, "1" ) );
276
277 no_embedded( cpu_peek )
278
279}
280
281void cpu_pokew( Environment * _environment, char * _address, char * _source ) {
282
283 inline( cpu_poke )
284
285 outline1("LD A, (%s)", _source);
286 outline1("LD HL, (%s)", _address);
287 outline0("LD (HL), A");
288 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
289 outline0("INC HL");
290 outline0("LD (HL), A");
291
292 no_embedded( cpu_poke )
293
294}
295
296void cpu_pokew_const( Environment * _environment, char * _address, int _source ) {
297
298 // inline( cpu_poke )
299
300 outline1("LD A, (%s)", (unsigned char)(_source&0xff));
301 outline1("LD HL, (%s)", _address);
302 outline0("LD (HL), A");
303 outline1("LD A, (%s)", (unsigned char)((_source>>8)&0xff));
304 outline0("INC HL");
305 outline0("LD (HL), A");
306
307 // no_embedded( cpu_poke )
308
309}
310
311void cpu_peekd( Environment * _environment, char * _address, char * _target ) {
312
313 inline( cpu_peek )
314
315 outline1("LD HL, (%s)", _address);
316 outline0("LD A, (HL)");
317 outline1("LD (%s), A", _target);
318 outline0("INC HL");
319 outline0("LD A, (HL)");
320 outline1("LD (%s), A", address_displacement( _environment, _target, "1" ) );
321 outline0("INC HL");
322 outline0("LD A, (HL)");
323 outline1("LD (%s), A", address_displacement( _environment, _target, "2" ) );
324 outline0("INC HL");
325 outline0("LD A, (HL)");
326 outline1("LD (%s), A", address_displacement( _environment, _target, "3" ) );
327
328 no_embedded( cpu_peek )
329
330}
331
332void cpu_poked( Environment * _environment, char * _address, char * _source ) {
333
334 inline( cpu_poke )
335
336 outline1("LD A, (%s)", _source);
337 outline1("LD HL, (%s)", _address);
338 outline0("LD (HL), A");
339 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
340 outline0("INC HL");
341 outline0("LD (HL), A");
342 outline1("LD A, (%s)", address_displacement( _environment, _source, "2" ) );
343 outline0("INC HL");
344 outline0("LD (HL), A");
345 outline1("LD A, (%s)", address_displacement( _environment, _source, "3" ) );
346 outline0("INC HL");
347 outline0("LD (HL), A");
348
349 no_embedded( cpu_poke )
350
351}
352
353void cpu_poked_const( Environment * _environment, char * _address, int _source ) {
354
355 // inline( cpu_poke )
356
357 outline1("LD A, (%s)", (unsigned char)((_source)&0xff));
358 outline1("LD HL, (%s)", _address);
359 outline0("LD (HL), A");
360 outline1("LD A, (%s)", (unsigned char)((_source>>8)&0xff));
361 outline0("INC HL");
362 outline0("LD (HL), A");
363 outline1("LD A, (%s)", (unsigned char)((_source>>16)&0xff));
364 outline0("INC HL");
365 outline0("LD (HL), A");
366 outline1("LD A, (%s)", (unsigned char)((_source>>24)&0xff));
367 outline0("INC HL");
368 outline0("LD (HL), A");
369
370 // no_embedded( cpu_poke )
371
372}
373
387void cpu_fill_blocks( Environment * _environment, char * _address, char * _blocks, char * _pattern ) {
388
389 inline( cpu_fill_blocks )
390
391 MAKE_LABEL
392
393 outline1("LD A, (%s)", _pattern);
394 outline1("LD HL, (%s)", _address);
395 outline0("LD (HL),A")
396 outline0("LD E,L");
397 outline0("LD D,H");
398 outline0("INC DE");
399 outline0("LD (DE),A")
400 outline0("LD C,0");
401 outline1("LD A, (%s)", _blocks);
402 outline0("CP 0");
403 outline1("JR Z, %sdone", label);
404 outline0("DEC A");
405 outline0("LD B,A");
406 outline0("CALL REPLACEMENT_LDIR");
407
408 outline1("LD A, (%s)", _pattern);
409 outline0("LD (HL),A")
410 outline0("LD E,L");
411 outline0("LD D,H");
412 outline0("INC DE");
413 outline0("LD (DE),A")
414 outline0("LD C,255");
415 outline0("LD A,0");
416 outline0("LD B,A");
417 outline0("CALL REPLACEMENT_LDIR");
418 outhead1("%sdone:", label);
419
420 embedded( cpu_fill_blocks, src_hw_sm83_cpu_fill_blocks_asm );
421
422 outline1("LD A, (%s)", _blocks);
423 outline0("LD B, A");
424 outline1("LD A, (%s)", _pattern);
425 outline1("LD HL, (%s)", _address);
426 outline0("CALL CPUFILLBLOCKS");
427
428 done( )
429
430}
431
445void cpu_fill( Environment * _environment, char * _address, char * _bytes, int _bytes_width, char * _pattern ) {
446
447 MAKE_LABEL
448
449 no_inline( cpu_fill )
450
451 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
452
453 if ( _bytes_width == 8 ) {
454 outline1("LD A, (%s)", _bytes);
455 outline0("LD C, A");
456 } else {
457 outline1("LD A, (%s)", _bytes);
458 outline0("LD C, A");
459 outline1("LD A, (%s+1)", _bytes);
460 outline0("LD B, A");
461 }
462
463 if ( _pattern ) {
464 outline1("LD A, (%s)", _pattern);
465 } else {
466 outline0("LD A, 0");
467 }
468
469 outline1("LD HL, (%s)", _address);
470
471 if ( _bytes_width == 8 ) {
472 outline0("CALL CPUFILL8");
473 } else {
474 outline0("CALL CPUFILL16");
475 }
476
477 done( )
478}
479
493void cpu_fill_size( Environment * _environment, char * _address, int _bytes, char * _pattern ) {
494
495 MAKE_LABEL
496
497 no_inline( cpu_fill )
498
499 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
500
501 outline1("LD A, $%2.2x", (unsigned char) ( _bytes & 0xff ) );
502 outline0("LD C, A");
503
504 if ( _bytes < 256 ) {
505
506 } else {
507 outline1("LD A, $%2.2x", (unsigned char) ( ( _bytes >> 8 ) & 0xff ) );
508 outline0("LD B, A");
509 }
510
511 if ( _pattern ) {
512 outline1("LD A, (%s)", _pattern);
513 } else {
514 outline0("LD A, 0");
515 }
516
517 outline1("LD HL, (%s)", _address);
518 if ( _bytes < 256 ) {
519 outline0("CALL CPUFILL8");
520 } else {
521 outline0("CALL CPUFILL16");
522 }
523
524 done( )
525
526}
527
541void cpu_fill_size_value( Environment * _environment, char * _address, int _bytes, int _pattern ) {
542
543 MAKE_LABEL
544
545 no_inline( cpu_fill )
546
547 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
548
549 outline1("LD A, $%2.2x", (unsigned char) ( _bytes & 0xff ) );
550 outline0("LD C, A");
551
552 if ( _bytes < 256 ) {
553
554 } else {
555 outline1("LD A, $%2.2x", (unsigned char) ( ( _bytes >> 8 ) & 0xff ) );
556 outline0("LD B, A");
557 }
558
559 outline1("LD A, $%2.2x", _pattern);
560 outline1("LD HL, (%s)", _address);
561 if ( _bytes < 256 ) {
562 outline0("CALL CPUFILL8");
563 } else {
564 outline0("CALL CPUFILL16");
565 }
566
567 done( )
568
569}
570
584void cpu_fill_direct( Environment * _environment, char * _address, char * _bytes, char * _pattern ) {
585
586 MAKE_LABEL
587
588 no_inline( cpu_fill )
589
590 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
591
592 outline1("LD A, (%s)", _bytes);
593 outline0("LD C, A");
594 outline1("LD A, (%s+1)", _bytes);
595 outline0("LD B, A");
596 if ( _pattern ) {
597 outline1("LD A, (%s)", _pattern);
598 } else {
599 outline0("LD A, 0");
600 }
601 outline1("LD HL, %s", _address);
602 outline0("CALL CPUFILL16");
603
604 done( )
605
606}
607
621void cpu_fill_direct_size( Environment * _environment, char * _address, int _bytes, char * _pattern ) {
622
623 MAKE_LABEL
624
625 no_inline( cpu_fill )
626
627 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
628
629 outline1("LD A, $%2.2x", (unsigned char) ( _bytes & 0xff ) );
630 outline0("LD C, A");
631
632 if ( _bytes < 256 ) {
633
634 } else {
635 outline1("LD A, $%2.2x", (unsigned char) ( ( _bytes >> 8 ) & 0xff ) );
636 outline0("LD B, A");
637 }
638
639 if ( _pattern ) {
640 outline1("LD A, (%s)", _pattern);
641 } else {
642 outline0("LD A, 0");
643 }
644
645 outline1("LD HL, %s", _address);
646 if ( _bytes < 256 ) {
647 outline0("CALL CPUFILL8");
648 } else {
649 outline0("CALL CPUFILL16");
650 }
651
652 done( )
653
654}
655
669void cpu_fill_direct_size_value( Environment * _environment, char * _address, int _bytes, int _pattern ) {
670
671 MAKE_LABEL
672
673 no_inline( cpu_fill )
674
675 embedded( cpu_fill, src_hw_sm83_cpu_fill_asm );
676
677 outline1("LD A, $%2.2x", (unsigned char) ( _bytes & 0xff ) );
678 outline0("LD C, A");
679
680 if ( _bytes < 256 ) {
681
682 } else {
683 outline1("LD A, $%2.2x", (unsigned char) ( ( _bytes >> 8 ) & 0xff ) );
684 outline0("LD B, A");
685 }
686
687 outline1("LD A, $%2.2x", _pattern);
688 outline1("LD HL, %s", _address);
689 if ( _bytes < 256 ) {
690 outline0("CALL CPUFILL8");
691 } else {
692 outline0("CALL CPUFILL16");
693 }
694
695 done( )
696
697}
698
699/*****************************************************************************
700 * 8 BIT MANIPULATION
701 ****************************************************************************/
702
710void cpu_move_8bit( Environment * _environment, char *_source, char *_destination ) {
711
712 inline( cpu_move_8bit )
713
714 outline1("LD A, (%s)", _source);
715 outline1("LD (%s), A", _destination);
716
717 no_embedded( cpu_move_8bit )
718
719}
720
728void cpu_store_8bit( Environment * _environment, char *_destination, int _value ) {
729
730 inline( cpu_store_8bit )
731
732 outline1("LD A, $%2.2x", ( _value & 0xff ) );
733 outline1("LD (%s), A", _destination);
734
735 no_embedded( cpu_store_8bit )
736
737}
738
746void cpu_store_char( Environment * _environment, char *_destination, int _value ) {
747
748 inline( cpu_store_char )
749
750 outline1("LD A, '%c'", ( _value & 0xff ) );
751 outline1("LD (%s), A", _destination);
752
753 no_embedded( cpu_store_char )
754
755}
756
757void cpu_store_8bit_with_offset( Environment * _environment, char *_destination, int _value, int _offset ) {
758
759 inline( cpu_store_8bit_with_offset )
760
761 outline1("LD DE, %s", _destination);
762 outline1("ADD DE, $%2.2x", ( _offset & 0xff ) );
763 outline1("LD A, $%2.2x", ( _value & 0xff ) );
764 outline0("LD (DE), A");
765
766 no_embedded( cpu_store_8bit_with_offset )
767
768}
769
770void cpu_store_8bit_with_offset2( Environment * _environment, char *_destination, char * _offset, int _value ) {
771
772 inline( cpu_store_8bit_with_offset2 )
773
774 outline1("LD HL, %s", _destination);
775 outline1("LD A, (%s)", _offset);
776 outline0("LD E, A");
777 outline0("LD D, 0");
778 outline0("ADD HL, DE" );
779 outline1("LD A, $%2.2x", ( _value & 0xff ) );
780 outline0("LD (HL), A");
781
782 no_embedded( cpu_store_8bit_with_offset2 )
783
784}
785
795void cpu_compare_8bit( Environment * _environment, char *_source, char *_destination, char *_other, int _positive ) {
796
797 MAKE_LABEL
798
799 inline( cpu_compare_8bit )
800
801 outline1("LD HL, %s", _destination);
802 outline1("LD A, (%s)", _source);
803 outline0("CP (HL)");
804 outline1("JP NZ, %s", label);
805 outline1("LD A, $%2.2x", 0xff*_positive);
806 if ( _other ) {
807 outline1("LD (%s), A", _other);
808 } else {
809 outline0("LD (HL), A");
810 }
811 outline1("JMP %sb2", label);
812 outhead1("%s:", label);
813 outline1("LD A, $%2.2x", 0xff*(1-_positive));
814 if ( _other ) {
815 outline1("LD (%s), A", _other);
816 } else {
817 outline0("LD (HL), A");
818 }
819 outhead1("%sb2:", label);
820
821 no_embedded( cpu_compare_8bit )
822
823}
824
834void cpu_compare_8bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _positive ) {
835
836 MAKE_LABEL
837
838 inline( cpu_compare_8bit )
839
840 outline1("LD A, (%s)", _source);
841 outline1("CP $%2.2x", _destination);
842 outline1("JP NZ, %s", label);
843 outline1("LD A, $%2.2x", 0xff*_positive);
844 outline1("LD (%s), A", _other);
845 outline1("JMP %sb2", label);
846 outhead1("%s:", label);
847 outline1("LD A, $%2.2x", 0xff*(1-_positive));
848 outline1("LD (%s), A", _other);
849 outhead1("%sb2:", label);
850
851 no_embedded( cpu_compare_8bit )
852
853}
854
855void cpu_compare_and_branch_8bit( Environment * _environment, char *_source, char * _destination, char *_label, int _positive ) {
856
857 inline( cpu_compare_and_branch_8bit )
858
859 MAKE_LABEL
860
861 outline1("LD A, (%s)", _destination);
862 outline0("LD B, A");
863 outline1("LD A, (%s)", _source);
864 outline1("CP B", _destination );
865 if ( _positive ) {
866 outline1("JP Z, %s", _label);
867 } else {
868 outline1("JP NZ, %s", _label);
869 }
870
871 no_embedded( cpu_compare_and_branch_8bit )
872
873}
874
884void cpu_compare_and_branch_8bit_const( Environment * _environment, char *_source, int _destination, char *_label, int _positive ) {
885
886 inline( cpu_compare_and_branch_8bit_const )
887
888 MAKE_LABEL
889
890 outline1("LD A, (%s)", _source);
891 outline1("CP $%2.2x", _destination );
892 if ( _positive ) {
893 outline1("JP Z, %s", _label);
894 } else {
895 outline1("JP NZ, %s", _label);
896 }
897
898 no_embedded( cpu_compare_and_branch_8bit_const )
899
900}
901
911void cpu_prepare_for_compare_and_branch_8bit( Environment * _environment, char *_source ) {
912
913 inline( cpu_compare_and_branch_8bit_const )
914
915 outline1("LD A, (%s)", _source);
916
917 no_embedded( cpu_compare_and_branch_8bit_const )
918
919}
920
930void cpu_execute_compare_and_branch_8bit_const( Environment * _environment, int _destination, char *_label, int _positive ) {
931
932 inline( cpu_compare_and_branch_8bit_const )
933
934 MAKE_LABEL
935
936 outline1("CP $%2.2x", _destination );
937 if ( _positive ) {
938 outline1("JP Z, %s", _label);
939 } else {
940 outline1("JP NZ, %s", _label);
941 }
942
943 no_embedded( cpu_compare_and_branch_8bit_const )
944
945}
946
956void cpu_compare_and_branch_char_const( Environment * _environment, char *_source, int _destination, char *_label, int _positive ) {
957
958 inline( cpu_compare_and_branch_8bit_const )
959
960 MAKE_LABEL
961
962 outline1("LD A, (%s)", _source);
963 outline1("CP '%c'", _destination );
964 if ( _positive ) {
965 outline1("JP Z, %s", _label);
966 } else {
967 outline1("JP NZ, %s", _label);
968 }
969
970 no_embedded( cpu_compare_and_branch_8bit_const )
971
972}
973
983void cpu_less_than_8bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
984
985 MAKE_LABEL
986
987 inline( cpu_less_than_8bit )
988
989 if ( _signed ) {
990
991 outline1("LD A, (%s)", _destination);
992 outline0("LD B, A");
993 outline1("LD A, (%s)", _source);
994 outline0("SUB A, B");
995 if ( _equal ) {
996 outline1("JP Z,%strue", label);
997 }
998 outline1("JP PO,%snoxor", label);
999 outline0("XOR $80");
1000 outhead1("%snoxor:", label);
1001 outline1("JP M,%strue", label);
1002 outline1("JP PE,%sfalse", label);
1003 outhead1("%sfalse:", label);
1004 outline0("LD A, 0");
1005 if ( _other ) {
1006 outline1("LD (%s), A", _other);
1007 } else {
1008 outline1("LD (%s), A", _destination);
1009 }
1010 outline1("JMP %sb2", label);
1011 outhead1("%strue:", label);
1012 outline0("LD A, $ff");
1013 if ( _other ) {
1014 outline1("LD (%s), A", _other);
1015 } else {
1016 outline1("LD (%s), A", _destination);
1017 }
1018 outhead1("%sb2:", label);
1019
1020 } else {
1021
1022 outline1("LD A, (%s)", _destination);
1023 outline0("LD B, A");
1024 outline1("LD A, (%s)", _source);
1025 outline0("CP B");
1026 outline1("JR C, %s", label);
1027 if ( _equal ) {
1028 outline1("JR Z, %s", label);
1029 }
1030 outline0("LD A, 0");
1031 if ( _other ) {
1032 outline1("LD (%s), A", _other);
1033 } else {
1034 outline1("LD (%s), A", _destination);
1035 }
1036 outline1("JMP %sb2", label);
1037 outhead1("%s:", label);
1038 outline0("LD A, $ff");
1039 if ( _other ) {
1040 outline1("LD (%s), A", _other);
1041 } else {
1042 outline1("LD (%s), A", _destination);
1043 }
1044 outhead1("%sb2:", label);
1045
1046 }
1047
1048 embedded( cpu_less_than_8bit, src_hw_sm83_cpu_less_than_8bit_asm );
1049
1050 if ( _signed ) {
1051
1052 outline1("LD A, (%s)", _destination);
1053 outline0("LD H, A");
1054 outline1("LD A, (%s)", _source);
1055 outline0("LD D, A");
1056 if ( _equal ) {
1057 outline0("CALL CPULTE8S");
1058 } else {
1059 outline0("CALL CPULT8S");
1060 }
1061 if ( _other ) {
1062 outline1("LD (%s), A", _other);
1063 } else {
1064 outline1("LD (%s), A", _destination);
1065 }
1066
1067 } else {
1068
1069 outline1("LD A, (%s)", _destination);
1070 outline0("LD B, A");
1071 outline1("LD A, (%s)", _source);
1072 if ( _equal ) {
1073 outline0("CALL CPULTE8U");
1074 } else {
1075 outline0("CALL CPULT8U");
1076 }
1077 if ( _other ) {
1078 outline1("LD (%s), A", _other);
1079 } else {
1080 outline1("LD (%s), A", _destination);
1081 }
1082
1083 }
1084
1085 done( )
1086
1087}
1088
1089void cpu_less_than_8bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
1090
1091 MAKE_LABEL
1092
1093 inline( cpu_less_than_8bit )
1094
1095 if ( _signed ) {
1096
1097 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
1098 outline0("LD B, A");
1099 outline1("LD A, (%s)", _source);
1100 outline0("SUB A, B");
1101 if ( _equal ) {
1102 outline1("JP Z,%strue", label);
1103 }
1104 outline1("JP PO,%snoxor", label);
1105 outline0("XOR $80");
1106 outhead1("%snoxor:", label);
1107 outline1("JP M,%strue", label);
1108 outline1("JP PE,%sfalse", label);
1109 outhead1("%sfalse:", label);
1110 outline0("LD A, 0");
1111 outline1("LD (%s), A", _other);
1112 outline1("JMP %sb2", label);
1113 outhead1("%strue:", label);
1114 outline0("LD A, $ff");
1115 outline1("LD (%s), A", _other);
1116 outhead1("%sb2:", label);
1117
1118 } else {
1119
1120 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
1121 outline0("LD B, A");
1122 outline1("LD A, (%s)", _source);
1123 outline0("CP B");
1124 outline1("JR C, %s", label);
1125 if ( _equal ) {
1126 outline1("JR Z, %s", label);
1127 }
1128 outline0("LD A, 0");
1129 outline1("LD (%s), A", _other);
1130 outline1("JMP %sb2", label);
1131 outhead1("%s:", label);
1132 outline0("LD A, $ff");
1133 outline1("LD (%s), A", _other);
1134 outhead1("%sb2:", label);
1135
1136 }
1137
1138 embedded( cpu_less_than_8bit, src_hw_sm83_cpu_less_than_8bit_asm );
1139
1140 if ( _signed ) {
1141
1142 outline1("LD A, $%2.2x", _destination);
1143 outline0("LD H, A");
1144 outline1("LD A, (%s)", _source);
1145 outline0("LD D, A");
1146 if ( _equal ) {
1147 outline0("CALL CPULTE8S");
1148 } else {
1149 outline0("CALL CPULT8S");
1150 }
1151 outline1("LD (%s), A", _other);
1152
1153 } else {
1154
1155 outline1("LD A, $%2.2x", _destination);
1156 outline0("LD B, A");
1157 outline1("LD A, (%s)", _source);
1158 if ( _equal ) {
1159 outline0("CALL CPULTE8U");
1160 } else {
1161 outline0("CALL CPULT8U");
1162 }
1163 outline1("LD (%s), A", _other);
1164
1165 }
1166
1167 done( )
1168
1169}
1170
1171void cpu_less_than_and_branch_8bit_const( Environment * _environment, char *_source, int _destination, char *_label, int _equal, int _signed ) {
1172
1173 MAKE_LABEL
1174
1175 inline( cpu_less_than_8bit )
1176
1177 if ( _signed ) {
1178
1179 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
1180 outline0("LD B, A");
1181 outline1("LD A, (%s)", _source);
1182 outline0("SUB A, B");
1183 if ( _equal ) {
1184 outline1("JP Z,%strue", label);
1185 }
1186 outline1("JP PO,%snoxor", label);
1187 outline0("XOR $80");
1188 outhead1("%snoxor:", label);
1189 outline1("JP M,%strue", label);
1190 outline1("JP PE,%sfalse", label);
1191 outhead1("%sfalse:", label);
1192 outline1("JP %sb2", label);
1193 outhead1("%strue:", label);
1194 outline1("JP %s", _label);
1195 outhead1("%sb2:", label);
1196
1197 } else {
1198
1199 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
1200 outline0("LD B, A");
1201 outline1("LD A, (%s)", _source);
1202 outline0("CP B");
1203 outline1("JR C, %s", label);
1204 if ( _equal ) {
1205 outline1("JR Z, %s", label);
1206 }
1207 outline1("JP %sb2", label);
1208 outhead1("%s:", label);
1209 outline1("JP %s", _label);
1210 outhead1("%sb2:", label);
1211
1212 }
1213
1214 embedded( cpu_less_than_8bit, src_hw_sm83_cpu_less_than_8bit_asm );
1215
1216 if ( _signed ) {
1217
1218 outline1("LD A, $%2.2x", _destination);
1219 outline0("LD B, A");
1220 outline1("LD A, (%s)", _source);
1221 if ( _equal ) {
1222 outline0("CALL CPULTE8S");
1223 } else {
1224 outline0("CALL CPULT8S");
1225 }
1226 outline0("CP 0");
1227 outline1("JR Z, %sno", label);
1228 outline1("JP %s", _label);
1229 outhead1("%sno:", label);
1230
1231 } else {
1232
1233 outline1("LD A, $%2.2x", _destination);
1234 outline0("LD B, A");
1235 outline1("LD A, (%s)", _source);
1236 if ( _equal ) {
1237 outline0("CALL CPULTE8U");
1238 } else {
1239 outline0("CALL CPULT8U");
1240 }
1241 outline0("CP 0");
1242 outline1("JR Z, %sno", label);
1243 outline1("JP %s", _label);
1244 outhead1("%sno:", label);
1245
1246 }
1247
1248 done( )
1249
1250}
1251
1261void cpu_greater_than_8bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
1262
1263 cpu_less_than_8bit( _environment, _source, _destination, _other, !_equal, _signed );
1264 if ( _other ) {
1265 cpu_not_8bit( _environment, _other, _other );
1266 } else {
1267 cpu_not_8bit( _environment, _destination, _destination );
1268 }
1269
1270}
1271
1272void cpu_greater_than_8bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
1273
1274 cpu_less_than_8bit_const( _environment, _source, _destination, _other, !_equal, _signed );
1275 cpu_not_8bit( _environment, _other, _other );
1276
1277}
1278
1287void cpu_math_add_8bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
1288
1289 inline( cpu_math_add_8bit )
1290
1291 outline0("LD B, 0" );
1292 outline1("LD A, (%s)", _source );
1293 outline0("LD B, A" );
1294 outline1("LD A, (%s)", _destination );
1295 outline0("ADD A, B" );
1296 if ( _other ) {
1297 outline1("LD (%s), A", _other );
1298 } else {
1299 outline1("LD (%s), A", _destination );
1300 }
1301
1302 no_embedded( cpu_math_add_8bit )
1303
1304}
1305
1306void cpu_math_add_8bit_const( Environment * _environment, char *_source, int _destination, char *_other ) {
1307
1308 inline( cpu_math_add_8bit )
1309
1310 outline0("LD B, 0" );
1311 outline1("LD A, (%s)", _source );
1312 outline0("ADD A, B" );
1313 outline0("LD B, A" );
1314 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
1315 outline0("ADD A, B" );
1316 outline1("LD (%s), A", _other );
1317
1318 no_embedded( cpu_math_add_8bit )
1319
1320}
1321
1330void cpu_math_sub_8bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
1331
1332 inline( cpu_math_sub_8bit )
1333
1334 outline0("LD B, 0" );
1335 outline1("LD A, (%s)", _destination );
1336 outline0("SUB A, B" );
1337 outline0("LD B, A" );
1338 outline1("LD A, (%s)", _source );
1339 outline0("SUB A,B" );
1340 if ( _other ) {
1341 outline1("LD (%s), A", _other );
1342 } else {
1343 outline1("LD (%s), A", _destination );
1344 }
1345
1346 no_embedded( cpu_math_add_8bit )
1347
1348}
1349
1357void cpu_math_double_8bit( Environment * _environment, char *_source, char *_other, int _signed ) {
1358
1359 inline( cpu_math_double_8bit )
1360
1361 if ( _signed ) {
1362
1363 outline1("LD A, (%s)", _source );
1364 outline0("ADD A, A" );
1365 if ( _other ) {
1366 outline1("LD (%s), A", _other );
1367 } else {
1368 outline1("LD (%s), A", _source );
1369 }
1370
1371 } else {
1372 outline1("LD A, (%s)", _source );
1373 outline0("ADD A, A" );
1374 if ( _other ) {
1375 outline1("LD (%s), A", _other );
1376 } else {
1377 outline1("LD (%s), A", _source );
1378 }
1379 }
1380
1381 no_embedded( cpu_math_double_8bit )
1382
1383}
1384
1393
1394void cpu_math_mul_8bit_to_16bit( Environment * _environment, char *_source, char *_destination, char *_other, int _signed ) {
1395
1396 MAKE_LABEL
1397
1398 inline( cpu_math_mul_8bit_to_16bit )
1399
1400 if ( _signed ) {
1401
1402 outline1("LD A, (%s)", _source );
1403 outline0("LD B, A" );
1404 outline1("LD A, (%s)", _destination );
1405 outline0("XOR A, B" );
1406 outline0("AND $80" );
1407 outline0("LD B, A" );
1408 outline0("PUSH B" );
1409
1410 outline1("LD A, (%s)", _source );
1411 outline0("AND $80" );
1412 outline0("CP 0" );
1413 outline1("JR Z, %spositive", label );
1414 outline1("LD A, (%s)", _source );
1415 outline0("XOR $FF" );
1416 outline0("INC A" );
1417 outline1("JMP %sdone1", label );
1418
1419 outhead1("%spositive:", label );
1420 outline1("LD A, (%s)", _source );
1421
1422 outhead1("%sdone1:", label );
1423 outline0("LD H, A" );
1424
1425 outline1("LD A, (%s)", _destination );
1426 outline0("AND $80" );
1427 outline0("CP 0" );
1428 outline1("JR Z, %spositive2", label );
1429 outline1("LD A, (%s)", _destination );
1430 outline0("XOR $FF" );
1431 outline0("INC A" );
1432 outline1("JMP %sdone2", label );
1433 outhead1("%spositive2:", label );
1434 outline1("LD A, (%s)", _destination );
1435
1436 outhead1("%sdone2:", label );
1437 outline0("LD C, A" );
1438
1439 outline0("LD E, A" );
1440
1441 outline0("LD D,0");
1442 outline0("LD L,D");
1443 outline0("LD B,8");
1444
1445 outhead1("%s:", label );
1446 outline0("ADD HL, HL" );
1447 outline1("JR NC,%sb2", label );
1448 outline0("ADD HL, DE" );
1449
1450 outhead1("%sb2:", label );
1451
1452 outline1("DJNZ %s", label );
1453
1454 outline1("LD (%s), HL", _other );
1455 outline0("POP B" );
1456 outline0("LD A, B" );
1457 outline0("AND $80" );
1458 outline0("CP 0" );
1459 outline1("JR Z,%snc", label );
1460 cpu_complement2_16bit( _environment, _other, NULL );
1461 outhead1("%snc:", label );
1462
1463 } else {
1464
1465 outline1("LD A, (%s)", _source );
1466 outline0("LD H, A" );
1467 outline1("LD A, (%s)", _destination );
1468 outline0("LD E, A" );
1469
1470 outline0("LD D,0");
1471 outline0("LD L,D");
1472 outline0("LD B,8");
1473
1474 outhead1("%s:", label );
1475 outline0("ADD HL, HL" );
1476 outline1("JR NC,%sb2", label );
1477 outline0("ADD HL, DE" );
1478
1479 outhead1("%sb2:", label );
1480
1481 outline1("DJNZ %s", label );
1482 outline1("LD (%s), HL", _other );
1483
1484 }
1485
1486 embedded( cpu_math_mul_8bit_to_16bit, src_hw_sm83_cpu_math_mul_8bit_to_16bit_asm );
1487
1488 if ( _signed ) {
1489
1490 outline1("LD A, (%s)", _destination);
1491 outline0("LD (IYLR), A");
1492 outline1("LD A, (%s)", _source);
1493 outline0("LD (IXLR), A");
1494 outline0("CALL CPUMUL8B8T16S");
1495 outline1("LD (%s), HL", _other);
1496
1497 } else {
1498
1499 outline1("LD A, (%s)", _destination);
1500 outline0("LD (IYLR), A");
1501 outline1("LD A, (%s)", _source);
1502 outline0("LD (IXLR), A");
1503 outline0("CALL CPUMUL8B8T16U");
1504 outline1("LD (%s), HL", _other);
1505
1506 }
1507
1508 done( )
1509
1510}
1511
1519void cpu_math_div2_const_8bit( Environment * _environment, char *_source, int _steps, int _signed, char * _remainder ) {
1520
1521 inline( cpu_math_div2_const_8bit )
1522
1523 MAKE_LABEL
1524
1525 if ( _remainder ) {
1526 outline1("LD A, (%s)", _source );
1527 outline0("AND $1" );
1528 outline1("LD (%s), A", _remainder );
1529 }
1530 if ( _signed ) {
1531 outline1("LD A, (%s)", _source );
1532 outline0("AND $80" );
1533 outline0("PUSH AF" );
1534 outline0("CP 0" );
1535 outline1("JR Z, %spos", label );
1536 cpu_complement2_16bit( _environment, _source, _source );
1537 outline1("JMP %spos2", label );
1538 outhead1("%spos:", label );
1539 outhead1("%spos2:", label );
1540 outline1("LD A, (%s)", _source );
1541 while( _steps ) {
1542 outline0("SRA A" );
1543 --_steps;
1544 }
1545 outline1("LD (%s), A", _source );
1546 outline0("POP AF" );
1547 outline0("AND $80" );
1548 outline0("CP 0" );
1549 outline1("JR Z, %sdone", label );
1550 cpu_complement2_16bit( _environment, _source, _source );
1551 outhead1("%sdone:", label );
1552 } else {
1553 outline1("LD A, (%s)", _source );
1554 while( _steps ) {
1555 outline0("SRA A" );
1556 --_steps;
1557 }
1558 outline1("LD (%s), A", _source );
1559 }
1560
1561 embedded( cpu_math_div2_const_8bit, src_hw_sm83_cpu_math_div2_const_8bit_asm );
1562
1563 if ( _remainder ) {
1564 outline1("LD A, (%s)", _source );
1565 outline0("AND $1" );
1566 outline1("LD (%s), A", _remainder );
1567 }
1568 outline1("LD A, (%s)", _source);
1569 outline0("LD B, A");
1570 outline1("LD A, $%2.2x", _steps);
1571 outline0("LD C, A");
1572 if ( _signed ) {
1573 outline0("CALL CPUDIV2CONST8S");
1574 } else {
1575 outline0("CALL CPUDIV2CONST8U");
1576 }
1577 outline0("LD A, B");
1578 outline1("LD (%s), A", _source);
1579
1580 done( )
1581
1582}
1583
1591void cpu_math_mul2_const_8bit( Environment * _environment, char *_source, int _steps, int _signed ) {
1592
1593 inline( cpu_math_mul2_const_8bit )
1594
1595 if ( _signed ) {
1596 outline1("LD A, (%s)", _source );
1597 outline0("AND $80" );
1598 outline0("PUSH AF" );
1599 outline1("LD A, (%s)", _source );
1600 outline0("AND $7F" );
1601 while( _steps ) {
1602 outline0("SLA A" );
1603 --_steps;
1604 }
1605 outline0("LD B, A" );
1606 outline0("POP AF" );
1607 outline0("OR A, B" );
1608 outline1("LD (%s), A", _source );
1609
1610 } else {
1611 outline1("LD A, (%s)", _source );
1612 while( _steps ) {
1613 outline0("SLA A" );
1614 --_steps;
1615 }
1616 outline1("LD (%s), A", _source );
1617 }
1618
1619 embedded( cpu_math_mul2_const_8bit, src_hw_sm83_cpu_math_mul2_const_8bit_asm );
1620
1621 outline1("LD A, (%s)", _source);
1622 outline0("LD B, A");
1623 outline1("LD A, $%2.2x", _steps);
1624 outline0("LD C, A");
1625 if ( _signed ) {
1626 outline0("CALL CPUMUL2CONST8S");
1627 } else {
1628 outline0("CALL CPUMUL2CONST8U");
1629 }
1630 outline0("LD A, B");
1631 outline1("LD (%s), A", _source);
1632
1633 done( )
1634
1635}
1636
1644void cpu_math_complement_const_8bit( Environment * _environment, char *_source, int _value ) {
1645
1646 inline( cpu_math_complement_const_8bit )
1647
1648 outline1("LD A, (%s)", _source );
1649 outline0("LD B, A" );
1650 outline1("LD A, $%2.2x", ( _value & 0xff ) );
1651 outline0("SUB A, B" );
1652 outline1("LD (%s), A", _source );
1653
1654 no_embedded( cpu_math_complement_const_8bit )
1655
1656}
1657
1665void cpu_math_and_const_8bit( Environment * _environment, char *_source, int _mask ) {
1666
1667 inline( cpu_math_and_const_8bit )
1668
1669 outline1("LD A, (%s)", _source );
1670 outline1("AND $%2.2x", _mask );
1671 outline1("LD (%s), A", _source );
1672
1673 no_embedded( cpu_math_and_const_8bit )
1674
1675}
1676
1677/*****************************************************************************
1678 * 16 BIT MANIPULATION
1679 ****************************************************************************/
1680
1688void cpu_move_16bit( Environment * _environment, char *_source, char *_destination ) {
1689
1690 inline( cpu_move_16bit )
1691
1692 outline1("LD HL, (%s)", _source );
1693 outline1("LD (%s), HL", _destination );
1694
1695 no_embedded( cpu_move_16bit )
1696
1697}
1698
1699void cpu_addressof_16bit( Environment * _environment, char *_source, char *_destination ) {
1700
1701 inline( cpu_addressof_16bit )
1702
1703 outline1("LD HL, %s", _source );
1704 outline1("LD (%s), HL", _destination );
1705
1706 no_embedded( cpu_addressof_16bit )
1707
1708}
1709
1717void cpu_store_16bit( Environment * _environment, char *_destination, int _value ) {
1718
1719 inline( cpu_store_16bit )
1720
1721 outline1("LD HL, $%4.4x", _value & 0xffff );
1722 outline1("LD (%s), HL", _destination );
1723
1724 no_embedded( cpu_store_16bit )
1725
1726}
1727
1736void cpu_compare_16bit( Environment * _environment, char *_source, char *_destination, char *_other, int _positive ) {
1737
1738 MAKE_LABEL
1739
1740 inline( cpu_compare_16bit )
1741
1742 outline1("LD A, (%s)", _source);
1743 outline0("LD B, A");
1744 outline1("LD A, (%s)", _destination);
1745 outline0("CP B");
1746 outline1("JP NZ, %s", label);
1747 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
1748 outline0("LD B, A");
1749 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
1750 outline0("CP B");
1751 outline1("JP NZ, %s", label);
1752 outline1("LD A, $%2.2x", 0xff*_positive);
1753 if ( _other ) {
1754 outline1("LD (%s), A", _other);
1755 } else {
1756 outline1("LD (%s), A", _destination);
1757 }
1758 outline1("JMP %sb2", label);
1759 outhead1("%s:", label);
1760 outline1("LD A, $%2.2x", 0xff*(1-_positive));
1761 if ( _other ) {
1762 outline1("LD (%s), A", _other);
1763 } else {
1764 outline1("LD (%s), A", _destination);
1765 }
1766 outhead1("%sb2:", label);
1767
1768 embedded( cpu_compare_16bit, src_hw_sm83_cpu_compare_16bit_asm )
1769
1770 outline1("LD HL, %s", _source);
1771 outline1("LD DE, %s", _destination);
1772 outline1("LD A, $%2.2x", ( 0xff*(1-_positive)) );
1773 outline0("LD (IXLR), A" );
1774 outline1("LD A, $%2.2x", ( (0xff*_positive) ) );
1775 outline0("LD (IXHR), A" );
1776 outline0("CALL CPUCOMPARE16");
1777 if ( _other ) {
1778 outline1("LD (%s), A", _other);
1779 } else {
1780 outline1("LD (%s), A", _destination);
1781 }
1782
1783 done( )
1784
1785}
1786
1795void cpu_compare_16bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _positive ) {
1796
1797 MAKE_LABEL
1798
1799 inline( cpu_compare_16bit )
1800
1801 outline1("LD A, (%s)", _source);
1802 outline0("LD B, A");
1803 outline1("LD A, $%2.2x", (unsigned char)(_destination&0xff));
1804 outline0("CP B");
1805 outline1("JP NZ, %s", label);
1806 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
1807 outline0("LD B, A");
1808 outline1("LD A, $%2.2x", (unsigned char)((_destination>>8)&0xff));
1809 outline0("CP B");
1810 outline1("JP NZ, %s", label);
1811 outline1("LD A, $%2.2x", 0xff*_positive);
1812 outline1("LD (%s), A", _other);
1813 outline1("JMP %sb2", label);
1814 outhead1("%s:", label);
1815 outline1("LD A, $%2.2x", 0xff*(1-_positive));
1816 outline1("LD (%s), A", _other);
1817 outhead1("%sb2:", label);
1818
1819 embedded( cpu_compare_16bit, src_hw_sm83_cpu_compare_16bit_asm )
1820
1821 outline1("LD HL, %s", _source);
1822 outline1("LD DE, $%4.4x", _destination);
1823 outline1("LD A, $%2.2x", ( 0xff*(1-_positive)) );
1824 outline0("LD (IXLR), A" );
1825 outline1("LD A, $%2.2x", ( (0xff*_positive) ) );
1826 outline0("LD (IXHR), A" );
1827 outline0("CALL CPUCOMPARE16CONST");
1828 outline1("LD (%s), A", _other);
1829
1830 done( )
1831
1832}
1833
1834void cpu_compare_and_branch_16bit( Environment * _environment, char *_source, char *_destination, char *_label, int _positive ) {
1835
1836 inline( cpu_compare_and_branch_16bit )
1837
1838 MAKE_LABEL
1839
1840 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
1841 outline0("LD B, A");
1842 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
1843 outline0("CP B");
1844 outline1("JP NZ, %s", label);
1845 outline1("LD A, (%s)", _source);
1846 outline0("LD B, A");
1847 outline1("LD A, (%s)", _destination);
1848 outline0("CP B");
1849 outline1("JP NZ, %s", label);
1850 if ( _positive ) {
1851 outline1("JP %s", _label);
1852 outhead1("%s:", label );
1853 } else {
1854 outline1("JP %snot", label);
1855 outhead1("%s:", label );
1856 outline1("JP %s", _label);
1857 outhead1("%snot:", label );
1858 }
1859
1860 no_embedded( cpu_compare_and_branch_16bit )
1861
1862}
1863
1873void cpu_compare_and_branch_16bit_const( Environment * _environment, char *_source, int _destination, char *_label, int _positive ) {
1874
1875 inline( cpu_compare_and_branch_16bit_const )
1876
1877 MAKE_LABEL
1878
1879 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
1880 outline1("CP $%2.2x", ( _destination >> 8 ) & 0xff );
1881 outline1("JP NZ, %s", label);
1882 outline1("LD A, (%s)", _source);
1883 outline1("CP $%2.2x", ( _destination & 0xff ) );
1884 outline1("JP NZ, %s", label);
1885 if ( _positive ) {
1886 outline1("JP %s", _label);
1887 outhead1("%s:", label );
1888 } else {
1889 outline1("JP %snot", label);
1890 outhead1("%s:", label );
1891 outline1("JP %s", _label);
1892 outhead1("%snot:", label );
1893 }
1894
1895 no_embedded( cpu_compare_and_branch_16bit_const )
1896
1897}
1898
1908void cpu_less_than_16bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
1909
1910 MAKE_LABEL
1911
1912 inline( cpu_less_than_16bit )
1913
1914 if ( _signed ) {
1915
1916 outline1("LD HL, (%s)", _source);
1917 outline0("LD D, H");
1918 outline0("LD E, L");
1919 outline1("LD HL, (%s)", _destination);
1920 outline0("LD A, H" );
1921 outline0("XOR D" );
1922 outline1("JP M,%scmpgte2", label );
1923 outline0("CALL SBC_HL_DE" );
1924 if ( _equal ) {
1925 outline1("JR Z,%scmpgte3", label );
1926 } else {
1927 outline1("JR Z,%scmpgte1", label );
1928 }
1929 outline1("JR NC,%scmpgte3", label );
1930 outhead1("%scmpgte1:", label );
1931 outline0("LD A, 0");
1932 if ( _other ) {
1933 outline1("LD (%s), A", _other);
1934 } else {
1935 outline1("LD (%s), A", _destination);
1936 }
1937 outline1("JMP %send", label );
1938 outhead1("%scmpgte2:", label );
1939 outline0("BIT 7,D" );
1940 outline1("JR Z, %scmpgte1", label );
1941 outhead1("%scmpgte3:", label );
1942 outline0("LD A, $ff");
1943 if ( _other ) {
1944 outline1("LD (%s), A", _other);
1945 } else {
1946 outline1("LD (%s), A", _destination);
1947 }
1948 outhead1("%send:", label );
1949
1950 } else {
1951
1952 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
1953 outline0("LD B, A");
1954 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
1955 outline0("CP B");
1956 outline1("JR Z, %sl2", label);
1957 outline1("JR C, %s", label);
1958 outline1("JR %s_0", label);
1959 outhead1("%sl2:", label);
1960 outline1("LD A, (%s)", _destination);
1961 outline0("LD B, A");
1962 outline1("LD A, (%s)", _source);
1963 outline0("CP B");
1964 outline1("JR C, %s", label);
1965 if ( _equal ) {
1966 outline1("JR Z, %s", label);
1967 }
1968 outhead1("%s_0:", label);
1969 outline0("LD A, 0");
1970 if ( _other ) {
1971 outline1("LD (%s), A", _other);
1972 } else {
1973 outline1("LD (%s), A", _destination);
1974 }
1975 outline1("JMP %sb2", label);
1976 outhead1("%s:", label);
1977 outline0("LD A, $ff");
1978 if ( _other ) {
1979 outline1("LD (%s), A", _other);
1980 } else {
1981 outline1("LD (%s), A", _destination);
1982 }
1983 outhead1("%sb2:", label);
1984
1985 }
1986
1987 embedded( cpu_less_than_16bit, src_hw_sm83_cpu_less_than_16bit_asm );
1988
1989 if ( _signed ) {
1990
1991 outline1("LD HL, (%s)", _source);
1992 outline0("LD D, H");
1993 outline0("LD E, L");
1994 outline1("LD HL, (%s)", _destination);
1995 if ( _equal ) {
1996 outline0("CALL CPULTE16S");
1997 } else {
1998 outline0("CALL CPULT16S");
1999 }
2000 if ( _other ) {
2001 outline1("LD (%s), A", _other);
2002 } else {
2003 outline1("LD (%s), A", _destination);
2004 }
2005
2006 } else {
2007
2008 outline1("LD HL, (%s)", _source);
2009 outline0("LD D, H");
2010 outline0("LD E, L");
2011 outline1("LD HL, (%s)", _destination);
2012 if ( _equal ) {
2013 outline0("CALL CPULTE16U");
2014 } else {
2015 outline0("CALL CPULT16U");
2016 }
2017 if ( _other ) {
2018 outline1("LD (%s), A", _other);
2019 } else {
2020 outline1("LD (%s), A", _destination);
2021 }
2022
2023 }
2024
2025 done( )
2026
2027}
2028
2029void cpu_less_than_16bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
2030
2031 MAKE_LABEL
2032
2033 inline( cpu_less_than_16bit )
2034
2035 if ( _signed ) {
2036
2037 outline1("LD HL, (%s)", _source);
2038 outline0("LD D, H");
2039 outline0("LD E, L");
2040 outline1("LD HL, $%4.4x", ( _destination & 0xffff ) );
2041 outline0("LD A, H" );
2042 outline0("XOR D" );
2043 outline1("JP M,%scmpgte2", label );
2044 outline0("CALL SBC_HL_DE" );
2045 if ( _equal ) {
2046 outline1("JR Z,%scmpgte3", label );
2047 } else {
2048 outline1("JR Z,%scmpgte1", label );
2049 }
2050 outline1("JR NC,%scmpgte3", label );
2051 outhead1("%scmpgte1:", label );
2052 outline0("LD A, 0");
2053 outline1("LD (%s), A", _other);
2054 outline1("JMP %send", label );
2055 outhead1("%scmpgte2:", label );
2056 outline0("BIT 7,D" );
2057 outline1("JR Z, %scmpgte1", label );
2058 outhead1("%scmpgte3:", label );
2059 outline0("LD A, $ff");
2060 outline1("LD (%s), A", _other);
2061 outhead1("%send:", label );
2062
2063 } else {
2064
2065 outline1("LD A, $%2.2x", ( ( _destination >> 8 ) & 0xff ) );
2066 outline0("LD B, A");
2067 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
2068 outline0("CP B");
2069 outline1("JR Z, %sl2", label);
2070 outline1("JR C, %s", label);
2071 outline1("JR %s_0", label);
2072 outhead1("%sl2:", label);
2073 outline1("LD A, $%2.2x", ( _destination & 0xff ) );
2074 outline0("LD B, A");
2075 outline1("LD A, (%s)", _source);
2076 outline0("CP B");
2077 outline1("JR C, %s", label);
2078 if ( _equal ) {
2079 outline1("JR Z, %s", label);
2080 }
2081 outhead1("%s_0:", label);
2082 outline0("LD A, 0");
2083 outline1("LD (%s), A", _other);
2084 outline1("JMP %sb2", label);
2085 outhead1("%s:", label);
2086 outline0("LD A, $ff");
2087 outline1("LD (%s), A", _other);
2088 outhead1("%sb2:", label);
2089
2090 }
2091
2092 embedded( cpu_less_than_16bit, src_hw_sm83_cpu_less_than_16bit_asm );
2093
2094 if ( _signed ) {
2095
2096 outline1("LD HL, (%s)", _source);
2097 outline0("LD D, H");
2098 outline0("LD E, L");
2099 outline1("LD HL, $%4.4x", ( _destination & 0Xffff ) );
2100 if ( _equal ) {
2101 outline0("CALL CPULTE16S");
2102 } else {
2103 outline0("CALL CPULT16S");
2104 }
2105 outline1("LD (%s), A", _other);
2106
2107 } else {
2108
2109 outline1("LD HL, (%s)", _source);
2110 outline0("LD D, H");
2111 outline0("LD E, L");
2112 outline1("LD HL, $%4.4x", ( _destination & 0Xffff ) );
2113 if ( _equal ) {
2114 outline0("CALL CPULTE16U");
2115 } else {
2116 outline0("CALL CPULT16U");
2117 }
2118 outline1("LD (%s), A", _other);
2119
2120 }
2121
2122 done( )
2123
2124}
2125
2135void cpu_greater_than_16bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
2136
2137 cpu_less_than_16bit( _environment, _source, _destination, _other, !_equal, _signed );
2138 if ( _other ) {
2139 cpu_not_8bit( _environment, _other, _other );
2140 } else {
2141 cpu_not_8bit( _environment, _destination, _destination );
2142 }
2143
2144}
2145
2146void cpu_greater_than_16bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
2147
2148 cpu_less_than_16bit_const( _environment, _source, _destination, _other, !_equal, _signed );
2149 cpu_not_8bit( _environment, _other, _other );
2150
2151}
2152
2161void cpu_math_add_16bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
2162
2163 inline( cpu_math_add_16bit )
2164
2165 outline1("LD HL, (%s)", _destination);
2166 outline0("LD D, H");
2167 outline0("LD E, L");
2168 outline1("LD HL, (%s)", _source );
2169 outline0("ADD HL, DE" );
2170 if ( _other ) {
2171 outline1("LD (%s), HL", _other );
2172 } else {
2173 outline1("LD (%s), HL", _destination );
2174 }
2175
2176 no_embedded( cpu_math_add_16bit )
2177
2178}
2179
2180void cpu_math_add_16bit_const( Environment * _environment, char *_source, int _destination, char *_other ) {
2181
2182 inline( cpu_math_add_16bit )
2183
2184 outline1("LD HL, (%s)", _source );
2185 outline1("LD DE, $%4.4x", ( _destination & 0xffff ) );
2186 outline0("ADD HL, DE" );
2187 outline1("LD (%s), HL", _other );
2188
2189 no_embedded( cpu_math_add_16bit )
2190
2191}
2192
2193void cpu_math_add_16bit_with_16bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
2194
2195 inline( cpu_math_add_16bit_with_16bit )
2196
2197 outline0("AND $0");
2198 outline1("LD HL, (%s)", _source );
2199 outline1("LD DE, %s", _destination );
2200 outline0("ADD HL, DE" );
2201 outline1("LD (%s), HL", _other );
2202
2203 no_embedded( cpu_math_add_16bit_with_16bit )
2204
2205}
2206
2214void cpu_math_double_16bit( Environment * _environment, char *_source, char *_other, int _signed ) {
2215
2216 inline( cpu_math_double_16bit )
2217
2218 outline1("LD HL, (%s)", _source);
2219 outline0("SLA L" );
2220 outline0("RL H" );
2221 if ( _other ) {
2222 outline1("LD (%s), HL", _other );
2223 } else {
2224 outline1("LD (%s), HL", _source );
2225 }
2226
2227 no_embedded( cpu_math_double_16bit )
2228
2229}
2230
2239void cpu_math_mul_16bit_to_32bit( Environment * _environment, char *_source, char *_destination, char *_other, int _signed ) {
2240
2241 MAKE_LABEL
2242
2243 no_inline( cpu_math_mul_16bit_to_32bit )
2244
2245 embedded( cpu_math_mul_16bit_to_32bit, src_hw_sm83_cpu_math_mul_16bit_to_32bit_asm );
2246
2247 if ( _signed ) {
2248
2249 outline1("LD HL, (%s)", _source );
2250 outline0("LD (IXR), HL" );
2251 outline1("LD HL, (%s)", _destination );
2252 outline0("LD (IYR), HL" );
2253 outline0("CALL CPUMUL16B16T32S")
2254 outline1("LD (%s), HL", _other );
2255 outline0("LD H, B");
2256 outline0("LD L, C");
2257 outline1("LD (%s), HL", address_displacement( _environment, _other, "2" ) );
2258
2259 } else {
2260
2261 outline1("LD HL, (%s)", _source );
2262 outline0("LD B, H");
2263 outline0("LD C, L");
2264 outline1("LD HL, (%s)", _destination);
2265 outline0("LD D, H");
2266 outline0("LD E, L");
2267 outline0("CALL CPUMUL16B16T32U")
2268 outline1("LD (%s), HL", _other );
2269 outline0("LD H, B");
2270 outline0("LD L, C");
2271 outline1("LD (%s), BC", address_displacement( _environment, _other, "2" ) );
2272
2273 }
2274
2275 done( )
2276
2277}
2278
2279void cpu_math_mul_nbit_to_nbit( Environment * _environment, char *_source, char *_destination, char *_other, int _bits ) {
2280
2281 MAKE_LABEL
2282
2283 int i;
2284
2285 char afterLabel[MAX_TEMPORARY_STORAGE]; sprintf( afterLabel, "%safter", label);
2286 char destination[MAX_TEMPORARY_STORAGE]; sprintf( destination, "CPUMATHMULNBITTONBIT%d_DESTINATION", (_bits>>3));
2287 char source[MAX_TEMPORARY_STORAGE]; sprintf( source, "CPUMATHMULNBITTONBIT%d_SOURCE", (_bits>>3));
2288 char other[MAX_TEMPORARY_STORAGE]; sprintf( other, "CPUMATHMULNBITTONBIT%d_OTHER", (_bits>>3));
2289
2290 // no_inline( cpu_math_mul_nbit_to_nbit )
2291
2292 // embedded( cpu_math_mul_nbit_to_nbit, src_hw_6502_cpu_math_mul_nbit_to_nbit_asm )
2293
2294 if ( ! _environment->cpuOptimization.cpu_math_mul_nbit_to_nbit[_bits>>3] ) {
2295
2296 outline1("JP %s", afterLabel );
2297
2298 outhead2("CPUMATHMULNBITTONBIT%d_SOURCE: defs %d", _bits>>3, _bits>>3 );
2299 outhead2("CPUMATHMULNBITTONBIT%d_DESTINATION: defs %d", _bits>>3, _bits>>3 );
2300 outhead2("CPUMATHMULNBITTONBIT%d_OTHER: defs %d", _bits>>3, _bits>>3 );
2301
2302 outhead1("CPUMATHMULNBITTONBIT%d:", _bits>>3);
2303 outhead0("LD A, $00");
2304 for( i=0; i<(_bits>>3); ++i ) {
2305 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
2306 outline1("LD (%s), A", address_displacement( _environment, other, offset ) );
2307 }
2308 outline1("LD C, $%2.2x", _bits );
2309
2310 outhead1("CPUMATHMULNBITTONBIT%dL1:", _bits>>3);
2311
2312 // The process of multiplying binary numbers is similar and easier to do than
2313 // decimal multiplication as binary numbers consist of only two digits which
2314 // are 0 and 1. The method of multiplying binary numbers is given below. The
2315 // same set of rules also apply to binary numbers with a decimal point. Let
2316 // us take the example of multiplying (11101) and (1001).
2317 //
2318 // The decimal equivalent of (11101) is 29 and the decimal equivalent
2319 // of (1001) is 9. Now let us multiply these numbers.
2320
2321 // Step 1: Write down the multiplicand (11101) and the multiplier (1001)
2322 // one below the other in proper positions.
2323
2324 char multiplyByBit0Label[MAX_TEMPORARY_STORAGE]; sprintf( multiplyByBit0Label, "%sb%dbit0", label, _bits>>3 );
2325
2326 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", (_bits>>3)-1 );
2327
2328 outline1("LD A, (%s)", address_displacement( _environment, destination, offset ) );
2329 outline0("SRA A" );
2330 outline1("LD (%s), A", address_displacement( _environment, destination, offset ) );
2331 for( i=(_bits>>3)-2; i>-1; --i ) {
2332 sprintf( offset, "%d", i );
2333 outline1("LD A, (%s)", address_displacement( _environment, destination, offset ) );
2334 outline0("RR A" );
2335 outline1("LD (%s), A", address_displacement( _environment, destination, offset ) );
2336 }
2337 outline1("JR C, %sx", multiplyByBit0Label );
2338 outline1("JP %s", multiplyByBit0Label );
2339 outhead1("%sx:", multiplyByBit0Label );
2340
2341 // Step 2: Multiply the rightmost digit or the least significant bit (LSB)
2342 // of the multiplier (1) with all the digits of the multiplicand (11101).
2343
2344 outline0("SCF" );
2345 outline0("CCF" );
2346 for( i=0; i<(_bits>>3); ++i ) {
2347 sprintf( offset, "%d", i );
2348 outline1("LD A, (%s)", address_displacement( _environment, source, offset ) );
2349 outline0("LD B, A" );
2350 outline1("LD A, (%s)", address_displacement( _environment, other, offset ) );
2351 outline0("ADC A, B" );
2352 outline1("LD (%s), A", address_displacement( _environment, other, offset ) );
2353 }
2354
2355 // Step 3: Add a place holder of '0' or 'X' before multiplying the next
2356 // higher order digit of the multiplier& with the multiplicand.
2357
2358 outhead1("%s:", multiplyByBit0Label);
2359
2360 outline0("SCF" );
2361 outline0("CCF" );
2362 outline1("LD A, (%s)", address_displacement( _environment, source, "0" ) );
2363 outline0("SLA A" );
2364 outline1("LD (%s), A", address_displacement( _environment, source, "0" ) );
2365 for( i=1; i<(_bits>>3); ++i ) {
2366 sprintf( offset, "%d", i );
2367 outline1("LD A, (%s)", address_displacement( _environment, source, offset ) );
2368 outline0("RL A" );
2369 outline1("LD (%s), A", address_displacement( _environment, source, offset ) );
2370 }
2371
2372 // Step 4: Repeat the same process for all the next higher-order digits
2373 // until we reach the most significant bit (MSB) which is the left-most
2374 // digit of the multiplicand with the multiplier.
2375
2376 outline0("DEC C" );
2377 outline0("LD A, C" );
2378 outline0("CP 0" );
2379 outline1("JP NZ, CPUMATHMULNBITTONBIT%dL1", (_bits>>3) );
2380
2381 outline0("RET" );
2382
2383 // Step 5: The product obtained in each row is called the partial product.
2384 // Finally, add all the partial products. To add all the binary numbers
2385 // use the rules of binary addition.
2386
2387 // (The rules for binary addition are listed as follows: 0 + 0 = 0, 0 + 1 = 1, and 1 + 1 = 0, with a carryover of 1. So, 1 + 1 = 10 and 1 + 1 + 1 = 11 in the binary number system)
2388 outhead1("%s:", afterLabel );
2389
2390 }
2391
2392 for( i=0; i<(_bits>>3); ++i ) {
2393 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
2394 outline1("LD A, (%s)", address_displacement( _environment, _source, offset ) );
2395 outline1("LD (%s), A", address_displacement( _environment, source, offset ) );
2396 outline1("LD A, (%s)", address_displacement( _environment, _destination, offset ) );
2397 outline1("LD (%s), A", address_displacement( _environment, destination, offset ) );
2398 }
2399 outline1("CALL CPUMATHMULNBITTONBIT%d", _bits >> 3 );
2400 for( i=0; i<(_bits>>3); ++i ) {
2401 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
2402 outline1("LD A, (%s)", address_displacement( _environment, other, offset ) );
2403 if ( _other ) {
2404 outline1("LD (%s), A", address_displacement( _environment, _other, offset ) );
2405 } else {
2406 outline1("LD (%s), A", address_displacement( _environment, _destination, offset ) );
2407 }
2408 }
2409
2410 // done()
2411
2412}
2413
2414void cpu_math_mul2_const_nbit( Environment * _environment, char *_source, int _steps, int _bits ) {
2415
2416 int i;
2417
2418 inline( cpu_math_mul2_const_nbit )
2419
2420 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", (_bits>>3)-1 );
2421 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
2422 outline0("AND $80");
2423 outline0("LD B, A");
2424 while( _steps ) {
2425 outline0("SCF")
2426 outline0("CCF");
2427 outline1("LD A, (%s)", address_displacement(_environment, _source, "0"));
2428 outline0("SLA A");
2429 outline1("LD (%s), A", address_displacement(_environment, _source, "0"));
2430 for( i=1; i<(_bits>>3); ++i ) {
2431 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i);
2432 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
2433 outline0("RL A");
2434 outline1("LD (%s), A", address_displacement(_environment, _source, offset));
2435 }
2436 --_steps;
2437 }
2438 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
2439 outline0("OR B");
2440 outline1("LD (%s), A", address_displacement(_environment, _source, offset));
2441
2442 no_embedded( cpu_math_mul2_const_nbit )
2443
2444}
2445
2454void cpu_math_sub_16bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
2455
2456 inline( cpu_math_sub_16bit )
2457
2458 outline1("LD HL, (%s)", _destination);
2459 outline0("LD D, H");
2460 outline0("LD E, L");
2461 outline1("LD HL, (%s)", _source );
2462 outline0("AND A" );
2463 outline0("CALL SBC_HL_DE" );
2464 if ( _other ) {
2465 outline1("LD (%s), HL", _other );
2466 } else {
2467 outline1("LD (%s), HL", _destination );
2468 }
2469
2470 no_embedded( cpu_math_sub_16bit )
2471
2472}
2473
2481void cpu_math_complement_const_16bit( Environment * _environment, char *_source, int _value ) {
2482
2483 inline( cpu_math_complement_const_16bit )
2484
2485 outline1("LD HL, (%s)", _source);
2486 outline0("LD D, H");
2487 outline0("LD E, L");
2488 outline1("LD HL, $%4.4x", _value );
2489 outline0("LD A, E" );
2490 outline0("XOR $FF" );
2491 outline0("LD E, A" );
2492 outline0("LD A, D" );
2493 outline0("XOR $FF" );
2494 outline0("LD D, A" );
2495 outline0("INC DE" );
2496 outline0("ADD HL, DE" );
2497 outline1("LD (%s), HL", _source );
2498
2499 no_embedded( cpu_math_complement_const_16bit )
2500
2501}
2502
2510void cpu_math_div2_const_16bit( Environment * _environment, char *_source, int _steps, int _signed, char * _remainder ) {
2511
2512 inline( cpu_math_div2_const_16bit )
2513
2514 MAKE_LABEL
2515
2516 if ( _remainder ) {
2517 outline1("LD A, (%s)", _source );
2518 outline0("AND $1" );
2519 outline1("LD (%s), A", _remainder );
2520 }
2521 if ( _signed ) {
2522 outline1("LD A, (%s)", address_displacement(_environment, _source, "1") );
2523 outline0("AND $80" );
2524 outline0("CP 0" );
2525 outline0("PUSH AF" );
2526 outline1("JR Z, %spos", label );
2527 cpu_complement2_16bit( _environment, _source, _source );
2528 outline1("JMP %spos2", label );
2529 outhead1("%spos:", label );
2530 outhead1("%spos2:", label );
2531 outline1("LD HL, (%s)", _source );
2532 while( _steps ) {
2533 outline0("SRA H" );
2534 outline0("RR L" );
2535 --_steps;
2536 }
2537 outline1("LD (%s), HL", _source );
2538 outline0("POP AF" );
2539 outline0("AND $80" );
2540 outline0("CP 0" );
2541 outline1("JR Z, %sdone", label );
2542 cpu_complement2_16bit( _environment, _source, _source );
2543 outhead1("%sdone:", label );
2544 } else {
2545 outline1("LD HL, (%s)", _source );
2546 while( _steps ) {
2547 outline0("SRA H" );
2548 outline0("RR L" );
2549 --_steps;
2550 }
2551 outline1("LD (%s), HL", _source );
2552
2553 }
2554
2555 embedded( cpu_math_div2_const_16bit, src_hw_sm83_cpu_math_div2_const_16bit_asm )
2556
2557 if ( _remainder ) {
2558 outline1("LD A, (%s)", _source );
2559 outline0("AND $1" );
2560 outline1("LD (%s), A", _remainder );
2561 }
2562 if ( _signed ) {
2563 if ( _steps ) {
2564 outline1("LD HL, (%s)", _source );
2565 outline1("LD A, $%2.2x", _steps );
2566 outline0("LD C, A" );
2567 outline0("CALL CPUDIV2CONST16S" );
2568 outline1("LD (%s), HL", _source );
2569 }
2570 } else {
2571 if ( _steps ) {
2572 outline1("LD HL, (%s)", _source );
2573 outline1("LD A, $%2.2x", _steps );
2574 outline0("LD C, A" );
2575 outline0("CALL CPUDIV2CONST16U" );
2576 outline1("LD (%s), HL", _source );
2577 }
2578
2579 }
2580
2581 done( )
2582
2583}
2584
2592void cpu_math_mul2_const_16bit( Environment * _environment, char *_source, int _steps, int _signed ) {
2593
2594 inline( cpu_math_mul2_const_16bit )
2595
2596 MAKE_LABEL
2597
2598 if ( _signed ) {
2599 outline1("LD A, (%s)", address_displacement(_environment, _source, "1") );
2600 outline0("AND $80" );
2601 outline0("PUSH AF" );
2602 outline0("CP 0" );
2603 outline1("JR Z, %spos", label );
2604 cpu_complement2_16bit( _environment, _source, _source );
2605 outline1("JMP %spos2", label );
2606 outhead1("%spos:", label );
2607 outhead1("%spos2:", label );
2608 outline1("LD HL, (%s)", _source );
2609 while( _steps ) {
2610 outline0("SLA L" );
2611 outline0("RL H" );
2612 --_steps;
2613 }
2614 outline1("LD (%s), HL", _source );
2615 outline0("POP AF" );
2616 outline0("AND $80" );
2617 outline0("CP 0" );
2618 outline1("JR Z, %sdone", label );
2619 cpu_complement2_16bit( _environment, _source, _source );
2620 outhead1("%sdone:", label );
2621 } else {
2622 outline1("LD HL, (%s)", _source );
2623 while( _steps ) {
2624 outline0("SLA L" );
2625 outline0("RL H" );
2626 --_steps;
2627 }
2628 outline1("LD (%s), HL", _source );
2629 }
2630
2631 no_embedded( cpu_math_mul2_const_16bit )
2632
2633}
2634
2642void cpu_math_and_const_16bit( Environment * _environment, char *_source, int _mask ) {
2643
2644 inline( cpu_math_and_const_16bit )
2645
2646 outline1("LD A, (%s)", _source );
2647 outline1("AND $%2.2x", ( _mask & 0xff ) );
2648 outline1("LD (%s), A", _source );
2649 outline1("LD A, (%s)", address_displacement(_environment, _source, "1") );
2650 outline1("AND $%2.2x", ( ( _mask >> 8 ) & 0xff ) );
2651 outline1("LD (%s), A", address_displacement(_environment, _source, "1") );
2652
2653 no_embedded( cpu_math_and_const_16bit )
2654
2655}
2656
2657/*****************************************************************************
2658 * 32 BIT MANIPULATION
2659 ****************************************************************************/
2660
2668void cpu_move_32bit( Environment * _environment, char *_source, char *_destination ) {
2669
2670 inline( cpu_move_32bit )
2671
2672 outline1("LD A, (%s)", _source );
2673 outline1("LD (%s), A", _destination );
2674 outline1("LD A, (%s)", address_displacement(_environment, _source, "1") );
2675 outline1("LD (%s), A", address_displacement(_environment, _destination, "1") );
2676 outline1("LD A, (%s)", address_displacement(_environment, _source, "2") );
2677 outline1("LD (%s), A", address_displacement(_environment, _destination, "2") );
2678 outline1("LD A, (%s)", address_displacement(_environment, _source, "3") );
2679 outline1("LD (%s), A", address_displacement(_environment, _destination, "3") );
2680
2681 no_embedded( cpu_move_32bit )
2682
2683}
2684
2692void cpu_store_32bit( Environment * _environment, char *_destination, int _value ) {
2693
2694 inline( cpu_store_32bit )
2695
2696 outline1("LD HL, $%4.4x", ( _value & 0xffff ) );
2697 outline1("LD (%s), HL", _destination );
2698 outline1("LD HL, $%2.2x", ( ( _value >> 16 ) & 0xffff ) );
2699 outline1("LD (%s), HL", address_displacement(_environment, _destination, "2") );
2700
2701 no_embedded( cpu_move_32bit )
2702
2703}
2704
2714void cpu_compare_32bit( Environment * _environment, char *_source, char *_destination, char *_other, int _positive ) {
2715
2716 inline( cpu_compare_32bit )
2717
2718 MAKE_LABEL
2719
2720 outline1("LD A, (%s)", _source);
2721 outline0("LD B, A");
2722 outline1("LD A, (%s)", _destination);
2723 outline0("CP B");
2724 outline1("JP NZ, %s", label);
2725 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
2726 outline0("LD B, A");
2727 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
2728 outline0("CP B");
2729 outline1("JP NZ, %s", label);
2730 outline1("LD A, (%s)", address_displacement(_environment, _source, "2"));
2731 outline0("LD B, A");
2732 outline1("LD A, (%s)", address_displacement(_environment, _destination, "2"));
2733 outline0("CP B");
2734 outline1("JP NZ, %s", label);
2735 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
2736 outline0("LD B, A");
2737 outline1("LD A, (%s)", address_displacement(_environment, _destination, "3"));
2738 outline0("CP B");
2739 outline1("JP NZ, %s", label);
2740 outline1("LD A, $%2.2x", 0xff*_positive);
2741 if ( _other ) {
2742 outline1("LD (%s), A", _other);
2743 } else {
2744 outline1("LD (%s), A", _destination);
2745 }
2746 outline1("JMP %s_2", label);
2747 outhead1("%s:", label);
2748 outline1("LD A, $%2.2x", 0xff*(1-_positive));
2749 if ( _other ) {
2750 outline1("LD (%s), A", _other);
2751 } else {
2752 outline1("LD (%s), A", _destination);
2753 }
2754 outhead1("%s_2:", label);
2755
2756 embedded( cpu_compare_32bit, src_hw_sm83_cpu_compare_32bit_asm )
2757
2758 outline1("LD HL, %s", _source);
2759 outline1("LD DE, %s", _destination);
2760 outline1("LD A, $%2.2x", ( 0xff*(1-_positive)) );
2761 outline0("LD (IXLR), A" );
2762 outline1("LD A, $%2.2x", ( (0xff*_positive) ) );
2763 outline0("LD (IXHR), A" );
2764 outline0("CALL CPUCOMPARE32");
2765 if ( _other ) {
2766 outline1("LD (%s), A", _other);
2767 } else {
2768 outline1("LD (%s), A", _destination);
2769 }
2770
2771 done( )
2772
2773}
2774
2784void cpu_compare_32bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _positive ) {
2785
2786 no_inline( cpu_compare_32bit )
2787
2788 embedded( cpu_compare_32bit, src_hw_sm83_cpu_compare_32bit_asm )
2789
2790 outline1("LD HL, $%4.4x", (unsigned int)((_destination>>16)&0xffff));
2791 outline0("LD (IYR), HL");
2792 outline1("LD HL, $%4.4x", (unsigned int)(_destination&0xffff));
2793 outline0("LD E, L");
2794 outline0("LD D, H");
2795 outline1("LD HL, %s", _source);
2796 outline1("LD A, $%2.2x", ( 0xff*(1-_positive)) );
2797 outline0("LD (IXLR), A" );
2798 outline1("LD A, $%2.2x", ( (0xff*_positive) ) );
2799 outline0("LD (IXHR), A" );
2800 outline0("CALL CPUCOMPARE32CONST");
2801 outline1("LD (%s), A", _other);
2802
2803 done( )
2804
2805}
2806
2816void cpu_compare_and_branch_32bit_const( Environment * _environment, char *_source, int _destination, char *_label, int _positive ) {
2817
2818 inline( cpu_compare_and_branch_32bit_const )
2819
2820 MAKE_LABEL
2821
2822 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
2823 outline1("CP $%2.2x", ( _destination >> 24 ) & 0xff );
2824 outline1("JP NZ, %s", label);
2825 outline1("LD A, (%s)", address_displacement(_environment, _source, "2"));
2826 outline1("CP $%2.2x", ( _destination >> 16 ) & 0xff );
2827 outline1("JP NZ, %s", label);
2828 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
2829 outline1("CP $%2.2x", ( _destination >> 8 ) & 0xff );
2830 outline1("JP NZ, %s", label);
2831 outline1("LD A, (%s)", _source);
2832 outline1("CP $%2.2x", ( _destination & 0xff ) );
2833 outline1("JP NZ, %s", label);
2834
2835 if ( _positive ) {
2836 outline1("JP %s", _label);
2837 outhead1("%s:", label );
2838 } else {
2839 outline1("JP %snot", label);
2840 outhead1("%s:", label );
2841 outline1("JP %s", _label);
2842 outhead1("%snot:", label );
2843 }
2844
2845 no_embedded( cpu_compare_and_branch_32bit_const )
2846
2847}
2848
2858void cpu_less_than_32bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
2859
2860 MAKE_LABEL
2861
2862 no_inline( cpu_less_than_32bit )
2863
2864 embedded( cpu_less_than_32bit, src_hw_sm83_cpu_less_than_32bit_asm );
2865
2866 if ( _signed ) {
2867
2868 outline1("LD DE, %s", _destination);
2869 outline1("LD HL, %s", _source);
2870 if ( _equal ) {
2871 outline0("CALL CPULTE32S");
2872 } else {
2873 outline0("CALL CPULT32S");
2874 }
2875 if ( _other ) {
2876 outline1("LD (%s), A", _other);
2877 } else {
2878 outline1("LD (%s), A", _destination);
2879 }
2880
2881 } else {
2882
2883 outline1("LD DE, %s", _destination);
2884 outline1("LD HL, %s", _source);
2885 if ( _equal ) {
2886 outline0("CALL CPULTE32U");
2887 } else {
2888 outline0("CALL CPULT32U");
2889 }
2890 if ( _other ) {
2891 outline1("LD (%s), A", _other);
2892 } else {
2893 outline1("LD (%s), A", _destination);
2894 }
2895
2896 }
2897
2898 done( )
2899
2900
2901}
2902
2903void cpu_less_than_nbit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _bits ) {
2904
2905 MAKE_LABEL
2906
2907 int i;
2908
2909 inline( cpu_less_than_nbit_const )
2910
2911 if ( _equal ) {
2912
2913 cpu_compare_nbit_const( _environment, _source, _destination, _other, 1, _bits );
2914
2915 outline1("LD A, (%s)", _other);
2916 outline0("CP 0" );
2917 outline1("JR Z, %sless", label );
2918 outline1("JP %sdone", label );
2919 outhead1("%sless:", label );
2920
2921 }
2922
2923 for( i=(_bits>>3)-2; i>-1; --i ) {
2924 char offset[MAX_TEMPORARY_STORAGE]; sprintf(offset, "%d", i );
2925 outline1("LD B, $%2.2x", (unsigned char)((_destination>>(i*8))&0xff) );
2926 outline1("LD A, (%s)", address_displacement(_environment, _source, offset ) );
2927 outline0("CP B");
2928 outline2("JR Z, %snext%dx", label, i );
2929 outline1("JP C, %sbga", label );
2930 outline1("JP %sagb", label );
2931 outhead2("%snext%dx:", label, i );
2932 }
2933
2934 outhead1("%sbga:", label );
2935 outline0("LD A, 0xff" );
2936 outline1("LD (%s), A", _other );
2937 outline1("JR %sdone", label );
2938
2939 outhead1("%sagb:", label );
2940 outline0("LD A, 0x00" );
2941 outline1("LD (%s), A", _other );
2942 outline1("JR %sdone", label );
2943
2944 outhead1("%sdone:", label );
2945
2946 no_embedded( cpu_less_than_nbit_const )
2947
2948}
2949
2950void cpu_less_than_32bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
2951
2952 MAKE_LABEL
2953
2954 no_inline( cpu_less_than_32bit )
2955
2956 embedded( cpu_less_than_32bit, src_hw_sm83_cpu_less_than_32bit_asm );
2957
2958 if ( _signed ) {
2959
2960 outline1("LD DE, $%4.4x", ( ( _destination >> 16 ) & 0xffff ) );
2961 outline0("PUSH DE" );
2962 outline1("LD DE, $%4.4x", ( _destination & 0xffff ) );
2963 outline0("PUSH DE" );
2964 outline0("LD DE, SP" );
2965 // outline0("LD IY, DE" );
2966 outline1("LD HL, %s", _source);
2967 if ( _equal ) {
2968 outline0("CALL CPULTE32S");
2969 } else {
2970 outline0("CALL CPULT32S");
2971 }
2972 outline1("LD (%s), A", _other);
2973 outline0("POP DE" );
2974 outline0("POP DE" );
2975
2976 } else {
2977
2978 outline1("LD DE, $%4.4x", ( ( _destination >> 16 ) & 0xffff ) );
2979 outline0("PUSH DE" );
2980 outline1("LD DE, $%4.4x", ( _destination & 0xffff ) );
2981 outline0("PUSH DE" );
2982 outline0("LD DE, SP" );
2983 // outline0("LD IY, DE" );
2984 outline1("LD HL, %s", _source);
2985 if ( _equal ) {
2986 outline0("CALL CPULTE32U");
2987 } else {
2988 outline0("CALL CPULT32U");
2989 }
2990 outline1("LD (%s), A", _other);
2991 outline0("POP DE" );
2992 outline0("POP DE" );
2993
2994 }
2995
2996 done( )
2997
2998}
2999
3000void cpu_less_than_nbit( Environment * _environment, char *_source, char * _destination, char *_other, int _equal, int _bits ) {
3001
3002 MAKE_LABEL
3003
3004 int i;
3005
3006 inline( cpu_less_than_nbit )
3007
3008 if ( _equal ) {
3009
3010 cpu_compare_nbit( _environment, _source, _destination, _other, 1, _bits );
3011
3012 if ( _other ) {
3013 outline1("LD A, (%s)", _other);
3014 } else {
3015 outline1("LD A, (%s)", _destination);
3016 }
3017
3018 outline0("CP 0" );
3019 outline1("JR Z, %sless", label );
3020 outline1("JP %sdone", label );
3021 outhead1("%sless:", label );
3022
3023 }
3024
3025 for( i=(_bits>>3)-1; i>-1; --i ) {
3026 char offset[MAX_TEMPORARY_STORAGE]; sprintf(offset, "%d", i );
3027 outline1("LD A, (%s)", address_displacement(_environment, _destination, offset ) );
3028 outline0("LD B, A");
3029 outline1("LD A, (%s)", address_displacement(_environment, _source, offset ) );
3030 outline0("CP B");
3031 outline2("JR Z, %snext%dx", label, i );
3032 outline1("JP C, %sbga", label );
3033 outline1("JP %sagb", label );
3034 outhead2("%snext%dx:", label, i );
3035 }
3036
3037 outhead1("%sbga:", label );
3038 outline0("LD A, 0xff" );
3039 outline1("LD (%s), A", _other );
3040 outline1("JR %sdone", label );
3041
3042 outhead1("%sagb:", label );
3043 outline0("LD A, 0x00" );
3044 outline1("LD (%s), A", _other );
3045 outline1("JR %sdone", label );
3046
3047 outhead1("%sdone:", label );
3048
3049 no_embedded( cpu_less_than_nbit )
3050
3051}
3052
3062void cpu_greater_than_32bit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _signed ) {
3063
3064 cpu_less_than_32bit( _environment, _source, _destination, _other, !_equal, _signed );
3065 if ( _other ) {
3066 cpu_not_8bit( _environment, _other, _other );
3067 } else {
3068 cpu_not_8bit( _environment, _destination, _destination );
3069 }
3070
3071}
3072
3073void cpu_greater_than_32bit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _signed ) {
3074
3075 cpu_less_than_32bit_const( _environment, _source, _destination, _other, !_equal, _signed );
3076 cpu_not_8bit( _environment, _other, _other );
3077
3078}
3079
3080void cpu_greater_than_nbit( Environment * _environment, char *_source, char *_destination, char *_other, int _equal, int _bits ) {
3081
3082 inline( cpu_greater_than_nbit )
3083
3084 cpu_less_than_nbit( _environment, _source, _destination, _other, !_equal, _bits );
3085 if ( _other ) {
3086 cpu_not_8bit( _environment, _other, _other );
3087 } else {
3088 cpu_not_8bit( _environment, _destination, _destination );
3089 }
3090
3091 no_embedded( cpu_greater_than_nbit )
3092
3093}
3094
3095void cpu_greater_than_nbit_const( Environment * _environment, char *_source, int _destination, char *_other, int _equal, int _bits ) {
3096
3097 inline( cpu_greater_than_nbit )
3098
3099 cpu_less_than_nbit_const( _environment, _source, _destination, _other, !_equal, _bits );
3100 cpu_not_8bit( _environment, _other, _other );
3101
3102 no_embedded( cpu_greater_than_nbit )
3103
3104}
3105
3114void cpu_math_add_32bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
3115
3116 inline( cpu_math_add_32bit )
3117
3118 outline1("LD HL, (%s)", _destination);
3119 outline0("LD D, H");
3120 outline0("LD E, L");
3121 outline1("LD HL, (%s)", _source );
3122 outline0("CALL REPLACEMENT_EXX" );
3123 outline1("LD HL, (%s)", address_displacement(_environment, _destination, "2"));
3124 outline0("LD D, H");
3125 outline0("LD E, L");
3126 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2") );
3127 outline0("CALL REPLACEMENT_EXX" );
3128 outline0("ADD HL, DE" );
3129 outline0("CALL REPLACEMENT_EXX" );
3130 outline0("CALL ADC_HL_DE" );
3131 outline0("CALL REPLACEMENT_EXX" );
3132 if ( _other ) {
3133 outline1("LD (%s), HL", _other );
3134 outline0("CALL REPLACEMENT_EXX" );
3135 outline1("LD (%s), HL", address_displacement( _environment, _other, "2" ) );
3136 } else {
3137 outline1("LD (%s), HL", _destination );
3138 outline0("CALL REPLACEMENT_EXX" );
3139 outline1("LD (%s), HL", address_displacement( _environment, _destination, "2" ) );
3140 }
3141
3142 no_embedded( cpu_math_add_32bit )
3143
3144}
3145
3146void cpu_math_add_nbit( Environment * _environment, char *_source, char *_destination, char *_other, int _bits ) {
3147
3148 inline( cpu_math_add_nbit )
3149
3150 outline0("SCF");
3151 outline0("CCF");
3152 for( int i=0; i<(_bits>>3); ++i ) {
3153 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
3154 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
3155 outline0("LD B, A");
3156 outline1("LD A, (%s)", address_displacement(_environment, _destination, offset));
3157 outline0("ADC A, B");
3158 if ( _other ) {
3159 outline1("LD (%s), A", address_displacement(_environment, _other, offset));
3160 } else {
3161 outline1("LD (%s), A", address_displacement(_environment, _destination, offset));
3162 }
3163 }
3164 no_embedded( cpu_math_add_nbit )
3165
3166}
3167
3168void cpu_math_add_32bit_const( Environment * _environment, char *_source, int _destination, char *_other ) {
3169
3170 inline( cpu_math_add_32bit_const )
3171
3172 outline1("LD HL, (%s)", _source );
3173 outline1("LD DE, $%4.4x", ( _destination & 0xffff ) );
3174 outline0("CALL REPLACEMENT_EXX" );
3175 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2") );
3176 outline1("LD DE, $%4.4x", ( ( _destination >> 16 ) & 0xffff ) );
3177 outline0("CALL REPLACEMENT_EXX" );
3178 outline0("ADD HL, DE" );
3179 outline0("CALL REPLACEMENT_EXX" );
3180 outline0("CALL ADC_HL_DE" );
3181 outline0("CALL REPLACEMENT_EXX" );
3182 outline1("LD (%s), HL", _other );
3183 outline0("CALL REPLACEMENT_EXX" );
3184 outline1("LD (%s), HL", address_displacement( _environment, _other, "2" ) );
3185
3186 no_embedded( cpu_math_add_32bit_const )
3187
3188}
3189
3197void cpu_math_double_32bit( Environment * _environment, char *_source, char *_other, int _signed ) {
3198
3199 inline( cpu_math_double_32bit )
3200
3201 if ( _other ) {
3202 cpu_math_add_32bit( _environment, _source, _source, _other );
3203 } else {
3204 cpu_math_add_32bit( _environment, _source, _source, _source );
3205 }
3206
3207 no_embedded( cpu_math_double_32bit )
3208
3209}
3210
3219void cpu_math_sub_32bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
3220
3221 inline( cpu_math_sub_32bit )
3222
3223 MAKE_LABEL
3224
3225 outline1("LD HL, (%s)", _destination);
3226 outline0("LD D, H");
3227 outline0("LD E, L");
3228 outline1("LD HL, (%s)", _source );
3229 outline0("LD A, E" );
3230 outline0("XOR $FF" );
3231 outline0("LD E, A" );
3232 outline0("LD A, D" );
3233 outline0("XOR $FF" );
3234 outline0("LD D, A" );
3235 outline0("INC DE" );
3236 outline0("LD A, D" );
3237 outline0("OR E" );
3238 outline0("PUSH AF" );
3239 outline0("CALL REPLACEMENT_EXX" );
3240 outline1("LD HL, (%s)", address_displacement(_environment, _destination, "2"));
3241 outline0("LD D, H");
3242 outline0("LD E, L");
3243 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2") );
3244 outline0("LD A, E" );
3245 outline0("XOR $FF" );
3246 outline0("LD E, A" );
3247 outline0("LD A, D" );
3248 outline0("XOR $FF" );
3249 outline0("LD D, A" );
3250 outline0("POP AF" );
3251 outline0("CP 0" );
3252 outline1("JR NZ, %snoincde", label );
3253 outline0("INC DE" );
3254 outline1("%snoincde:", label );
3255 outline0("CALL REPLACEMENT_EXX" );
3256 outline0("ADD HL, DE" );
3257 outline0("CALL REPLACEMENT_EXX" );
3258 outline0("CALL ADC_HL_DE" );
3259 outline0("CALL REPLACEMENT_EXX" );
3260 if ( _other ) {
3261 outline1("LD (%s), HL", _other );
3262 outline0("CALL REPLACEMENT_EXX" );
3263 outline1("LD (%s), HL", address_displacement( _environment, _other, "2" ) );
3264 } else {
3265 outline1("LD (%s), HL", _destination );
3266 outline0("CALL REPLACEMENT_EXX" );
3267 outline1("LD (%s), HL", address_displacement( _environment, _destination, "2" ) );
3268 }
3269
3270 no_embedded( cpu_math_sub_32bit )
3271
3272}
3273
3274void cpu_math_sub_nbit( Environment * _environment, char *_source, char *_destination, char *_other, int _bits ) {
3275
3276 inline( cpu_math_sub_nbit )
3277
3278 outline0("SCF");
3279 outline0("CCF");
3280 for( int i=0; i<(_bits)>>3; ++i ) {
3281 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
3282 outline1("LD A, (%s)", address_displacement(_environment, _destination, offset));
3283 outline0("LD B, A");
3284 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
3285 outline0("SBC A, B");
3286 if ( _other ) {
3287 outline1("LD (%s), A", address_displacement(_environment, _other, offset));
3288 } else {
3289 outline1("LD (%s), A", address_displacement(_environment, _destination, offset));
3290 }
3291 }
3292
3293 no_embedded( cpu_math_sub_nbit )
3294
3295}
3296
3304void cpu_math_complement_const_32bit( Environment * _environment, char *_source, int _value ) {
3305
3306 inline( cpu_math_complement_const_32bit )
3307
3308 outline1("LD HL, (%s)", _source);
3309 outline0("LD D, H");
3310 outline0("LD E, L");
3311 outline1("LD HL, $%4.4x", ( _value & 0xffff ) );
3312 outline0("LD A, E" );
3313 outline0("XOR $FF" );
3314 outline0("LD E, A" );
3315 outline0("LD A, D" );
3316 outline0("XOR $FF" );
3317 outline0("LD D, A" );
3318 outline0("INC DE" );
3319 outline0("CALL REPLACEMENT_EXX" );
3320 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
3321 outline0("LD D, H");
3322 outline0("LD E, L");
3323 outline1("LD HL, $%4.4x", ( ( _value >> 16 ) & 0xffff ) );
3324 outline0("LD A, E" );
3325 outline0("XOR $FF" );
3326 outline0("LD E, A" );
3327 outline0("LD A, D" );
3328 outline0("XOR $FF" );
3329 outline0("LD D, A" );
3330 outline0("INC DE" );
3331 outline0("CALL REPLACEMENT_EXX" );
3332 outline0("ADD HL, DE" );
3333 outline0("CALL REPLACEMENT_EXX" );
3334 outline0("CALL ADC_HL_DE" );
3335 outline0("CALL REPLACEMENT_EXX" );
3336 outline1("LD (%s), HL", _source );
3337 outline0("CALL REPLACEMENT_EXX" );
3338 outline1("LD (%s), HL", address_displacement( _environment, _source, "2" ) );
3339
3340 no_embedded( cpu_math_complement_const_32bit )
3341
3342}
3343
3351void cpu_math_div2_const_32bit( Environment * _environment, char *_source, int _steps, int _signed, char * _remainder ) {
3352
3353 inline( cpu_math_div2_const_32bit )
3354
3355 MAKE_LABEL
3356
3357 if ( _remainder ) {
3358 outline1("LD A, (%s)", _source );
3359 outline0("AND $1" );
3360 outline1("LD (%s), A", _remainder );
3361 }
3362 if ( _signed ) {
3363 outline1("LD A, (%s)", address_displacement(_environment, _source, "3") );
3364 outline0("AND $80" );
3365 outline0("CP 0" );
3366 outline0("PUSH AF" );
3367 outline1("JR Z, %spos", label );
3368 cpu_complement2_32bit( _environment, _source, _source );
3369 outline1("JMP %spos2", label );
3370 outhead1("%spos:", label );
3371 outhead1("%spos2:", label );
3372 outline1("LD HL, (%s)", _source);
3373 outline0("LD D, H");
3374 outline0("LD E, L");
3375 outline0("PUSH HL");
3376 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2") );
3377 outline0("LD B, H");
3378 outline0("LD C, L");
3379 outline0("POP HL");
3380 while( _steps ) {
3381 outline0("SRA B" );
3382 outline0("RR C" );
3383 outline0("RR D" );
3384 outline0("RR E" );
3385 --_steps;
3386 }
3387 outline1("LD (%s),DE", _source );
3388 outline0("PUSH HL");
3389 outline0("LD H, B");
3390 outline0("LD L, C");
3391 outline1("LD (%s), HL", address_displacement(_environment, _source, "2") );
3392 outline0("POP HL");
3393 outline0("POP AF" );
3394 outline0("AND $80" );
3395 outline0("CP 0" );
3396 outline1("JR Z, %sdone", label );
3397 cpu_complement2_32bit( _environment, _source, _source );
3398 outhead1("%sdone:", label );
3399 } else {
3400 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2") );
3401 outline0("LD BC, HL" );
3402 outline1("LD HL, (%s)", _source);
3403 while( _steps ) {
3404 outline0("SRA B" );
3405 outline0("RR C" );
3406 outline0("RR H" );
3407 outline0("RR L" );
3408 --_steps;
3409 }
3410 outline1("LD (%s), HL", _source );
3411 outline0("LD HL, BC");
3412 outline1("LD (%s), HL", address_displacement( _environment, _source, "2" ) );
3413 }
3414
3415 no_embedded( cpu_math_div2_const_32bit )
3416
3417}
3418
3426void cpu_math_mul2_const_32bit( Environment * _environment, char *_source, int _steps, int _signed ) {
3427
3428 inline( cpu_math_mul2_const_32bit )
3429
3430 MAKE_LABEL
3431
3432 if ( _signed ) {
3433 outline1("LD A, (%s)", address_displacement(_environment, _source, "3") );
3434 outline0("AND $80" );
3435 outline0("CP 0" );
3436 outline0("PUSH AF" );
3437 outline1("JR Z, %spos", label );
3438 cpu_complement2_32bit( _environment, _source, _source );
3439 outline1("JMP %spos2", label );
3440 outhead1("%spos:", label );
3441 outhead1("%spos2:", label );
3442 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
3443 outline0("LD D, H");
3444 outline0("LD E, L");
3445 outline1("LD HL, (%s)", _source );
3446 while( _steps ) {
3447 outline0("SLA L" );
3448 outline0("RL H" );
3449 outline0("RL E" );
3450 outline0("RL D" );
3451 --_steps;
3452 }
3453 outline1("LD (%s), HL", _source );
3454 outline0("LD H, D");
3455 outline0("LD L, E");
3456 outline1("LD (%s), HL", address_displacement( _environment, _source, "2" ) );
3457 outline0("POP AF" );
3458 outline0("AND $80" );
3459 outline0("CP 0" );
3460 outline1("JR Z, %sdone", label );
3461 cpu_complement2_32bit( _environment, _source, _source );
3462 outhead1("%sdone:", label );
3463 } else {
3464 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
3465 outline0("LD D, H");
3466 outline0("LD E, L");
3467 outline1("LD HL, (%s)", _source );
3468 while( _steps ) {
3469 outline0("SLA L" );
3470 outline0("RL H" );
3471 outline0("RL D" );
3472 outline0("RL E" );
3473 --_steps;
3474 }
3475 outline1("LD (%s), HL", _source );
3476 outline0("LD H, D");
3477 outline0("LD L, E");
3478 outline1("LD (%s), HL", address_displacement( _environment, _source, "2" ) );
3479 }
3480
3481 no_embedded( cpu_math_mul2_const_32bit )
3482
3483}
3484
3492void cpu_math_and_const_32bit( Environment * _environment, char *_source, int _mask ) {
3493
3494 inline( cpu_math_and_const_32bit )
3495
3496 outline1("LD A, (%s)", _source );
3497 outline1("AND $%2.2x", ( _mask & 0xff ) );
3498 outline1("LD (%s), A", _source );
3499 outline1("LD A, (%s)", address_displacement(_environment, _source, "1") );
3500 outline1("AND $%2.2x", ( ( _mask >> 8 ) & 0xff ) );
3501 outline1("LD (%s), A", address_displacement(_environment, _source, "1") );
3502 outline1("LD A, (%s)", address_displacement(_environment, _source, "2") );
3503 outline1("AND $%2.2x", ( ( _mask >> 16 ) & 0xff ) );
3504 outline1("LD (%s), A", address_displacement(_environment, _source, "2") );
3505 outline1("LD A, (%s)", address_displacement(_environment, _source, "3") );
3506 outline1("AND $%2.2x", ( ( _mask >> 24 ) & 0xff ) );
3507 outline1("LD (%s), A", address_displacement(_environment, _source, "3") );
3508
3509 no_embedded( cpu_math_and_const_32bit )
3510
3511}
3512
3516void cpu_combine_nibbles( Environment * _environment, char * _low_nibble, char * _hi_nibble, char * _byte ) {
3517
3518 no_inline( cpu_combine_nibbles )
3519
3520 embedded( cpu_combine_nibbles, src_hw_sm83_cpu_combine_nibbles_asm );
3521
3522 outline1("LD A, (%s)", _hi_nibble );
3523 outline1("LD HL, %s", _low_nibble );
3524 outline1("LD DE, %s", _byte );
3525 outline0("CALL CPUCOMBINENIBBLES" );
3526
3527 done( )
3528
3529}
3530
3531void cpu_jump( Environment * _environment, char * _label ) {
3532
3533 outline1("jp %s", _label );
3534
3535}
3536
3537void cpu_call_addr( Environment * _environment, int _address ) {
3538
3539 outline1("call $%4.4x", _address );
3540
3541}
3542
3543void cpu_call( Environment * _environment, char * _label ) {
3544
3545 outline1("call %s", _label );
3546
3547}
3548
3549void cpu_call_indirect( Environment * _environment, char * _value ) {
3550
3551 MAKE_LABEL
3552
3553 char indirectLabel[MAX_TEMPORARY_STORAGE]; sprintf( indirectLabel, "%sindirect", label );
3554
3555 outline0( "LD (CALLINDIRECTSAVEHL), HL" )
3556 outline1( "LD HL, (%s)", _value )
3557 outline0( "LD (CALLINDIRECT+1), HL" )
3558 outline0( "LD HL, (CALLINDIRECTSAVEHL)" )
3559 outline0( "CALL CALLINDIRECT" );
3560
3561}
3562
3563void cpu_jump_indirect( Environment * _environment, char * _value ) {
3564
3565 outline1( "LD HL, (%s)", _value )
3566 outline0( "JP (HL)" );
3567
3568}
3569
3570int cpu_register_decode( Environment * _environment, char * _register ) {
3571
3572 Z80Register result = REGISTER_NONE;
3573
3574 if ( !_environment->emptyProcedure ) {
3575
3576 if ( strcmp( _register, "A" ) == 0 ) {
3577 result = REGISTER_A;
3578 } else if ( strcmp( _register, "B" ) == 0 ) {
3579 result = REGISTER_B;
3580 } else if ( strcmp( _register, "C" ) == 0 ) {
3581 result = REGISTER_C;
3582 } else if ( strcmp( _register, "D" ) == 0 ) {
3583 result = REGISTER_D;
3584 } else if ( strcmp( _register, "E" ) == 0 ) {
3585 result = REGISTER_E;
3586 } else if ( strcmp( _register, "H" ) == 0 ) {
3587 result = REGISTER_H;
3588 } else if ( strcmp( _register, "L" ) == 0 ) {
3589 result = REGISTER_L;
3590 } else if ( strcmp( _register, "F" ) == 0 ) {
3591 if ( !_environment->emptyProcedure ) {
3592 CRITICAL_UNSETTABLE_CPU_REGISTER( _register );
3593 }
3594 // result = REGISTER_F;
3595 } else if ( strcmp( _register, "I" ) == 0 ) {
3596 if ( !_environment->emptyProcedure ) {
3597 CRITICAL_UNSETTABLE_CPU_REGISTER( _register );
3598 }
3599 // result = REGISTER_I;
3600 } else if ( strcmp( _register, "R" ) == 0 ) {
3601 if ( !_environment->emptyProcedure ) {
3602 CRITICAL_UNSETTABLE_CPU_REGISTER( _register );
3603 }
3604 // result = REGISTER_R;
3605 } else if ( strcmp( _register, "SP" ) == 0 ) {
3606 if ( !_environment->emptyProcedure ) {
3607 CRITICAL_UNSETTABLE_CPU_REGISTER( _register );
3608 }
3609 // result = REGISTER_SP;
3610 } else if ( strcmp( _register, "PC" ) == 0 ) {
3611 if ( !_environment->emptyProcedure ) {
3612 CRITICAL_UNSETTABLE_CPU_REGISTER( _register );
3613 }
3614 } else if ( strcmp( _register, "BC" ) == 0 ) {
3615 result = REGISTER_BC;
3616 } else if ( strcmp( _register, "DE" ) == 0 ) {
3617 result = REGISTER_DE;
3618 } else if ( strcmp( _register, "HL" ) == 0 ) {
3619 result = REGISTER_HL;
3620 } else if ( strcmp( _register, "(IXLR)" ) == 0 ) {
3621 result = REGISTER_IXL;
3622 } else if ( strcmp( _register, "(IXHR)" ) == 0 ) {
3623 result = REGISTER_IXH;
3624 } else if ( strcmp( _register, "(IYLR)" ) == 0 ) {
3625 result = REGISTER_IYL;
3626 } else if ( strcmp( _register, "IYH" ) == 0 ) {
3627 result = REGISTER_IYH;
3628 } else if ( strcmp( _register, "CARRY" ) == 0 ) {
3629 result = REGISTER_CARRY;
3630 } else if ( strcmp( _register, "ZERO" ) == 0 ) {
3631 result = REGISTER_ZERO;
3632 } else if ( strcmp( _register, "HLA" ) == 0 ) {
3633 result = REGISTER_HLA;
3634 } else {
3635
3636 }
3637
3638 }
3639
3640 return (int)result;
3641
3642}
3643
3644void cpu_set_asmio( Environment * _environment, int _asmio, int _value ) {
3645
3646 if ( IS_REGISTER( _asmio ) ) {
3647
3648 MAKE_LABEL
3649
3650 Z80Register reg = (Z80Register) _asmio;
3651
3652 switch ( reg ) {
3653 case REGISTER_NONE:
3654 CRITICAL_UNKNOWN_CPU_REGISTER( );
3655 break;
3656 case REGISTER_F:
3657 case REGISTER_I:
3658 case REGISTER_R:
3659 case REGISTER_SP:
3660 case REGISTER_PC:
3661 case REGISTER_AF:
3662 break;
3663 case REGISTER_A:
3664 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3665 break;
3666 case REGISTER_B:
3667 outline0( "PUSH AF" );
3668 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3669 outline0( "LD B, A" );
3670 outline0( "POP AF" );
3671 break;
3672 case REGISTER_C:
3673 outline0( "PUSH AF" );
3674 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3675 outline0( "LD C, A" );
3676 outline0( "POP AF" );
3677 break;
3678 case REGISTER_D:
3679 outline0( "PUSH AF" );
3680 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3681 outline0( "LD D, A" );
3682 outline0( "POP AF" );
3683 break;
3684 case REGISTER_E:
3685 outline0( "PUSH AF" );
3686 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3687 outline0( "LD E, A" );
3688 outline0( "POP AF" );
3689 break;
3690 case REGISTER_H:
3691 outline0( "PUSH AF" );
3692 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3693 outline0( "LD H, A" );
3694 outline0( "POP AF" );
3695 break;
3696 case REGISTER_L:
3697 outline0( "PUSH AF" );
3698 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3699 outline0( "LD L, A" );
3700 outline0( "POP AF" );
3701 break;
3702 case REGISTER_BC:
3703 outline0( "PUSH HL" );
3704 outline1( "LD HL, $%4.4x", (unsigned short)(_value & 0xffff) );
3705 outline0( "LD BC, HL" );
3706 outline0( "POP HL" );
3707 break;
3708 case REGISTER_DE:
3709 outline0( "PUSH HL" );
3710 outline1( "LD HL, $%4.4x", (unsigned short)(_value & 0xffff) );
3711 outline0( "LD DE, HL" );
3712 outline0( "POP HL" );
3713 break;
3714 case REGISTER_HL:
3715 outline1( "LD HL, $%4.4x", (unsigned short)(_value & 0xffff) );
3716 break;
3717 case REGISTER_IXL:
3718 outline0( "PUSH AF" );
3719 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3720 outline0( "LD (IXLR), A" );
3721 outline0( "POP AF" );
3722 break;
3723 case REGISTER_IXH:
3724 outline0( "PUSH AF" );
3725 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3726 outline0( "LD (IXHR), A" );
3727 outline0( "POP AF" );
3728 break;
3729 case REGISTER_IYL:
3730 outline0( "PUSH AF" );
3731 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3732 outline0( "LD (IYLR), A" );
3733 outline0( "POP AF" );
3734 break;
3735 case REGISTER_IYH:
3736 outline0( "PUSH AF" );
3737 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3738 outline0( "LD (IYHR), A" );
3739 outline0( "POP AF" );
3740 break;
3741 case REGISTER_CARRY:
3742 outline0( "PUSH AF" );
3743 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3744 outline0( "CP 0" );
3745 outline1( "JR Z, %snoc", label );
3746 outline0( "LD A, $1" );
3747 outline0( "SRL A" );
3748 outline1( "JP %sdone", label );
3749 outhead1( "%snoc:", label );
3750 outline0( "SRL A" );
3751 outhead1( "%sdone:", label );
3752 outline0( "POP AF" );
3753 break;
3754 case REGISTER_ZERO:
3755 outline0( "PUSH AF" );
3756 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3757 outline0( "CP 0" );
3758 outline0( "POP AF" );
3759 break;
3760 case REGISTER_HLA:
3761 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3762 outline1( "LD HL, $%4.4x", (unsigned char)((_value >> 8 ) & 0xffff ) );
3763 break;
3764 }
3765
3766 } else {
3767
3768 Z80Stack stk = (Z80Stack) _asmio;
3769
3770 switch ( stk ) {
3771 case STACK_NONE:
3772 break;
3773 case STACK_BYTE:
3774 outline1( "LD A, $%2.2x", (unsigned char)(_value & 0xff ) );
3775 outline0( "PUSH A" );
3776 break;
3777 case STACK_WORD:
3778 outline1( "LD HL, $%4.4x", (unsigned short)(_value & 0xffff) );
3779 outline0( "PUSH HL" );
3780 break;
3781 case STACK_DWORD:
3782 outline1( "LD HL, $%4.4x", (unsigned short)(_value & 0xffff) );
3783 outline0( "PUSH HL" );
3784 outline1( "LD HL, $%4.4x", (unsigned short)((_value>>16) & 0xffff) );
3785 outline0( "PUSH HL" );
3786 break;
3787 }
3788
3789 }
3790
3791}
3792
3793void cpu_set_asmio_indirect( Environment * _environment, int _asmio, char * _value ) {
3794
3795 if ( IS_REGISTER( _asmio ) ) {
3796
3797 MAKE_LABEL
3798
3799 Z80Register reg = (Z80Register) _asmio;
3800
3801 switch ( reg ) {
3802 case REGISTER_NONE:
3803 CRITICAL_UNKNOWN_CPU_REGISTER( );
3804 break;
3805 case REGISTER_F:
3806 case REGISTER_I:
3807 case REGISTER_R:
3808 case REGISTER_SP:
3809 case REGISTER_PC:
3810 case REGISTER_AF:
3811 break;
3812 case REGISTER_A:
3813 outline1( "LD A, (%s)", _value );
3814 break;
3815 case REGISTER_B:
3816 outline0( "PUSH AF" );
3817 outline1( "LD A, (%s)", _value );
3818 outline0( "LD B, A" );
3819 outline0( "POP AF" );
3820 break;
3821 case REGISTER_C:
3822 outline0( "PUSH AF" );
3823 outline1( "LD A, (%s)", _value );
3824 outline0( "LD C, A" );
3825 outline0( "POP AF" );
3826 break;
3827 case REGISTER_D:
3828 outline0( "PUSH AF" );
3829 outline1( "LD A, (%s)", _value );
3830 outline0( "LD D, A" );
3831 outline0( "POP AF" );
3832 break;
3833 case REGISTER_E:
3834 outline0( "PUSH AF" );
3835 outline1( "LD A, (%s)", _value );
3836 outline0( "LD E, A" );
3837 outline0( "POP AF" );
3838 break;
3839 case REGISTER_H:
3840 outline0( "PUSH AF" );
3841 outline1( "LD A, (%s)", _value );
3842 outline0( "LD H, A" );
3843 outline0( "POP AF" );
3844 break;
3845 case REGISTER_L:
3846 outline0( "PUSH AF" );
3847 outline1( "LD A, (%s)", _value );
3848 outline0( "LD L, A" );
3849 outline0( "POP AF" );
3850 break;
3851 case REGISTER_BC:
3852 outline0( "PUSH HL" );
3853 outline1( "LD HL, (%s)", _value );
3854 outline0( "LD BC, HL" );
3855 outline0( "POP HL" );
3856 break;
3857 case REGISTER_DE:
3858 outline0( "PUSH HL" );
3859 outline1( "LD HL, (%s)", _value );
3860 outline0( "LD DE, HL" );
3861 outline0( "POP HL" );
3862 break;
3863 case REGISTER_HL:
3864 outline1( "LD HL, (%s)", _value );
3865 break;
3866 case REGISTER_IXL:
3867 outline0( "PUSH AF" );
3868 outline1( "LD A, (%s)", _value );
3869 outline0( "LD (IXLR), A" );
3870 outline0( "POP AF" );
3871 break;
3872 case REGISTER_IXH:
3873 outline0( "PUSH AF" );
3874 outline1( "LD A, (%s)", _value );
3875 outline0( "LD (IXHR), A" );
3876 outline0( "POP AF" );
3877 break;
3878 case REGISTER_IYL:
3879 outline0( "PUSH AF" );
3880 outline1( "LD A, (%s)", _value );
3881 outline0( "LD (IYLR), A" );
3882 outline0( "POP AF" );
3883 break;
3884 case REGISTER_IYH:
3885 outline0( "PUSH AF" );
3886 outline1( "LD A, (%s)", _value );
3887 outline0( "LD (IYHR), A" );
3888 outline0( "POP AF" );
3889 break;
3890 case REGISTER_CARRY:
3891 outline0( "PUSH AF" );
3892 outline1( "LD A, (%s)", _value );
3893 outline0( "CP 0" );
3894 outline1( "JR Z, %snoc", label );
3895 outline0( "LD A, $1" );
3896 outline0( "SRL A" );
3897 outline1( "JP %sdone", label );
3898 outhead1( "%snoc:", label );
3899 outline0( "SRL A" );
3900 outhead1( "%sdone:", label );
3901 outline0( "POP AF" );
3902 break;
3903 case REGISTER_ZERO:
3904 outline0( "PUSH AF" );
3905 outline1( "LD A, (%s)", _value );
3906 outline0( "CP 0" );
3907 outline0( "POP AF" );
3908 break;
3909 case REGISTER_HLA:
3910 outline1( "LD A, (%s)", address_displacement( _environment, _value, "2" ) );
3911 outline0( "LD H, A" );
3912 outline1( "LD A, (%s)", address_displacement( _environment, _value, "1" ) );
3913 outline0( "LD L, A" );
3914 outline1( "LD A, (%s)", _value );
3915 break;
3916 }
3917
3918 } else {
3919
3920 Z80Stack stk = (Z80Stack) _asmio;
3921
3922 switch ( stk ) {
3923 case STACK_NONE:
3924 break;
3925 case STACK_BYTE:
3926 outline1( "LD A, (%s)", _value );
3927 outline0( "PUSH A" );
3928 break;
3929 case STACK_WORD:
3930 outline1( "LD HL, (%s)", _value );
3931 outline0( "PUSH HL" );
3932 break;
3933 case STACK_DWORD:
3934 outline1( "LD HL, (%s)", address_displacement( _environment, _value, "0" ) );
3935 outline0( "PUSH HL" );
3936 outline1( "LD HL, (%s)", address_displacement( _environment, _value, "2" ) );
3937 outline0( "PUSH HL" );
3938 break;
3939 }
3940
3941 }
3942
3943}
3944
3945void cpu_get_asmio_indirect( Environment * _environment, int _asmio, char * _value ) {
3946
3947 if ( IS_REGISTER( _asmio ) ) {
3948
3949 MAKE_LABEL
3950
3951 Z80Register reg = (Z80Register) _asmio;
3952
3953 switch ( reg ) {
3954 case REGISTER_NONE:
3955 CRITICAL_UNKNOWN_CPU_REGISTER( );
3956 break;
3957 case REGISTER_F:
3958 case REGISTER_I:
3959 case REGISTER_R:
3960 case REGISTER_SP:
3961 case REGISTER_PC:
3962 case REGISTER_AF:
3963 break;
3964 case REGISTER_A:
3965 outline1( "LD (%s), A", _value );
3966 break;
3967 case REGISTER_B:
3968 outline0( "PUSH AF" );
3969 outline0( "LD A, B" );
3970 outline1( "LD (%s), A", _value );
3971 outline0( "POP AF" );
3972 break;
3973 case REGISTER_C:
3974 outline0( "PUSH AF" );
3975 outline0( "LD A, C" );
3976 outline1( "LD (%s), A", _value );
3977 outline0( "POP AF" );
3978 break;
3979 case REGISTER_D:
3980 outline0( "PUSH AF" );
3981 outline0( "LD A, D" );
3982 outline1( "LD (%s), A", _value );
3983 outline0( "POP AF" );
3984 break;
3985 case REGISTER_E:
3986 outline0( "PUSH AF" );
3987 outline0( "LD A, E" );
3988 outline1( "LD (%s), A", _value );
3989 outline0( "POP AF" );
3990 break;
3991 case REGISTER_H:
3992 outline0( "PUSH AF" );
3993 outline0( "LD A, H" );
3994 outline1( "LD (%s), A", _value );
3995 outline0( "POP AF" );
3996 break;
3997 case REGISTER_L:
3998 outline0( "PUSH AF" );
3999 outline0( "LD A, L" );
4000 outline1( "LD (%s), A", _value );
4001 outline0( "POP AF" );
4002 break;
4003 case REGISTER_BC:
4004 outline0( "PUSH HL" );
4005 outline0( "LD HL, BC" );
4006 outline1( "LD (%s), HL", _value );
4007 outline0( "POP HL" );
4008 break;
4009 case REGISTER_DE:
4010 outline0( "PUSH HL" );
4011 outline0( "LD HL, DE" );
4012 outline1( "LD (%s), HL", _value );
4013 outline0( "POP HL" );
4014 break;
4015 case REGISTER_HL:
4016 outline1( "LD (%s), HL", _value );
4017 break;
4018 case REGISTER_IXL:
4019 outline0( "PUSH AF" );
4020 outline0( "LD A, (IXLR)" );
4021 outline1( "LD (%s), A", _value );
4022 outline0( "POP AF" );
4023 break;
4024 case REGISTER_IXH:
4025 outline0( "PUSH AF" );
4026 outline0( "LD A, (IXHR)" );
4027 outline1( "LD (%s), A", _value );
4028 outline0( "POP AF" );
4029 break;
4030 case REGISTER_IYL:
4031 outline0( "PUSH AF" );
4032 outline0( "LD A, (IYLR)" );
4033 outline1( "LD (%s), A", _value );
4034 outline0( "POP AF" );
4035 break;
4036 case REGISTER_IYH:
4037 outline0( "PUSH AF" );
4038 outline0( "LD A, IYH" );
4039 outline1( "LD (%s), A", _value );
4040 outline0( "POP AF" );
4041 break;
4042 case REGISTER_CARRY:
4043 outline0( "PUSH AF" );
4044 outline1( "JR NC, %snoc", label );
4045 outline0( "LD A, $1" );
4046 outline1( "LD (%s), A", _value );
4047 outline1( "JP %sdone", label );
4048 outhead1( "%snoc:", label );
4049 outline0( "LD A, $0" );
4050 outline1( "LD (%s), A", _value );
4051 outhead1( "%sdone:", label );
4052 outline0( "POP AF" );
4053 break;
4054 case REGISTER_ZERO:
4055 outline0( "PUSH AF" );
4056 outline1( "JR NZ, %snoz", label );
4057 outline0( "LD A, $1" );
4058 outline1( "LD (%s), A", _value );
4059 outline1( "JP %sdone", label );
4060 outhead1( "%snoz:", label );
4061 outline0( "LD A, $0" );
4062 outline1( "LD (%s), A", _value );
4063 outhead1( "%sdone:", label );
4064 outline0( "POP AF" );
4065 break;
4066 case REGISTER_HLA:
4067 outline1( "LD (%s), A", _value );
4068 outline0( "LD A, L" );
4069 outline1( "LD (%s), A", address_displacement( _environment, _value, "1" ) );
4070 outline0( "LD A, H" );
4071 outline1( "LD (%s), A", address_displacement( _environment, _value, "2" ) );
4072 break;
4073 }
4074
4075 } else {
4076
4077 Z80Stack stk = (Z80Stack) _asmio;
4078
4079 switch ( stk ) {
4080 case STACK_NONE:
4081 break;
4082 case STACK_BYTE:
4083 outline0( "POP AF" );
4084 outline1( "LD (%s), A", _value );
4085 break;
4086 case STACK_WORD:
4087 outline0( "POP HL" );
4088 outline1( "LD (%s), HL", _value );
4089 break;
4090 case STACK_DWORD:
4091 outline0( "POP HL" );
4092 outline1( "LD (%s), HL", address_displacement( _environment, _value, "0" ) );
4093 outline0( "POP HL" );
4094 outline1( "LD (%s), HL", address_displacement( _environment, _value, "2" ) );
4095 break;
4096 }
4097
4098 }
4099
4100}
4101
4102void cpu_return( Environment * _environment ) {
4103
4104 outline0("RET" );
4105
4106}
4107
4108void cpu_pop( Environment * _environment ) {
4109
4110 outline0("POP HL" );
4111
4112}
4113
4114void cpu_halt( Environment * _environment ) {
4115
4116 MAKE_LABEL
4117
4118 outhead1("%s:", label );
4119 outline1("jp %s", label );
4120
4121}
4122
4123void cpu_end( Environment * _environment ) {
4124
4125 outline0("DI");
4126 outline0("HLT");
4127
4128}
4129
4130void cpu_random( Environment * _environment, char * _entropy ) {
4131
4132 MAKE_LABEL
4133
4134 inline( cpu_random )
4135
4136 if ( _entropy ) {
4137 outline0("LD HL, (CPURANDOM_SEED)");
4138 outline0("LD B, (HL)");
4139 outline0("INC HL");
4140 outline0("LD A, (HL)");
4141 outline0("XOR B");
4142 outline1("LD HL, (%s)", _entropy);
4143 outline0("LD D, H");
4144 outline0("LD E, L");
4145 // outline0("LD B, H");
4146 outline0("LD C, L");
4147 outline0("ADD HL, HL");
4148 outline0("RL E");
4149 outline0("RL D");
4150 outline0("ADD HL, DE");
4151 outline0("RL E");
4152 outline0("RL D");
4153 outline0("INC L");
4154 outline0("ADD HL, BC");
4155 outline0("LD (CPURANDOM_SEED), HL");
4156 outline0("LD HL, (CPURANDOM_SEED+2)");
4157 outline0("ADD HL, DE");
4158 outline0("LD (CPURANDOM_SEED+1), HL");
4159 outline0("EX DE, HL");
4160 outline0("LD HL, (CPURANDOM_SEED)");
4161 outline0("PUSH HL");
4162 outline1("LD HL, (%s)", _entropy);
4163 outline0("LD D, H");
4164 outline0("LD E, L");
4165 outline0("POP HL");
4166 outline0("ADD HL, HL");
4167 outline0("RL C");
4168 outline0("RL B");
4169 outline0("LD (CPURANDOM_SEED+1), BC");
4170 outline0("SBC A, A");
4171 outline0("AND %11000101");
4172 outline0("XOR L");
4173 outline0("LD L, A");
4174 outline0("LD (CPURANDOM_SEED+1), HL");
4175 outline0("EX DE, HL");
4176 outline0("ADD HL, BC");
4177 }
4178
4179 embedded( cpu_random, src_hw_sm83_cpu_random_asm );
4180
4181 done()
4182
4183
4184}
4185
4186void cpu_random_8bit( Environment * _environment, char * _entropy, char * _result ) {
4187
4188 cpu_random( _environment, _entropy );
4189
4190 if ( _result ) {
4191 outline0("CALL CPURANDOM16" );
4192 outline0("LD A, H" );
4193 outline1("LD (%s), A", _result );
4194 }
4195
4196}
4197
4198void cpu_random_16bit( Environment * _environment, char * _entropy, char * _result ) {
4199
4200 cpu_random( _environment, _entropy );
4201
4202 if ( _result ) {
4203 outline0("CALL CPURANDOM16" );
4204 outline1("LD (%s), HL", _result );
4205 }
4206
4207}
4208
4209void cpu_random_32bit( Environment * _environment, char * _entropy, char * _result ) {
4210
4211 cpu_random( _environment, _entropy );
4212
4213 if ( _result ) {
4214 outline0("CALL CPURANDOM32" );
4215 outline1("LD (%s), HL", _result );
4216 outline1("LD (%s), BC", address_displacement( _environment, _result, "2" ) );
4217 }
4218
4219}
4220
4221void cpu_limit_16bit( Environment * _environment, char * _variable, int _value ) {
4222
4223 MAKE_LABEL
4224
4225 outline1( "LD A, (%s)", _variable );
4226 outline1( "CP $%2.2x", _value );
4227 outline1( "JR C, %s", label );
4228 outline1( "SUB $%2.2x", _value );
4229 outline1( "LD (%s), A", _variable );
4230 outhead1( "%s:", label );
4231
4232}
4233
4234void cpu_busy_wait( Environment * _environment, char * _timing ) {
4235
4236 MAKE_LABEL
4237
4238 outline1("LD A, (%s)", _timing );
4239 outhead1("%s:", label );
4240 outline0("DEC A");
4241 outline1("JR NZ, %s", label);
4242
4243}
4244
4252void cpu_port_out( Environment * _environment, char * _port, char * _value ) {
4253
4254 outline1("LD A, (%s)", _value );
4255 outline1("OUT (%s), A", _port );
4256
4257}
4258
4259void cpu_logical_and_8bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4260
4261 MAKE_LABEL
4262
4263 outline1("LD A, (%s)", _left );
4264 outline0("CMP 0" );
4265 outline1("JR Z, %s", label );
4266 outline1("LD A, (%s)", _right );
4267 outline0("CMP 0" );
4268 outline1("JR Z, %s", label );
4269 outline0("LD A, $ff" );
4270 outline1("LD (%s), A", _result );
4271 outline1("JMP %s_2", label );
4272 outhead1("%s:", label );
4273 outline0("LD A, 0" );
4274 outline1("LD (%s), A", _result );
4275 outhead1("%s_2:", label );
4276
4277
4278}
4279
4280void cpu_and_8bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4281
4282 MAKE_LABEL
4283
4284 outline1("LD HL, %s", _left );
4285 outline1("LD DE, %s", _right );
4286 outline0("LD A, (HL)" );
4287 outline0("LD B, A" );
4288 outline0("LD A, (DE)" );
4289 outline0("AND B" );
4290 outline1("LD (%s), A", _result );
4291
4292}
4293
4294void cpu_and_8bit_const( Environment * _environment, char * _left, int _right, char * _result ) {
4295
4296 MAKE_LABEL
4297
4298 outline1("LD A, (%s)", _left );
4299 outline1("OR $%2.2x", _right );
4300 outline1("LD (%s), A", _result );
4301
4302}
4303
4304void cpu_and_16bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4305
4306 MAKE_LABEL
4307
4308 outline1("LD HL, %s", _left );
4309 outline1("LD DE, %s", _right );
4310 outline0("LD A, (HL)" );
4311 outline0("LD B, A" );
4312 outline0("LD A, (DE)" );
4313 outline0("AND B" );
4314 outline1("LD (%s), A", _result );
4315 outline0("INC HL" );
4316 outline0("INC DE" );
4317 outline0("LD A, (HL)" );
4318 outline0("LD B, A" );
4319 outline0("LD A, (DE)" );
4320 outline0("AND B" );
4321 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4322
4323}
4324
4325void cpu_and_32bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4326
4327 MAKE_LABEL
4328
4329 outline1("LD HL, %s", _left );
4330 outline1("LD DE, %s", _right );
4331 outline0("LD A, (HL)" );
4332 outline0("LD B, A" );
4333 outline0("LD A, (DE)" );
4334 outline0("AND B" );
4335 outline1("LD (%s), A", _result );
4336 outline0("INC HL" );
4337 outline0("INC DE" );
4338 outline0("LD A, (HL)" );
4339 outline0("LD B, A" );
4340 outline0("LD A, (DE)" );
4341 outline0("AND B" );
4342 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4343 outline0("INC HL" );
4344 outline0("INC DE" );
4345 outline0("LD A, (HL)" );
4346 outline0("LD B, A" );
4347 outline0("LD A, (DE)" );
4348 outline0("AND B" );
4349 outline1("LD (%s), A", address_displacement( _environment, _result, "2" ) );
4350 outline0("INC HL" );
4351 outline0("INC DE" );
4352 outline0("LD A, (HL)" );
4353 outline0("LD B, A" );
4354 outline0("LD A, (DE)" );
4355 outline0("AND B" );
4356 outline1("LD (%s), A", address_displacement( _environment, _result, "3" ) );
4357
4358}
4359
4360void cpu_logical_or_8bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4361
4362 MAKE_LABEL
4363
4364 outline1("LD A, (%s)", _left );
4365 outline1("JR NZ, %sd1", label );
4366 outline1("LD A, (%s)", _right );
4367 outline1("JR NZ, %sd1", label );
4368 outhead1("%s0:", label );
4369 outline0("LD A, 0" );
4370 outline1("LD (%s), A", _result );
4371 outline1("JMP %sx", label );
4372 outhead1("%sd1:", label );
4373 outline0("LD A, $ff" );
4374 outline1("LD (%s), A", _result );
4375 outhead1("%sx:", label );
4376
4377}
4378
4379void cpu_or_8bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4380
4381 MAKE_LABEL
4382
4383 outline1("LD HL, %s", _left );
4384 outline1("LD A, (%s)", _right );
4385 outline0("LD B, A" );
4386 outline0("LD A, (HL)" );
4387 outline0("OR B" );
4388 outline1("LD (%s), A", _result );
4389
4390}
4391
4392void cpu_or_8bit_const( Environment * _environment, char * _left, int _right, char * _result ) {
4393
4394 MAKE_LABEL
4395
4396 outline1("LD A, (%s)", _left );
4397 outline1("OR $%2.2x", _right );
4398 outline1("LD (%s), A", _result );
4399
4400}
4401
4402
4403void cpu_or_16bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4404
4405 MAKE_LABEL
4406
4407 outline1("LD HL, %s", _left );
4408 outline1("LD A, (%s)", _right );
4409 outline0("LD B, A" );
4410 outline0("LD A, (HL)" );
4411 outline0("OR B" );
4412 outline1("LD (%s), A", _result );
4413 outline0("INC HL" );
4414 outline1("LD A, (%s)", address_displacement( _environment, _right, "1" ) );
4415 outline0("LD B, A" );
4416 outline0("LD A, (HL)" );
4417 outline0("OR B" );
4418 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4419 outline0("INC HL" );
4420
4421}
4422
4423void cpu_or_32bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4424
4425 MAKE_LABEL
4426
4427 outline1("LD HL, %s", _left );
4428 outline1("LD A, (%s)", _right );
4429 outline0("LD B, A" );
4430 outline0("LD A, (HL)" );
4431 outline0("OR B" );
4432 outline1("LD (%s), A", _result );
4433 outline0("INC HL" );
4434 outline1("LD A, (%s)", address_displacement( _environment, _right, "1" ) );
4435 outline0("LD B, A" );
4436 outline0("LD A, (HL)" );
4437 outline0("OR B" );
4438 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4439 outline0("INC HL" );
4440 outline1("LD A, (%s)", address_displacement( _environment, _right, "2" ) );
4441 outline0("LD B, A" );
4442 outline0("LD A, (HL)" );
4443 outline0("OR B" );
4444 outline1("LD (%s), A", address_displacement( _environment, _result, "2" ) );
4445 outline0("INC HL" );
4446 outline1("LD A, (%s)", address_displacement( _environment, _right, "3" ) );
4447 outline0("LD B, A" );
4448 outline0("LD A, (HL)" );
4449 outline0("OR B" );
4450 outline1("LD (%s), A", address_displacement( _environment, _result, "3" ) );
4451
4452}
4453
4454void cpu_xor_8bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4455
4456 MAKE_LABEL
4457
4458 outline1("LD A, (%s)", _left );
4459 outline0("LD B, A" );
4460 outline1("LD A, (%s)", _right );
4461 outline0("XOR B" );
4462 outline1("LD (%s), A", _result );
4463
4464}
4465
4466void cpu_xor_8bit_const( Environment * _environment, char * _left, int _right, char * _result ) {
4467
4468 MAKE_LABEL
4469
4470 outline1("LD HL, %s", _left );
4471 outline0("LD A, (HL)" );
4472 outline1("XOR $%2.2x", (unsigned char)(_right&0xff) );
4473 outline1("LD (%s), A", _result );
4474
4475}
4476
4477void cpu_xor_16bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4478
4479 MAKE_LABEL
4480
4481 outline1("LD HL, %s", _left );
4482 outline0("LD A, (HL)" );
4483 outline0("LD B, A" );
4484 outline1("LD A, (%s)", _right );
4485 outline0("XOR B" );
4486 outline1("LD (%s), A", _result );
4487 outline0("INC HL" );
4488 outline0("LD A, (HL)" );
4489 outline0("LD B, A" );
4490 outline1("LD A, (%s)", address_displacement( _environment, _right, "1" ) );
4491 outline0("XOR B" );
4492 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4493 outline0("INC HL" );
4494
4495}
4496
4497void cpu_xor_16bit_const( Environment * _environment, char * _left, int _right, char * _result ) {
4498
4499 MAKE_LABEL
4500
4501 outline1("LD HL, %s", _left );
4502 outline1("LD DE, %s", _result );
4503 outline0("LD A, (HL)" );
4504 outline1("XOR $%2.2x", (unsigned char)((_right) & 0xff) );
4505 outline0("LD (DE), A" );
4506 outline0("INC HL" );
4507 outline0("INC DE" );
4508 outline0("LD A, (HL)" );
4509 outline1("XOR $%2.2x", (unsigned char)((_right>>8) & 0xff) );
4510 outline0("LD (DE), A" );
4511 outline0("INC HL" );
4512 outline0("INC DE" );
4513
4514}
4515
4516
4517void cpu_xor_32bit( Environment * _environment, char * _left, char * _right, char * _result ) {
4518
4519 MAKE_LABEL
4520
4521 outline1("LD HL, %s", _left );
4522 outline0("LD A, (HL)" );
4523 outline0("LD B, A" );
4524 outline1("LD A, (%s)", _right );
4525 outline0("XOR B" );
4526 outline1("LD (%s), A", _result );
4527 outline0("INC HL" );
4528 outline0("LD A, (HL)" );
4529 outline0("LD B, A" );
4530 outline1("LD A, (%s)", address_displacement( _environment, _right, "1" ) );
4531 outline0("XOR B" );
4532 outline1("LD (%s), A", address_displacement( _environment, _result, "1" ) );
4533 outline0("INC HL" );
4534 outline0("LD A, (HL)" );
4535 outline0("LD B, A" );
4536 outline1("LD A, (%s)", address_displacement( _environment, _right, "2" ) );
4537 outline0("XOR B" );
4538 outline1("LD (%s), A", address_displacement( _environment, _result, "2" ) );
4539 outline0("INC HL" );
4540 outline0("LD A, (HL)" );
4541 outline0("LD B, A" );
4542 outline1("LD A, (%s)", address_displacement( _environment, _right, "3" ) );
4543 outline0("XOR B" );
4544 outline1("LD (%s), A", address_displacement( _environment, _result, "3" ) );
4545
4546}
4547
4548void cpu_xor_32bit_const( Environment * _environment, char * _left, int _right, char * _result ) {
4549
4550 MAKE_LABEL
4551
4552 outline1("LD HL, %s", _left );
4553 outline1("LD DE, %s", _result );
4554 outline0("LD A, (HL)" );
4555 outline1("XOR $%2.2x", (unsigned char)(_right & 0xff ) );
4556 outline0("LD (DE), A" );
4557 outline0("INC HL" );
4558 outline0("INC DE" );
4559 outline0("LD A, (HL)" );
4560 outline1("XOR $%2.2x", (unsigned char)((_right>>8) & 0xff ) );
4561 outline0("LD (DE), A" );
4562 outline0("INC HL" );
4563 outline0("INC DE" );
4564 outline0("LD A, (HL)" );
4565 outline1("XOR $%2.2x", (unsigned char)((_right>>16) & 0xff ) );
4566 outline0("LD (DE), A" );
4567 outline0("INC HL" );
4568 outline0("INC DE" );
4569 outline0("LD A, (HL)" );
4570 outline1("XOR $%2.2x", (unsigned char)((_right>>24) & 0xff ) );
4571 outline0("LD (DE), A" );
4572
4573}
4574
4575void cpu_swap_8bit( Environment * _environment, char * _left, char * _right ) {
4576
4577 no_inline( cpu_swap_8bit )
4578
4579 embedded( cpu_swap_8bit, src_hw_sm83_cpu_swap_asm ) // it is not an error: swap 8/16/32 shares code
4580
4581 outline1("LD HL, %s", _right );
4582 outline1("LD DE, %s", _left );
4583 outline0("LD B, 1" );
4584 outline0("CALL CPUSWAP" );
4585
4586 done( )
4587
4588}
4589
4590void cpu_swap_16bit( Environment * _environment, char * _left, char * _right ) {
4591
4592 no_inline( cpu_swap_8bit )
4593
4594 embedded( cpu_swap_8bit, src_hw_sm83_cpu_swap_asm ) // it is not an error: swap 8/16/32 shares code
4595
4596 outline1("LD HL, %s", _right );
4597 outline1("LD DE, %s", _left );
4598 outline0("LD B, 2" );
4599 outline0("CALL CPUSWAP" );
4600
4601 done( )
4602
4603}
4604
4605void cpu_swap_32bit( Environment * _environment, char * _left, char * _right ) {
4606
4607 no_inline( cpu_swap_8bit )
4608
4609 embedded( cpu_swap_8bit, src_hw_sm83_cpu_swap_asm ) // it is not an error: swap 8/16/32 shares code
4610
4611 outline1("LD HL, %s", _right );
4612 outline1("LD DE, %s", _left );
4613 outline0("LD B, 4" );
4614 outline0("CALL CPUSWAP" );
4615
4616 done( )
4617
4618}
4619
4620void cpu_logical_not_8bit( Environment * _environment, char * _value, char * _result ) {
4621
4622 outline1("LD A, (%s)", _value );
4623 outline0("XOR $FF" );
4624 outline1("LD (%s), A", _result );
4625
4626}
4627
4628void cpu_not_8bit( Environment * _environment, char * _value, char * _result ) {
4629
4630 outline1("LD A, (%s)", _value );
4631 outline0("XOR $FF" );
4632 outline1("LD (%s), A", _result );
4633
4634}
4635
4636void cpu_not_16bit( Environment * _environment, char * _value, char * _result ) {
4637
4638 outline1("LD HL, %s", _value );
4639 outline1("LD DE, %s", _result );
4640 outline0("LD A, (HL)" );
4641 outline0("XOR $FF" );
4642 outline0("LD (DE), A" );
4643 outline0("INC HL" );
4644 outline0("INC DE" );
4645 outline0("LD A, (HL)" );
4646 outline0("XOR $FF" );
4647 outline0("LD (DE), A" );
4648
4649}
4650
4651void cpu_not_32bit( Environment * _environment, char * _value, char * _result ) {
4652
4653 outline1("LD HL, %s", _value );
4654 outline1("LD DE, %s", _result );
4655 outline0("LD A, (HL)" );
4656 outline0("XOR $FF" );
4657 outline0("LD (DE), A" );
4658 outline0("INC HL" );
4659 outline0("INC DE" );
4660 outline0("LD A, (HL)" );
4661 outline0("XOR $FF" );
4662 outline0("LD (DE), A" );
4663 outline0("INC HL" );
4664 outline0("INC DE" );
4665 outline0("LD A, (HL)" );
4666 outline0("XOR $FF" );
4667 outline0("LD (DE), A" );
4668 outline0("INC HL" );
4669 outline0("INC DE" );
4670 outline0("LD A, (HL)" );
4671 outline0("XOR $FF" );
4672 outline0("LD (DE), A" );
4673
4674}
4675
4676void cpu_di( Environment * _environment ) {
4677
4678 outline0("DI" );
4679
4680}
4681
4682void cpu_ei( Environment * _environment ) {
4683
4684 outline0("EI" );
4685
4686}
4687
4688void cpu_inc( Environment * _environment, char * _variable ) {
4689
4690 outline1("LD A, (%s)", _variable );
4691 outline0("INC A" );
4692 outline1("LD (%s), A", _variable );
4693
4694}
4695
4696void cpu_dec( Environment * _environment, char * _variable ) {
4697
4698 outline1("LD A, (%s)", _variable );
4699 outline0("DEC A" );
4700 outline1("LD (%s), A", _variable );
4701
4702}
4703
4704void cpu_inc_16bit( Environment * _environment, char * _variable ) {
4705
4706 outline1("LD HL, (%s)", _variable );
4707 outline0("INC HL" );
4708 outline1("LD (%s), HL", _variable );
4709
4710}
4711
4712void cpu_inc_32bit( Environment * _environment, char * _variable ) {
4713
4714 MAKE_LABEL
4715
4716 outline1("LD HL, (%s)", _variable );
4717 outline0("INC HL" );
4718 outline1("LD (%s), HL", _variable );
4719 outline0("LD A, L" );
4720 outline0("CMP 0" );
4721 outline1("JR NZ, %s", label );
4722 outline0("LD A, h" );
4723 outline0("CMP 0" );
4724 outline1("JR NZ, %s", label );
4725 outline1("LD HL, (%s)", address_displacement(_environment, _variable, "2") );
4726 outline0("INC HL" );
4727 outline1("LD (%s), HL", address_displacement( _environment, _variable, "2" ) );
4728 outhead1("%s:", label );
4729
4730}
4731
4732void cpu_inc_nbit( Environment * _environment, char * _variable, int _bits ) {
4733
4734 MAKE_LABEL
4735
4736 inline( cpu_inc_nbit )
4737
4738 for( int i=0; i<(_bits>>3);++i ) {
4739 char offset[MAX_TEMPORARY_STORAGE]; sprintf(offset, "%d", i );
4740 outline1("LD A, (%s)", address_displacement(_environment, _variable, offset ) );
4741 outline0("INC A");
4742 outline1("LD (%s), A", address_displacement(_environment, _variable, offset ) );
4743 outline1("JP NZ, %s", label );
4744 }
4745 outhead1("%s:", label );
4746
4747 no_embedded( cpu_inc_nbit )
4748
4749}
4750
4751void cpu_dec_16bit( Environment * _environment, char * _variable ) {
4752
4753 outline1("LD HL, (%s)", _variable );
4754 outline0("DEC HL" );
4755 outline1("LD (%s), HL", _variable );
4756
4757}
4758
4759void cpu_dec_32bit( Environment * _environment, char * _variable ) {
4760
4761 MAKE_LABEL
4762
4763 outline1("LD HL, (%s)", _variable );
4764 outline0("DEC HL" );
4765 outline1("LD (%s), HL", _variable );
4766 outline0("LD A, L" );
4767 outline0("AND H" );
4768 outline0("CP $FF" );
4769 outline1("JR NZ, %s", label );
4770 outline1("LD HL, (%s)", _variable );
4771 outline0("DEC HL" );
4772 outline1("LD (%s), HL", _variable );
4773 outhead1("%s:", label );
4774
4775}
4776
4777void cpu_dec_nbit( Environment * _environment, char * _variable, int _bits ) {
4778
4779 MAKE_LABEL
4780
4781 inline( cpu_dec_32bit )
4782
4783 for( int i=0; i<(_bits>>3); ++i ) {
4784 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
4785 outline1("LD A, (%s)", address_displacement(_environment, _variable, offset) );
4786 outline0("DEC A" );
4787 outline1("LD (%s), A", address_displacement(_environment, _variable, offset) );
4788 outline0("CP $FF" );
4789 outline1("JP NZ, %s", label );
4790 }
4791 outhead1("%s:", label );
4792
4793 no_embedded( cpu_dec_32bit )
4794
4795}
4796
4797void cpu_mem_move( Environment * _environment, char *_source, char *_destination, char *_size ) {
4798
4799 deploy( duff, src_hw_sm83_duff_asm );
4800
4801 outline1("LD HL, (%s)", _destination);
4802 outline0("LD D, H");
4803 outline0("LD E, L");
4804 outline1("LD HL, (%s)", _source);
4805 outline1("LD A, (%s)", _size);
4806 outline0("LD C, A");
4807 outline0("LD B, 0");
4808 outline0("CALL DUFFDEVICE");
4809
4810}
4811
4812void cpu_mem_move_16bit( Environment * _environment, char *_source, char *_destination, char *_size ) {
4813
4814 deploy( duff, src_hw_sm83_duff_asm );
4815
4816 outline1("LD HL, (%s)", _destination);
4817 outline0("LD D, H");
4818 outline0("LD E, L");
4819 outline1("LD HL, (%s)", _size);
4820 outline0("LD BC, HL");
4821 outline1("LD HL, (%s)", _source);
4822 outline0("CALL DUFFDEVICE");
4823
4824}
4825
4826void cpu_mem_move_direct( Environment * _environment, char *_source, char *_destination, char *_size ) {
4827
4828 deploy( duff, src_hw_sm83_duff_asm );
4829
4830 outline1("LD HL, %s", _source);
4831 outline1("LD DE, %s", _destination);
4832 outline1("LD A, (%s)", _size);
4833 outline0("LD C, A");
4834 outline0("LD B, 0");
4835 outline0("CALL DUFFDEVICE");
4836
4837}
4838
4839void cpu_mem_move_direct2( Environment * _environment, char *_source, char *_destination, char *_size ) {
4840
4841 deploy( duff, src_hw_sm83_duff_asm );
4842
4843 outline1("LD HL, (%s)", _size);
4844 outline0("LD BC, HL");
4845 outline1("LD HL, (%s)", _source);
4846 outline1("LD DE, %s", _destination);
4847 outline0("CALL DUFFDEVICE");
4848
4849}
4850
4851void cpu_mem_move_direct2_size( Environment * _environment, char *_source, char *_destination, int _size ) {
4852
4853 deploy( duff, src_hw_sm83_duff_asm );
4854
4855 outline1("LD HL, (%s)", _source);
4856 outline1("LD DE, %s", _destination);
4857 outline1("LD BC, $%4.4x", _size);
4858 outline0("CALL DUFFDEVICE");
4859
4860}
4861
4862void cpu_mem_move_size( Environment * _environment, char *_source, char *_destination, int _size ) {
4863
4864 if ( _size > 0 ) {
4865
4866 deploy( duff, src_hw_sm83_duff_asm );
4867
4868 outline1("LD HL, (%s)", _destination);
4869 outline0("LD D, H");
4870 outline0("LD E, L");
4871 outline1("LD HL, (%s)", _source);
4872 outline1("LD A, $%2.2x", ( _size & 0xff ) );
4873 outline0("LD C, A");
4874 outline1("LD B, $%2.2x", ( _size >> 8 ) & 0xff );
4875 outline0("CALL DUFFDEVICE");
4876
4877 }
4878
4879}
4880
4881void cpu_mem_move_direct_size( Environment * _environment, char *_source, char *_destination, int _size ) {
4882
4883 if ( _size > 0 ) {
4884
4885 deploy( duff, src_hw_sm83_duff_asm );
4886
4887 outline1("LD HL, %s", _source);
4888 outline1("LD DE, %s", _destination);
4889 outline1("LD A, $%2.2x", ( _size & 0xff ) );
4890 outline0("LD C, A");
4891 outline1("LD B, $%2.2x", ( _size >> 8 ) & 0xff );
4892 outline0("CALL DUFFDEVICE");
4893 }
4894
4895}
4896
4897void cpu_mem_move_direct_indirect_size( Environment * _environment, char *_source, char *_destination, int _size ) {
4898
4899 if ( _size ) {
4900
4901 deploy( duff, src_hw_sm83_duff_asm );
4902
4903 outline1("LD HL, (%s)", _destination);
4904 outline0("LD D, H");
4905 outline0("LD E, L");
4906 outline1("LD HL, %s", _source);
4907 outline1("LD A, $%2.2x", ( _size & 0xff ) );
4908 outline0("LD C, A");
4909 outline1("LD B, $%2.2x", ( _size >> 8 ) & 0xff );
4910 outline0("CALL DUFFDEVICE");
4911 }
4912
4913}
4914
4915void cpu_mem_move_indirect_direct_size( Environment * _environment, char *_source, char *_destination, int _size ) {
4916
4917 if ( _size ) {
4918
4919 deploy( duff, src_hw_sm83_duff_asm );
4920
4921 outline1("LD HL, (%s)", _source);
4922 outline1("LD DE, %s", _destination);
4923 outline1("LD A, $%2.2x", ( _size & 0xff ) );
4924 outline0("LD C, A");
4925 outline1("LD B, $%2.2x", ( _size >> 8 ) & 0xff );
4926 outline0("CALL DUFFDEVICE");
4927 }
4928
4929}
4930
4931void cpu_compare_memory( Environment * _environment, char *_source, char *_destination, char *_size, char * _result, int _equal ) {
4932
4933 MAKE_LABEL
4934
4935 outline1("LD A, (%s)", _size);
4936 outline0("CP 0");
4937 outline1("JR Z, %sequal", label);
4938 outline0("LD C, A");
4939 outline1("LD HL, (%s)", _destination);
4940 outline0("LD D, H");
4941 outline0("LD E, L");
4942 outline1("LD HL, (%s)", _source);
4943 outhead1("%s:", label );
4944 outline0("LD A, (HL)");
4945 outline0("LD B, A");
4946 outline0("LD A, (DE)");
4947 outline0("CP B");
4948 outline1("JR NZ, %sdiff", label);
4949 outline0("INC DE");
4950 outline0("INC HL");
4951 outline0("DEC C");
4952 outline1("JR NZ, %s", label);
4953 outhead1("%sequal:", label );
4954 outline1("LD A, $%2.2x", _equal ? 255 : 0 );
4955 outline1("LD (%s), A", _result );
4956 outline1("JMP %sfinal", label );
4957 outhead1("%sdiff:", label );
4958 outline1("LD A, $%2.2x", _equal ? 0 : 255 );
4959 outline1("LD (%s), A", _result );
4960 outhead1("%sfinal:", label );
4961
4962}
4963
4964void cpu_compare_memory_size( Environment * _environment, char *_source, char *_destination, int _size, char * _result, int _equal ) {
4965
4966 MAKE_LABEL
4967
4968 outline1("LD HL, (%s)", _destination);
4969 outline0("LD D, H");
4970 outline0("LD E, L");
4971 outline1("LD HL, (%s)", _source);
4972 outline1("LD A, $%2.2x", ( _size & 0xff ) );
4973 outline0("LD C, A");
4974 outhead1("%s:", label );
4975 outline0("LD A, (HL)");
4976 outline0("LD B, A");
4977 outline0("LD A, (DE)");
4978 outline0("CP B");
4979 outline1("JR NZ, %sdiff", label);
4980 outline0("INC DE");
4981 outline0("INC HL");
4982 outline0("DEC C");
4983 outline1("JR NZ, %s", label);
4984 outline1("LD A, $%2.2x", _equal ? 255 : 0 );
4985 outline1("LD (%s), A", _result );
4986 outline1("JMP %sfinal", label );
4987 outhead1("%sdiff:", label );
4988 outline1("LD A, $%2.2x", _equal ? 0 : 255 );
4989 outline1("LD (%s), A", _result );
4990 outhead1("%sfinal:", label );
4991
4992}
4993
4994void cpu_less_than_memory( Environment * _environment, char *_source, char *_destination, char *_size, char * _result, int _equal ) {
4995
4996 MAKE_LABEL
4997
4998 outline1("LD HL, (%s)", _destination);
4999 outline0("LD D, H");
5000 outline0("LD E, L");
5001 outline1("LD HL, (%s)", _source);
5002 outline1("LD A, (%s)", _size);
5003 outline0("LD C, A");
5004 outhead1("%s:", label );
5005 outline0("LD A, (DE)");
5006 outline0("LD B, A");
5007 outline0("LD A, (HL)");
5008 outline0("CP B");
5009 if ( _equal ) {
5010 outline1("JR Z, %seq", label);
5011 }
5012 outline1("JR NC, %sdiff", label);
5013 if ( ! _equal ) {
5014 outline1("JR Z, %sdiff", label);
5015 }
5016 outhead1("%seq:", label );
5017 outline0("INC DE");
5018 outline0("INC HL");
5019 outline0("DEC C");
5020 outline1("JR NZ, %s", label);
5021 outline0("LD A, $ff" );
5022 outline1("LD (%s), A", _result );
5023 outline1("JMP %sfinal", label );
5024 outhead1("%sdiff:", label );
5025 outline0("LD A, 0" );
5026 outline1("LD (%s), A", _result );
5027 outhead1("%sfinal:", label );
5028
5029}
5030
5031void cpu_less_than_memory_size( Environment * _environment, char *_source, char *_destination, int _size, char * _result, int _equal ) {
5032
5033 MAKE_LABEL
5034
5035 outline1("LD HL, (%s)", _destination);
5036 outline0("LD D, H");
5037 outline0("LD E, L");
5038 outline1("LD HL, (%s)", _source);
5039 outline1("LD A, $%2.2x", ( _size & 0xff ) );
5040 outline0("LD C, A");
5041 outhead1("%s:", label );
5042 outline0("LD A, (DE)");
5043 outline0("LD B, A");
5044 outline0("LD A, (HL)");
5045 outline0("CP B");
5046 if ( _equal ) {
5047 outline1("JR Z, %seq", label);
5048 }
5049 outline1("JR NC, %sdiff", label);
5050 if ( ! _equal ) {
5051 outline1("JR Z, %sdiff", label);
5052 }
5053 outhead1("%seq:", label );
5054 outline0("INC DE");
5055 outline0("INC HL");
5056 outline0("DEC C");
5057 outline1("JR NZ, %s", label);
5058 outline0("LD A, $ff" );
5059 outline1("LD (%s), A", _result );
5060 outline1("JMP %sfinal", label );
5061 outhead1("%sdiff:", label );
5062 outline0("LD A, 0" );
5063 outline1("LD (%s), A", _result );
5064 outhead1("%sfinal:", label );
5065
5066}
5067
5068void cpu_greater_than_memory( Environment * _environment, char *_source, char *_destination, char *_size, char * _result, int _equal ) {
5069
5070 MAKE_LABEL
5071
5072 outline1("LD HL, (%s)", _destination);
5073 outline0("LD D, H");
5074 outline0("LD E, L");
5075 outline1("LD HL, (%s)", _source);
5076 outline1("LD A, (%s)", _size);
5077 outline0("LD C, A");
5078 outhead1("%s:", label );
5079 outline0("LD A, (DE)");
5080 outline0("LD B, A");
5081 outline0("LD A, (HL)");
5082 outline0("CP B");
5083 if ( !_equal ) {
5084 outline1("JR Z, %sdiff", label);
5085 }
5086 outline1("JR C, %sdiff", label);
5087 outline0("INC DE");
5088 outline0("INC HL");
5089 outline0("DEC C");
5090 outline1("JR NZ, %s", label);
5091 outline1("LD A, $%2.2x", 255 );
5092 outline1("LD (%s), A", _result );
5093 outline1("JMP %sfinal", label );
5094 outhead1("%sdiff:", label );
5095 outline1("LD A, $%2.2x", 0 );
5096 outline1("LD (%s), A", _result );
5097 outhead1("%sfinal:", label );
5098
5099}
5100
5101void cpu_greater_than_memory_size( Environment * _environment, char *_source, char *_destination, int _size, char * _result, int _equal ) {
5102
5103 MAKE_LABEL
5104
5105 outline1("LD HL, (%s)", _destination);
5106 outline0("LD D, H");
5107 outline0("LD E, L");
5108 outline1("LD HL, (%s)", _source);
5109 outline1("LD A, $%2.2x", ( _size & 0xff ) );
5110 outline0("LD C, A");
5111 outhead1("%s:", label );
5112 outline0("LD A, (DE)");
5113 outline0("LD B, A");
5114 outline0("LD A, (HL)");
5115 outline0("CP B");
5116 if ( ! _equal ) {
5117 outline1("JR Z, %sdiff", label);
5118 }
5119 outline1("JR C, %sdiff", label);
5120 outline0("INC DE");
5121 outline0("INC HL");
5122 outline0("DEC C");
5123 outline1("JR NZ, %s", label);
5124 outline1("LD A, $%2.2x", 255 );
5125 outline1("LD (%s), A", _result );
5126 outline1("JMP %sfinal", label );
5127 outhead1("%sdiff:", label );
5128 outline1("LD A, $%2.2x", 0 );
5129 outline1("LD (%s), A", _result );
5130 outhead1("%sfinal:", label );
5131
5132}
5133
5134void cpu_math_add_16bit_with_8bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
5135
5136 outline1("LD HL, (%s)", _source );
5137 outline0("LD DE, 0" );
5138 outline1("LD A, (%s)", _destination );
5139 outline0("LD E, A" );
5140 outline0("ADD HL, DE" );
5141 if ( _other ) {
5142 outline1("LD (%s), HL", _other );
5143 } else {
5144 outline1("LD (%s), HL", _destination );
5145 }
5146
5147}
5148
5149void cpu_math_sub_16bit_with_8bit( Environment * _environment, char *_source, char *_destination, char *_other ) {
5150
5151 outline1("LD HL, (%s)", _source );
5152 outline0("LD DE, 0" );
5153 outline1("LD A, (%s)", _destination );
5154 outline0("LD E, A" );
5155 outline0("CALL SBC_HL_DE" );
5156 if ( _other ) {
5157 outline1("LD (%s), HL", _other );
5158 } else {
5159 outline1("LD (%s), HL", _destination );
5160 }
5161
5162}
5163
5164void cpu_uppercase( Environment * _environment, char *_source, char *_size, char *_result ) {
5165
5166 MAKE_LABEL
5167
5168 if ( _result ) {
5169 outline1("LD HL, (%s)", _result);
5170 outline0("LD D, H");
5171 outline0("LD E, L");
5172 } else {
5173 outline1("LD HL, (%s)", _source);
5174 outline0("LD D, H");
5175 outline0("LD E, L");
5176 }
5177 outline1("LD A, (%s)", _size);
5178 outline0("LD C, A" );
5179 outline1("LD HL, (%s)", _source );
5180 outhead1("%supper:", label );
5181 outline0("LD A, (HL)" );
5182
5183 outline0("CP 97");
5184 outline1("JR C, %snext", label);
5185
5186 outline0("CP 122");
5187 outline1("JR NC, %snext", label);
5188
5189 outline0("SUB A, 32");
5190 outline0("LD (DE), A" );
5191 outline1("JP %sdone", label );
5192
5193 outhead1("%snext:", label );
5194 outline0("LD (DE), A" );
5195 outhead1("%sdone:", label );
5196 outline0("INC HL" );
5197 outline0("INC DE" );
5198 outline0("DEC C" );
5199 outline0("LD A, C" );
5200 outline0("CP 0" );
5201 outline1("JR NZ, %supper", label);
5202
5203}
5204
5205void cpu_lowercase( Environment * _environment, char *_source, char *_size, char *_result ) {
5206
5207 MAKE_LABEL
5208
5209 if ( _result ) {
5210 outline1("LD HL, (%s)", _result);
5211 outline0("LD D, H");
5212 outline0("LD E, L");
5213 } else {
5214 outline1("LD HL, (%s)", _source);
5215 outline0("LD D, H");
5216 outline0("LD E, L");
5217 }
5218 outline1("LD A, (%s)", _size);
5219 outline0("LD C, A" );
5220 outline1("LD HL, (%s)", _source );
5221 outhead1("%slower:", label );
5222 outline0("LD A, (HL)" );
5223
5224 outline0("CP 65");
5225 outline1("JR C, %snext", label);
5226
5227 outline0("CP 91");
5228 outline1("JR NC, %snext", label);
5229
5230 outline0("ADC A, 31");
5231 outline0("LD (DE), A" );
5232 outline1("JP %sdone", label );
5233 outhead1("%snext:", label );
5234 outline0("LD (DE), A" );
5235 outhead1("%sdone:", label );
5236 outline0("INC HL" );
5237 outline0("INC DE" );
5238 outline0("DEC C" );
5239 outline0("LD A, C" );
5240 outline0("CP 0" );
5241 outline1("JR NZ, %slower", label);
5242
5243}
5244
5245void cpu_convert_string_into_8bit( Environment * _environment, char * _string, char * _len, char * _value ) {
5246
5247 Variable * temp = variable_temporary( _environment, VT_WORD, "(temp)" );
5248
5249 cpu_convert_string_into_16bit( _environment, _string, _len, temp->realName );
5250
5251 cpu_move_8bit( _environment, temp->realName, _value );
5252
5253}
5254
5255void cpu_convert_string_into_16bit( Environment * _environment, char * _string, char * _len, char * _value ) {
5256
5257 MAKE_LABEL
5258
5259 outline0("LD HL, 0" );
5260 outline0("LD (IXR), HL" );
5261 outline1("LD A, (%s)", _len );
5262 outline0("LD (IXR), A" );
5263
5264 outline0("LD A, 0" );
5265 outline1("LD (%s), A", _value );
5266 outline1("LD (%s+1), A", _value );
5267
5268 outline1("LD HL, (%s)", _string );
5269
5270 outhead1("%srepeat:", label );
5271
5272 outline0("LD A, (HL)" );
5273 outline0("CP $40" );
5274 outline1("JP NC, %send", label);
5275 outline0("CP $30" );
5276 outline1("JP C, %send", label);
5277 outline0("SBC A, $30" );
5278
5279 outline0("PUSH AF" );
5280 outline1("LD A, (%s)", address_displacement(_environment, _value, "1") );
5281 outline0("LD B, A" );
5282 outline1("LD A, (%s)", _value );
5283 outline0("LD C, A" );
5284 outline0("POP AF" );
5285 outline0("LD E, A" );
5286 outline0("LD D, 0" );
5287 outline0("PUSH HL" );
5288 outline0("LD HL, 0" );
5289 outline0("CALL ADC_HL_DE" );
5290 outline0("CALL ADC_HL_BC" );
5291 outline1("LD (%s), HL", _value );
5292 outline0("POP HL" );
5293
5294
5295 // MULT x 10
5296
5297 outline0("INC HL" );
5298 outline0("PUSH HL" );
5299 outline0("LD HL, (IXR)" );
5300 outline0("DEC HL" );
5301 outline0("LD (IXR), HL" );
5302 outline0("POP HL" );
5303 outline0("LD A, 0" );
5304 outline0("PUSH HL" );
5305 outline0("LD HL, (IXR)" );
5306 outline0("CP L" );
5307 outline0("POP HL" );
5308 outline1("JR Z,%send", label );
5309
5310 outline0("PUSH HL" );
5311
5312 outline0("PUSH HL" );
5313 outline1("LD HL, (%s)", _value );
5314 outline0("LD D, H");
5315 outline0("LD E, L");
5316 outline0("POP HL" );
5317
5318 outline0("LD A, 10" );
5319 outline0("LD B, 8" );
5320 outline0("LD HL, 0" );
5321 outline0("ADD HL, HL" );
5322 outline0("RLCA" );
5323 outline0("JR NC,$+3" );
5324 outline0("ADD HL, DE" );
5325 outline0("DJNZ $-5" );
5326 outline1("LD (%s), HL", _value );
5327
5328 outline0("POP HL" );
5329
5330 outline1("JMP %srepeat", label );
5331
5332 outhead1("%send:", label );
5333
5334}
5335
5336void cpu_fill_indirect( Environment * _environment, char * _address, char * _size, char * _pattern, int _size_size ) {
5337
5338 MAKE_LABEL
5339
5340 // Use the current bitmap address as starting address for filling routine.
5341 outline1("LD HL, (%s)", _address );
5342 outline0("LD D, H");
5343 outline0("LD E, L");
5344 outline1("LD HL, (%s)", _pattern);
5345
5346 // Fill the bitmap with the given pattern.
5347 if ( _size_size >= 16 ) {
5348 outline1("LD A, (%s)", _size);
5349 outline0("LD C, A" );
5350 outline1("LD A, (%s+1)", _size);
5351 outline0("LD B, A" );
5352 outhead1("%sx:", label);
5353 outline0("LD A, (HL)");
5354 outline0("LD (DE),A");
5355 outline0("INC DE");
5356 outline0("DEC BC");
5357 outline0("LD A, B");
5358 outline0("OR C");
5359 outline1("JR NZ,%sx", label);
5360 } else {
5361 outline1("LD A, (%s)", _size);
5362 outline0("LD C, A" );
5363 outhead1("%sx:", label);
5364 outline0("LD A, (HL)");
5365 outline0("LD (DE),A");
5366 outline0("INC DE");
5367 outline0("DEC C");
5368 outline1("JR NZ,%sx", label);
5369 }
5370
5371}
5372
5373void cpu_flip_8bit( Environment * _environment, char * _source, char * _destination ) {
5374
5375 no_inline( cpu_flip )
5376
5377 embedded( cpu_flip, src_hw_sm83_cpu_flip_asm );
5378
5379 outline1("LD A, (%s)", _source );
5380 outline0("CALL CPUFLIP8");
5381 if ( _destination ) {
5382 outline1("LD (%s), A", _destination );
5383 } else {
5384 outline1("LD (%s), A", _source );
5385 }
5386
5387 done( )
5388
5389}
5390
5391void cpu_flip( Environment * _environment, char * _source, char * _size, char * _destination ) {
5392
5393 no_inline( cpu_flip )
5394
5395 embedded( cpu_flip, src_hw_sm83_cpu_flip_asm );
5396
5397 outline1("LD HL, (%s)", _destination );
5398 outline0("LD D, H");
5399 outline0("LD E, L");
5400 outline1("LD HL, (%s)", _source);
5401 outline1("LD A, (%s)", _size);
5402 outline0("CALL CPUFLIP");
5403
5404 done( )
5405
5406}
5407
5408void cpu_move_8bit_indirect( Environment * _environment, char *_source, char * _value ) {
5409
5410 outline1("LD HL, (%s)", _value );
5411 outline0("LD D, H");
5412 outline0("LD E, L");
5413 outline1("LD A, (%s)", _source);
5414 outline0("LD (DE), A");
5415
5416}
5417
5418void cpu_move_8bit_with_offset2( Environment * _environment, char *_source, char * _value, char * _offset ) {
5419
5420 outline1("LD HL, %s", _value);
5421 outline1("LD A, (%s)", _offset );
5422 outline0("LD E, A" );
5423 outline0("LD D, 0" );
5424 outline0("ADD HL, DE" );
5425 outline1("LD A, (%s)", _source);
5426 outline0("LD (HL), A");
5427
5428}
5429
5430void cpu_move_8bit_indirect_with_offset( Environment * _environment, char *_source, char * _value, int _offset ) {
5431
5432 outline1("LD HL, (%s)", _value);
5433 outline1("LD DE, $%2.2x", ( _offset & 0xff ) );
5434 outline0("ADD HL, DE" );
5435 outline1("LD A, (%s)", _source);
5436 outline0("LD (HL), A");
5437
5438}
5439
5440void cpu_move_8bit_indirect2( Environment * _environment, char * _value, char *_source ) {
5441
5442 outline1("LD HL, (%s)", _value );
5443 outline0("LD D, H");
5444 outline0("LD E, L");
5445 outline0("LD A, (DE)");
5446 outline1("LD (%s), A", _source);
5447
5448}
5449
5450void cpu_move_8bit_indirect2_8bit( Environment * _environment, char * _value, char * _offset, char *_source ) {
5451
5452 outline1("LD HL, %s", _value);
5453 outline1("LD A, (%s)", _offset);
5454 outline0("LD E, A");
5455 outline0("LD A, 0");
5456 outline0("LD D, A");
5457 outline0("ADD HL, DE");
5458 outline0("LD A, (HL)");
5459 outline1("LD (%s), A", _source );
5460
5461}
5462
5463void cpu_move_8bit_indirect2_16bit( Environment * _environment, char * _value, char * _offset, char *_source ) {
5464
5465 outline1("LD HL, (%s)", _offset );
5466 outline0("LD D, H");
5467 outline0("LD E, L");
5468 outline1("LD HL, %s", _value);
5469 outline0("ADD HL, DE");
5470 outline0("LD A, (HL)");
5471 outline1("LD (%s), A", _source );
5472
5473}
5474
5475void cpu_move_16bit_indirect( Environment * _environment, char *_source, char * _value ) {
5476
5477 outline1("LD HL, (%s)", _value );
5478 outline0("LD D, H");
5479 outline0("LD E, L");
5480 outline1("LD HL, (%s)", _source);
5481 outline0("LD A, L");
5482 outline0("LD (DE), A");
5483 outline0("INC DE");
5484 outline0("LD A, H");
5485 outline0("LD (DE), A");
5486
5487}
5488
5489void cpu_move_16bit_indirect2( Environment * _environment, char * _value, char *_source ) {
5490
5491 outline1("LD HL, (%s)", _value );
5492 outline0("LD D, H");
5493 outline0("LD E, L");
5494 outline0("LD A, (DE)");
5495 outline1("LD (%s), A", _source);
5496 outline0("INC DE");
5497 outline0("LD A, (DE)");
5498 outline1("LD (%s), A", address_displacement(_environment, _source, "1"));
5499
5500}
5501
5502void cpu_move_16bit_indirect2_8bit( Environment * _environment, char * _value, char * _offset, char *_source ) {
5503
5504 outline1("LD HL, %s", _value);
5505 outline1("LD A, (%s)", _offset);
5506 outline0("LD E, A");
5507 outline0("LD A, 0");
5508 outline0("LD D, A");
5509 outline0("ADD HL, DE");
5510 outline0("ADD HL, DE");
5511 outline0("LD A, (HL)");
5512 outline1("LD (%s), A", _source );
5513 outline0("INC HL");
5514 outline0("LD A, (HL)");
5515 outline1("LD (%s), A", address_displacement(_environment, _source, "1") );
5516
5517}
5518
5519void cpu_move_32bit_indirect( Environment * _environment, char *_source, char * _value ) {
5520
5521 outline1("LD HL, (%s)", _value );
5522 outline0("LD D, H");
5523 outline0("LD E, L");
5524 outline1("LD HL, (%s)", _source);
5525 outline0("LD A, L");
5526 outline0("LD (DE), A");
5527 outline0("INC DE");
5528 outline0("LD A, H");
5529 outline0("LD (DE), A");
5530 outline0("INC DE");
5531 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
5532 outline0("LD A, L");
5533 outline0("LD (DE), A");
5534 outline0("INC DE");
5535 outline0("LD A, H");
5536 outline0("LD (DE), A");
5537 outline0("INC DE");
5538
5539}
5540
5541void cpu_move_nbit_indirect( Environment * _environment, int _n, char *_source, char * _value ) {
5542
5543 outline1("LD HL, (%s)", _value );
5544 outline0("LD D, H");
5545 outline0("LD E, L");
5546
5547 char step[MAX_TEMPORARY_STORAGE];
5548 char step2[MAX_TEMPORARY_STORAGE];
5549
5550 int stepIndex = 0;
5551 while( _n ) {
5552 sprintf( step, "%d", stepIndex );
5553 sprintf( step2, "%d", stepIndex+2 );
5554 if ( _n >= 32 ) {
5555 outline1("LD HL, (%s)", address_displacement(_environment, _source, step));
5556 outline0("LD A, L");
5557 outline0("LD (DE), A");
5558 outline0("INC DE");
5559 outline0("LD A, H");
5560 outline0("LD (DE), A");
5561 outline0("INC DE");
5562 outline1("LD HL, (%s)", address_displacement(_environment, _source, step2));
5563 outline0("LD A, L");
5564 outline0("LD (DE), A");
5565 outline0("INC DE");
5566 outline0("LD A, H");
5567 outline0("LD (DE), A");
5568 outline0("INC DE");
5569 stepIndex += 4;
5570 _n -= 32;
5571 } else {
5572 switch( _n ) {
5573 case 32: case 31: case 30: case 29:
5574 case 28: case 27: case 26: case 25:
5575 outline1("LD HL, (%s)", address_displacement(_environment, _source, step));
5576 outline0("LD A, L");
5577 outline0("LD (DE), A");
5578 outline0("INC DE");
5579 outline0("LD A, H");
5580 outline0("LD (DE), A");
5581 outline0("INC DE");
5582 outline1("LD HL, (%s)", address_displacement(_environment, _source, step2));
5583 outline0("LD A, L");
5584 outline0("LD (DE), A");
5585 outline0("INC DE");
5586 outline0("LD A, H");
5587 outline0("LD (DE), A");
5588 outline0("INC DE");
5589 break;
5590 case 24: case 23: case 22: case 21:
5591 case 20: case 19: case 18: case 17:
5592 outline1("LD HL, (%s)", address_displacement(_environment, _source, step));
5593 outline0("LD A, L");
5594 outline0("LD (DE), A");
5595 outline0("INC DE");
5596 outline0("LD A, H");
5597 outline0("LD (DE), A");
5598 outline0("INC DE");
5599 outline1("LD A, (%s)", address_displacement(_environment, _source, step2));
5600 outline0("LD (DE), A");
5601 outline0("INC DE");
5602 break;
5603 case 16: case 15: case 14: case 13:
5604 case 12: case 11: case 10: case 9:
5605 outline1("LD HL, (%s)", address_displacement(_environment, _source, step));
5606 outline0("LD A, L");
5607 outline0("LD (DE), A");
5608 outline0("INC DE");
5609 outline0("LD A, H");
5610 outline0("LD (DE), A");
5611 outline0("INC DE");
5612 break;
5613 case 8: case 7: case 6: case 5:
5614 case 4: case 3: case 2: case 1:
5615 outline1("LD A, (%s)", address_displacement(_environment, _source, step));
5616 outline0("LD (DE), A");
5617 outline0("INC DE");
5618 break;
5619 }
5620 _n = 0;
5621 }
5622 }
5623}
5624
5625void cpu_move_32bit_indirect2( Environment * _environment, char * _value, char *_source ) {
5626
5627 outline1("LD HL, (%s)", _value );
5628 outline0("LD D, H");
5629 outline0("LD E, L");
5630 outline0("LD A, (DE)");
5631 outline0("LD L, A");
5632 outline0("INC DE");
5633 outline0("LD A, (DE)");
5634 outline0("LD H, A");
5635 outline0("INC DE");
5636 outline1("LD (%s), HL", _source);
5637 outline0("LD A, (DE)");
5638 outline0("LD L, A");
5639 outline0("INC DE");
5640 outline0("LD A, (DE)");
5641 outline0("LD H, A");
5642 outline0("INC DE");
5643 outline1("LD (%s), HL", address_displacement( _environment, _source, "2" ) );
5644
5645}
5646
5647void cpu_move_nbit_indirect2( Environment * _environment, int _n, char * _value, char *_source ) {
5648
5649 outline1("LD HL, (%s)", _value );
5650 outline0("LD D, H");
5651 outline0("LD E, L");
5652
5653 char step[MAX_TEMPORARY_STORAGE];
5654 char step2[MAX_TEMPORARY_STORAGE];
5655
5656 int stepIndex = 0;
5657 while( _n ) {
5658 sprintf( step, "%d", stepIndex );
5659 sprintf( step2, "%d", stepIndex+2 );
5660 if ( _n >= 32 ) {
5661 outline0("LD A, (DE)");
5662 outline0("LD L, A");
5663 outline0("INC DE");
5664 outline0("LD A, (DE)");
5665 outline0("LD H, A");
5666 outline0("INC DE");
5667 outline1("LD (%s), HL", address_displacement( _environment, _source, step ) );
5668 outline0("LD A, (DE)");
5669 outline0("LD L, A");
5670 outline0("INC DE");
5671 outline0("LD A, (DE)");
5672 outline0("LD H, A");
5673 outline0("INC DE");
5674 outline1("LD (%s), HL", address_displacement( _environment, _source, step2 ) );
5675 stepIndex += 4;
5676 _n -= 32;
5677 } else {
5678 switch( _n ) {
5679 case 32: case 31: case 30: case 29:
5680 case 28: case 27: case 26: case 25:
5681 outline0("LD A, (DE)");
5682 outline0("LD L, A");
5683 outline0("INC DE");
5684 outline0("LD A, (DE)");
5685 outline0("LD H, A");
5686 outline0("INC DE");
5687 outline1("LD (%s), HL", address_displacement( _environment, _source, step ) );
5688 outline0("LD A, (DE)");
5689 outline0("LD L, A");
5690 outline0("INC DE");
5691 outline0("LD A, (DE)");
5692 outline0("LD H, A");
5693 outline0("INC DE");
5694 outline1("LD (%s), HL", address_displacement( _environment, _source, step2 ) );
5695 break;
5696 case 24: case 23: case 22: case 21:
5697 case 20: case 19: case 18: case 17:
5698 outline0("LD A, (DE)");
5699 outline0("LD L, A");
5700 outline0("INC DE");
5701 outline0("LD A, (DE)");
5702 outline0("LD H, A");
5703 outline0("INC DE");
5704 outline1("LD (%s), HL", address_displacement( _environment, _source, step ) );
5705 outline0("LD A, (DE)");
5706 outline0("INC DE");
5707 outline1("LD (%s), A", address_displacement( _environment, _source, step2 ) );
5708 break;
5709 case 16: case 15: case 14: case 13:
5710 case 12: case 11: case 10: case 9:
5711 outline0("LD A, (DE)");
5712 outline0("LD L, A");
5713 outline0("INC DE");
5714 outline0("LD A, (DE)");
5715 outline0("LD H, A");
5716 outline0("INC DE");
5717 outline1("LD (%s), HL", address_displacement( _environment, _source, step ) );
5718 break;
5719 case 8: case 7: case 6: case 5:
5720 case 4: case 3: case 2: case 1:
5721 outline0("LD A, (DE)");
5722 outline0("INC DE");
5723 outline1("LD (%s), A", address_displacement( _environment, _source, step ) );
5724 break;
5725 }
5726 _n = 0;
5727 }
5728 }
5729
5730}
5731
5732void cpu_math_div_32bit_to_16bit( Environment * _environment, char *_source, char *_destination, char *_other, char * _other_remainder, int _signed ) {
5733
5734 MAKE_LABEL
5735
5736 if ( _signed ) {
5737
5738 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
5739 outline0("AND $80");
5740 outline0("CP 0" );
5741 outline0("PUSH AF");
5742 outline1("JR Z,%spositive", label);
5743 cpu_complement2_32bit( _environment, _source, NULL );
5744 outhead1("%spositive:", label);
5745 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
5746 outline0("AND $80");
5747 outline0("CP 0" );
5748 outline0("PUSH AF");
5749 outline1("JR Z,%spositive2", label);
5750 cpu_complement2_16bit( _environment, _destination, NULL );
5751 outhead1("%spositive2:", label);
5752
5753 outline1("LD A, (%s)", _destination);
5754 outline0("LD E, A");
5755 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
5756 outline0("LD D, A");
5757 outline0("PUSH HL");
5758 outline1("LD HL, (%s)", _source);
5759 outline0("LD (IXR), HL");
5760 outline0("POP HL");
5761 outline1("LD A, (%s)", address_displacement(_environment, _source, "2"));
5762 outline0("LD C, A");
5763 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
5764
5765 outline0("LD HL, 0");
5766 outline0("LD B, 32");
5767 outhead1("%sdiv32a:", label);
5768
5769 outline0("PUSH HL");
5770 outline0("LD HL, (IXR)");
5771 outline0("ADD HL, HL");
5772 outline0("LD (IXR), HL");
5773 outline0("POP HL");
5774
5775 outline0("RL C");
5776 outline0("RLA");
5777 outline0("CALL ADC_HL_HL");
5778 outline1("JR C, %sdiv32ov", label);
5779 outline0("CALL SBC_HL_DE");
5780 outline1("JR NC, %sdiv32setbit", label);
5781 outline0("ADD HL, DE");
5782 outline1("DJNZ %sdiv32a", label);
5783 outline1("JR %sdiv32end", label);
5784 outhead1("%sdiv32ov:", label);
5785 outline0("OR A");
5786 outline0("CALL SBC_HL_DE");
5787 outhead1("%sdiv32setbit:", label);
5788 outline0("PUSH HL");
5789 outline0("LD HL, (IXR)");
5790 outline0("INC HL");
5791 outline0("LD (IXR), HL");
5792 outline0("POP HL");
5793 outline1("DJNZ %sdiv32a", label);
5794 outhead1("%sdiv32end:", label);
5795
5796 outline1("LD (%s), A", address_displacement(_environment, _other, "3"));
5797 outline0("LD A, C" );
5798 outline1("LD (%s), A", address_displacement(_environment, _other, "2"));
5799
5800 outline0("PUSH HL");
5801 outline0("LD HL, (IXR)");
5802 outline1("LD (%s), HL", _other);
5803 outline0("POP HL");
5804
5805 outline0("LD A, L");
5806 outline1("LD (%s), A", _other_remainder);
5807 outline0("LD A, H");
5808 outline1("LD (%s), A", address_displacement(_environment, _other_remainder, "1"));
5809
5810 outline0("POP AF");
5811 outline0("LD B, A");
5812 outline0("CMP $80");
5813 outline1("JR NZ, %srepositive", label);
5814 cpu_complement2_16bit( _environment, _destination, NULL );
5815 outhead1("%srepositive:", label);
5816 outline0("POP AF");
5817 outline0("LD C, A");
5818 outline0("CMP $80");
5819 outline1("JR NZ, %srepositive2", label );
5820 cpu_complement2_32bit( _environment, _source, NULL );
5821 outhead1("%srepositive2:", label);
5822 outline0("LD A, B");
5823 outline0("XOR C");
5824 outline0("AND $80");
5825 outline0("CP $80");
5826 outline1("JR NZ, %srepositive3", label );
5827 cpu_complement2_32bit( _environment, _other, NULL );
5828 outhead1("%srepositive3:", label);
5829
5830 } else {
5831
5832 outline1("LD HL, (%s)", _source);
5833 outline0("LD (IXR), HL");
5834 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
5835 outline0("LD A, L");
5836 outline0("LD C, A");
5837 outline0("LD A, H");
5838
5839 outline0("PUSH HL");
5840 outline1("LD HL, (%s)", _destination );
5841 outline0("LD D, H");
5842 outline0("LD E, L");
5843 outline0("POP HL");
5844
5845 outline0("LD HL, 0");
5846 outline0("LD B, 32");
5847 outhead1("%sloop1:", label);
5848
5849 outline0("PUSH HL");
5850 outline0("LD HL, (IXR)");
5851 outline0("ADD HL, HL");
5852 outline0("LD (IXR), HL");
5853 outline0("POP HL");
5854
5855 outline0("RL C");
5856 outline0("RLA");
5857 outline0("CALL ADC_HL_HL");
5858 outline1("JR C, %sloop2", label);
5859 outline0("CALL SBC_HL_DE");
5860 outline1("JR NC, %sloop3", label);
5861 outline0("ADD HL, DE");
5862 outline1("DJNZ %sloop1", label);
5863 outline1("JR %sdone", label);
5864 outhead1("%sloop2:", label);
5865 outline0("OR A");
5866 outline0("CALL SBC_HL_DE");
5867 outhead1("%sloop3:", label);
5868 outline0("PUSH HL");
5869 outline0("LD HL, (IXR)");
5870 outline0("INC HL");
5871 outline0("LD (IXR), HL");
5872 outline0("POP HL");
5873 outline1("DJNZ %sloop1", label);
5874 outhead1("%sdone:", label);
5875
5876 outline1("LD (%s), HL", _other_remainder);
5877 outline0("LD H, A");
5878 outline0("LD A, C");
5879 outline0("LD L, C");
5880 outline1("LD (%s), HL", _other);
5881 outline0("LD HL, (IXR)");
5882 outline1("LD (%s), HL", _other);
5883
5884 }
5885
5886}
5887
5888void cpu_math_div_32bit_to_16bit_const( Environment * _environment, char *_source, int _destination, char *_other, char * _other_remainder, int _signed ) {
5889
5890 MAKE_LABEL
5891
5892 if ( _signed ) {
5893
5894 int destination = abs(_destination);
5895
5896 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
5897 outline0("AND $80");
5898 outline0("CP 0" );
5899 outline0("PUSH AF");
5900 outline1("JR Z,%spositive", label);
5901 cpu_complement2_32bit( _environment, _source, NULL );
5902 outhead1("%spositive:", label);
5903
5904 outline1("LD DE, $%4.4x", destination);
5905
5906 outline1("LD HL, (%s)", _source);
5907 outline0("LD (IXR), HL");
5908
5909 outline1("LD A, (%s)", address_displacement(_environment, _source, "2"));
5910 outline0("LD C, A");
5911 outline1("LD A, (%s)", address_displacement(_environment, _source, "3"));
5912
5913 outline0("LD HL, 0");
5914 outline0("LD B, 32");
5915 outhead1("%sdiv32a:", label);
5916
5917 outline0("PUSH HL");
5918 outline0("LD HL, (IXR)");
5919 outline0("ADD HL, HL");
5920 outline0("LD (IXR), HL");
5921 outline0("POP HL");
5922
5923 outline0("RL C");
5924 outline0("RLA");
5925 outline0("CALL ADC_HL_HL");
5926 outline1("JR C, %sdiv32ov", label);
5927 outline0("CALL SBC_HL_DE");
5928 outline1("JR NC, %sdiv32setbit", label);
5929 outline0("ADD HL, DE");
5930 outline1("DJNZ %sdiv32a", label);
5931 outline1("JR %sdiv32end", label);
5932 outhead1("%sdiv32ov:", label);
5933 outline0("OR A");
5934 outline0("CALL SBC_HL_DE");
5935 outhead1("%sdiv32setbit:", label);
5936 outline0("PUSH HL");
5937 outline0("LD HL, (IXR)");
5938 outline0("INC HL");
5939 outline0("LD (IXR), HL");
5940 outline0("POP HL");
5941 outline1("DJNZ %sdiv32a", label);
5942 outhead1("%sdiv32end:", label);
5943
5944 outline1("LD (%s), A", address_displacement(_environment, _other, "3"));
5945 outline0("LD A, C" );
5946 outline1("LD (%s), A", address_displacement(_environment, _other, "2"));
5947
5948 outline0("PUSH HL");
5949 outline0("LD HL, (IXR)");
5950 outline1("LD (%s), HL", _other);
5951 outline0("POP HL");
5952
5953 outline0("LD A, L");
5954 outline1("LD (%s), A", _other_remainder);
5955 outline0("LD A, H");
5956 outline1("LD (%s), A", address_displacement(_environment, _other_remainder, "1"));
5957
5958 outline1("LD B, $%2.2x", (_destination < 0) ? 0x80 : 0x00 );
5959 outhead1("%srepositive:", label);
5960 outline0("POP AF");
5961 outline0("LD C, A");
5962 outline0("CMP $80");
5963 outline1("JR NZ, %srepositive2", label );
5964 cpu_complement2_32bit( _environment, _source, NULL );
5965 outhead1("%srepositive2:", label);
5966 outline0("LD A, B");
5967 outline0("XOR C");
5968 outline0("AND $80");
5969 outline0("CP $80");
5970 outline1("JR NZ, %srepositive3", label );
5971 cpu_complement2_32bit( _environment, _other, NULL );
5972 outhead1("%srepositive3:", label);
5973
5974 } else {
5975
5976 outline1("LD HL, (%s)", _source);
5977 outline0("LD (IXR), HL");
5978 outline1("LD HL, (%s)", address_displacement(_environment, _source, "2"));
5979 outline0("LD A, L");
5980 outline0("LD C, A");
5981 outline0("LD A, H");
5982 outline1("LD DE, $%4.4x", _destination);
5983
5984 outline0("LD HL, 0");
5985 outline0("LD B, 32");
5986 outhead1("%sloop1:", label);
5987
5988 outline0("PUSH HL");
5989 outline0("LD HL, (IXR)");
5990 outline0("ADD HL, HL");
5991 outline0("LD (IXR), HL");
5992 outline0("POP HL");
5993
5994 outline0("RL C");
5995 outline0("RLA");
5996 outline0("CALL ADC_HL_HL");
5997 outline1("JR C, %sloop2", label);
5998 outline0("CALL SBC_HL_DE");
5999 outline1("JR NC, %sloop3", label);
6000 outline0("ADD HL, DE");
6001 outline1("DJNZ %sloop1", label);
6002 outline1("JR %sdone", label);
6003 outhead1("%sloop2:", label);
6004 outline0("OR A");
6005 outline0("CALL SBC_HL_DE");
6006 outhead1("%sloop3:", label);
6007 outline0("PUSH AF");
6008 outline0("LD A, (IXR)");
6009 outline0("INC A");
6010 outline0("LD (IXR), A");
6011 outline0("POP AF");
6012 outline1("DJNZ %sloop1", label);
6013 outhead1("%sdone:", label);
6014
6015 outline1("LD (%s), HL", _other_remainder);
6016 outline0("LD H, A");
6017 outline0("LD A, C");
6018 outline0("LD L, C");
6019 outline1("LD (%s), HL", _other);
6020 outline0("LD HL, (IXR)");
6021 outline1("LD (%s), HL", _other);
6022
6023 }
6024
6025}
6026
6027void cpu_math_div_16bit_to_16bit( Environment * _environment, char *_source, char *_destination, char *_other, char * _other_remainder, int _signed ) {
6028
6029 MAKE_LABEL
6030
6031 if ( _signed ) {
6032
6033 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
6034 outline0("AND $80");
6035 outline0("CP 0" );
6036 outline0("PUSH AF");
6037 outline1("JR Z,%spositive", label);
6038 cpu_complement2_16bit( _environment, _source, NULL );
6039 outhead1("%spositive:", label);
6040 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
6041 outline0("AND $80");
6042 outline0("CP 0" );
6043 outline0("PUSH AF");
6044 outline1("JR Z,%spositive2", label);
6045 cpu_complement2_16bit( _environment, _destination, NULL );
6046 outhead1("%spositive2:", label);
6047
6048 outline1("LD HL, %s", _source);
6049 outline0("LD A, (HL)");
6050 outline0("LD C, A");
6051 outline0("INC HL");
6052 outline0("LD A, (HL)");
6053
6054 outline0("PUSH HL");
6055 outline1("LD HL, (%s)", _destination);
6056 outline0("LD D, H");
6057 outline0("LD E, L");
6058 outline0("POP HL");
6059
6060 outline0("LD HL, 0");
6061 outline0("LD B, 16");
6062 outhead1("%sloop:", label );
6063 // outline0("SLL C");
6064 outline0("SCF");
6065 outline0("RL C");
6066 outline0("RLA");
6067 outline0("CALL ADC_HL_HL");
6068 outline0("CALL SBC_HL_DE");
6069 outline0("JR NC, $+4");
6070 outline0("ADD HL, DE");
6071 outline0("DEC C");
6072 outline1("DJNZ %sloop", label);
6073 outline1("LD (%s), HL", _other_remainder);
6074 outline1("LD DE, %s", _other);
6075 outline0("LD B, A");
6076 outline0("LD A, C");
6077 outline0("LD (DE), A");
6078 outline0("INC DE");
6079 outline0("LD A, B");
6080 outline0("LD (DE), A");
6081
6082 outline0("POP AF");
6083 outline0("LD B, A");
6084 outline0("CMP $80");
6085 outline1("JR NZ, %srepositive", label);
6086 cpu_complement2_16bit( _environment, _destination, NULL );
6087 outhead1("%srepositive:", label);
6088 outline0("POP AF");
6089 outline0("LD C, A");
6090 outline0("CMP $80");
6091 outline1("JR NZ, %srepositive2", label );
6092 cpu_complement2_16bit( _environment, _source, NULL );
6093 outhead1("%srepositive2:", label);
6094 outline0("LD A, B");
6095 outline0("XOR C");
6096 outline0("AND $80");
6097 outline0("CP $80");
6098 outline1("JR NZ, %srepositive3", label );
6099 cpu_complement2_16bit( _environment, _other, NULL );
6100 outhead1("%srepositive3:", label);
6101
6102 } else {
6103
6104 outline1("LD HL, %s", _source);
6105 outline0("LD A, (HL)");
6106 outline0("LD C, A");
6107 outline0("INC HL");
6108 outline0("LD A, (HL)");
6109
6110 outline0("PUSH HL");
6111 outline1("LD HL, (%s)", _destination);
6112 outline0("LD D, H");
6113 outline0("LD E, L");
6114 outline0("POP HL");
6115
6116 outline0("LD HL, 0");
6117 outline0("LD B, 16");
6118 outhead1("%sloop:", label );
6119 // outline0("SLL C");
6120 outline0("SCF");
6121 outline0("RL C");
6122 outline0("RLA");
6123 outline0("CALL ADC_HL_HL");
6124 outline0("CALL SBC_HL_DE");
6125 outline0("JR NC, $+4");
6126 outline0("ADD HL, DE");
6127 outline0("DEC C");
6128 outline1("DJNZ %sloop", label);
6129 outline1("LD (%s), HL", _other_remainder);
6130 outline1("LD DE, %s", _other);
6131 outline0("LD B, A");
6132 outline0("LD A, C");
6133 outline0("LD (DE), A");
6134 outline0("INC DE");
6135 outline0("LD A, B");
6136 outline0("LD (DE), A");
6137
6138 }
6139
6140}
6141
6142void cpu_math_div_16bit_to_16bit_const( Environment * _environment, char *_source, int _destination, char *_other, char * _other_remainder, int _signed ) {
6143
6144 MAKE_LABEL
6145
6146 if ( _signed ) {
6147
6148 int destination = abs(_destination);
6149
6150 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
6151 outline0("AND $80");
6152 outline0("CP 0" );
6153 outline0("PUSH AF");
6154 outline1("JR Z,%spositive", label);
6155 cpu_complement2_16bit( _environment, _source, NULL );
6156 outhead1("%spositive:", label);
6157 // outline1("LD A, $%2.2x", (unsigned char)( (_destination>>8) & 0xff));
6158 // outline0("AND $80");
6159 // outline0("CP 0" );
6160 // outline0("PUSH AF");
6161 // outline1("JR Z,%spositive2", label);
6162 // cpu_complement2_16bit( _environment, _destination, NULL );
6163 // outhead1("%spositive2:", label);
6164
6165 outline1("LD HL, %s", _source);
6166 outline0("LD A, (HL)");
6167 outline0("LD C, A");
6168 outline0("INC HL");
6169 outline0("LD A, (HL)");
6170 outline1("LD DE, $%4.4x", destination);
6171
6172 outline0("LD HL, 0");
6173 outline0("LD B, 16");
6174 outhead1("%sloop:", label );
6175 // outline0("SLL C");
6176 outline0("SCF");
6177 outline0("RL C");
6178 outline0("RLA");
6179 outline0("CALL ADC_HL_HL");
6180 outline0("CALL SBC_HL_DE");
6181 outline0("JR NC, $+4");
6182 outline0("ADD HL, DE");
6183 outline0("DEC C");
6184 outline1("DJNZ %sloop", label);
6185 outline1("LD (%s), HL", _other_remainder);
6186 outline1("LD DE, %s", _other);
6187 outline0("LD B, A");
6188 outline0("LD A, C");
6189 outline0("LD (DE), A");
6190 outline0("INC DE");
6191 outline0("LD A, B");
6192 outline0("LD (DE), A");
6193
6194 // outline0("POP AF");
6195 outline1("LD B, $%2.2x", _destination < 0 ? 0x80 : 0x00 );
6196 // outline0("CMP $80");
6197 // outline1("JR NZ, %srepositive", label);
6198 // cpu_complement2_16bit( _environment, _destination, NULL );
6199 outhead1("%srepositive:", label);
6200 outline0("POP AF");
6201 outline0("LD C, A");
6202 outline0("CMP $80");
6203 outline1("JR NZ, %srepositive2", label );
6204 cpu_complement2_16bit( _environment, _source, NULL );
6205 outhead1("%srepositive2:", label);
6206 outline0("LD A, B");
6207 outline0("XOR C");
6208 outline0("AND $80");
6209 outline0("CP $80");
6210 outline1("JR NZ, %srepositive3", label );
6211 cpu_complement2_16bit( _environment, _other, NULL );
6212 outhead1("%srepositive3:", label);
6213
6214 } else {
6215
6216 outline1("LD HL, %s", _source);
6217 outline0("LD A, (HL)");
6218 outline0("LD C, A");
6219 outline0("INC HL");
6220 outline0("LD A, (HL)");
6221 outline1("LD DE, $%4.4x", _destination);
6222
6223 outline0("LD HL, 0");
6224 outline0("LD B, 16");
6225 outhead1("%sloop:", label );
6226 // outline0("SLL C");
6227 outline0("SCF");
6228 outline0("RL C");
6229 outline0("RLA");
6230 outline0("CALL ADC_HL_HL");
6231 outline0("CALL SBC_HL_DE");
6232 outline0("JR NC, $+4");
6233 outline0("ADD HL, DE");
6234 outline0("DEC C");
6235 outline1("DJNZ %sloop", label);
6236 outline1("LD (%s), HL", _other_remainder);
6237 outline1("LD DE, %s", _other);
6238 outline0("LD B, A");
6239 outline0("LD A, C");
6240 outline0("LD (DE), A");
6241 outline0("INC DE");
6242 outline0("LD A, B");
6243 outline0("LD (DE), A");
6244
6245 }
6246
6247}
6248
6249void cpu_math_div_nbit_to_nbit( Environment * _environment, char *_source, char *_destination, char *_other, char * _other_remainder, int _bits ) {
6250
6251 MAKE_LABEL
6252
6253 int i;
6254
6255 inline( cpu_math_div_nbit_to_nbit )
6256
6257 char afterLabel[MAX_TEMPORARY_STORAGE]; sprintf( afterLabel, "%safter", label );
6258 char skipLabel[MAX_TEMPORARY_STORAGE]; sprintf( skipLabel, "%sskip", label );
6259 char skip2Label[MAX_TEMPORARY_STORAGE]; sprintf( skip2Label, "%sskipb", label );
6260 char skip3Label[MAX_TEMPORARY_STORAGE]; sprintf( skip3Label, "%sskipc", label );
6261 char skip4Label[MAX_TEMPORARY_STORAGE]; sprintf( skip4Label, "%sskipd", label );
6262 char quotient[MAX_TEMPORARY_STORAGE]; sprintf( quotient, "CPUMATHDIVNBITTONBIT%d_QUOTIENT", _bits >> 3 );
6263 char divisor[MAX_TEMPORARY_STORAGE]; sprintf( divisor, "CPUMATHDIVNBITTONBIT%d_DIVISOR", _bits >> 3 );
6264 char dividend[MAX_TEMPORARY_STORAGE]; sprintf( dividend, "CPUMATHDIVNBITTONBIT%d_DIVIDEND", _bits >> 3 );
6265 char result1[MAX_TEMPORARY_STORAGE]; sprintf( result1, "CPUMATHDIVNBITTONBIT%d_RESULT1", _bits >> 3 );
6266 char result2[MAX_TEMPORARY_STORAGE]; sprintf( result2, "CPUMATHDIVNBITTONBIT%d_RESULT2", _bits >> 3 );
6267 char k[MAX_TEMPORARY_STORAGE]; sprintf( k, "CPUMATHDIVNBITTONBIT%d_K", _bits >> 3 );
6268
6269 if ( ! _environment->cpuOptimization.cpu_math_div_nbit_to_nbit[_bits>>3] ) {
6270
6271 cpu_jump( _environment, afterLabel );
6272
6273 outhead2("%s: defs %d", quotient, _bits>>3 );
6274 outhead2("%s: defs %d", divisor, _bits>>3 );
6275 outhead2("%s: defs %d", dividend, _bits>>3 );
6276 outhead1("%s: db 0", k );
6277 outhead1("%s: db 0", result1 );
6278 outhead1("%s: db 0", result2 );
6279
6280 // public static long div(long dividend, long divisor) {
6281 // long quotient = 0;
6282
6283 outhead1("CPUMATHDIVNBITTONBIT%d:", _bits>>3);
6284 outhead0("LD A, $00");
6285 for( i=0; i<(_bits>>3); ++i ) {
6286 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
6287 outline1("LD (%s), A", address_displacement( _environment, quotient, offset ) );
6288 }
6289
6290 // int k = 0;
6291 cpu_store_8bit( _environment, k, 0 );
6292
6293 // while (divisor <= dividend && divisor > 0) {
6294
6295 cpu_label( _environment, label );
6296 cpu_less_than_nbit( _environment, divisor, dividend, result1, 1, _bits );
6297 cpu_greater_than_nbit_const( _environment, divisor, 0, result2, 0, _bits );
6298 cpu_and_8bit( _environment, result1, result2, result1 );
6299 cpu_compare_and_branch_8bit_const( _environment, result1, 0, skipLabel, 1 );
6300
6301 // divisor <<= 1;
6302
6303 cpu_math_mul2_const_nbit( _environment, divisor, 1, _bits );
6304
6305 // k++;
6306
6307 cpu_inc( _environment, k );
6308
6309 // }
6310
6311 cpu_jump( _environment, label );
6312
6313 cpu_label( _environment, skipLabel );
6314
6315 // while (k-- > 0) {
6316
6317 cpu_greater_than_8bit_const( _environment, k, 0, result1, 0, 1 );
6318 cpu_dec( _environment, k );
6319 cpu_compare_and_branch_8bit_const( _environment, result1, 0, skip2Label, 1 );
6320
6321 // divisor >>= 1;
6322
6323 cpu_math_div2_const_nbit( _environment, divisor, 1, _bits, NULL );
6324
6325 // if (divisor <= dividend) {
6326 cpu_less_than_nbit( _environment, divisor, dividend, result1, 1, _bits );
6327 cpu_compare_and_branch_8bit_const( _environment, result1, 0, skip3Label, 1 );
6328
6329 // dividend -= divisor;
6330
6331 cpu_math_sub_nbit( _environment, dividend, divisor, dividend, _bits );
6332
6333 // quotient = (quotient << 1) + 1;
6334 cpu_math_mul2_const_nbit( _environment, quotient, 1, _bits );
6335 cpu_inc_nbit( _environment, quotient, _bits );
6336
6337 // }
6338 cpu_jump( _environment, skip4Label );
6339 cpu_label( _environment, skip3Label );
6340 // else quotient <<= 1;
6341 cpu_math_mul2_const_nbit( _environment, quotient, 1, _bits );
6342 cpu_label( _environment, skip4Label );
6343 cpu_jump( _environment, skipLabel );
6344
6345 // }
6346 cpu_label( _environment, skip2Label );
6347 // return quotient;
6348 cpu_return( _environment );
6349
6350 cpu_label( _environment, afterLabel );
6351
6352 }
6353
6354 for( i=0; i<(_bits>>3); ++i ) {
6355 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
6356 outline1("LD A, (%s)", address_displacement( _environment, _source, offset ) );
6357 outline1("LD (%s), A", address_displacement( _environment, dividend, offset ) );
6358 outline1("LD A, (%s)", address_displacement( _environment, _destination, offset ) );
6359 outline1("LD (%s), A", address_displacement( _environment, divisor, offset ) );
6360 }
6361 outline1("CALL CPUMATHDIVNBITTONBIT%d", _bits>>3);
6362
6363 for( i=0; i<(_bits>>3); ++i ) {
6364 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
6365 if ( _other ) {
6366 outline1("LD A, (%s)", address_displacement( _environment, quotient, offset ) );
6367 outline1("LD (%s), A", address_displacement( _environment, _other, offset ) );
6368 } else {
6369 outline1("LD A, (%s)", address_displacement( _environment, quotient, offset ) );
6370 outline1("LD (%s), A", address_displacement( _environment, _destination, offset ) );
6371 }
6372 }
6373
6374 // }
6375 no_embedded( cpu_math_div_nbit_to_nbit )
6376
6377}
6378
6379void cpu_math_div_nbit_to_nbit_const( Environment * _environment, char *_source, int _destination, char *_other, char * _other_remainder, int _bits ) {
6380
6381 MAKE_LABEL
6382
6383 int i;
6384
6385 inline( cpu_math_div_nbit_to_nbit )
6386
6387 char afterLabel[MAX_TEMPORARY_STORAGE]; sprintf( afterLabel, "%safter", label );
6388 char data[MAX_TEMPORARY_STORAGE]; sprintf( data, "CPUMATHDIVNBITTONBITCONST%d_DATA", _bits >> 3 );
6389
6390 if ( ! _environment->cpuOptimization.cpu_math_div_nbit_to_nbit_const[_bits>>3] ) {
6391
6392 cpu_jump( _environment, afterLabel );
6393
6394 outhead2("%s: defs %d", data, _bits>>3 );
6395
6396 cpu_label( _environment, afterLabel );
6397
6398 }
6399
6400 for( i=0; i<(_bits>>3); ++i ) {
6401 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
6402 outline1("LD A, $%2.2x", (unsigned char)( (_destination >> (i*8)) & 0xff ) );
6403 outline1("LD (%s), A", address_displacement( _environment, data, offset ) );
6404 }
6405 cpu_math_div_nbit_to_nbit( _environment, _source, data, _other, _other_remainder, _bits );
6406
6407 // }
6408 no_embedded( cpu_math_div_nbit_to_nbit )
6409
6410}
6411
6412void cpu_math_div2_const_nbit( Environment * _environment, char *_source, int _steps, int _bits, char * _remainder ) {
6413
6414 inline( cpu_math_div2_const_nbit )
6415
6416 MAKE_LABEL
6417
6418 if ( _remainder ) {
6419 outline1("LD A, (%s)", _source);
6420 outline0("AND $01" );
6421 outline1("LD (%s), A", _remainder);
6422 }
6423 char offsetMsb[MAX_TEMPORARY_STORAGE]; sprintf( offsetMsb, "%d", (_bits>>3)-1 );
6424
6425 outline1("LD A, (%s)", address_displacement(_environment, _source, offsetMsb));
6426 outline0("AND $80");
6427 outline0("LD B, A");
6428 outline0("CP $80");
6429 outline1("JP NZ, %snocomplement", label );
6430 cpu_complement2_nbit( _environment, _source, _source, _bits );
6431 outhead1("%snocomplement:", label );
6432 while( _steps ) {
6433 outline0("SCF");
6434 outline0("CCF");
6435 outline1("LD A, (%s)", address_displacement(_environment, _source, offsetMsb));
6436 outline0("SRA A");
6437 outline1("LD (%s), A", address_displacement(_environment, _source, offsetMsb));
6438 for( int i=(_bits>>3)-2; i>-1; --i ) {
6439 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
6440 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
6441 outline0("RR A");
6442 outline1("LD (%s), A", address_displacement(_environment, _source, offset));
6443 }
6444 --_steps;
6445 }
6446 outline0("LD A, B");
6447 outline0("CP $80");
6448 outline1("JP NZ, %snocomplement2", label );
6449 cpu_complement2_nbit( _environment, _source, _source, _bits );
6450 outhead1("%snocomplement2:", label );
6451
6452 no_embedded( cpu_math_div2_const_nbit )
6453
6454}
6455
6456void cpu_math_div_8bit_to_8bit( Environment * _environment, char *_source, char *_destination, char *_other, char * _other_remainder, int _signed ) {
6457
6458 MAKE_LABEL
6459
6460 if ( _signed ) {
6461
6462 outline1("LD A, (%s)", _source );
6463 outline0("LD B, A" );
6464 outline1("LD A, (%s)", _destination );
6465 outline0("XOR A, B" );
6466 outline0("AND $80" );
6467 outline0("PUSH AF" );
6468 outline1("LD A, (%s)", _source );
6469 outline0("AND $80" );
6470 outline0("CP 0" );
6471 outline1("JR Z,%spos", label );
6472 outline1("LD A, (%s)", _source );
6473 outline0("XOR $FF" );
6474 outline0("ADC $1" );
6475 outline1("JMP %spos2", label );
6476 outhead1("%spos:", label );
6477 outline1("LD A, (%s)", _source );
6478 outhead1("%spos2:", label );
6479 outline0("LD D, A");
6480
6481 outline1("LD A, (%s)", _destination );
6482 outline0("AND $80" );
6483 outline0("CP 0" );
6484 outline1("JR Z,%sposx", label );
6485 outline1("LD A, (%s)", _destination );
6486 outline0("XOR $FF" );
6487 outline0("ADC $1" );
6488 outline1("JMP %sposx2", label );
6489 outhead1("%sposx:", label );
6490 outline1("LD A, (%s)", _destination );
6491 outhead1("%sposx2:", label );
6492 outline0("LD E, A");
6493
6494 outline0("XOR A");
6495 outline0("AND A");
6496 outline0("LD B, 8");
6497 outhead1("%sloop:", label);
6498 outline0("SLA D");
6499 outline0("RLA");
6500 outline0("CP E");
6501 outline0("JR C, $+4");
6502 outline0("SUB E");
6503 outline0("INC D");
6504 outline1("DJNZ %sloop", label );
6505
6506 outline1("LD (%s), A", _other_remainder);
6507 outline0("LD A, D");
6508 outline1("LD (%s), A", _other);
6509
6510 outline0("POP AF" );
6511 outline0("AND $80" );
6512 outline0("CP 0" );
6513 outline1("JR Z,%spos3", label );
6514 outline1("LD A, (%s)", _other );
6515 outline0("XOR $FF" );
6516 outline0("ADC $1" );
6517 outline1("LD (%s), A", _other );
6518 outhead1("%spos3:", label );
6519
6520 } else {
6521
6522 outline1("LD A, (%s)", _source);
6523 outline0("LD D, A");
6524 outline1("LD A, (%s)", _destination);
6525 outline0("LD E, A");
6526
6527 outline0("XOR A");
6528 outline0("LD B, 8");
6529 outhead1("%sloop:", label);
6530
6531 outline0("SLA D");
6532 outline0("RLA");
6533 outline0("CP E");
6534 outline0("JR C, $+4");
6535 outline0("SUB E");
6536 outline0("INC D");
6537 outline1("DJNZ %sloop", label );
6538
6539 outline1("LD (%s), A", _other_remainder);
6540 outline0("LD A, D");
6541 outline1("LD (%s), A", _other);
6542
6543 }
6544}
6545
6546void cpu_math_div_8bit_to_8bit_const( Environment * _environment, char *_source, int _destination, char *_other, char * _other_remainder, int _signed ) {
6547
6548 MAKE_LABEL
6549
6550 if ( _signed ) {
6551
6552 outline1("LD A, (%s)", _source );
6553 outline0("LD B, A" );
6554 outline1("LD A, $%2.2x", _destination );
6555 outline0("XOR A, B" );
6556 outline0("AND $80" );
6557 outline0("PUSH AF" );
6558 outline1("LD A, (%s)", _source );
6559 outline0("AND $80" );
6560 outline0("CP 0" );
6561 outline1("JR Z,%spos", label );
6562 outline1("LD A, (%s)", _source );
6563 outline0("XOR $FF" );
6564 outline0("ADC $1" );
6565 outline1("JMP %spos2", label );
6566 outhead1("%spos:", label );
6567 outline1("LD A, (%s)", _source );
6568 outhead1("%spos2:", label );
6569 outline0("LD D, A");
6570
6571 outline1("LD A, $%2.2x", _destination );
6572 outline0("AND $80" );
6573 outline0("CP 0" );
6574 outline1("JR Z,%sposx", label );
6575 outline1("LD A, $%2.2x", _destination );
6576 outline0("XOR $FF" );
6577 outline0("ADC $1" );
6578 outline1("JMP %sposx2", label );
6579 outhead1("%sposx:", label );
6580 outline1("LD A, $%2.2x", _destination );
6581 outhead1("%sposx2:", label );
6582 outline0("LD E, A");
6583
6584 outline0("XOR A");
6585 outline0("AND A");
6586 outline0("LD B, 8");
6587 outhead1("%sloop:", label);
6588 outline0("SLA D");
6589 outline0("RLA");
6590 outline0("CP E");
6591 outline0("JR C, $+4");
6592 outline0("SUB E");
6593 outline0("INC D");
6594 outline1("DJNZ %sloop", label );
6595
6596 outline1("LD (%s), A", _other_remainder);
6597 outline0("LD A, D");
6598 outline1("LD (%s), A", _other);
6599
6600 outline0("POP AF" );
6601 outline0("AND $80" );
6602 outline0("CP 0" );
6603 outline1("JR Z,%spos3", label );
6604 outline1("LD A, (%s)", _other );
6605 outline0("XOR $FF" );
6606 outline0("ADC $1" );
6607 outline1("LD (%s), A", _other );
6608 outhead1("%spos3:", label );
6609
6610 } else {
6611
6612 outline1("LD A, (%s)", _source);
6613 outline0("LD D, A");
6614 outline1("LD A, $%2.2x", _destination);
6615 outline0("LD E, A");
6616
6617 outline0("XOR A");
6618 outline0("LD B, 8");
6619 outhead1("%sloop:", label);
6620
6621 outline0("SLA D");
6622 outline0("RLA");
6623 outline0("CP E");
6624 outline0("JR C, $+4");
6625 outline0("SUB E");
6626 outline0("INC D");
6627 outline1("DJNZ %sloop", label );
6628
6629 outline1("LD (%s), A", _other_remainder);
6630 outline0("LD A, D");
6631 outline1("LD (%s), A", _other);
6632
6633 }
6634}
6635
6636void cpu_bit_check( Environment * _environment, char *_value, int _position, char * _result, int _bitwidth ) {
6637
6638 no_inline( cpu_bit_check_extended )
6639
6640 embedded( cpu_bit_check_extended, src_hw_sm83_cpu_bit_check_extended_asm );
6641
6642 outline1("LD DE, %s", _value);
6643 outline1("LD A, $%2.2x", _position );
6644 outline0("CALL CPUBITCHECKEXTENDED" );
6645
6646 if ( _result ) {
6647 outline1("LD (%s), A", _result);
6648 }
6649
6650 done( )
6651
6652}
6653
6654void cpu_bit_check_extended( Environment * _environment, char *_value, char * _position, char * _result, int _bitwidth ) {
6655
6656 MAKE_LABEL
6657
6658 no_inline( cpu_bit_check_extended )
6659
6660 embedded( cpu_bit_check_extended, src_hw_sm83_cpu_bit_check_extended_asm );
6661
6662 outline1("LD DE, %s", _value);
6663 outline1("LD A, (%s)", _position );
6664 outline0("CALL CPUBITCHECKEXTENDED" );
6665
6666 if ( _result ) {
6667 outline1("LD (%s), A", _result);
6668 }
6669
6670 done( )
6671
6672}
6673
6674void cpu_bit_inplace_8bit( Environment * _environment, char * _value, int _position, int * _bit ) {
6675
6676 _environment->bitmaskNeeded = 1;
6677
6678 MAKE_LABEL
6679
6680 no_inline( cpu_bit_inplace )
6681
6682 embedded( cpu_bit_inplace, src_hw_sm83_cpu_bit_inplace_asm );
6683
6684 if ( _bit ) {
6685 if ( * _bit ) {
6686 outline0("LD A, $ff" );
6687 } else {
6688 outline0("LD A, $0" );
6689 }
6690 outline0("SRL A" );
6691 }
6692 outline1("LD DE, %s", _value );
6693 outline1("LD A, $%2.2x", _position);
6694 outline0("CALL CPUBITINPLACE");
6695
6696 done( )
6697
6698}
6699
6700void cpu_bit_inplace_8bit_extended_indirect( Environment * _environment, char * _address, char * _position, char * _bit ) {
6701
6702 _environment->bitmaskNeeded = 1;
6703
6704 MAKE_LABEL
6705
6706 no_inline( cpu_bit_inplace )
6707
6708 embedded( cpu_bit_inplace, src_hw_sm83_cpu_bit_inplace_asm );
6709
6710 if ( _bit ) {
6711 outline1("LD A, (%s)", _bit );
6712 outline0("CP $0" );
6713 outline1("JR Z, %s", label );
6714 outline0("LD A, 1" );;
6715 outline0("SRL A" );
6716 outhead1("%s:", label );
6717 }
6718 outline1("LD HL, (%s)", _address);
6719 outline0("LD D, H");
6720 outline0("LD E, L");
6721 outline1("LD A, (%s)", _position);
6722 outline0("CALL CPUBITINPLACE");
6723
6724 done( )
6725
6726}
6727
6728void cpu_number_to_string_vars( Environment * _environment ) {
6729
6730 variable_import( _environment, "N2DINV", VT_BUFFER, _environment->numberConfig.maxBytes );
6731 variable_import( _environment, "N2DBUF", VT_BUFFER, _environment->numberConfig.maxDigits );
6732 variable_import( _environment, "N2DEND", VT_BUFFER, 1 );
6733
6734}
6735
6736void cpu_number_to_string( Environment * _environment, char * _number, char * _string, char * _string_size, int _bits, int _signed ) {
6737
6738 MAKE_LABEL
6739
6740 deploy_with_vars( numberToString, src_hw_sm83_number_to_string_asm, cpu_number_to_string_vars );
6741
6742 outline0("LD A, 0");
6743 outline0("LD (IXHR), A");
6744 switch( _bits ) {
6745 case 8:
6746 outline1("LD A, (%s)", _number);
6747 outline0("LD (N2DINV), A");
6748 if ( _signed ) {
6749 outline0("AND $80");
6750 outline0("CP 0");
6751 outline1("JR Z, %sp81", label);
6752 cpu_complement2_8bit( _environment, "N2DINV", NULL );
6753 outline0("LD A, $ff");
6754 outline0("LD (IXHR), A");
6755 outhead1("%sp81:", label);
6756 }
6757 outline0("CALL N2D8");
6758 break;
6759 case 16:
6760 outline1("LD HL, (%s)", _number);
6761 outline0("LD (N2DINV), HL");
6762 if ( _signed ) {
6763 outline0("LD A, H");
6764 outline0("AND $80");
6765 outline0("CP 0");
6766 outline1("JR Z, %sp81", label);
6767 cpu_complement2_16bit( _environment, "N2DINV", NULL );
6768 outline0("LD A, $ff");
6769 outline0("LD (IXHR), A");
6770 outhead1("%sp81:", label);
6771 }
6772 outline0("CALL N2D16");
6773 break;
6774 case 32:
6775 outline1("LD HL, (%s)", _number);
6776 outline0("LD (N2DINV), HL");
6777 outline1("LD HL, (%s)", address_displacement(_environment, _number, "2"));
6778 outline0("LD (N2DINV+2), HL");
6779 if ( _signed ) {
6780 outline0("LD A, H");
6781 outline0("AND $80");
6782 outline0("CP 0");
6783 outline1("JR Z, %sp81", label);
6784 cpu_complement2_32bit( _environment, "N2DINV", NULL );
6785 outline0("LD A, $ff");
6786 outline0("LD (IXHR), A");
6787 outhead1("%sp81:", label);
6788 }
6789 outline0("CALL N2D32");
6790 break;
6791 case 0:
6792 CRITICAL_DEBUG_UNSUPPORTED( _number, "unknown");
6793 default:
6794 cpu_mem_move_direct_size( _environment, _number, "N2DINV", _bits >> 3 );
6795 if ( _signed ) {
6796 outline1("LD A, (N2DINV+%d)", (_bits >> 3)-1 );
6797 outline0("AND $80");
6798 outline0("CP 0");
6799 outline1("JP Z, %sp81", label);
6800 cpu_complement2_nbit( _environment, "N2DINV", NULL, _bits );
6801 outline0("LD A, $ff");
6802 outline0("LD (IXHR), A");
6803 outhead1("%sp81:", label);
6804 }
6805 outline0("CALL N2STRING");
6806 break;
6807 }
6808
6809 outline1("LD HL, (%s)", _string);
6810 outline0("LD DE, HL");
6811 outline0("LD A, (IXHR)");
6812 outline0("CP 0");
6813 outline1("JR Z, %spos", label);
6814 outline0("LD A, '-'");
6815 outline0("LD (DE), A");
6816 outline0("INC DE");
6817 outline0("INC C");
6818 outhead1("%spos:", label);
6819 outline0("LD A, C");
6820 outline1("LD (%s), A", _string_size);
6821 outline0("CALL REPLACEMENT_LDIR");
6822
6823}
6824
6825void cpu_bits_to_string_vars( Environment * _environment ) {
6826
6827 variable_import( _environment, "BINSTRBUF", VT_BUFFER, 32 );
6828 variable_import( _environment, "BINTOSTRDIGIT0", VT_BYTE, '0' );
6829 variable_import( _environment, "BINTOSTRDIGIT1", VT_BYTE, '1' );
6830}
6831
6832void cpu_bits_to_string( Environment * _environment, char * _number, char * _string, char * _string_size, int _bits, char * _zero, char * _one ) {
6833
6834 deploy_with_vars( bitsToString,src_hw_sm83_bits_to_string_asm, cpu_bits_to_string_vars );
6835
6836 if ( _zero ) {
6837 outline1("LD A, (%s)", _zero);
6838 } else {
6839 outline0("LD A, '0'" );
6840 }
6841 outline0("LD (BINTOSTRDIGIT0), A" );
6842
6843 if ( _one ) {
6844 outline1("LD A, (%s)", _one);
6845 } else {
6846 outline0("LD A, '1'" );
6847 }
6848 outline0("LD (BINTOSTRDIGIT1), A" );
6849
6850 switch( _bits ) {
6851 case 32:
6852 outline0("PUSH HL");
6853 outline1("LD HL, (%s)", address_displacement(_environment, _number, "2"));
6854 outline0("LD B, H");
6855 outline0("LD B, L");
6856 outline0("POP HL");
6857 outline0("PUSH HL");
6858 outline1("LD HL, (%s)", _number);
6859 outline0("LD D, H");
6860 outline0("LD E, L");
6861 outline0("POP HL");
6862 break;
6863 case 16:
6864 outline0("LD BC, 0" );
6865 outline0("PUSH HL");
6866 outline1("LD HL, (%s)", _number);
6867 outline0("LD D, H");
6868 outline0("LD E, L");
6869 outline0("POP HL");
6870 break;
6871 case 8:
6872 outline0("LD BC, 0" );
6873 outline0("LD D, 0" );
6874 outline1("LD A, (%s)", _number );
6875 outline0("LD E, A" );
6876 outline0("LD A, 0" );
6877 break;
6878 }
6879
6880 outline1("LD A, $%2.2x", ( _bits & 0xff ) );
6881 outline0("CALL BINSTR");
6882
6883 outline0("PUSH HL");
6884 outline1("LD HL, (%s)", _string);
6885 outline0("LD D, H");
6886 outline0("LD E, L");
6887 outline0("POP HL");
6888
6889 outline1("LD A, $%2.2x", ( (_bits) & 0xff ) );
6890 outline0("LD C, A");
6891 outline0("LD B, 0");
6892 outline0("CALL REPLACEMENT_LDIR");
6893
6894 outline1("LD A, $%2.2x", ( _bits & 0xff ) );
6895 outline1("LD HL, %s", _string_size );
6896 outline0("LD (HL), A" );
6897
6898}
6899
6900void cpu_hex_to_string_calc_string( Environment * _environment, char * _size, int _separator, char * _string_size ) {
6901
6902 MAKE_LABEL
6903
6904 deploy_embedded( cpu_math_mul_8bit_to_16bit, src_hw_sm83_cpu_math_mul_8bit_to_16bit_asm );
6905
6906 outline1("LD A, (%s)", _size );
6907 outline0("LD (IYLR), A");
6908 outline1("LD A, $%2.2x", 2 + (_separator?1:0));
6909 outline0("LD (IXLR), A");
6910 outline0("CALL CPUMUL8B8T16U");
6911 outline0("LD A, L");
6912 outline1("LD (%s), A", _string_size);
6913
6914}
6915
6916void cpu_hex_to_string_calc_string_size( Environment * _environment, int _size, int _separator, char * _string_size ) {
6917
6918 MAKE_LABEL
6919
6920 deploy_embedded( cpu_math_mul_8bit_to_16bit, src_hw_sm83_cpu_math_mul_8bit_to_16bit_asm );
6921
6922 outline1("LD A, $%2.2x", (unsigned char)(_size&0xff) );
6923 outline0("LD (IYLR), A");
6924 outline1("LD A, $%2.2x", 2 + (_separator?1:0));
6925 outline0("LD (IXLR), A");
6926 outline0("CALL CPUMUL8B8T16U");
6927 outline0("LD A, L");
6928 outline1("LD (%s), A", _string_size);
6929
6930}
6931
6932void cpu_hex_to_string( Environment * _environment, char * _number, char * _string, char * _size, int _separator ) {
6933
6934 MAKE_LABEL
6935
6936 inline( cpu_hex_to_string )
6937
6938 embedded( cpu_hex_to_string, src_hw_sm83_cpu_hex_to_string_asm );
6939
6940 outline1("LD B, $%2.2x", (unsigned char)(_separator*3));
6941 outline1("LD A, (%s)", _size);
6942 outline0("LD C, A");
6943 outline1("LD HL, (%s)", _string );
6944 outline0("LD DE, HL");
6945 outline1("LD HL, (%s)", _number );
6946 outline0("CALL H2STRING" );
6947
6948 done()
6949
6950}
6951
6952void cpu_dsdefine( Environment * _environment, char * _string, char * _index ) {
6953
6954 deploy( duff, src_hw_sm83_duff_asm );
6955 deploy( dstring,src_hw_sm83_dstring_asm );
6956
6957 outline1( "LD HL, %s", _string );
6958 outline0( "CALL DSDEFINE" );
6959 outline0( "LD A, B" );
6960 outline1( "LD (%s), A", _index );
6961
6962}
6963
6964void cpu_dsalloc( Environment * _environment, char * _size, char * _index ) {
6965
6966 deploy( duff, src_hw_sm83_duff_asm );
6967 deploy( dstring,src_hw_sm83_dstring_asm );
6968
6969 outline1( "LD A, (%s)", _size );
6970 outline0( "LD C, A" );
6971 outline0( "CALL DSALLOC" );
6972 outline0( "LD A, B" );
6973 outline1( "LD (%s), A", _index );
6974
6975}
6976
6977void cpu_dsalloc_size( Environment * _environment, int _size, char * _index ) {
6978
6979 deploy( duff, src_hw_sm83_duff_asm );
6980 deploy( dstring,src_hw_sm83_dstring_asm );
6981
6982 outline1( "LD A, $%2.2x", ( _size & 0xff ) );
6983 outline0( "LD C, A" );
6984 outline0( "CALL DSALLOC" );
6985 outline0( "LD A, B" );
6986 outline1( "LD (%s), A", _index );
6987
6988}
6989
6990void cpu_dsfree( Environment * _environment, char * _index ) {
6991
6992 deploy( duff, src_hw_sm83_duff_asm );
6993 deploy( dstring,src_hw_sm83_dstring_asm );
6994
6995 outline1( "LD A, (%s)", _index );
6996 outline0( "LD B, A" );
6997 outline0( "CALL DSFREE" );
6998
6999}
7000
7001void cpu_dswrite( Environment * _environment, char * _index ) {
7002
7003 deploy( duff, src_hw_sm83_duff_asm );
7004 deploy( dstring,src_hw_sm83_dstring_asm );
7005
7006 outline1( "LD A, (%s)", _index );
7007 outline0( "LD B, A" );
7008 outline0( "CALL DSWRITE" );
7009
7010}
7011
7012void cpu_dsresize( Environment * _environment, char * _index, char * _resize ) {
7013
7014 deploy( duff, src_hw_sm83_duff_asm );
7015 deploy( dstring,src_hw_sm83_dstring_asm );
7016
7017 outline1( "LD A, (%s)", _index );
7018 outline0( "LD B, A" );
7019 outline1( "LD A, (%s)", _resize );
7020 outline0( "LD C, A" );
7021 outline0( "CALL DSRESIZE" );
7022
7023}
7024
7025void cpu_dsresize_size( Environment * _environment, char * _index, int _resize ) {
7026
7027 deploy( duff, src_hw_sm83_duff_asm );
7028 deploy( dstring,src_hw_sm83_dstring_asm );
7029
7030 outline1( "LD A, (%s)", _index );
7031 outline0( "LD B, A" );
7032 outline1( "LD A, $%2.2x", ( _resize & 0xff ) );
7033 outline0( "LD C, A" );
7034 outline0( "CALL DSRESIZE" );
7035
7036}
7037
7038void cpu_dsgc( Environment * _environment ) {
7039
7040 deploy( duff, src_hw_sm83_duff_asm );
7041 deploy( dstring,src_hw_sm83_dstring_asm );
7042
7043 outline0( "CALL DSGC" );
7044
7045}
7046
7047void cpu_dsinit( Environment * _environment ) {
7048
7049 deploy( duff, src_hw_sm83_duff_asm );
7050 deploy( dstring,src_hw_sm83_dstring_asm );
7051
7052 outline0( "CALL DSINIT" );
7053
7054}
7055
7056void cpu_dsdescriptor( Environment * _environment, char * _index, char * _address, char * _size ) {
7057
7058 deploy( duff, src_hw_sm83_duff_asm );
7059 deploy( dstring,src_hw_sm83_dstring_asm );
7060
7061 if ( _address || _size ) {
7062 outline1( "LD A, (%s)", _index );
7063 outline0( "LD B, A" );
7064 outline0( "CALL DSDESCRIPTOR" );
7065 outline0( "LD HL, (IXR)" );
7066 if ( _size ) {
7067 outline0( "LD A, (HL)" );
7068 outline1( "LD (%s), A", _size );
7069 }
7070 if ( _address ) {
7071 outline0( "INC HL" );
7072 outline0( "LD A, (HL)" );
7073 outline1( "LD (%s), A", _address );
7074 outline0( "INC HL" );
7075 outline0( "LD A, (HL)" );
7076 outline1( "LD (%s), A", address_displacement(_environment, _address, "1") );
7077 }
7078 }
7079
7080}
7081
7082void cpu_dsassign( Environment * _environment, char * _original, char * _copy ) {
7083
7084 deploy( duff, src_hw_sm83_duff_asm );
7085 deploy( dstring,src_hw_sm83_dstring_asm );
7086
7087 outline1( "LD A, (%s)", _copy );
7088 outline0( "LD B, A");
7089 outline1( "LD A, (%s)", _original );
7090 outline0( "CALL DSASSIGN" );
7091 outline0( "LD A, B" );
7092 outline1( "LD (%s), A", _copy );
7093
7094}
7095
7096void cpu_dsassign_string( Environment * _environment, char * _string, char * _copy ) {
7097
7098 deploy( duff, src_hw_sm83_duff_asm );
7099 deploy( dstring,src_hw_sm83_dstring_asm );
7100
7101 outline1( "LD A, (%s)", _copy );
7102 outline0( "LD B, A");
7103 outline1( "LD HL, %s", _string );
7104 outline0( "CALL DSASSIGNSTR" );
7105 outline0( "LD A, B" );
7106 outline1( "LD (%s), A", _copy );
7107
7108}
7109
7110void cpu_move_8bit_indirect_with_offset2( Environment * _environment, char *_source, char * _value, char * _offset ) {
7111
7112 outline1("LD HL, (%s)", _value);
7113 outline1("LD A, (%s)", _offset );
7114 outline0("LD E, A" );
7115 outline0("LD A, 0" );
7116 outline0("LD D, A" );
7117 outline0("ADD HL, DE" );
7118 outline1("LD A, (%s)", _source);
7119 outline0("LD (HL), A");
7120
7121}
7122
7123void cpu_complement2_8bit( Environment * _environment, char * _source, char * _destination ) {
7124 outline1( "LD A, (%s)", _source );
7125 outline0( "XOR $FF" );
7126 if ( _destination ) {
7127 outline1( "LD (%s), A", _destination );
7128 } else {
7129 outline1( "LD (%s), A", _source );
7130 }
7131 if ( _destination ) {
7132 cpu_inc( _environment, _destination );
7133 } else {
7134 cpu_inc( _environment, _source );
7135 }
7136}
7137
7138void cpu_complement2_16bit( Environment * _environment, char * _source, char * _destination ) {
7139 outline1( "LD A, (%s)", _source );
7140 outline0( "XOR $FF" );
7141 if ( _destination ) {
7142 outline1( "LD (%s), A", _destination );
7143 } else {
7144 outline1( "LD (%s), A", _source );
7145 }
7146 outline1( "LD A, (%s)", address_displacement(_environment, _source, "1") );
7147 outline0( "XOR $FF" );
7148 if ( _destination ) {
7149 outline1( "LD (%s), A", address_displacement(_environment, _destination, "1") );
7150 } else {
7151 outline1( "LD (%s), A", address_displacement(_environment, _source, "1") );
7152 }
7153 if ( _destination ) {
7154 cpu_inc_16bit( _environment, _destination );
7155 } else {
7156 cpu_inc_16bit( _environment, _source );
7157 }
7158}
7159
7160void cpu_complement2_32bit( Environment * _environment, char * _source, char * _destination ) {
7161 outline1( "LD A, (%s)", _source );
7162 outline0( "XOR $FF" );
7163 if ( _destination ) {
7164 outline1( "LD (%s), A", _destination );
7165 } else {
7166 outline1( "LD (%s), A", _source );
7167 }
7168 outline1( "LD A, (%s)", address_displacement(_environment, _source, "1") );
7169 outline0( "XOR $FF" );
7170 if ( _destination ) {
7171 outline1( "LD (%s), A", address_displacement(_environment, _destination, "1") );
7172 } else {
7173 outline1( "LD (%s), A", address_displacement(_environment, _source, "1") );
7174 }
7175 outline1( "LD A, (%s)", address_displacement(_environment, _source, "2") );
7176 outline0( "XOR $FF" );
7177 if ( _destination ) {
7178 outline1( "LD (%s), A", address_displacement(_environment, _destination, "2") );
7179 } else {
7180 outline1( "LD (%s), A", address_displacement(_environment, _source, "2") );
7181 }
7182 outline1( "LD A, (%s)", address_displacement(_environment, _source, "3") );
7183 outline0( "XOR $FF" );
7184 if ( _destination ) {
7185 outline1( "LD (%s), A", address_displacement(_environment, _destination, "3") );
7186 } else {
7187 outline1( "LD (%s), A", address_displacement(_environment, _source, "3") );
7188 }
7189 if ( _destination ) {
7190 cpu_inc_32bit( _environment, _destination );
7191 } else {
7192 cpu_inc_32bit( _environment, _source );
7193 }
7194}
7195
7196void cpu_complement2_nbit( Environment * _environment, char * _source, char * _destination, int _bits ) {
7197
7198 for( int i=0; i<(_bits>>3); ++i ) {
7199 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
7200 outline1( "LD A, (%s)", address_displacement(_environment, _source, offset) );
7201 outline0( "XOR $FF" );
7202 if ( _destination ) {
7203 outline1( "LD (%s), A", address_displacement(_environment, _destination, "1") );
7204 } else {
7205 outline1( "LD (%s), A", address_displacement(_environment, _source, "1") );
7206 }
7207 }
7208 if ( _destination ) {
7209 cpu_inc_nbit( _environment, _destination, _bits );
7210 } else {
7211 cpu_inc_nbit( _environment, _source, _bits );
7212 }
7213
7214}
7215
7216void cpu_compare_nbit_const( Environment * _environment, char *_source, int _destination, char *_other, int _positive, int _bits ) {
7217
7218 MAKE_LABEL
7219
7220 inline( cpu_compare_nbit )
7221
7222 for( int i=0; i<(_bits>>3); ++i ) {
7223 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
7224 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
7225 outline1("LD B, $%2.2x", (unsigned char)((_destination>>(i*8))&0xff));
7226 outline0("CP B");
7227 outline1("JP NZ, %s", label);
7228 }
7229 outline1("LD A, $%2.2x", 0xff*_positive);
7230 if ( _other ) {
7231 outline1("LD (%s), A", _other);
7232 } else {
7233 outline1("LD (%s), A", _destination);
7234 }
7235 outline1("JP %s_2", label);
7236 outhead1("%s:", label);
7237 outline1("LD A, $%2.2x", 0xff*(1-_positive));
7238 if ( _other ) {
7239 outline1("LD (%s), A", _other);
7240 } else {
7241 outline1("LD (%s), A", _destination);
7242 }
7243 outhead1("%s_2:", label);
7244
7245 no_embedded( cpu_compare_nbit )
7246
7247}
7248
7249void cpu_sqroot( Environment * _environment, char * _number, char * _result ) {
7250
7251 deploy( sqr, src_hw_sm83_sqr_asm );
7252
7253 outline1("LD HL, (%s)", _number );
7254
7255 outline0("CALL SQROOT" );
7256
7257 outline1("LD (%s),A", _result );
7258
7259}
7260
7261void cpu_dstring_vars( Environment * _environment ) {
7262
7263 int count = _environment->dstring.count == 0 ? DSTRING_DEFAULT_COUNT : _environment->dstring.count;
7264 int space = _environment->dstring.space == 0 ? DSTRING_DEFAULT_SPACE : _environment->dstring.space;
7265
7266#if !defined(__vg5000__) && !defined(__cpc__) && !defined(__c128z__) && !defined(__zx__)
7267 outhead0("section data" );
7268#endif
7269 outhead1("stringscount = %d", count );
7270 outhead1("stringsspace = %d", space );
7271 outhead0("MAXSTRINGS: DB stringscount" );
7272 outhead0("DESCRIPTORS: DEFS stringscount*4, $00" );
7273 outhead0("WORKING: DEFS stringsspace, $00" );
7274 outhead0("TEMPORARY: DEFS stringsspace, $00" );
7275 outhead0("FREE_STRING: DW (stringsspace-1)" );
7276#if !defined(__vg5000__) && !defined(__cpc__) && !defined(__c128z__) && !defined(__zx__)
7277 outhead0("section code" );
7278#endif
7279
7280}
7281
7282void cpu_protothread_vars( Environment * _environment ) {
7283
7284 int count = _environment->protothreadConfig.count;
7285
7286 variable_import( _environment, "PROTOTHREADLC", VT_BUFFER, count );
7287 // outhead1("PROTOTHREADLC: DEFS %d", count );
7288 variable_import( _environment, "PROTOTHREADST", VT_BUFFER, count );
7289 // outhead1("PROTOTHREADST: DEFS %d", count );
7290 variable_import( _environment, "PROTOTHREADCT", VT_BYTE, 0 );
7291 // outhead0("PROTOTHREADCT: DEFB 0" );
7292 variable_import( _environment, "PROTOTHREADLOOP", VT_BUFFER, 1 + count * 8 );
7293 variable_import( _environment, "PROTOTHREADCOUNT", VT_BYTE, count );
7294
7295}
7296
7297
7298void cpu_protothread_loop( Environment * _environment ) {
7299
7300 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7301
7302 outline0("CALL PROTOTHREADLOOP" );
7303
7304}
7305
7306void cpu_protothread_register_at( Environment * _environment, char * _index, char * _label ) {
7307
7308 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7309
7310 outline1("LD HL, %s", _label );
7311 outline1("LD A, (%s)", _index );
7312 outline0("LD B, A");
7313
7314 outline0("CALL PROTOTHREADREGAT" );
7315
7316}
7317
7318void cpu_protothread_register( Environment * _environment, char * _label, char * _index ) {
7319
7320 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7321
7322 outline1("LD HL, %s", _label );
7323
7324 outline0("CALL PROTOTHREADREG" );
7325
7326 outline0("LD A, B" );
7327 outline1("LD (%s), A", _index );
7328
7329}
7330
7331void cpu_protothread_unregister( Environment * _environment, char * _index ) {
7332
7333 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7334
7335 outline1("LD A, (%s)", _index );
7336 outline0("LD B, A" );
7337
7338 outline0("CALL PROTOTHREADUNREG" );
7339
7340}
7341
7342void cpu_protothread_save( Environment * _environment, char * _index, int _step ) {
7343
7344 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7345
7346 outline1("LD A, (%s)", _index );
7347 outline0("LD B, A" );
7348 outline1("LD A, $%2.2x", ( _step & 0xff ) );
7349
7350 outline0("CALL PROTOTHREADSAVE" );
7351
7352}
7353
7354void cpu_protothread_restore( Environment * _environment, char * _index, char * _step ) {
7355
7356 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7357
7358 outline1("LD A, (%s)", _index );
7359 outline0("LD B, A" );
7360
7361 outline0("CALL PROTOTHREADRESTORE" );
7362
7363 outline1("LD (%s), A", _step );
7364
7365}
7366
7367void cpu_protothread_set_state( Environment * _environment, char * _index, int _state ) {
7368
7369 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7370
7371 outline1("LD A, (%s)", _index );
7372 outline0("LD B, A" );
7373 outline1("LD A, $%2.2x", ( _state & 0xff ) );
7374
7375 outline0("CALL PROTOTHREADSETSTATE" );
7376
7377}
7378
7379void cpu_protothread_get_state( Environment * _environment, char * _index, char * _state ) {
7380
7381 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7382
7383 outline1("LD A, (%s)", _index );
7384 outline0("LD B, A" );
7385
7386 outline0("CALL PROTOTHREADGETSTATE" );
7387
7388 outline1("LD (%s), A", _state );
7389
7390}
7391
7392void cpu_protothread_get_address( Environment * _environment, char * _index, char * _address ) {
7393
7394 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7395
7396 outline1("LD A, (%s)", _index );
7397 outline0("LD B, A" );
7398
7399 outline0("CALL PROTOTHREADGETADDRESS" );
7400
7401 outline1("LD (%s), HL", _address );
7402
7403}
7404
7405void cpu_protothread_current( Environment * _environment, char * _current ) {
7406
7407 deploy_with_vars( protothread, src_hw_sm83_protothread_asm, cpu_protothread_vars );
7408
7409 outline0("LD A, (PROTOTHREADCT)" );
7410 outline1("LD (%s), A", _current );
7411
7412}
7413
7414void cpu_set_callback( Environment * _environment, char * _callback, char * _label ) {
7415
7416 outline1("LD DE, %s", _label );
7417 outline1("LD HL, %s", _callback );
7418 outline0("INC HL" );
7419 outline0("LD (HL), E" );
7420 outline0("INC HL" );
7421 outline0("LD (HL), D" );
7422
7423}
7424
7425void cpu_msc1_uncompress_direct_direct( Environment * _environment, char * _input, char * _output ) {
7426
7427 MAKE_LABEL
7428
7429 inline( cpu_msc1_uncompress )
7430
7431 embedded( cpu_msc1_uncompress, src_hw_sm83_msc1_asm );
7432
7433 outline1("LD HL, %s", _input);
7434 outline1("LD DE, %s", _output);
7435 outline0("CALL MSC1UNCOMPRESS");
7436
7437 done()
7438
7439}
7440
7441void cpu_msc1_uncompress_direct_indirect( Environment * _environment, char * _input, char * _output ) {
7442
7443 MAKE_LABEL
7444
7445 inline( cpu_msc1_uncompress )
7446
7447 embedded( cpu_msc1_uncompress, src_hw_sm83_msc1_asm );
7448
7449 outline1("LD HL, (%s)", _output );
7450 outline0("LD D, H" );
7451 outline0("LD E, L" );
7452 outline1("LD HL, %s", _input);
7453 outline0("CALL MSC1UNCOMPRESS");
7454
7455 done()
7456
7457}
7458
7459void cpu_msc1_uncompress_indirect_direct( Environment * _environment, char * _input, char * _output ) {
7460
7461 MAKE_LABEL
7462
7463 inline( cpu_msc1_uncompress )
7464
7465 embedded( cpu_msc1_uncompress, src_hw_sm83_msc1_asm );
7466
7467 outline1("LD HL, (%s)", _input);
7468 outline1("LD DE, %s", _output);
7469 outline0("CALL MSC1UNCOMPRESS");
7470
7471 done()
7472
7473}
7474
7475void cpu_msc1_uncompress_indirect_indirect( Environment * _environment, char * _input, char * _output ) {
7476
7477 MAKE_LABEL
7478
7479 inline( cpu_msc1_uncompress )
7480
7481 embedded( cpu_msc1_uncompress, src_hw_sm83_msc1_asm );
7482
7483 outline1("LD HL, (%s)", _output );
7484 outline0("LD D, H" );
7485 outline0("LD E, L" );
7486 outline1("LD HL, (%s)", _input);
7487 outline0("CALL MSC1UNCOMPRESS");
7488
7489 done()
7490
7491}
7492
7493void cpu_out( Environment * _environment, char * _port, char * _value ) {
7494
7495 outline1("LD HL, (%s)", _port );
7496 outline0("LD BC, HL" );
7497 outline1("LD A, (%s)", _value );
7498 outline0("OUT (C), A" );
7499
7500}
7501
7502void cpu_in( Environment * _environment, char * _port, char * _value ) {
7503
7504 outline1("LD HL, (%s)", _port );
7505 outline0("LD BC, HL" );
7506 outline0("IN A, (C)" );
7507 outline1("LD (%s), A", _value );
7508
7509}
7510
7511void cpu_out_direct( Environment * _environment, char * _port, char * _value ) {
7512
7513 outline1("LD A, (%s)", _value );
7514 outline1("LD BC, %s", _port );
7515 outline0("OUT (C), A" );
7516
7517}
7518
7519void cpu_in_direct( Environment * _environment, char * _port, char * _value ) {
7520
7521 outline1("LD BC, %s", _port );
7522 outline0("IN A, (C)" );
7523 outline1("LD (%s), A", _value );
7524
7525}
7526
7527void cpu_string_sub( Environment * _environment, char * _source, char * _source_size, char * _pattern, char * _pattern_size, char * _destination, char * _destination_size ) {
7528
7529 MAKE_LABEL
7530
7531 inline( cpu_string_sub )
7532
7533 embedded( cpu_string_sub, src_hw_sm83_cpu_string_sub_asm );
7534
7535 outline1("LD HL, (%s)", _pattern);
7536 outline0("LD (IXR), HL");
7537
7538 outline1("LD A, (%s)", _source);
7539 outline0("LD L, A");
7540 outline1("LD A, (%s)", address_displacement(_environment, _source, "1"));
7541 outline0("LD H, A");
7542 outline1("LD A, (%s)", _source_size);
7543 outline0("LD (IYLR), A");
7544
7545 outline1("LD A, (%s)", _pattern_size);
7546 outline0("LD (IYHR), A");
7547
7548 outline1("LD A, (%s)", _destination);
7549 outline0("LD E, A");
7550 outline1("LD A, (%s)", address_displacement(_environment, _destination, "1"));
7551 outline0("LD D, A");
7552
7553 outline0("CALL CPUSTRINGSUB");
7554
7555 outline0("LD A, (IYLR)");
7556 outline1("LD (%s), A", _destination_size);
7557
7558 done()
7559}
7560
7561static char SM83_BLIT_REGISTER[][2] = {
7562 "L",
7563 "H",
7564 "E",
7565 "D"
7566};
7567
7568#define SM83_BLII_REGISTER_COUNT ( sizeof( SM83_BLIT_REGISTER ) / 2 )
7569
7570void cpu_blit_initialize( Environment * _environment ) {
7571
7572 _environment->blit.freeRegisters = 0;
7573 _environment->blit.usedMemory = 0;
7574
7575 // outline0("; cpu_blit_initialize");
7576
7577 outline0("PUSH HL");
7578 outline0("PUSH DE");
7579
7580}
7581
7582void cpu_blit_finalize( Environment * _environment ) {
7583
7584 // outline0("; cpu_blit_finalize");
7585
7586 _environment->blit.freeRegisters = 0;
7587 _environment->blit.usedMemory = 0;
7588
7589 outline0("POP DE");
7590 outline0("POP HL");
7591
7592}
7593
7594char * cpu_blit_register_name( Environment * _environment, int _register ) {
7595
7596 if ( _register < SM83_BLII_REGISTER_COUNT ) {
7597 return &SM83_BLIT_REGISTER[_register][0];
7598 } else {
7599 return &SM83_BLIT_REGISTER[ (_register & 0xff00) >> 8][0];
7600 }
7601}
7602
7603int cpu_blit_alloc_register( Environment * _environment ) {
7604
7605 int reg = 0;
7606
7607 for( reg = 0; reg < SM83_BLII_REGISTER_COUNT; ++reg ) {
7608 int registerMask = ( 0x01 << reg );
7609 int isRegisterUsed = _environment->blit.freeRegisters & registerMask;
7610 if ( ! isRegisterUsed ) {
7611 _environment->blit.freeRegisters |= registerMask;
7612 // printf( "sm83_blit_alloc_register() %4.4x -> $%4.4x\n", _environment->blit.freeRegisters, reg );
7613 // outline1("; cpu_blit_alloc_register = %d", reg );
7614 return reg;
7615 }
7616 }
7617
7618 int location = _environment->blit.usedMemory++;
7619
7620 if ( location > 0xff ) {
7621 CRITICAL_BLIT_ALLOC_MEMORY_EXHAUSTED( );
7622 }
7623
7624 for( reg = 0; reg < SM83_BLII_REGISTER_COUNT; ++reg ) {
7625 int registerMask = ( 0x10 << reg );
7626 int isRegisterUsed = _environment->blit.freeRegisters & registerMask;
7627 if ( ! isRegisterUsed ) {
7628 outline1( "LD A, %s", &SM83_BLIT_REGISTER[reg][0] );
7629 outline2( "LD (%sbs+$%2.2x), A", _environment->blit.realName, location );
7630 _environment->blit.freeRegisters |= registerMask;
7631 // printf( "sm83_blit_alloc_register() -> %4.4x $%4.4x\n", _environment->blit.freeRegisters, ( ( reg << 8 ) | location ) );
7632 // outline1("; cpu_blit_alloc_register = %d", ( ( (reg+1) << 8 ) | location ) );
7633 return ( ( (reg+1) << 8 ) | location );
7634 }
7635 }
7636
7637 CRITICAL_BLIT_ALLOC_REGISTER_EXHAUSTED( );
7638
7639}
7640
7641void cpu_blit_free_register( Environment * _environment, int _register ) {
7642
7643 // outline1("; cpu_blit_free_register = %d", _register );
7644
7645 // printf( "sm83_blit_free_register($%4.4x)\n", _register );
7646
7647 int location = _register & 0xff;
7648 int reg;
7649
7650 if ( _register < SM83_BLII_REGISTER_COUNT ) {
7651 int registerMask = ( 0x01 << _register );
7652 int isRegisterUsed = _environment->blit.freeRegisters & registerMask;
7653 if ( isRegisterUsed ) {
7654 _environment->blit.freeRegisters &= ~registerMask;
7655 return;
7656 } else {
7657 CRITICAL_BLIT_INVALID_FREE_REGISTER( _environment->blit.name, _register );
7658 }
7659 } else {
7660 int registerMask = 0x10 << ( ( ( _register >> 8 ) & 0xff ) - 1 );
7661 int isRegisterUsed = _environment->blit.freeRegisters & registerMask;
7662 if ( isRegisterUsed ) {
7663 outline2( "LD A, (%sbs+$%2.2x)", _environment->blit.realName, location );
7664 outline1( "LD %s, A", &SM83_BLIT_REGISTER[reg][0] );
7665 _environment->blit.freeRegisters &= ~registerMask;
7666 return;
7667 }
7668 }
7669
7670 CRITICAL_BLIT_INVALID_FREE_REGISTER( _environment->blit.name, _register );
7671
7672}
7673
7682void cpu_store_nbit( Environment * _environment, char *_destination, int _n, int _value[] ) {
7683
7684 int i = 0;
7685 while( _n ) {
7686 char destinationAddress[MAX_TEMPORARY_STORAGE]; sprintf( destinationAddress, "%s+%d", _destination, i*4 );
7687 if ( _n <= 32 ) {
7688 switch( _n ) {
7689 case 1: case 2: case 3: case 4:
7690 case 5: case 6: case 7: case 8:
7691 cpu_store_8bit( _environment, destinationAddress, ( _value[i] & (0xff>>(8-_n)) ) );
7692 break;
7693 case 9: case 10: case 11: case 12:
7694 case 13: case 14: case 15: case 16:
7695 cpu_store_8bit( _environment, destinationAddress, ( _value[i] & (0xff) ) );
7696 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7697 cpu_store_8bit( _environment, destinationAddress, ( _value[i+1] & (0xff>>(16-_n)) ) );
7698 break;
7699 case 17: case 18: case 19: case 20:
7700 case 21: case 22: case 23: case 24:
7701 cpu_store_8bit( _environment, destinationAddress, ( _value[i] & (0xff) ) );
7702 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7703 cpu_store_8bit( _environment, destinationAddress, ( _value[i+1] & (0xff) ) );
7704 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7705 cpu_store_8bit( _environment, destinationAddress, ( _value[i+2] & (0xff>>(24-_n)) ) );
7706 break;
7707 case 25: case 26: case 27: case 28:
7708 case 29: case 30: case 31: case 32:
7709 default:
7710 cpu_store_8bit( _environment, destinationAddress, ( _value[i] & (0xff) ) );
7711 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7712 cpu_store_8bit( _environment, destinationAddress, ( _value[i+1] & (0xff) ) );
7713 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7714 cpu_store_8bit( _environment, destinationAddress, ( _value[i+2] & (0xff) ) );
7715 sprintf( destinationAddress, "%s+%d", _destination, i*4+3 );
7716 cpu_store_8bit( _environment, destinationAddress, ( _value[i+3] & (0xff>>(32-_n)) ) );
7717 break;
7718 }
7719 _n = 0;
7720 } else {
7721 cpu_store_8bit( _environment, destinationAddress, ( _value[i] & (0xff) ) );
7722 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7723 cpu_store_8bit( _environment, destinationAddress, ( _value[i+1] & (0xff) ) );
7724 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7725 cpu_store_8bit( _environment, destinationAddress, ( _value[i+2] & (0xff) ) );
7726 sprintf( destinationAddress, "%s+%d", _destination, i*4+3 );
7727 cpu_store_8bit( _environment, destinationAddress, ( _value[i+3] & (0xff>>(32-_n)) ) );
7728 _n -= 32;
7729 }
7730 ++i;
7731 }
7732
7733}
7734
7743void cpu_move_nbit( Environment * _environment, int _n, char * _source, char *_destination ) {
7744
7745 int i = 0;
7746 while( _n ) {
7747 char sourceAddress[MAX_TEMPORARY_STORAGE]; sprintf( sourceAddress, "%s+%d", _source, i*4 );
7748 char destinationAddress[MAX_TEMPORARY_STORAGE]; sprintf( destinationAddress, "%s+%d", _destination, i*4 );
7749 if ( _n <= 32 ) {
7750 switch( _n ) {
7751 case 1: case 2: case 3: case 4:
7752 case 5: case 6: case 7: case 8:
7753 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7754 break;
7755 case 9: case 10: case 11: case 12:
7756 case 13: case 14: case 15: case 16:
7757 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7758 sprintf( sourceAddress, "%s+%d", _source, i*4+1 );
7759 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7760 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7761 break;
7762 case 17: case 18: case 19: case 20:
7763 case 21: case 22: case 23: case 24:
7764 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7765 sprintf( sourceAddress, "%s+%d", _source, i*4+1 );
7766 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7767 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7768 sprintf( sourceAddress, "%s+%d", _source, i*4+2 );
7769 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7770 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7771 break;
7772 case 25: case 26: case 27: case 28:
7773 case 29: case 30: case 31: case 32:
7774 default:
7775 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7776 sprintf( sourceAddress, "%s+%d", _source, i*4+1 );
7777 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7778 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7779 sprintf( sourceAddress, "%s+%d", _source, i*4+2 );
7780 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7781 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7782 sprintf( sourceAddress, "%s+%d", _source, i*4+3 );
7783 sprintf( destinationAddress, "%s+%d", _destination, i*4+3 );
7784 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7785 break;
7786 }
7787 _n = 0;
7788 } else {
7789 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7790 sprintf( sourceAddress, "%s+%d", _source, i*4+1 );
7791 sprintf( destinationAddress, "%s+%d", _destination, i*4+1 );
7792 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7793 sprintf( sourceAddress, "%s+%d", _source, i*4+2 );
7794 sprintf( destinationAddress, "%s+%d", _destination, i*4+2 );
7795 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7796 sprintf( sourceAddress, "%s+%d", _source, i*4+3 );
7797 sprintf( destinationAddress, "%s+%d", _destination, i*4+3 );
7798 cpu_move_8bit( _environment, sourceAddress, destinationAddress );
7799 _n -= 32;
7800 }
7801 ++i;
7802 }
7803
7804}
7805
7814void cpu_compare_nbit( Environment * _environment, char *_source, char *_destination, char *_other, int _positive, int _bits ) {
7815
7816 MAKE_LABEL
7817
7818 inline( cpu_compare_nbit )
7819
7820 for( int i=0; i<(_bits>>3); ++i ) {
7821 char offset[MAX_TEMPORARY_STORAGE]; sprintf( offset, "%d", i );
7822 outline1("LD A, (%s)", address_displacement(_environment, _source, offset));
7823 outline0("LD B, A" );
7824 outline1("LD A, (%s)", address_displacement(_environment, _destination, offset));
7825 outline0("CP B");
7826 outline1("JP NZ, %s", label);
7827 }
7828 outline1("LD A, $%2.2x", 0xff*_positive);
7829 if ( _other ) {
7830 outline1("LD (%s), A", _other);
7831 } else {
7832 outline1("LD (%s), A", _destination);
7833 }
7834 outline1("JP %s_2", label);
7835 outhead1("%s:", label);
7836 outline1("LD A, $%2.2x", 0xff*(1-_positive));
7837 if ( _other ) {
7838 outline1("LD (%s), A", _other);
7839 } else {
7840 outline1("LD (%s), A", _destination);
7841 }
7842 outhead1("%s_2:", label);
7843
7844 no_embedded( cpu_compare_nbit )
7845
7846}
7847
7848// [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
7849// FAST (24) seeeeeee mmmmmmmm mmmmmmmm
7850
7851void cpu_float_fast_from_double_to_int_array( Environment * _environment, double _value, int _result[] ) {
7852
7853 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_from_double_to_int_array" );
7854
7855}
7856
7857//
7858// [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
7859// SINGLE (32) seeeeeee emmmmmmm mmmmmmmm mmmmmmmm
7860//
7861
7862void cpu_float_single_from_double_to_int_array( Environment * _environment, double _value, int _result[] ) {
7863
7864 CRITICAL_UNIMPLEMENTED( "sm83_float_single_from_double_to_int_array" );
7865
7866}
7867
7868//
7869// [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
7870// EXTENDED (80) seeeeeee eeeeeeee mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm mmmmmmmm
7871//
7872
7873void cpu_float_double_from_double_to_int_array( Environment * _environment, double _value, int _result[] ) {
7874
7875 CRITICAL_UNIMPLEMENTED( "sm83_float_double_from_double_to_int_array" );
7876
7877}
7878
7879void cpu_float_fast_to_string( Environment * _environment, char * _x, char * _string, char * _string_size ) {
7880
7881 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_to_string" );
7882
7883}
7884
7885void cpu_float_single_to_string( Environment * _environment, char * _x, char * _string, char * _string_size ) {
7886
7887 CRITICAL_UNIMPLEMENTED( "sm83_float_single_to_string" );
7888
7889}
7890
7891void cpu_float_double_to_string( Environment * _environment, char * _x, char * _string, char * _string_size ) {
7892
7893 CRITICAL_UNIMPLEMENTED( "sm83_float_double_to_string" );
7894
7895}
7896
7897void cpu_float_fast_from_16( Environment * _environment, char * _value, char * _result, int _signed ) {
7898
7899 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_from_16" );
7900
7901}
7902
7903void cpu_float_fast_from_8( Environment * _environment, char * _value, char * _result, int _signed ) {
7904
7905 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_from_8" );
7906
7907}
7908
7909void cpu_float_fast_to_16( Environment * _environment, char * _value, char * _result, int _signed ) {
7910
7911 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_to_16" );
7912
7913}
7914
7915void cpu_float_fast_to_8( Environment * _environment, char * _value, char * _result, int _signed ) {
7916
7917 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_to_8" );
7918
7919}
7920
7921void cpu_float_fast_add( Environment * _environment, char * _x, char * _y, char * _result ) {
7922
7923 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_add" );
7924
7925}
7926
7927void cpu_float_fast_sub( Environment * _environment, char * _x, char * _y, char * _result ) {
7928
7929 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_sub" );
7930
7931}
7932
7933void cpu_float_fast_mul( Environment * _environment, char * _x, char * _y, char * _result ) {
7934
7935 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_mul" );
7936
7937}
7938
7939void cpu_float_fast_div( Environment * _environment, char * _x, char * _y, char * _result ) {
7940
7941 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_div" );
7942
7943}
7944
7945void cpu_float_fast_cmp( Environment * _environment, char * _x, char * _y, char * _result ) {
7946
7947 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_cmp" );
7948
7949}
7950
7951void cpu_float_fast_sin( Environment * _environment, char * _angle, char * _result ) {
7952
7953 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_sin" );
7954
7955}
7956
7957void cpu_float_fast_cos( Environment * _environment, char * _angle, char * _result ) {
7958
7959 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_cos" );
7960
7961}
7962
7963void cpu_float_fast_tan( Environment * _environment, char * _angle, char * _result ) {
7964
7965 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_tan" );
7966
7967}
7968
7969void cpu_float_fast_sqr( Environment * _environment, char * _value, char * _result ) {
7970
7971 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_sqr" );
7972
7973}
7974
7975void cpu_float_fast_mod1( Environment * _environment, char * _value, char * _result ) {
7976
7977 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_mod1" );
7978
7979}
7980
7981void cpu_float_fast_neg( Environment * _environment, char * _value, char * _result ) {
7982
7983 CRITICAL_UNIMPLEMENTED( "sm83_float_fast_neg" );
7984
7985}
7986
7987void cpu_float_single_from_16( Environment * _environment, char * _value, char * _result, int _signed ) {
7988
7989 CRITICAL_UNIMPLEMENTED( "sm83_float_single_from_16" );
7990
7991}
7992
7993void cpu_float_single_from_8( Environment * _environment, char * _value, char * _result, int _signed ) {
7994
7995 CRITICAL_UNIMPLEMENTED( "sm83_float_single_from_8" );
7996
7997}
7998
7999
8000void cpu_float_single_to_16( Environment * _environment, char * _value, char * _result, int _signed ) {
8001
8002 CRITICAL_UNIMPLEMENTED( "sm83_float_single_to_16" );
8003
8004}
8005
8006void cpu_float_single_to_8( Environment * _environment, char * _value, char * _result, int _signed ) {
8007
8008 CRITICAL_UNIMPLEMENTED( "sm83_float_single_to_8" );
8009
8010}
8011
8012void cpu_float_single_add( Environment * _environment, char * _x, char * _y, char * _result ) {
8013
8014 CRITICAL_UNIMPLEMENTED( "sm83_float_single_add" );
8015
8016}
8017
8018void cpu_float_single_sub( Environment * _environment, char * _x, char * _y, char * _result ) {
8019
8020 CRITICAL_UNIMPLEMENTED( "sm83_float_single_sub" );
8021
8022}
8023
8024void cpu_float_single_mul( Environment * _environment, char * _x, char * _y, char * _result ) {
8025
8026 CRITICAL_UNIMPLEMENTED( "sm83_float_single_mul" );
8027
8028}
8029
8030void cpu_float_single_div( Environment * _environment, char * _x, char * _y, char * _result ) {
8031
8032 CRITICAL_UNIMPLEMENTED( "sm83_float_single_div" );
8033
8034}
8035
8036void cpu_float_single_cmp( Environment * _environment, char * _x, char * _y, char * _result ) {
8037
8038 CRITICAL_UNIMPLEMENTED( "sm83_float_single_cmp" );
8039
8040}
8041
8042void cpu_float_single_neg( Environment * _environment, char * _value, char * _result ) {
8043
8044 CRITICAL_UNIMPLEMENTED( "sm83_float_single_neg" );
8045
8046}
8047
8048void cpu_float_single_sin( Environment * _environment, char * _angle, char * _result ) {
8049
8050 CRITICAL_UNIMPLEMENTED( "sm83_float_single_sin" );
8051
8052}
8053
8054void cpu_float_single_cos( Environment * _environment, char * _angle, char * _result ) {
8055
8056 CRITICAL_UNIMPLEMENTED( "sm83_float_single_cos" );
8057
8058}
8059
8060void cpu_float_single_tan( Environment * _environment, char * _angle, char * _result ) {
8061
8062 CRITICAL_UNIMPLEMENTED( "sm83_float_single_tan" );
8063
8064}
8065
8066void cpu_float_single_sqr( Environment * _environment, char * _value, char * _result ) {
8067
8068 CRITICAL_UNIMPLEMENTED( "sm83_float_single_sqr" );
8069
8070}
8071
8072void cpu_float_single_mod1( Environment * _environment, char * _value, char * _result ) {
8073
8074 CRITICAL_UNIMPLEMENTED( "sm83_float_single_mod1" );
8075
8076}
8077
8078void cpu_address_table_build( Environment * _environment, char * _table, int * _values, char *_address[], int _count ) {
8079
8080 outhead1("%s:", _table );
8081 for( int i=0; i<_count; ++i ) {
8082 outline2("DEFW $%4.4x, %s", _values[i], _address[i] );
8083 }
8084
8085}
8086
8087void cpu_address_table_lookup( Environment * _environment, char * _table, int _count ) {
8088
8089 outhead1("LOOKFOR%s:", _table );
8090 if ( _count ) {
8091 outline1("LD HL, %s", _table );
8092 outline0("LD C, 0" );
8093 outhead1("LOOKFOR%sL1:", _table );
8094 outline0("LD A, (HL)" );
8095 outline0("INC HL" );
8096 outline0("LD B, A" );
8097 outline0("LD A, E" );
8098 outline0("CP B" );
8099 outline1("JR NZ, LOOKFOR%sNEXT3", _table );
8100 outline0("LD A, (HL)" );
8101 outline0("INC HL" );
8102 outline0("LD B, A" );
8103 outline0("LD A, D" );
8104 outline0("CP B" );
8105 outline1("JR NZ, LOOKFOR%sNEXT2", _table );
8106 outline0("LD A, (HL)" );
8107 outline0("INC HL" );
8108 outline0("LD E, A" );
8109 outline0("LD A, (HL)" );
8110 outline0("INC HL" );
8111 outline0("LD D, A" );
8112 outline0("RET" );
8113 outhead1("LOOKFOR%sNEXT3:", _table );
8114 outline0("INC HL" );
8115 outhead1("LOOKFOR%sNEXT2:", _table );
8116 outline0("INC HL" );
8117 outline0("INC HL" );
8118 outline0("INC C" );
8119 outline0("LD A, C" );
8120 outline1("CP $%4.4x", (_count+1) );
8121 outline1("JR NZ, LOOKFOR%sL1", _table );
8122 }
8123 outline0("RET" );
8124
8125}
8126
8127void cpu_address_table_call( Environment * _environment, char * _table, char * _value, char * _address ) {
8128
8129 outline0("PUSH HL");
8130 outline1("LD HL, (%s)", _value );
8131 outline0("LD D, H" );
8132 outline0("LD E, L" );
8133 outline0("POP HL");
8134 outline1("CALL LOOKFOR%s", _table );
8135 outline0("PUSH HL");
8136 outline0("LD H, D" );
8137 outline0("LD L, E" );
8138 outline1("LD (%s), HL", _address );
8139 outline0("POP HL");
8140
8141}
8142
8143void cpu_move_8bit_signed_16bit_signed( Environment * _environment, char *_source, char *_destination ) {
8144
8145 outline1("LD HL, %s", _destination );
8146 outline1("LD A, (%s)", _source );
8147 outline0("LD (HL), A" );
8148 outline0("INC HL" );
8149 outline0("ADD A, A" );
8150 outline0("SBC A" );
8151 outline0("LD (HL), A" );
8152
8153}
8154
8155void cpu_move_8bit_signed_16bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8156
8157 outline1("LD HL, %s", _destination );
8158 outline1("LD A, (%s)", _source );
8159 outline0("LD (HL), A" );
8160 outline0("INC HL" );
8161 outline0("ADD A, A" );
8162 outline0("SBC A" );
8163 outline0("LD (HL), A" );
8164
8165}
8166
8167void cpu_move_8bit_unsigned_16bit_signed( Environment * _environment, char *_source, char *_destination ){
8168
8169 outline1("LD HL, %s", _destination );
8170 outline1("LD A, (%s)", _source );
8171 outline0("LD (HL), A" );
8172 outline0("INC HL" );
8173 outline0("LD A, 0" );
8174 outline0("LD (HL), A" );
8175
8176}
8177
8178void cpu_move_8bit_unsigned_16bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8179
8180 outline1("LD HL, %s", _destination );
8181 outline1("LD A, (%s)", _source );
8182 outline0("LD (HL), A" );
8183 outline0("INC HL" );
8184 outline0("LD A, 0" );
8185 outline0("LD (HL), A" );
8186
8187}
8188
8189void cpu_move_8bit_signed_32bit_signed( Environment * _environment, char *_source, char *_destination ){
8190
8191 outline1("LD HL, %s", _destination );
8192 outline1("LD A, (%s)", _source );
8193 outline0("LD (HL), A" );
8194 outline0("INC HL" );
8195 outline0("ADD A, A" );
8196 outline0("SBC A" );
8197 outline0("LD (HL), A" );
8198 outline0("INC HL" );
8199 outline0("LD (HL), A" );
8200 outline0("INC HL" );
8201 outline0("LD (HL), A" );
8202
8203}
8204
8205void cpu_move_8bit_signed_32bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8206
8207 outline1("LD HL, %s", _destination );
8208 outline1("LD A, (%s)", _source );
8209 outline0("LD (HL), A" );
8210 outline0("INC HL" );
8211 outline0("ADD A, A" );
8212 outline0("SBC A" );
8213 outline0("LD (HL), A" );
8214 outline0("INC HL" );
8215 outline0("LD (HL), A" );
8216 outline0("INC HL" );
8217 outline0("LD (HL), A" );
8218
8219}
8220
8221void cpu_move_8bit_unsigned_32bit_signed( Environment * _environment, char *_source, char *_destination ){
8222
8223 outline1("LD HL, %s", _destination );
8224 outline1("LD A, (%s)", _source );
8225 outline0("LD (HL), A" );
8226 outline0("INC HL" );
8227 outline0("LD A, 0" );
8228 outline0("LD (HL), A" );
8229 outline0("INC HL" );
8230 outline0("LD A, 0" );
8231 outline0("LD (HL), A" );
8232 outline0("INC HL" );
8233 outline0("LD A, 0" );
8234 outline0("LD (HL), A" );
8235
8236}
8237void cpu_move_8bit_unsigned_32bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8238
8239 outline1("LD HL, %s", _destination );
8240 outline1("LD A, (%s)", _source );
8241 outline0("LD (HL), A" );
8242 outline0("INC HL" );
8243 outline0("LD A, 0" );
8244 outline0("LD (HL), A" );
8245 outline0("INC HL" );
8246 outline0("LD A, 0" );
8247 outline0("LD (HL), A" );
8248 outline0("INC HL" );
8249 outline0("LD A, 0" );
8250 outline0("LD (HL), A" );
8251
8252}
8253
8254void cpu_move_16bit_signed_8bit_signed( Environment * _environment, char *_source, char *_destination ){
8255
8256 outline1("LD HL, (%s)", _source );
8257 outline0("LD A, L" );
8258 outline1("LD (%s), A", _destination );
8259
8260}
8261void cpu_move_16bit_signed_8bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8262
8263 outline1("LD HL, (%s)", _source );
8264 outline0("LD A, L" );
8265 outline1("LD (%s), A", _destination );
8266
8267}
8268void cpu_move_16bit_unsigned_8bit_signed( Environment * _environment, char *_source, char *_destination ){
8269
8270 outline1("LD HL, (%s)", _source );
8271 outline0("LD A, L" );
8272 outline1("LD (%s), A", _destination );
8273
8274}
8275void cpu_move_16bit_unsigned_8bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8276
8277 outline1("LD HL, (%s)", _source );
8278 outline0("LD A, L" );
8279 outline1("LD (%s), A", _destination );
8280
8281}
8282
8283void cpu_move_16bit_signed_32bit_signed( Environment * _environment, char *_source, char *_destination ){
8284
8285 outline1("LD HL, %s", _destination );
8286 outline1("LD A, (%s)", _source );
8287 outline0("LD (HL), A" );
8288 outline0("INC HL" );
8289 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
8290 outline0("LD (HL), A" );
8291 outline0("INC HL" );
8292 outline0("ADD A, A" );
8293 outline0("SBC A" );
8294 outline0("LD (HL), A" );
8295 outline0("INC HL" );
8296 outline0("LD (HL), A" );
8297
8298}
8299
8300void cpu_move_16bit_signed_32bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8301
8302 outline1("LD HL, %s", _destination );
8303 outline1("LD A, (%s)", _source );
8304 outline0("LD (HL), A" );
8305 outline0("INC HL" );
8306 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
8307 outline0("LD (HL), A" );
8308 outline0("INC HL" );
8309 outline0("ADD A, A" );
8310 outline0("SBC A" );
8311 outline0("LD (HL), A" );
8312 outline0("INC HL" );
8313 outline0("LD (HL), A" );
8314
8315}
8316
8317void cpu_move_16bit_unsigned_32bit_signed( Environment * _environment, char *_source, char *_destination ){
8318
8319 outline1("LD HL, %s", _destination );
8320 outline1("LD A, (%s)", _source );
8321 outline0("LD (HL), A" );
8322 outline0("INC HL" );
8323 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
8324 outline0("LD (HL), A" );
8325 outline0("INC HL" );
8326 outline0("LD A, 0" );
8327 outline0("LD (HL), A" );
8328 outline0("INC HL" );
8329 outline0("LD (HL), A" );
8330
8331}
8332void cpu_move_16bit_unsigned_32bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8333
8334 outline1("LD HL, %s", _destination );
8335 outline1("LD A, (%s)", _source );
8336 outline0("LD (HL), A" );
8337 outline0("INC HL" );
8338 outline1("LD A, (%s)", address_displacement( _environment, _source, "1" ) );
8339 outline0("LD (HL), A" );
8340 outline0("INC HL" );
8341 outline0("LD A, 0" );
8342 outline0("LD (HL), A" );
8343 outline0("INC HL" );
8344 outline0("LD (HL), A" );
8345
8346}
8347
8348void cpu_move_32bit_signed_8bit_signed( Environment * _environment, char *_source, char *_destination ){
8349
8350 outline1("LD A, (%s)", _source );
8351 outline1("LD (%s), A", _destination );
8352
8353}
8354void cpu_move_32bit_signed_8bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8355
8356 outline1("LD A, (%s)", _source );
8357 outline1("LD (%s), A", _destination );
8358
8359}
8360void cpu_move_32bit_unsigned_8bit_signed( Environment * _environment, char *_source, char *_destination ){
8361
8362 outline1("LD A, (%s)", _source );
8363 outline1("LD (%s), A", _destination );
8364
8365}
8366void cpu_move_32bit_unsigned_8bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8367
8368 outline1("LD A, (%s)", _source );
8369 outline1("LD (%s), A", _destination );
8370
8371}
8372
8373void cpu_move_32bit_signed_16bit_signed( Environment * _environment, char *_source, char *_destination ){
8374
8375 outline1("LD HL, (%s)", _source );
8376 outline1("LD (%s), HL", _destination );
8377
8378}
8379
8380void cpu_move_32bit_signed_16bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8381
8382 outline1("LD HL, (%s)", _source );
8383 outline1("LD (%s), HL", _destination );
8384
8385}
8386
8387void cpu_move_32bit_unsigned_16bit_signed( Environment * _environment, char *_source, char *_destination ){
8388
8389 outline1("LD HL, (%s)", _source );
8390 outline1("LD (%s), HL", _destination );
8391
8392}
8393
8394void cpu_move_32bit_unsigned_16bit_unsigned( Environment * _environment, char *_source, char *_destination ){
8395
8396 outline1("LD HL, (%s)", _source );
8397 outline1("LD (%s), HL", _destination );
8398
8399}
8400
8401void cpu_float_fast_log( Environment * _environment, char * _value, char * _result ) {
8402
8403 CRITICAL_UNIMPLEMENTED("LOG");
8404
8405}
8406
8407void cpu_float_single_log( Environment * _environment, char * _value, char * _result ) {
8408
8409 CRITICAL_UNIMPLEMENTED("LOG");
8410
8411}
8412
8413void cpu_float_fast_exp( Environment * _environment, char * _value, char * _result ) {
8414
8415 CRITICAL_UNIMPLEMENTED("EXP");
8416
8417}
8418
8419void cpu_float_single_exp( Environment * _environment, char * _value, char * _result ) {
8420
8421 CRITICAL_UNIMPLEMENTED("EXP");
8422
8423}
8424
8425void cpu_encrypt( Environment * _environment, char * _data, char * _data_size, char * _key, char * _key_size, char * _output ) {
8426
8427 deploy( encrypt, src_hw_sm83_encrypt_asm );
8428
8429 outline1("LD HL, (%s)", _output );
8430 outline0("LD DE, HL" );
8431 outline1("LD HL, (%s)", _key );
8432 outline0("LD (IXR), HL" );
8433 outline1("LD HL, (%s)", _data );
8434 outline1("LD A, (%s)", _data_size );
8435 outline0("LD C, A" );
8436 outline1("LD A, (%s)", _key_size );
8437 outline0("LD B, A" );
8438 outline0("CALL ENCRYPT" );
8439
8440}
8441
8442void cpu_decrypt( Environment * _environment, char * _data, char * _data_size, char * _key, char * _key_size, char * _output, char * _result ) {
8443
8444 deploy( decrypt, src_hw_sm83_decrypt_asm );
8445
8446 outline1("LD HL, (%s)", _output );
8447 outline0("LD DE, HL" );
8448 outline1("LD HL, (%s)", _key );
8449 outline0("LD (IXR), HL" );
8450 outline1("LD HL, (%s)", _data );
8451 outline1("LD A, (%s)", _data_size );
8452 outline0("LD C, A" );
8453 outline1("LD A, (%s)", _key_size );
8454 outline0("LD B, A" );
8455 outline0("CALL DECRYPT" );
8456 cpu_ztoa( _environment );
8457 outline1("LD (%s), A", _result );
8458
8459}
8460
8461void cpu_hex_to_bin( Environment * _environment, char * _value_address, char * _value_size, char * _variable_address, char * _variable_size, char * _result ) {
8462
8463 deploy( hex2bin, src_hw_sm83_hex2bin_asm );
8464
8465 outline1("LD HL, (%s)", _variable_address );
8466 outline0("LD DE, HL");
8467 outline1("LD HL, (%s)", _value_address );
8468 outline1("LD A, (%s)", _value_size );
8469 outline0("LD C, A" );
8470 outline1("LD A, (%s)", _variable_size );
8471 outline0("LD B, A" );
8472 outline0("CALL HEX2BIN" );
8473 outline1("LD (%s), A", _result );
8474
8475}
8476
8477void cpu_dsfill( Environment * _environment, char * _string, char * _value ) {
8478
8479 deploy_preferred( duff, src_hw_sm83_duff_asm );
8480 deploy( dstring, src_hw_sm83_dstring_asm );
8481
8482 outline1( "LD A, (%s)", _string );
8483 outline0( "LD B, A" );
8484 outline1( "LD A, (%s)", _value );
8485 outline0( "CALL DSFILL" );
8486
8487}
8488
8489void cpu_dsfill_value( Environment * _environment, char * _string, int _value ) {
8490
8491 deploy_preferred( duff, src_hw_sm83_duff_asm );
8492 deploy( dstring, src_hw_sm83_dstring_asm );
8493
8494 outline1( "LD A, (%s)", _string );
8495 outline0( "LD B, A" );
8496 outline1( "LD A, $%2.2x", (unsigned char)(_value&0xff) );
8497 outline0( "CALL DSFILL" );
8498
8499}
8500
8501#endif
cpu_combine_nibbles
void cpu_combine_nibbles(Environment *_environment, char *_low_nibble, char *_hi_nibble, char *_byte)
Definition 6309.c:3724
cpu_math_double_32bit
void cpu_math_double_32bit(Environment *_environment, char *_source, char *_other, int _signed)
CPU 6309: emit code to double a 32 bit value
Definition 6309.c:3279
cpu_math_mul2_const_16bit
void cpu_math_mul2_const_16bit(Environment *_environment, char *_source, int _steps, int _signed)
CPU 6309: emit code to halves for several times a 8 bit value
Definition 6309.c:2461
cpu_math_mul_16bit_to_32bit
void cpu_math_mul_16bit_to_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _signed)
CPU 6309: emit code to multiply two 16 bit values in a 32 bit register
Definition 6309.c:1752
cpu_bveq
void cpu_bveq(Environment *_environment, char *_value, char *_label)
Definition 6309.c:334
cpu_bit_check_extended
void cpu_bit_check_extended(Environment *_environment, char *_value, char *_position, char *_result, int _bitwidth)
Definition 6309.c:5605
cpu_math_mul2_const_8bit
void cpu_math_mul2_const_8bit(Environment *_environment, char *_source, int _steps, int _signed)
CPU 6309: emit code to double for several times a 8 bit value
Definition 6309.c:1397
cpu_math_mul2_const_32bit
void cpu_math_mul2_const_32bit(Environment *_environment, char *_source, int _steps, int _signed)
CPU 6309: emit code to double for several times a 32 bit value
Definition 6309.c:3547
cpu_math_sub_8bit
void cpu_math_sub_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to subtract two 8 bit values
Definition 6309.c:1049
cpu_math_add_32bit
void cpu_math_add_32bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to add two 32 bit values
Definition 6309.c:3219
cpu_store_char
void cpu_store_char(Environment *_environment, char *_destination, int _value)
CPU 6309: emit code to store 8 bit
Definition 6309.c:785
cpu_math_complement_const_32bit
void cpu_math_complement_const_32bit(Environment *_environment, char *_source, int _value)
CPU 6309: emit code to calculate a 32 bit complement of a number
Definition 6309.c:3352
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_math_double_16bit
void cpu_math_double_16bit(Environment *_environment, char *_source, char *_other, int _signed)
CPU 6309: emit code to double a 16 bit value
Definition 6309.c:1728
cpu_math_sub_32bit
void cpu_math_sub_32bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to subtract two 32 bit values
Definition 6309.c:3304
cpu_math_div2_const_8bit
void cpu_math_div2_const_8bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
CPU 6309: emit code to halves for several times a 8 bit value
Definition 6309.c:1329
cpu_math_div_nbit_to_nbit
void cpu_math_div_nbit_to_nbit(Environment *_environment, char *_source, char *_destination, char *_other, char *_other_remainder, int _bits)
Definition 6309.c:2571
cpu_math_add_8bit
void cpu_math_add_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to add two 8 bit values
Definition 6309.c:1017
cpu_string_sub
void cpu_string_sub(Environment *_environment, char *_source, char *_source_size, char *_pattern, char *_pattern_size, char *_destination, char *_destination_size)
Definition 6309.c:6370
cpu_compare_8bit
void cpu_compare_8bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
CPU 6309: emit code to compare two 8 bit values
Definition 6309.c:811
cpu_math_and_const_32bit
void cpu_math_and_const_32bit(Environment *_environment, char *_source, int _mask)
CPU 6309: emit code to mask with "and" a value of 32 bit
Definition 6309.c:3698
cpu_addressof_16bit
void cpu_addressof_16bit(Environment *_environment, char *_source, char *_destination)
Definition 6309.c:1485
cpu_math_complement_const_8bit
void cpu_math_complement_const_8bit(Environment *_environment, char *_source, int _value)
CPU 6309: emit code to calculate an 8 bit complement of a number
Definition 6309.c:1432
cpu_math_complement_const_16bit
void cpu_math_complement_const_16bit(Environment *_environment, char *_source, int _value)
CPU 6309: emit code to calculate a 16 bit complement of a number
Definition 6309.c:2337
cpu_math_mul2_const_nbit
void cpu_math_mul2_const_nbit(Environment *_environment, char *_source, int _steps, int _bits)
Definition 6309.c:3664
cpu_move_32bit
void cpu_move_32bit(Environment *_environment, char *_source, char *_destination)
CPU 6309: emit code to move 32 bit
Definition 6309.c:2520
cpu_less_than_8bit
void cpu_less_than_8bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
CPU 6309: emit code to compare two 8 bit values
Definition 6309.c:950
cpu_dec_32bit
void cpu_dec_32bit(Environment *_environment, char *_variable)
Definition 6309.c:4652
cpu_math_add_16bit
void cpu_math_add_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to add two 16 bit values
Definition 6309.c:1661
cpu_protothread_vars
void cpu_protothread_vars(Environment *_environment)
Definition 6309.c:6143
cpu_math_add_16bit_with_16bit
void cpu_math_add_16bit_with_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to add two 16 bit values
Definition 6309.c:1696
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_fill
void cpu_fill(Environment *_environment, char *_address, char *_bytes, int _bytes_width, char *_pattern)
CPU 6309: emit code to fill up a memory area
Definition 6309.c:534
cpu_math_mul_8bit_to_16bit
void cpu_math_mul_8bit_to_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _signed)
CPU 6309: emit code to multiply two 8bit values in a 16 bit register
Definition 6309.c:1088
cpu_math_sub_16bit
void cpu_math_sub_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to subtract two 16 bit values
Definition 6309.c:2305
cpu_compare_and_branch_32bit_const
void cpu_compare_and_branch_32bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
CPU 6309: emit code to compare two 32 bit values and jump if they are equal/different
Definition 6309.c:2914
cpu_math_and_const_16bit
void cpu_math_and_const_16bit(Environment *_environment, char *_source, int _mask)
CPU 6309: emit code to mask with "and" a value of 16 bit
Definition 6309.c:2496
cpu_less_than_nbit_const
void cpu_less_than_nbit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _bits)
Definition 6309.c:3065
cpu_math_div2_const_32bit
void cpu_math_div2_const_32bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
CPU 6309: emit code to halves for several times a 32 bit value
Definition 6309.c:3376
cpu_move_16bit
void cpu_move_16bit(Environment *_environment, char *_source, char *_destination)
CPU 6309: emit code to move 16 bit
Definition 6309.c:1474
cpu_bneq
void cpu_bneq(Environment *_environment, char *_label)
CPU 6309: emit code to make long conditional jump
Definition 6309.c:324
cpu_math_double_8bit
void cpu_math_double_8bit(Environment *_environment, char *_source, char *_other, int _signed)
CPU 6309: emit code to double a 8 bit value
Definition 6309.c:1068
cpu_less_than_nbit
void cpu_less_than_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _bits)
Definition 6309.c:3021
cpu_hex_to_string
void cpu_hex_to_string(Environment *_environment, char *_number, char *_string, char *_size, int _separator)
Definition 6309.c:5865
cpu_math_add_32bit_const
void cpu_math_add_32bit_const(Environment *_environment, char *_source, int _destination, char *_other)
Definition 6309.c:3257
cpu_store_8bit
void cpu_store_8bit(Environment *_environment, char *_destination, int _value)
CPU 6309: emit code to store 8 bit
Definition 6309.c:761
cpu_swap_8bit
void cpu_swap_8bit(Environment *_environment, char *_left, char *_right)
Definition 6309.c:4451
cpu_compare_32bit
void cpu_compare_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
CPU 6309: emit code to compare two 32 bit values
Definition 6309.c:2769
cpu_store_8bit_with_offset2
void cpu_store_8bit_with_offset2(Environment *_environment, char *_source, char *_offset, int _value)
Definition 6309.c:6029
cpu_fill_blocks
void cpu_fill_blocks(Environment *_environment, char *_address, char *_blocks, char *_pattern)
CPU 6309: emit code to fill up a memory area
Definition 6309.c:484
cpu_bvneq
void cpu_bvneq(Environment *_environment, char *_value, char *_label)
Definition 6309.c:345
cpu_compare_and_branch_16bit
void cpu_compare_and_branch_16bit(Environment *_environment, char *_source, char *_destination, char *_label, int _positive)
Definition 6309.c:1552
cpu_poke
void cpu_poke(Environment *_environment, char *_address, char *_source)
Definition 6309.c:377
cpu_greater_than_nbit
void cpu_greater_than_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _bits)
Definition 6309.c:3189
cpu_less_than_16bit
void cpu_less_than_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
CPU 6309: emit code to compare two 8 bit values
Definition 6309.c:1603
cpu_math_and_const_8bit
void cpu_math_and_const_8bit(Environment *_environment, char *_source, int _mask)
CPU 6309: emit code to mask with "and" a value of 8 bit
Definition 6309.c:1451
cpu_inc_nbit
void cpu_inc_nbit(Environment *_environment, char *_variable, int _bits)
Definition 6309.c:4613
cpu_math_div2_const_16bit
void cpu_math_div2_const_16bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
CPU 6309: emit code to halves for several times a 16 bit value
Definition 6309.c:2356
cpu_compare_nbit
void cpu_compare_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive, int _bits)
Definition 6309.c:2804
cpu_ztoa
void cpu_ztoa(Environment *_environment)
Definition 6309.c:262
cpu_random
void cpu_random(Environment *_environment, char *_entropy)
Definition 6309.c:4075
cpu_compare_and_branch_8bit
void cpu_compare_and_branch_8bit(Environment *_environment, char *_source, char *_destination, char *_label, int _positive)
Definition 6309.c:851
cpu_ctoa
void cpu_ctoa(Environment *_environment)
Definition 6309.c:279
cpu_math_sub_nbit
void cpu_math_sub_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _bits)
Definition 6309.c:3325
cpu_math_div2_const_nbit
void cpu_math_div2_const_nbit(Environment *_environment, char *_source, int _steps, int _bits, char *_remainder)
Definition 6309.c:3503
cpu_store_8bit_with_offset
void cpu_store_8bit_with_offset(Environment *_environment, char *_destination, int _value, int _offset)
Definition 6309.c:6021
cpu_store_32bit
void cpu_store_32bit(Environment *_environment, char *_destination, int _value)
CPU 6309: emit code to store 32 bit
Definition 6309.c:2540
cpu_flip
void cpu_flip(Environment *_environment, char *_source, char *_size, char *_destination)
Definition 6309.c:5562
cpu_move_8bit
void cpu_move_8bit(Environment *_environment, char *_source, char *_destination)
CPU 6309: emit code to move 8 bit
Definition 6309.c:743
cpu_beq
void cpu_beq(Environment *_environment, char *_label)
CPU 6309: emit code to make long conditional jump
Definition 6309.c:308
cpu_compare_16bit
void cpu_compare_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
CPU 6309: emit code to compare two 16 bit values
Definition 6309.c:1523
cpu_peek
void cpu_peek(Environment *_environment, char *_address, char *_target)
Definition 6309.c:366
cpu_math_add_nbit
void cpu_math_add_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _bits)
Definition 6309.c:3238
cpu_compare_and_branch_8bit_const
void cpu_compare_and_branch_8bit_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:876
cpu_less_than_32bit
void cpu_less_than_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
CPU 6309: emit code to compare two 32 bit values
Definition 6309.c:2949
IS_REGISTER
#define IS_REGISTER(x)
Definition 6309.h:58
REGISTER_B
@ REGISTER_B
Definition 6309.h:64
REGISTER_D
@ REGISTER_D
Definition 6309.h:72
REGISTER_A
@ REGISTER_A
Definition 6309.h:63
REGISTER_NONE
@ REGISTER_NONE
Definition 6309.h:62
REGISTER_PC
@ REGISTER_PC
Definition 6309.h:71
STACK_NONE
@ STACK_NONE
Definition 6309.h:78
STACK_BYTE
@ STACK_BYTE
Definition 6309.h:79
STACK_WORD
@ STACK_WORD
Definition 6309.h:80
STACK_DWORD
@ STACK_DWORD
Definition 6309.h:81
REGISTER_CARRY
@ REGISTER_CARRY
Definition 6502.h:76
REGISTER_ZERO
@ REGISTER_ZERO
Definition 6502.h:77
cpu_bits_to_string_vars
void cpu_bits_to_string_vars(Environment *_environment)
Definition 8086.c:4589
cpu_number_to_string_vars
void cpu_number_to_string_vars(Environment *_environment)
Definition 8086.c:4513
REGISTER_SP
@ REGISTER_SP
Definition 8086.h:74
variable_retrieve
Variable * variable_retrieve(Environment *_environment, char *_name)
Definition _infrastructure.c:988
variable_import
Variable * variable_import(Environment *_environment, char *_name, VariableType _type, int _size_or_value)
Definition _infrastructure.c:778
variable_global
void variable_global(Environment *_environment, char *_pattern)
Definition _infrastructure.c:467
variable_temporary
Variable * variable_temporary(Environment *_environment, VariableType _type, char *_meaning)
Define a temporary variable.
Definition _infrastructure.c:1388
address_displacement
char * address_displacement(Environment *_environment, char *_address, char *_displacement)
Definition _infrastructure.c:14516
variable_store_buffer
Variable * variable_store_buffer(Environment *_environment, char *_destination, unsigned char *_buffer, int _size, int _at)
Definition _infrastructure.c:2175
offset
int offset
Definition _optimizer.c:681
DSTRING_DEFAULT_SPACE
#define DSTRING_DEFAULT_SPACE
Definition atari.h:152
DSTRING_DEFAULT_COUNT
#define DSTRING_DEFAULT_COUNT
Definition atari.h:151
decrypt
Variable * decrypt(Environment *_environment, char *_data, char *_key, char *_var)
Emit code for DECRYPT.
Definition decrypt.c:81
encrypt
Variable * encrypt(Environment *_environment, char *_data, char *_key)
Emit code for ENCRYPT.
Definition encrypt.c:79
REGISTER_I
@ REGISTER_I
Definition sc61860.h:62
REGISTER_L
@ REGISTER_L
Definition sc61860.h:71
abs
#define abs(ticks)
Definition sidreloc.c:338
cpu_and_32bit
void cpu_and_32bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4325
cpu_float_single_cos
void cpu_float_single_cos(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:8054
cpu_protothread_get_state
void cpu_protothread_get_state(Environment *_environment, char *_index, char *_state)
Definition sm83.c:7379
cpu_float_fast_neg
void cpu_float_fast_neg(Environment *_environment, char *_value, char *_result)
Definition sm83.c:7981
cpu_set_callback
void cpu_set_callback(Environment *_environment, char *_callback, char *_label)
Definition sm83.c:7414
cpu_move_32bit_indirect2
void cpu_move_32bit_indirect2(Environment *_environment, char *_value, char *_source)
Definition sm83.c:5625
cpu_dsfree
void cpu_dsfree(Environment *_environment, char *_index)
Definition sm83.c:6990
cpu_less_than_memory_size
void cpu_less_than_memory_size(Environment *_environment, char *_source, char *_destination, int _size, char *_result, int _equal)
Definition sm83.c:5031
cpu_dsresize_size
void cpu_dsresize_size(Environment *_environment, char *_index, int _resize)
Definition sm83.c:7025
cpu_hex_to_string_calc_string
void cpu_hex_to_string_calc_string(Environment *_environment, char *_size, int _separator, char *_string_size)
Definition sm83.c:6900
cpu_move_8bit_signed_32bit_unsigned
void cpu_move_8bit_signed_32bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8205
cpu_float_fast_from_8
void cpu_float_fast_from_8(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7903
cpu_in
void cpu_in(Environment *_environment, char *_port, char *_value)
Definition sm83.c:7502
cpu_hex_to_string_calc_string_size
void cpu_hex_to_string_calc_string_size(Environment *_environment, int _size, int _separator, char *_string_size)
Definition sm83.c:6916
cpu_pokew
void cpu_pokew(Environment *_environment, char *_address, char *_source)
Definition sm83.c:281
cpu_move_32bit_signed_16bit_unsigned
void cpu_move_32bit_signed_16bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8380
cpu_combine_nibbles
void cpu_combine_nibbles(Environment *_environment, char *_low_nibble, char *_hi_nibble, char *_byte)
Z80: emit code to combine nibbles
Definition sm83.c:3516
cpu_blit_register_name
char * cpu_blit_register_name(Environment *_environment, int _register)
Definition sm83.c:7594
cpu_di
void cpu_di(Environment *_environment)
Definition sm83.c:4676
cpu_float_fast_tan
void cpu_float_fast_tan(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:7963
cpu_math_double_32bit
void cpu_math_double_32bit(Environment *_environment, char *_source, char *_other, int _signed)
Z80: emit code to double a 32 bit value
Definition sm83.c:3197
cpu_protothread_restore
void cpu_protothread_restore(Environment *_environment, char *_index, char *_step)
Definition sm83.c:7354
cpu_msc1_uncompress_indirect_indirect
void cpu_msc1_uncompress_indirect_indirect(Environment *_environment, char *_input, char *_output)
Definition sm83.c:7475
cpu_not_16bit
void cpu_not_16bit(Environment *_environment, char *_value, char *_result)
Definition sm83.c:4636
cpu_move_8bit_unsigned_32bit_signed
void cpu_move_8bit_unsigned_32bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8221
cpu_math_mul2_const_16bit
void cpu_math_mul2_const_16bit(Environment *_environment, char *_source, int _steps, int _signed)
Z80: emit code to halves for several times a 8 bit value
Definition sm83.c:2592
cpu_math_div_16bit_to_16bit
void cpu_math_div_16bit_to_16bit(Environment *_environment, char *_source, char *_destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:6027
cpu_move_16bit_signed_32bit_signed
void cpu_move_16bit_signed_32bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8283
cpu_move_8bit_unsigned_16bit_signed
void cpu_move_8bit_unsigned_16bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8167
cpu_compare_32bit_const
void cpu_compare_32bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _positive)
Z80: emit code to compare two 32 bit values
Definition sm83.c:2784
cpu_math_mul_16bit_to_32bit
void cpu_math_mul_16bit_to_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _signed)
Z80: emit code to multiply two 16 bit values in a 32 bit register
Definition sm83.c:2239
cpu_swap_32bit
void cpu_swap_32bit(Environment *_environment, char *_left, char *_right)
Definition sm83.c:4605
cpu_float_fast_from_16
void cpu_float_fast_from_16(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7897
cpu_bveq
void cpu_bveq(Environment *_environment, char *_value, char *_label)
Definition sm83.c:202
cpu_dsresize
void cpu_dsresize(Environment *_environment, char *_index, char *_resize)
Definition sm83.c:7012
cpu_move_nbit_indirect
void cpu_move_nbit_indirect(Environment *_environment, int _n, char *_source, char *_value)
Definition sm83.c:5541
cpu_math_div_8bit_to_8bit_const
void cpu_math_div_8bit_to_8bit_const(Environment *_environment, char *_source, int _destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:6546
cpu_bit_check_extended
void cpu_bit_check_extended(Environment *_environment, char *_value, char *_position, char *_result, int _bitwidth)
Definition sm83.c:6654
cpu_math_div_32bit_to_16bit
void cpu_math_div_32bit_to_16bit(Environment *_environment, char *_source, char *_destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:5732
cpu_math_mul2_const_8bit
void cpu_math_mul2_const_8bit(Environment *_environment, char *_source, int _steps, int _signed)
Z80: emit code to double for several times a 8 bit value
Definition sm83.c:1591
cpu_float_fast_div
void cpu_float_fast_div(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:7939
cpu_move_32bit_signed_16bit_signed
void cpu_move_32bit_signed_16bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8373
cpu_move_32bit_unsigned_8bit_unsigned
void cpu_move_32bit_unsigned_8bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8366
cpu_math_mul2_const_32bit
void cpu_math_mul2_const_32bit(Environment *_environment, char *_source, int _steps, int _signed)
Z80: emit code to double for several times a 32 bit value
Definition sm83.c:3426
cpu_uppercase
void cpu_uppercase(Environment *_environment, char *_source, char *_size, char *_result)
Definition sm83.c:5164
cpu_math_add_16bit_with_8bit
void cpu_math_add_16bit_with_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
Definition sm83.c:5134
cpu_address_table_build
void cpu_address_table_build(Environment *_environment, char *_table, int *_values, char *_address[], int _count)
Definition sm83.c:8078
cpu_mem_move
void cpu_mem_move(Environment *_environment, char *_source, char *_destination, char *_size)
Definition sm83.c:4797
cpu_set_asmio_indirect
void cpu_set_asmio_indirect(Environment *_environment, int _asmio, char *_value)
Definition sm83.c:3793
cpu_msc1_uncompress_direct_indirect
void cpu_msc1_uncompress_direct_indirect(Environment *_environment, char *_input, char *_output)
Definition sm83.c:7441
cpu_math_sub_8bit
void cpu_math_sub_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to subtract two 8 bit values
Definition sm83.c:1330
cpu_xor_32bit_const
void cpu_xor_32bit_const(Environment *_environment, char *_left, int _right, char *_result)
Definition sm83.c:4548
cpu_math_add_32bit
void cpu_math_add_32bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to add two 32 bit values
Definition sm83.c:3114
cpu_protothread_save
void cpu_protothread_save(Environment *_environment, char *_index, int _step)
Definition sm83.c:7342
cpu_store_char
void cpu_store_char(Environment *_environment, char *_destination, int _value)
Z80: emit code to store 8 bit
Definition sm83.c:746
cpu_math_complement_const_32bit
void cpu_math_complement_const_32bit(Environment *_environment, char *_source, int _value)
Z80: emit code to calculate a 32 bit complement of a number
Definition sm83.c:3304
cpu_store_16bit
void cpu_store_16bit(Environment *_environment, char *_destination, int _value)
Z80: emit code to store 16 bit
Definition sm83.c:1717
cpu_poked
void cpu_poked(Environment *_environment, char *_address, char *_source)
Definition sm83.c:332
cpu_and_8bit_const
void cpu_and_8bit_const(Environment *_environment, char *_left, int _right, char *_result)
Definition sm83.c:4294
cpu_dsassign
void cpu_dsassign(Environment *_environment, char *_original, char *_copy)
Definition sm83.c:7082
cpu_math_double_16bit
void cpu_math_double_16bit(Environment *_environment, char *_source, char *_other, int _signed)
Z80: emit code to double a 16 bit value
Definition sm83.c:2214
cpu_math_sub_32bit
void cpu_math_sub_32bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to subtract two 32 bit values
Definition sm83.c:3219
SM83_BLII_REGISTER_COUNT
#define SM83_BLII_REGISTER_COUNT
Definition sm83.c:7568
cpu_complement2_8bit
void cpu_complement2_8bit(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:7123
cpu_msc1_uncompress_indirect_direct
void cpu_msc1_uncompress_indirect_direct(Environment *_environment, char *_input, char *_output)
Definition sm83.c:7459
cpu_math_div2_const_8bit
void cpu_math_div2_const_8bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
Z80: emit code to halves for several times a 8 bit value
Definition sm83.c:1519
cpu_less_than_memory
void cpu_less_than_memory(Environment *_environment, char *_source, char *_destination, char *_size, char *_result, int _equal)
Definition sm83.c:4994
cpu_dsalloc_size
void cpu_dsalloc_size(Environment *_environment, int _size, char *_index)
Definition sm83.c:6977
cpu_get_asmio_indirect
void cpu_get_asmio_indirect(Environment *_environment, int _asmio, char *_value)
Definition sm83.c:3945
cpu_move_16bit_unsigned_8bit_unsigned
void cpu_move_16bit_unsigned_8bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8275
cpu_float_fast_cos
void cpu_float_fast_cos(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:7957
cpu_protothread_set_state
void cpu_protothread_set_state(Environment *_environment, char *_index, int _state)
Definition sm83.c:7367
cpu_math_div_nbit_to_nbit
void cpu_math_div_nbit_to_nbit(Environment *_environment, char *_source, char *_destination, char *_other, char *_other_remainder, int _bits)
Definition sm83.c:6249
cpu_math_add_8bit
void cpu_math_add_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to add two 8 bit values
Definition sm83.c:1287
cpu_float_single_add
void cpu_float_single_add(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:8012
cpu_float_single_sub
void cpu_float_single_sub(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:8018
cpu_bit_inplace_8bit_extended_indirect
void cpu_bit_inplace_8bit_extended_indirect(Environment *_environment, char *_address, char *_position, char *_bit)
Definition sm83.c:6700
cpu_move_8bit_unsigned_32bit_unsigned
void cpu_move_8bit_unsigned_32bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8237
cpu_move_8bit_indirect
void cpu_move_8bit_indirect(Environment *_environment, char *_source, char *_value)
Definition sm83.c:5408
cpu_string_sub
void cpu_string_sub(Environment *_environment, char *_source, char *_source_size, char *_pattern, char *_pattern_size, char *_destination, char *_destination_size)
Definition sm83.c:7527
cpu_compare_8bit
void cpu_compare_8bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
Z80: emit code to compare two 8 bit values
Definition sm83.c:795
cpu_math_and_const_32bit
void cpu_math_and_const_32bit(Environment *_environment, char *_source, int _mask)
Z80: emit code to mask with "and" a value of 32 bit
Definition sm83.c:3492
cpu_fill_direct_size
void cpu_fill_direct_size(Environment *_environment, char *_address, int _bytes, char *_pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:621
cpu_addressof_16bit
void cpu_addressof_16bit(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:1699
cpu_dec_16bit
void cpu_dec_16bit(Environment *_environment, char *_variable)
Definition sm83.c:4751
cpu_dsgc
void cpu_dsgc(Environment *_environment)
Definition sm83.c:7038
cpu_move_16bit_signed_32bit_unsigned
void cpu_move_16bit_signed_32bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8300
cpu_inc
void cpu_inc(Environment *_environment, char *_variable)
Definition sm83.c:4688
cpu_poke_const
void cpu_poke_const(Environment *_environment, char *_address, int _source)
Definition sm83.c:254
cpu_fill_direct
void cpu_fill_direct(Environment *_environment, char *_address, char *_bytes, char *_pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:584
cpu_jump_indirect
void cpu_jump_indirect(Environment *_environment, char *_value)
Definition sm83.c:3563
cpu_math_complement_const_8bit
void cpu_math_complement_const_8bit(Environment *_environment, char *_source, int _value)
Z80: emit code to calculate an 8 bit complement of a number
Definition sm83.c:1644
cpu_dsdefine
void cpu_dsdefine(Environment *_environment, char *_string, char *_index)
Definition sm83.c:6952
cpu_math_complement_const_16bit
void cpu_math_complement_const_16bit(Environment *_environment, char *_source, int _value)
Z80: emit code to calculate a 16 bit complement of a number
Definition sm83.c:2481
cpu_move_16bit_unsigned_32bit_unsigned
void cpu_move_16bit_unsigned_32bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8332
cpu_math_mul2_const_nbit
void cpu_math_mul2_const_nbit(Environment *_environment, char *_source, int _steps, int _bits)
Definition sm83.c:2414
cpu_float_single_exp
void cpu_float_single_exp(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8419
cpu_move_32bit
void cpu_move_32bit(Environment *_environment, char *_source, char *_destination)
Z80: emit code to move 32 bit
Definition sm83.c:2668
cpu_fill_size
void cpu_fill_size(Environment *_environment, char *_address, int _bytes, char *_pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:493
cpu_dsfill
void cpu_dsfill(Environment *_environment, char *_string, char *_value)
Definition sm83.c:8477
cpu_less_than_8bit
void cpu_less_than_8bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:983
cpu_fill_direct_size_value
void cpu_fill_direct_size_value(Environment *_environment, char *_address, int _bytes, int _pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:669
cpu_float_double_to_string
void cpu_float_double_to_string(Environment *_environment, char *_x, char *_string, char *_string_size)
Definition sm83.c:7891
cpu_dec_32bit
void cpu_dec_32bit(Environment *_environment, char *_variable)
Definition sm83.c:4759
cpu_greater_than_16bit_const
void cpu_greater_than_16bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:2146
cpu_protothread_get_address
void cpu_protothread_get_address(Environment *_environment, char *_index, char *_address)
Definition sm83.c:7392
cpu_math_add_16bit
void cpu_math_add_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to add two 16 bit values
Definition sm83.c:2161
cpu_greater_than_16bit
void cpu_greater_than_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:2135
cpu_bit_inplace_8bit
void cpu_bit_inplace_8bit(Environment *_environment, char *_value, int _position, int *_bit)
Definition sm83.c:6674
cpu_math_add_16bit_const
void cpu_math_add_16bit_const(Environment *_environment, char *_source, int _destination, char *_other)
CPU 6502: emit code to add two 16 bit values
Definition sm83.c:2180
cpu_protothread_vars
void cpu_protothread_vars(Environment *_environment)
Definition sm83.c:7282
cpu_poked_const
void cpu_poked_const(Environment *_environment, char *_address, int _source)
Definition sm83.c:353
cpu_math_add_16bit_with_16bit
void cpu_math_add_16bit_with_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
CPU 6309: emit code to add two 16 bit values
Definition sm83.c:2193
cpu_compare_and_branch_16bit_const
void cpu_compare_and_branch_16bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
Z80: emit code to compare two 16 bit values and jump if they are equal/different
Definition sm83.c:1873
cpu_move_32bit_indirect
void cpu_move_32bit_indirect(Environment *_environment, char *_source, char *_value)
Definition sm83.c:5519
cpu_dswrite
void cpu_dswrite(Environment *_environment, char *_index)
Definition sm83.c:7001
cpu_complement2_nbit
void cpu_complement2_nbit(Environment *_environment, char *_source, char *_destination, int _bits)
Definition sm83.c:7196
cpu_greater_than_8bit
void cpu_greater_than_8bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:1261
cpu_or_16bit
void cpu_or_16bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4403
cpu_fill
void cpu_fill(Environment *_environment, char *_address, char *_bytes, int _bytes_width, char *_pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:445
cpu_move_16bit_indirect
void cpu_move_16bit_indirect(Environment *_environment, char *_source, char *_value)
Definition sm83.c:5475
cpu_limit_16bit
void cpu_limit_16bit(Environment *_environment, char *_variable, int _value)
Definition sm83.c:4221
cpu_move_8bit_indirect_with_offset2
void cpu_move_8bit_indirect_with_offset2(Environment *_environment, char *_source, char *_value, char *_offset)
Definition sm83.c:7110
cpu_less_than_32bit_const
void cpu_less_than_32bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:2950
cpu_move_nbit_indirect2
void cpu_move_nbit_indirect2(Environment *_environment, int _n, char *_value, char *_source)
Definition sm83.c:5647
cpu_and_8bit
void cpu_and_8bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4280
cpu_float_single_log
void cpu_float_single_log(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8407
cpu_math_mul_8bit_to_16bit
void cpu_math_mul_8bit_to_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _signed)
Z80: emit code to multiply two 8bit values in a 16 bit register
Definition sm83.c:1394
cpu_compare_16bit_const
void cpu_compare_16bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _positive)
Z80: emit code to compare two 16 bit values
Definition sm83.c:1795
cpu_math_sub_16bit
void cpu_math_sub_16bit(Environment *_environment, char *_source, char *_destination, char *_other)
Z80: emit code to subtract two 16 bit values
Definition sm83.c:2454
cpu_compare_and_branch_32bit_const
void cpu_compare_and_branch_32bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
Z80: emit code to compare two 32 bit values and jump if they are equal/different
Definition sm83.c:2816
cpu_store_nbit
void cpu_store_nbit(Environment *_environment, char *_destination, int _n, int _value[])
CPU Z80: emit code to store n bit
Definition sm83.c:7682
cpu_mem_move_direct_indirect_size
void cpu_mem_move_direct_indirect_size(Environment *_environment, char *_source, char *_destination, int _size)
Definition sm83.c:4897
cpu_dec_nbit
void cpu_dec_nbit(Environment *_environment, char *_variable, int _bits)
Definition sm83.c:4777
cpu_math_and_const_16bit
void cpu_math_and_const_16bit(Environment *_environment, char *_source, int _mask)
Z80: emit code to mask with "and" a value of 16 bit
Definition sm83.c:2642
cpu_move_8bit_indirect2_8bit
void cpu_move_8bit_indirect2_8bit(Environment *_environment, char *_value, char *_offset, char *_source)
Definition sm83.c:5450
cpu_float_single_from_16
void cpu_float_single_from_16(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7987
cpu_less_than_and_branch_8bit_const
void cpu_less_than_and_branch_8bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _equal, int _signed)
Definition sm83.c:1171
cpu_fill_indirect
void cpu_fill_indirect(Environment *_environment, char *_address, char *_size, char *_pattern, int _size_size)
Definition sm83.c:5336
cpu_mem_move_indirect_direct_size
void cpu_mem_move_indirect_direct_size(Environment *_environment, char *_source, char *_destination, int _size)
Definition sm83.c:4915
cpu_compare_and_branch_char_const
void cpu_compare_and_branch_char_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
Z80: emit code to compare two 8 bit values and jump if they are equal/different
Definition sm83.c:956
cpu_less_than_nbit_const
void cpu_less_than_nbit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _bits)
Definition sm83.c:2903
cpu_float_fast_sin
void cpu_float_fast_sin(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:7951
cpu_math_mul_nbit_to_nbit
void cpu_math_mul_nbit_to_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _bits)
Definition sm83.c:2279
cpu_label
void cpu_label(Environment *_environment, char *_label)
Definition sm83.c:226
cpu_dec
void cpu_dec(Environment *_environment, char *_variable)
Definition sm83.c:4696
cpu_and_16bit
void cpu_and_16bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4304
cpu_float_fast_log
void cpu_float_fast_log(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8401
cpu_move_nbit
void cpu_move_nbit(Environment *_environment, int _n, char *_source, char *_destination)
CPU Z80: emit code to store n bit
Definition sm83.c:7743
cpu_address_table_call
void cpu_address_table_call(Environment *_environment, char *_table, char *_value, char *_address)
Definition sm83.c:8127
cpu_logical_not_8bit
void cpu_logical_not_8bit(Environment *_environment, char *_value, char *_result)
Definition sm83.c:4620
cpu_pokew_const
void cpu_pokew_const(Environment *_environment, char *_address, int _source)
Definition sm83.c:296
cpu_logical_and_8bit
void cpu_logical_and_8bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4259
cpu_or_8bit_const
void cpu_or_8bit_const(Environment *_environment, char *_left, int _right, char *_result)
Definition sm83.c:4392
cpu_math_div2_const_32bit
void cpu_math_div2_const_32bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
Z80: emit code to halves for several times a 32 bit value
Definition sm83.c:3351
cpu_halt
void cpu_halt(Environment *_environment)
Definition sm83.c:4114
cpu_end
void cpu_end(Environment *_environment)
Definition sm83.c:4123
cpu_float_fast_from_double_to_int_array
void cpu_float_fast_from_double_to_int_array(Environment *_environment, double _value, int _result[])
Definition sm83.c:7851
cpu_compare_memory
void cpu_compare_memory(Environment *_environment, char *_source, char *_destination, char *_size, char *_result, int _equal)
Definition sm83.c:4931
cpu_greater_than_8bit_const
void cpu_greater_than_8bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:1272
cpu_complement2_16bit
void cpu_complement2_16bit(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:7138
cpu_dsinit
void cpu_dsinit(Environment *_environment)
Definition sm83.c:7047
cpu_xor_8bit
void cpu_xor_8bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4454
cpu_protothread_unregister
void cpu_protothread_unregister(Environment *_environment, char *_index)
Definition sm83.c:7331
cpu_decrypt
void cpu_decrypt(Environment *_environment, char *_data, char *_data_size, char *_key, char *_key_size, char *_output, char *_result)
Definition sm83.c:8442
cpu_complement2_32bit
void cpu_complement2_32bit(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:7160
cpu_protothread_register_at
void cpu_protothread_register_at(Environment *_environment, char *_index, char *_label)
Definition sm83.c:7306
cpu_blit_free_register
void cpu_blit_free_register(Environment *_environment, int _register)
Definition sm83.c:7641
cpu_lowercase
void cpu_lowercase(Environment *_environment, char *_source, char *_size, char *_result)
Definition sm83.c:5205
cpu_float_single_to_8
void cpu_float_single_to_8(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:8006
cpu_move_16bit
void cpu_move_16bit(Environment *_environment, char *_source, char *_destination)
Z80: emit code to move 16 bit
Definition sm83.c:1688
cpu_move_8bit_with_offset2
void cpu_move_8bit_with_offset2(Environment *_environment, char *_source, char *_value, char *_offset)
Definition sm83.c:5418
cpu_out
void cpu_out(Environment *_environment, char *_port, char *_value)
Definition sm83.c:7493
cpu_move_16bit_unsigned_8bit_signed
void cpu_move_16bit_unsigned_8bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8268
cpu_blit_finalize
void cpu_blit_finalize(Environment *_environment)
Definition sm83.c:7582
cpu_encrypt
void cpu_encrypt(Environment *_environment, char *_data, char *_data_size, char *_key, char *_key_size, char *_output)
Definition sm83.c:8425
cpu_bneq
void cpu_bneq(Environment *_environment, char *_label)
Z80: emit code to make long conditional jump
Definition sm83.c:192
cpu_compare_nbit_const
void cpu_compare_nbit_const(Environment *_environment, char *_source, int _destination, char *_other, int _positive, int _bits)
CPU 6502: emit code to compare two 32 bit values
Definition sm83.c:7216
cpu_float_single_mod1
void cpu_float_single_mod1(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8072
cpu_move_16bit_indirect2
void cpu_move_16bit_indirect2(Environment *_environment, char *_value, char *_source)
Definition sm83.c:5489
cpu_float_fast_cmp
void cpu_float_fast_cmp(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:7945
cpu_math_double_8bit
void cpu_math_double_8bit(Environment *_environment, char *_source, char *_other, int _signed)
Z80: emit code to double a 8 bit value
Definition sm83.c:1357
cpu_float_fast_mul
void cpu_float_fast_mul(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:7933
cpu_bits_to_string
void cpu_bits_to_string(Environment *_environment, char *_number, char *_string, char *_string_size, int _bits, char *_zero, char *_one)
Definition sm83.c:6832
cpu_dsalloc
void cpu_dsalloc(Environment *_environment, char *_size, char *_index)
Definition sm83.c:6964
cpu_less_than_nbit
void cpu_less_than_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _bits)
Definition sm83.c:3000
cpu_port_out
void cpu_port_out(Environment *_environment, char *_port, char *_value)
Z80: emit code to send one byte throught a I/O port
Definition sm83.c:4252
cpu_not_32bit
void cpu_not_32bit(Environment *_environment, char *_value, char *_result)
Definition sm83.c:4651
cpu_float_single_from_double_to_int_array
void cpu_float_single_from_double_to_int_array(Environment *_environment, double _value, int _result[])
Definition sm83.c:7862
cpu_float_single_to_16
void cpu_float_single_to_16(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:8000
cpu_greater_than_memory_size
void cpu_greater_than_memory_size(Environment *_environment, char *_source, char *_destination, int _size, char *_result, int _equal)
Definition sm83.c:5101
cpu_hex_to_string
void cpu_hex_to_string(Environment *_environment, char *_number, char *_string, char *_size, int _separator)
Definition sm83.c:6932
cpu_or_8bit
void cpu_or_8bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4379
cpu_store_8bit_with_offset2
void cpu_store_8bit_with_offset2(Environment *_environment, char *_destination, char *_offset, int _value)
Definition sm83.c:770
cpu_move_8bit_indirect2_16bit
void cpu_move_8bit_indirect2_16bit(Environment *_environment, char *_value, char *_offset, char *_source)
Definition sm83.c:5463
cpu_math_add_32bit_const
void cpu_math_add_32bit_const(Environment *_environment, char *_source, int _destination, char *_other)
Definition sm83.c:3168
cpu_move_8bit_indirect_with_offset
void cpu_move_8bit_indirect_with_offset(Environment *_environment, char *_source, char *_value, int _offset)
Definition sm83.c:5430
cpu_sqroot
void cpu_sqroot(Environment *_environment, char *_number, char *_result)
Definition sm83.c:7249
cpu_number_to_string
void cpu_number_to_string(Environment *_environment, char *_number, char *_string, char *_string_size, int _bits, int _signed)
Definition sm83.c:6736
cpu_greater_than_32bit
void cpu_greater_than_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:3062
cpu_peekd
void cpu_peekd(Environment *_environment, char *_address, char *_target)
Definition sm83.c:311
cpu_in_direct
void cpu_in_direct(Environment *_environment, char *_port, char *_value)
Definition sm83.c:7519
cpu_call_indirect
void cpu_call_indirect(Environment *_environment, char *_value)
Definition sm83.c:3549
cpu_call
void cpu_call(Environment *_environment, char *_label)
Definition sm83.c:3543
cpu_random_8bit
void cpu_random_8bit(Environment *_environment, char *_entropy, char *_result)
Definition sm83.c:4186
cpu_xor_8bit_const
void cpu_xor_8bit_const(Environment *_environment, char *_left, int _right, char *_result)
Definition sm83.c:4466
cpu_move_16bit_signed_8bit_unsigned
void cpu_move_16bit_signed_8bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8261
cpu_mem_move_direct
void cpu_mem_move_direct(Environment *_environment, char *_source, char *_destination, char *_size)
Definition sm83.c:4826
cpu_store_8bit
void cpu_store_8bit(Environment *_environment, char *_destination, int _value)
Z80: emit code to store 8 bit
Definition sm83.c:728
cpu_swap_8bit
void cpu_swap_8bit(Environment *_environment, char *_left, char *_right)
Definition sm83.c:4575
cpu_float_fast_to_8
void cpu_float_fast_to_8(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7915
cpu_mem_move_direct2
void cpu_mem_move_direct2(Environment *_environment, char *_source, char *_destination, char *_size)
Definition sm83.c:4839
cpu_init
void cpu_init(Environment *_environment)
Definition sm83.c:45
cpu_dstring_vars
void cpu_dstring_vars(Environment *_environment)
Definition sm83.c:7261
cpu_protothread_loop
void cpu_protothread_loop(Environment *_environment)
Definition sm83.c:7298
cpu_float_single_div
void cpu_float_single_div(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:8030
cpu_hex_to_bin
void cpu_hex_to_bin(Environment *_environment, char *_value_address, char *_value_size, char *_variable_address, char *_variable_size, char *_result)
Definition sm83.c:8461
cpu_out_direct
void cpu_out_direct(Environment *_environment, char *_port, char *_value)
Definition sm83.c:7511
cpu_greater_than_32bit_const
void cpu_greater_than_32bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:3073
cpu_protothread_current
void cpu_protothread_current(Environment *_environment, char *_current)
Definition sm83.c:7405
cpu_float_fast_to_16
void cpu_float_fast_to_16(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7909
cpu_mem_move_16bit
void cpu_mem_move_16bit(Environment *_environment, char *_source, char *_destination, char *_size)
Definition sm83.c:4812
cpu_compare_32bit
void cpu_compare_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
Z80: emit code to compare two 32 bit values
Definition sm83.c:2714
cpu_set_asmio
void cpu_set_asmio(Environment *_environment, int _asmio, int _value)
Definition sm83.c:3644
cpu_float_fast_sqr
void cpu_float_fast_sqr(Environment *_environment, char *_value, char *_result)
Definition sm83.c:7969
cpu_jump
void cpu_jump(Environment *_environment, char *_label)
Definition sm83.c:3531
cpu_move_16bit_unsigned_32bit_signed
void cpu_move_16bit_unsigned_32bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8317
cpu_blit_alloc_register
int cpu_blit_alloc_register(Environment *_environment)
Definition sm83.c:7603
cpu_move_32bit_signed_8bit_unsigned
void cpu_move_32bit_signed_8bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8354
cpu_mem_move_size
void cpu_mem_move_size(Environment *_environment, char *_source, char *_destination, int _size)
Definition sm83.c:4862
cpu_fill_blocks
void cpu_fill_blocks(Environment *_environment, char *_address, char *_blocks, char *_pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:387
cpu_bvneq
void cpu_bvneq(Environment *_environment, char *_value, char *_label)
Definition sm83.c:214
cpu_float_single_mul
void cpu_float_single_mul(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:8024
cpu_float_fast_exp
void cpu_float_fast_exp(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8413
cpu_move_16bit_signed_8bit_signed
void cpu_move_16bit_signed_8bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8254
cpu_compare_and_branch_16bit
void cpu_compare_and_branch_16bit(Environment *_environment, char *_source, char *_destination, char *_label, int _positive)
Definition sm83.c:1834
cpu_fill_size_value
void cpu_fill_size_value(Environment *_environment, char *_address, int _bytes, int _pattern)
Z80: emit code to fill up a memory area
Definition sm83.c:541
cpu_call_addr
void cpu_call_addr(Environment *_environment, int _address)
Definition sm83.c:3537
cpu_math_div_16bit_to_16bit_const
void cpu_math_div_16bit_to_16bit_const(Environment *_environment, char *_source, int _destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:6142
cpu_poke
void cpu_poke(Environment *_environment, char *_address, char *_source)
Definition sm83.c:242
cpu_bit_check
void cpu_bit_check(Environment *_environment, char *_value, int _position, char *_result, int _bitwidth)
Definition sm83.c:6636
cpu_protothread_register
void cpu_protothread_register(Environment *_environment, char *_label, char *_index)
Definition sm83.c:7318
cpu_move_32bit_signed_8bit_signed
void cpu_move_32bit_signed_8bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8348
cpu_float_single_to_string
void cpu_float_single_to_string(Environment *_environment, char *_x, char *_string, char *_string_size)
Definition sm83.c:7885
cpu_math_div_nbit_to_nbit_const
void cpu_math_div_nbit_to_nbit_const(Environment *_environment, char *_source, int _destination, char *_other, char *_other_remainder, int _bits)
Definition sm83.c:6379
cpu_float_single_tan
void cpu_float_single_tan(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:8060
cpu_nop
void cpu_nop(Environment *_environment)
Definition sm83.c:122
cpu_random_32bit
void cpu_random_32bit(Environment *_environment, char *_entropy, char *_result)
Definition sm83.c:4209
cpu_move_32bit_unsigned_16bit_unsigned
void cpu_move_32bit_unsigned_16bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8394
cpu_less_than_8bit_const
void cpu_less_than_8bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:1089
cpu_greater_than_nbit
void cpu_greater_than_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _bits)
Definition sm83.c:3080
cpu_prepare_for_compare_and_branch_8bit
void cpu_prepare_for_compare_and_branch_8bit(Environment *_environment, char *_source)
Z80: emit code to compare two 8 bit values and jump if they are equal/different
Definition sm83.c:911
cpu_less_than_16bit
void cpu_less_than_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:1908
cpu_mem_move_direct2_size
void cpu_mem_move_direct2_size(Environment *_environment, char *_source, char *_destination, int _size)
Definition sm83.c:4851
cpu_math_and_const_8bit
void cpu_math_and_const_8bit(Environment *_environment, char *_source, int _mask)
Z80: emit code to mask with "and" a value of 8 bit
Definition sm83.c:1665
cpu_move_32bit_unsigned_16bit_signed
void cpu_move_32bit_unsigned_16bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8387
cpu_msc1_uncompress_direct_direct
void cpu_msc1_uncompress_direct_direct(Environment *_environment, char *_input, char *_output)
Definition sm83.c:7425
cpu_float_single_sqr
void cpu_float_single_sqr(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8066
cpu_inc_32bit
void cpu_inc_32bit(Environment *_environment, char *_variable)
Definition sm83.c:4712
cpu_move_8bit_signed_16bit_signed
void cpu_move_8bit_signed_16bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8143
cpu_mem_move_direct_size
void cpu_mem_move_direct_size(Environment *_environment, char *_source, char *_destination, int _size)
Definition sm83.c:4881
cpu_float_fast_sub
void cpu_float_fast_sub(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:7927
cpu_xor_32bit
void cpu_xor_32bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4517
cpu_return
void cpu_return(Environment *_environment)
Definition sm83.c:4102
cpu_move_8bit_indirect2
void cpu_move_8bit_indirect2(Environment *_environment, char *_value, char *_source)
Definition sm83.c:5440
cpu_inc_nbit
void cpu_inc_nbit(Environment *_environment, char *_variable, int _bits)
Definition sm83.c:4732
cpu_pop
void cpu_pop(Environment *_environment)
Definition sm83.c:4108
cpu_math_sub_16bit_with_8bit
void cpu_math_sub_16bit_with_8bit(Environment *_environment, char *_source, char *_destination, char *_other)
Definition sm83.c:5149
cpu_random_16bit
void cpu_random_16bit(Environment *_environment, char *_entropy, char *_result)
Definition sm83.c:4198
cpu_ei
void cpu_ei(Environment *_environment)
Definition sm83.c:4682
cpu_register_decode
int cpu_register_decode(Environment *_environment, char *_register)
Definition sm83.c:3570
cpu_or_32bit
void cpu_or_32bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4423
cpu_bits_to_string_vars
void cpu_bits_to_string_vars(Environment *_environment)
Definition sm83.c:6825
cpu_math_div2_const_16bit
void cpu_math_div2_const_16bit(Environment *_environment, char *_source, int _steps, int _signed, char *_remainder)
Z80: emit code to halves for several times a 16 bit value
Definition sm83.c:2510
cpu_convert_string_into_8bit
void cpu_convert_string_into_8bit(Environment *_environment, char *_string, char *_len, char *_value)
Definition sm83.c:5245
cpu_inc_16bit
void cpu_inc_16bit(Environment *_environment, char *_variable)
Definition sm83.c:4704
cpu_logical_or_8bit
void cpu_logical_or_8bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4360
cpu_compare_nbit
void cpu_compare_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive, int _bits)
CPU Z80: emit code to compare n bit
Definition sm83.c:7814
cpu_address_table_lookup
void cpu_address_table_lookup(Environment *_environment, char *_table, int _count)
Definition sm83.c:8087
cpu_ztoa
void cpu_ztoa(Environment *_environment)
Definition sm83.c:128
cpu_random
void cpu_random(Environment *_environment, char *_entropy)
Definition sm83.c:4130
cpu_move_32bit_unsigned_8bit_signed
void cpu_move_32bit_unsigned_8bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8360
cpu_compare_and_branch_8bit
void cpu_compare_and_branch_8bit(Environment *_environment, char *_source, char *_destination, char *_label, int _positive)
Definition sm83.c:855
cpu_execute_compare_and_branch_8bit_const
void cpu_execute_compare_and_branch_8bit_const(Environment *_environment, int _destination, char *_label, int _positive)
Z80: emit code to compare two 8 bit values and jump if they are equal/different
Definition sm83.c:930
cpu_ctoa
void cpu_ctoa(Environment *_environment)
Definition sm83.c:145
cpu_move_16bit_indirect2_8bit
void cpu_move_16bit_indirect2_8bit(Environment *_environment, char *_value, char *_offset, char *_source)
Definition sm83.c:5502
cpu_float_single_from_8
void cpu_float_single_from_8(Environment *_environment, char *_value, char *_result, int _signed)
Definition sm83.c:7993
cpu_math_sub_nbit
void cpu_math_sub_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _bits)
Definition sm83.c:3274
cpu_float_single_cmp
void cpu_float_single_cmp(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:8036
cpu_move_8bit_signed_32bit_signed
void cpu_move_8bit_signed_32bit_signed(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8189
cpu_math_div2_const_nbit
void cpu_math_div2_const_nbit(Environment *_environment, char *_source, int _steps, int _bits, char *_remainder)
Definition sm83.c:6412
cpu_store_8bit_with_offset
void cpu_store_8bit_with_offset(Environment *_environment, char *_destination, int _value, int _offset)
Definition sm83.c:757
cpu_busy_wait
void cpu_busy_wait(Environment *_environment, char *_timing)
Definition sm83.c:4234
cpu_greater_than_memory
void cpu_greater_than_memory(Environment *_environment, char *_source, char *_destination, char *_size, char *_result, int _equal)
Definition sm83.c:5068
cpu_store_32bit
void cpu_store_32bit(Environment *_environment, char *_destination, int _value)
Z80: emit code to store 32 bit
Definition sm83.c:2692
cpu_peekw
void cpu_peekw(Environment *_environment, char *_address, char *_target)
Definition sm83.c:266
cpu_flip
void cpu_flip(Environment *_environment, char *_source, char *_size, char *_destination)
Definition sm83.c:5391
cpu_move_8bit
void cpu_move_8bit(Environment *_environment, char *_source, char *_destination)
Z80: emit code to move 8 bit
Definition sm83.c:710
cpu_beq
void cpu_beq(Environment *_environment, char *_label)
Z80: emit code to make long conditional jump
Definition sm83.c:176
cpu_compare_16bit
void cpu_compare_16bit(Environment *_environment, char *_source, char *_destination, char *_other, int _positive)
Z80: emit code to compare two 16 bit values
Definition sm83.c:1736
cpu_peek
void cpu_peek(Environment *_environment, char *_address, char *_target)
Definition sm83.c:230
cpu_float_fast_add
void cpu_float_fast_add(Environment *_environment, char *_x, char *_y, char *_result)
Definition sm83.c:7921
cpu_convert_string_into_16bit
void cpu_convert_string_into_16bit(Environment *_environment, char *_string, char *_len, char *_value)
Definition sm83.c:5255
cpu_float_single_sin
void cpu_float_single_sin(Environment *_environment, char *_angle, char *_result)
Definition sm83.c:8048
cpu_not_8bit
void cpu_not_8bit(Environment *_environment, char *_value, char *_result)
Definition sm83.c:4628
cpu_math_div_8bit_to_8bit
void cpu_math_div_8bit_to_8bit(Environment *_environment, char *_source, char *_destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:6456
cpu_dsdescriptor
void cpu_dsdescriptor(Environment *_environment, char *_index, char *_address, char *_size)
Definition sm83.c:7056
cpu_math_add_nbit
void cpu_math_add_nbit(Environment *_environment, char *_source, char *_destination, char *_other, int _bits)
Definition sm83.c:3146
cpu_compare_8bit_const
void cpu_compare_8bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _positive)
Z80: emit code to compare two 8 bit values
Definition sm83.c:834
cpu_xor_16bit
void cpu_xor_16bit(Environment *_environment, char *_left, char *_right, char *_result)
Definition sm83.c:4477
cpu_xor_16bit_const
void cpu_xor_16bit_const(Environment *_environment, char *_left, int _right, char *_result)
Definition sm83.c:4497
cpu_float_single_neg
void cpu_float_single_neg(Environment *_environment, char *_value, char *_result)
Definition sm83.c:8042
cpu_float_double_from_double_to_int_array
void cpu_float_double_from_double_to_int_array(Environment *_environment, double _value, int _result[])
Definition sm83.c:7873
cpu_swap_16bit
void cpu_swap_16bit(Environment *_environment, char *_left, char *_right)
Definition sm83.c:4590
cpu_compare_and_branch_8bit_const
void cpu_compare_and_branch_8bit_const(Environment *_environment, char *_source, int _destination, char *_label, int _positive)
Z80: emit code to compare two 8 bit values and jump if they are equal/different
Definition sm83.c:884
cpu_math_div_32bit_to_16bit_const
void cpu_math_div_32bit_to_16bit_const(Environment *_environment, char *_source, int _destination, char *_other, char *_other_remainder, int _signed)
Definition sm83.c:5888
cpu_greater_than_nbit_const
void cpu_greater_than_nbit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _bits)
Definition sm83.c:3095
cpu_number_to_string_vars
void cpu_number_to_string_vars(Environment *_environment)
Definition sm83.c:6728
cpu_float_fast_to_string
void cpu_float_fast_to_string(Environment *_environment, char *_x, char *_string, char *_string_size)
Definition sm83.c:7879
cpu_less_than_32bit
void cpu_less_than_32bit(Environment *_environment, char *_source, char *_destination, char *_other, int _equal, int _signed)
Z80: emit code to compare two 8 bit values
Definition sm83.c:2858
cpu_dsfill_value
void cpu_dsfill_value(Environment *_environment, char *_string, int _value)
Definition sm83.c:8489
cpu_dsassign_string
void cpu_dsassign_string(Environment *_environment, char *_string, char *_copy)
Definition sm83.c:7096
cpu_move_8bit_signed_16bit_unsigned
void cpu_move_8bit_signed_16bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8155
cpu_move_8bit_unsigned_16bit_unsigned
void cpu_move_8bit_unsigned_16bit_unsigned(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:8178
cpu_compare_memory_size
void cpu_compare_memory_size(Environment *_environment, char *_source, char *_destination, int _size, char *_result, int _equal)
Definition sm83.c:4964
cpu_float_fast_mod1
void cpu_float_fast_mod1(Environment *_environment, char *_value, char *_result)
Definition sm83.c:7975
cpu_math_add_8bit_const
void cpu_math_add_8bit_const(Environment *_environment, char *_source, int _destination, char *_other)
CPU 6502: emit code to add two 8 bit values
Definition sm83.c:1306
cpu_flip_8bit
void cpu_flip_8bit(Environment *_environment, char *_source, char *_destination)
Definition sm83.c:5373
cpu_blit_initialize
void cpu_blit_initialize(Environment *_environment)
Definition sm83.c:7570
cpu_less_than_16bit_const
void cpu_less_than_16bit_const(Environment *_environment, char *_source, int _destination, char *_other, int _equal, int _signed)
Definition sm83.c:2029
Z80Stack
enum _Z80Stack Z80Stack
REGISTER_DE
@ REGISTER_DE
Definition sm83.h:78
REGISTER_IYH
@ REGISTER_IYH
Definition sm83.h:83
REGISTER_IYL
@ REGISTER_IYL
Definition sm83.h:82
REGISTER_IXH
@ REGISTER_IXH
Definition sm83.h:81
REGISTER_F
@ REGISTER_F
Definition sm83.h:69
REGISTER_AF
@ REGISTER_AF
Definition sm83.h:76
REGISTER_C
@ REGISTER_C
Definition sm83.h:64
REGISTER_H
@ REGISTER_H
Definition sm83.h:67
REGISTER_R
@ REGISTER_R
Definition sm83.h:71
REGISTER_IXL
@ REGISTER_IXL
Definition sm83.h:80
REGISTER_BC
@ REGISTER_BC
Definition sm83.h:77
REGISTER_E
@ REGISTER_E
Definition sm83.h:66
REGISTER_HL
@ REGISTER_HL
Definition sm83.h:79
REGISTER_HLA
@ REGISTER_HLA
Definition sm83.h:84
Z80Register
enum _Z80Register Z80Register
_Blit::usedMemory
int usedMemory
Definition ugbc.h:2167
_Blit::name
char * name
Definition ugbc.h:2164
_Blit::freeRegisters
int freeRegisters
Definition ugbc.h:2166
_Blit::realName
char * realName
Definition ugbc.h:2165
_CpuOptimization::cpu_math_div_nbit_to_nbit_const
int cpu_math_div_nbit_to_nbit_const[32]
Definition ugbc.h:2087
_CpuOptimization::cpu_math_div_nbit_to_nbit
int cpu_math_div_nbit_to_nbit[32]
Definition ugbc.h:2086
_CpuOptimization::cpu_math_mul_nbit_to_nbit
int cpu_math_mul_nbit_to_nbit[32]
Definition ugbc.h:2085
_DString::space
int space
Definition ugbc.h:1970
_DString::count
int count
Definition ugbc.h:1969
_Environment::stackStartAddress
int stackStartAddress
Definition ugbc.h:3296
_Environment::bitmaskNeeded
int bitmaskNeeded
Definition ugbc.h:2659
_Environment::numberConfig
NumberConfig numberConfig
Definition ugbc.h:2410
_Environment::dstring
DString dstring
Definition ugbc.h:2405
_Environment::blit
Blit blit
Definition ugbc.h:2474
_Environment::stackSize
int stackSize
Definition ugbc.h:3294
_Environment::protothreadConfig
ProtothreadConfig protothreadConfig
Definition ugbc.h:2430
_Environment::emptyProcedure
int emptyProcedure
Definition ugbc.h:2932
_Environment::cpuOptimization
CpuOptimization cpuOptimization
Definition ugbc.h:3267
_NumberConfig::maxBytes
int maxBytes
Definition ugbc.h:2261
_NumberConfig::maxDigits
int maxDigits
Definition ugbc.h:2262
_ProtothreadConfig::count
int count
Definition ugbc.h:1976
_Variable::readonly
int readonly
Definition ugbc.h:1195
_Variable::realName
char * realName
Definition ugbc.h:982
no_embedded
#define no_embedded(s)
Definition ugbc.h:4380
MAX_TEMPORARY_STORAGE
#define MAX_TEMPORARY_STORAGE
Definition ugbc.h:563
CRITICAL_UNSETTABLE_CPU_REGISTER
#define CRITICAL_UNSETTABLE_CPU_REGISTER(v)
Definition ugbc.h:3625
embedded
#define embedded(s, e)
Definition ugbc.h:4385
deploy_with_vars
#define deploy_with_vars(s, e, v)
Definition ugbc.h:4320
CRITICAL_DEBUG_UNSUPPORTED
#define CRITICAL_DEBUG_UNSUPPORTED(v, t)
Definition ugbc.h:3478
no_inline
#define no_inline(s)
Definition ugbc.h:4376
done
#define done()
Definition ugbc.h:4389
CRITICAL_BLIT_ALLOC_REGISTER_EXHAUSTED
#define CRITICAL_BLIT_ALLOC_REGISTER_EXHAUSTED()
Definition ugbc.h:3610
Variable
struct _Variable Variable
Structure of a single variable.
outline2
#define outline2(s, a, b)
Definition ugbc.h:4254
Environment
struct _Environment Environment
Structure of compilation environment.
CRITICAL_BLIT_INVALID_FREE_REGISTER
#define CRITICAL_BLIT_INVALID_FREE_REGISTER(s, r)
Definition ugbc.h:3612
CRITICAL_BLIT_ALLOC_MEMORY_EXHAUSTED
#define CRITICAL_BLIT_ALLOC_MEMORY_EXHAUSTED()
Definition ugbc.h:3611
VT_WORD
@ VT_WORD
Definition ugbc.h:455
VT_BYTE
@ VT_BYTE
Definition ugbc.h:450
VT_BUFFER
@ VT_BUFFER
Definition ugbc.h:477
VT_ADDRESS
@ VT_ADDRESS
Definition ugbc.h:465
CRITICAL_UNKNOWN_CPU_REGISTER
#define CRITICAL_UNKNOWN_CPU_REGISTER()
Definition ugbc.h:3624
deploy_preferred
#define deploy_preferred(s, e)
Definition ugbc.h:4299
outhead0
#define outhead0(s)
Definition ugbc.h:4246
outline0
#define outline0(s)
Definition ugbc.h:4252
outhead2
#define outhead2(s, a, b)
Definition ugbc.h:4248
outline1
#define outline1(s, a)
Definition ugbc.h:4253
deploy_embedded
#define deploy_embedded(s, e)
Definition ugbc.h:4339
CRITICAL_UNIMPLEMENTED
#define CRITICAL_UNIMPLEMENTED(v)
Definition ugbc.h:3444
deploy
#define deploy(s, e)
Definition ugbc.h:4288
MAKE_LABEL
#define MAKE_LABEL
Definition ugbc.h:3351
outhead1
#define outhead1(s, a)
Definition ugbc.h:4247