ugBASIC 1.18
An isomorphic BASIC language compiler for retrocomputers
Loading...
Searching...
No Matches
atari.c
Go to the documentation of this file.
1/*****************************************************************************
2 * ugBASIC - an isomorphic BASIC language compiler for retrocomputers *
3 *****************************************************************************
4 * Copyright 2021-2026 Marco Spedaletti (asimov@mclink.it)
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *----------------------------------------------------------------------------
18 * Concesso in licenza secondo i termini della Licenza Apache, versione 2.0
19 * (la "Licenza"); è proibito usare questo file se non in conformità alla
20 * Licenza. Una copia della Licenza è disponibile all'indirizzo:
21 *
22 * http://www.apache.org/licenses/LICENSE-2.0
23 *
24 * Se non richiesto dalla legislazione vigente o concordato per iscritto,
25 * il software distribuito nei termini della Licenza è distribuito
26 * "COSì COM'è", SENZA GARANZIE O CONDIZIONI DI ALCUN TIPO, esplicite o
27 * implicite. Consultare la Licenza per il testo specifico che regola le
28 * autorizzazioni e le limitazioni previste dalla medesima.
29 ****************************************************************************/
30
31/****************************************************************************
32 * INCLUDE SECTION
33 ****************************************************************************/
34
35#if defined(__atari__) || defined(__atarixl__)
36
37#include "../ugbc.h"
38
39/****************************************************************************
40 * CODE SECTION
41 ****************************************************************************/
42
43void atari_xpen( Environment * _environment, char * _destination ) {
44
45 MAKE_LABEL
46
47 outline0("LDA $0234");
48 outline1("STA %s", _destination);
49 outline0("LDA #0");
50 outline1("STA _%s", address_displacement(_environment, _destination, "1"));
51 outhead1("%s:", label );
52
53}
54
55void atari_ypen( Environment * _environment, char * _destination ) {
56
57 MAKE_LABEL
58
59 outline0("LDA $235");
60 outline1("STA %s", _destination);
61 outline0("LDA #0");
62 outline1("STA %s", address_displacement(_environment, _destination, "1"));
63
64}
65
66void atari_inkey( Environment * _environment, char * _key ) {
67
68 _environment->bitmaskNeeded = 1;
69
70 deploy( keyboard, src_hw_atari_keyboard_asm);
71
72 outline0("JSR INKEY");
73 outline1("STA %s", _key);
74
75}
76
77void atari_wait_key( Environment * _environment, int _release ) {
78
79 _environment->bitmaskNeeded = 1;
80
81 deploy( keyboard, src_hw_atari_keyboard_asm );
82
83 if ( _release ) {
84 outline0("JSR WAITKEYRELEASE");
85 } else {
86 outline0("JSR WAITKEY");
87 }
88
89}
90
91void atari_wait_key_or_fire( Environment * _environment, int _port, int _release ) {
92
93 _environment->bitmaskNeeded = 1;
94
95 deploy( joystick, src_hw_atari_joystick_asm );
96 deploy( keyboard, src_hw_atari_keyboard_asm );
97 deploy( wait_key_or_fire, src_hw_atari_wait_key_or_fire_asm );
98
99 if ( _port == -1 ) {
100 outline0("JSR WAITKEYFIRE");
101 } else {
102 outline1("LDX #$%2.2x", _port );
103 outline0("JSR WAITKEYFIREX");
104 }
105
106}
107
108void atari_wait_key_or_fire_semivar( Environment * _environment, char * _port, int _release ) {
109
110 _environment->bitmaskNeeded = 1;
111
112 deploy( joystick, src_hw_atari_joystick_asm );
113 deploy( keyboard, src_hw_atari_keyboard_asm );
114 deploy( wait_key_or_fire, src_hw_atari_wait_key_or_fire_asm );
115
116 if ( ! _port ) {
117 outline0("JSR WAITKEYFIRE");
118 } else {
119 outline1("LDX %s", _port );
120 outline0("JSR WAITKEYFIREX");
121 }
122
123}
124
125void atari_wait_fire( Environment * _environment, int _port, int _release ) {
126
127 _environment->bitmaskNeeded = 1;
128
129 deploy( joystick, src_hw_atari_joystick_asm );
130
131 outline1("LDY #$%2.2x", _release );
132 if ( _port == -1 ) {
133 outline0("JSR WAITFIRE");
134 } else {
135 outline1("LDX #$%2.2x", (unsigned char)(_port&0xff) );
136 outline0("JSR WAITFIREX");
137 }
138
139}
140
141void atari_wait_fire_semivar( Environment * _environment, char * _port, int _release ) {
142
143 _environment->bitmaskNeeded = 1;
144
145 deploy( joystick, src_hw_atari_joystick_asm );
146
147 outline1("LDY #$%2.2x", _release );
148 if ( !_port ) {
149 outline0("JSR WAITFIRE");
150 } else {
151 outline1("LDX %s", _port );
152 outline0("JSR WAITFIREX");
153 }
154
155}
156
157void atari_key_state( Environment * _environment, char *_scancode, char * _result ) {
158
159 _environment->bitmaskNeeded = 1;
160
161 MAKE_LABEL
162
163 deploy( keyboard, src_hw_atari_keyboard_asm );
164
165 outline1("LDX %s", _scancode);
166 outline0("JSR KEYSTATE");
167 cpu_ctoa( _environment );
168 outline1("STA %s", _result);
169
170}
171
172void atari_scancode( Environment * _environment, char * _result ) {
173
174 _environment->bitmaskNeeded = 1;
175
176 deploy( keyboard, src_hw_atari_keyboard_asm);
177
178 outline0("JSR SCANCODE");
179 if ( _environment->vestigialConfig.rchack_falling_balls_1163 ) {
180 MAKE_LABEL
181 outline0("CMP #$FF");
182 outline1("BNE %s", label );
183 outline0("LDA #0");
184 outhead1("%s:", label );
185 }
186 outline1("STA %s", _result );
187
188}
189
190void atari_asciicode( Environment * _environment, char * _result ) {
191
192 _environment->bitmaskNeeded = 1;
193
194 deploy( keyboard, src_hw_atari_keyboard_asm);
195
196 outline0("JSR ASCIICODE");
197 outline1("STA %s", _result );
198
199}
200
201void atari_key_pressed( Environment * _environment, char *_scancode, char * _result ) {
202
203 MAKE_LABEL
204
205 deploy( keyboard, src_hw_atari_keyboard_asm );
206
207 outline1("LDX %s", _scancode);
208 outline0("JSR KEYPRESSED");
209 cpu_ctoa( _environment );
210 outline1("STA %s", _result);
211
212}
213
214
215void atari_scanshift( Environment * _environment, char * _shifts ) {
216
217 MAKE_LABEL
218
219 outline0("LDA #0" );
220 outline1("STA %s", _shifts );
221
222 outline0("LDA $02F2" );
223 outline0("AND #$40");
224 outline1("BNE %snokey", label );
225
226 outline0("LDA #3" );
227 outline1("STA %s", _shifts );
228
229 outhead1("%snokey:", label );
230
231}
232
233void atari_keyshift( Environment * _environment, char * _shifts ) {
234
235 _environment->bitmaskNeeded = 1;
236
237 deploy( keyboard, src_hw_atari_keyboard_asm );
238
239 outline0("JSR KEYSHIFT" );
240 outline1("STA %s", _shifts );
241
242}
243
244void atari_clear_key( Environment * _environment ) {
245
246 deploy( keyboard, src_hw_atari_keyboard_asm );
247
248 outline0("JSR CLEARKEY");
249
250}
251
252void atari_sys_call( Environment * _environment, int _destination ) {
253
254 outline1("JSR $%4.4x", _destination);
255
256}
257
258void atari_timer_set_status_on( Environment * _environment, char * _timer ) {
259
260 deploy( timer, src_hw_6502_timer_asm);
261
262 if ( _timer ) {
263 outline1("LDX %s", _timer );
264 } else {
265 outline0("LDX #0" );
266 }
267 outline0("LDY #$1" );
268 outline0("JSR TIMERSETSTATUS" );
269
270}
271
272void atari_timer_set_status_off( Environment * _environment, char * _timer ) {
273
274 deploy( timer, src_hw_6502_timer_asm);
275
276 if ( _timer ) {
277 outline1("LDX %s", _timer );
278 } else {
279 outline0("LDX #0" );
280 }
281 outline0("LDY #$0" );
282 outline0("JSR TIMERSETSTATUS" );
283
284}
285
286void atari_timer_set_counter( Environment * _environment, char * _timer, char * _counter ) {
287
288 deploy( timer, src_hw_6502_timer_asm);
289
290 if ( _timer ) {
291 outline1("LDX %s", _timer );
292 } else {
293 outline0("LDX #0" );
294 }
295 if ( _counter ) {
296 outline1("LDA %s", _counter );
297 } else {
298 outline0("LDA #0" );
299 }
300 outline0("STA MATHPTR2");
301 if ( _counter ) {
302 outline1("LDA %s", address_displacement( _environment, _counter, "1" ) );
303 }
304 outline0("STA MATHPTR3");
305 outline0("JSR TIMERSETCOUNTER" );
306
307}
308
309void atari_timer_set_init( Environment * _environment, char * _timer, char * _init ) {
310
311 deploy( timer, src_hw_6502_timer_asm);
312
313 if ( _timer ) {
314 outline1("LDX %s", _timer );
315 } else {
316 outline0("LDX #0" );
317 }
318 outline1("LDA %s", _init );
319 outline0("STA MATHPTR2");
320 outline1("LDA %s", address_displacement( _environment, _init, "1" ) );
321 outline0("STA MATHPTR3");
322 outline0("JSR TIMERSETINIT" );
323
324}
325
326void atari_timer_set_address( Environment * _environment, char * _timer, char * _address ) {
327
328 deploy( timer, src_hw_6502_timer_asm);
329
330 if ( _timer ) {
331 outline1("LDX %s", _timer );
332 } else {
333 outline0("LDX #0" );
334 }
335 outline1("LDA #<%s", _address );
336 outline0("STA MATHPTR2");
337 outline1("LDA #>%s", _address );
338 outline0("STA MATHPTR3");
339 outline0("JSR TIMERSETADDRESS" );
340
341}
342
343void atari_dload( Environment * _environment, char * _filename, char * _offset, char * _address, char * _size ) {
344
345 deploy_preferred( dcommon, src_hw_atari_dcommon_asm );
346 deploy_preferred( dload, src_hw_atari_dload_asm );
347
348 MAKE_LABEL
349
350 Variable * filename = variable_retrieve( _environment, _filename );
351 Variable * tnaddress = variable_temporary( _environment, VT_ADDRESS, "(address of target_name)");
352 Variable * tnsize = variable_temporary( _environment, VT_BYTE, "(size of target_name)");
353
354 Variable * address = NULL;
355 if ( _address ) {
356 address = variable_retrieve( _environment, _address );
357 }
358 Variable * size = NULL;
359 if ( _size ) {
360 size = variable_retrieve( _environment, _size );
361 }
362 Variable * offset = NULL;
363 if ( _offset ) {
364 offset = variable_retrieve( _environment, _offset );
365 }
366
367 switch( filename->type ) {
368 case VT_STRING:
369 cpu_move_8bit( _environment, filename->realName, tnsize->realName );
370 cpu_addressof_16bit( _environment, filename->realName, tnaddress->realName );
371 cpu_inc_16bit( _environment, tnaddress->realName );
372 break;
373 case VT_DSTRING:
374 cpu_dsdescriptor( _environment, filename->realName, tnaddress->realName, tnsize->realName );
375 break;
376 }
377
378 outline1("LDA %s", tnaddress->realName);
379 outline0("STA DCOMMONP1");
380 outline1("LDA %s", address_displacement(_environment, tnaddress->realName, "1"));
381 outline0("STA DCOMMONP1+1");
382 outline1("LDA %s", tnsize->realName);
383 outline0("STA DCOMMON0");
384
385 if ( address ) {
386
387 outline1("LDA %s", address->realName);
388 outline0("STA DCOMMONP2");
389 outline1("LDA %s", address_displacement(_environment, address->realName, "1"));
390 outline0("STA DCOMMONP2+1");
391
392 }
393
394 if ( size ) {
395
396 outline1("LDA %s", size->realName);
397 outline0("STA DCOMMON4");
398 outline1("LDA %s", address_displacement(_environment, size->realName, "1"));
399 outline0("STA DCOMMON5");
400
401 } else {
402
403 outline0("LDA #$ff");
404 outline0("STA DCOMMON4");
405 outline0("STA DCOMMON5");
406
407 }
408
409 if ( offset ) {
410
411 outline1("LDA %s", offset->realName);
412 outline0("STA DCOMMON6");
413 outline1("LDA %s", address_displacement(_environment, offset->realName, "1"));
414 outline0("STA DCOMMON7");
415
416 } else {
417
418 outline0("LDA #0");
419 outline0("STA DCOMMON6");
420 outline0("STA DCOMMON7");
421
422 }
423
424 outline0("JSR ATARIDLOAD");
425
426}
427
428void atari_dsave( Environment * _environment, char * _filename, char * _offset, char * _address, char * _size ) {
429
430 deploy_preferred( dcommon, src_hw_atari_dcommon_asm );
431 deploy( dsave, src_hw_atari_dsave_asm );
432
433 MAKE_LABEL
434
435 Variable * filename = variable_retrieve( _environment, _filename );
436 Variable * tnaddress = variable_temporary( _environment, VT_ADDRESS, "(address of target_name)");
437 Variable * tnsize = variable_temporary( _environment, VT_BYTE, "(size of target_name)");
438
439 Variable * address = NULL;
440 if ( _address ) {
441 address = variable_retrieve( _environment, _address );
442 }
443 Variable * size = NULL;
444 if ( _size ) {
445 size = variable_retrieve( _environment, _size );
446 }
447 Variable * offset = NULL;
448 if ( _offset ) {
449 offset = variable_retrieve( _environment, _offset );
450 }
451
452 switch( filename->type ) {
453 case VT_STRING:
454 cpu_move_8bit( _environment, filename->realName, tnsize->realName );
455 cpu_addressof_16bit( _environment, filename->realName, tnaddress->realName );
456 cpu_inc_16bit( _environment, tnaddress->realName );
457 break;
458 case VT_DSTRING:
459 cpu_dsdescriptor( _environment, filename->realName, tnaddress->realName, tnsize->realName );
460 break;
461 }
462
463 outline1("LDA %s", tnaddress->realName);
464 outline0("STA DCOMMONP1");
465 outline1("LDA %s", address_displacement(_environment, tnaddress->realName, "1"));
466 outline0("STA DCOMMONP1+1");
467 outline1("LDA %s", tnsize->realName);
468 outline0("STA DCOMMON0");
469
470 if ( address ) {
471
472 outline1("LDA %s", address->realName);
473 outline0("STA DCOMMONP2");
474 outline1("LDA %s", address_displacement(_environment, address->realName, "1"));
475 outline0("STA DCOMMONP2+1");
476
477 }
478
479 if ( size ) {
480
481 outline1("LDA %s", size->realName);
482 outline0("STA DCOMMON4");
483 outline1("LDA %s", address_displacement(_environment, size->realName, "1"));
484 outline0("STA DCOMMON5");
485
486 } else {
487
488 outline0("LDA #$00");
489 outline0("STA DCOMMON4");
490 outline0("STA DCOMMON5");
491
492 }
493
494 if ( offset ) {
495
496 outline1("LDA %s", offset->realName);
497 outline0("STA DCOMMON6");
498 outline1("LDA %s", address_displacement(_environment, offset->realName, "1"));
499 outline0("STA DCOMMON7");
500
501 } else {
502
503 outline0("LDA #0");
504 outline0("STA DCOMMON6");
505 outline0("STA DCOMMON7");
506
507 }
508
509 outline0("JSR ATARIDSAVE");
510
511}
512
513void atari_put_key( Environment * _environment, char *_string, char * _size ) {
514
515 outline1("LDA %s", _string );
516 outline0("STA TMPPTR" );
517 outline1("LDA %s", address_displacement( _environment, _string, "1" ) );
518 outline0("STA TMPPTR+1" );
519 outline1("LDX %s", _size );
520 outline0("JSR PUTKEY" );
521
522}
523
524void atari_serial_read( Environment * _environment, char * _address, char * _size ) {
525
526 deploy( serial, src_hw_atari_serial_asm);
527
528 outline1( "LDA %s", _address );
529 outline0( "STA TMPPTR" );
530 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
531 outline0( "STA TMPPTR+1" );
532 outline1( "LDA %s", _size );
533 outline0( "STA MATHPTR0" );
534 outline0( "JSR SERIALREAD" );
535
536}
537
538void atari_serial_write( Environment * _environment, char * _address, char * _size, char * _result ) {
539
540 deploy( serial, src_hw_atari_serial_asm);
541
542 outline1( "LDA %s", _address );
543 outline0( "STA TMPPTR" );
544 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
545 outline0( "STA TMPPTR+1" );
546 outline1( "LDA %s", _size );
547 outline0( "STA MATHPTR0" );
548 outline0( "JSR SERIALWRITE" );
549
550}
551
552void atari_fujinet_set_device( Environment * _environment, int _device_id ) {
553
554 deploy( serial, src_hw_atari_serial_asm);
555 deploy( fujinet, src_hw_atari_fujinet_asm);
556
557 cpu_store_8bit( _environment, "FUJINETDEVICEID", _device_id );
558
559}
560
561void atari_fujinet_set_device_var( Environment * _environment, char * _device_id ) {
562
563 deploy( serial, src_hw_atari_serial_asm);
564 deploy( fujinet, src_hw_atari_fujinet_asm);
565
566 cpu_move_8bit( _environment, _device_id, "FUJINETDEVICEID" );
567
568}
569
570void atari_fujinet_get_bytes_waiting( Environment * _environment, char * _bytes_waiting ) {
571
572 deploy( serial, src_hw_atari_serial_asm);
573 deploy( fujinet, src_hw_atari_fujinet_asm);
574
575 cpu_move_16bit( _environment, "FUJINETBYTESWAITING", _bytes_waiting );
576
577}
578
579void atari_fujinet_is_connected( Environment * _environment, char * _is_connected ) {
580
581 deploy( serial, src_hw_atari_serial_asm);
582 deploy( fujinet, src_hw_atari_fujinet_asm);
583
584 cpu_move_8bit( _environment, "FUJINETCONNECTED", _is_connected );
585
586}
587
588void atari_fujinet_get_error( Environment * _environment, char * _error ) {
589
590 deploy( serial, src_hw_atari_serial_asm);
591 deploy( fujinet, src_hw_atari_fujinet_asm);
592
593 cpu_move_8bit( _environment, "FUJINETERRORCODE", _error );
594
595}
596
597void atari_fujinet_is_ready( Environment * _environment, char * _ready ) {
598
599 deploy( serial, src_hw_atari_serial_asm);
600 deploy( fujinet, src_hw_atari_fujinet_asm);
601
602 cpu_call( _environment, "FUJINETREADY" );
603 outline1( "STA %s", _ready );
604
605}
606
607void atari_fujinet_open( Environment * _environment, char * _url, char * _size, char * _mode, char * _trans, char * _result ) {
608
609 deploy( serial, src_hw_atari_serial_asm);
610 deploy( fujinet, src_hw_atari_fujinet_asm);
611
612 if ( _mode ) {
613 outline1( "LDA %s", _mode );
614 } else {
615 outline0( "LDA #0" );
616 }
617 outline0( "STA MATHPTR3" );
618 if ( _trans ) {
619 outline1( "LDA %s", _trans );
620 } else {
621 outline0( "LDA #0" );
622 }
623 outline0( "STA MATHPTR4" );
624 outline1( "LDA %s", _url );
625 outline0( "STA TMPPTR2" );
626 outline1( "LDA %s", address_displacement( _environment, _url, "1" ) );
627 outline0( "STA TMPPTR2+1" );
628 outline1( "LDA %s", _size );
629 outline0( "STA MATHPTR2" );
630
631 cpu_call( _environment, "FUJINETOPEN" );
632
633 if ( _result ) {
634 outline1( "STA %s", _result );
635 }
636
637
638}
639
640void atari_fujinet_close( Environment * _environment ) {
641
642 deploy( serial, src_hw_atari_serial_asm);
643 deploy( fujinet, src_hw_atari_fujinet_asm);
644
645 cpu_call( _environment, "FUJINETCLOSE" );
646
647}
648
649void atari_fujinet_get_status( Environment * _environment ) {
650
651 deploy( serial, src_hw_atari_serial_asm);
652 deploy( fujinet, src_hw_atari_fujinet_asm);
653
654 cpu_call( _environment, "FUJINETGETSTATUS" );
655
656}
657
658void atari_fujinet_read( Environment * _environment, char * _buffer, char * _size ) {
659
660 deploy( serial, src_hw_atari_serial_asm);
661 deploy( fujinet, src_hw_atari_fujinet_asm);
662
663 outline1( "LDA %s", _buffer );
664 outline0( "STA TMPPTR2" );
665 outline1( "LDA %s", address_displacement( _environment, _buffer, "1" ) );
666 outline0( "STA TMPPTR2+1" );
667 outline1( "LDA %s", _size );
668 outline0( "STA MATHPTR2" );
669
670 cpu_call( _environment, "FUJINETREAD" );
671
672}
673
674void atari_fujinet_write( Environment * _environment, char * _buffer, char * _size, char * _result ) {
675
676 deploy( serial, src_hw_atari_serial_asm);
677 deploy( fujinet, src_hw_atari_fujinet_asm);
678
679 outline1( "LDA %s", _buffer );
680 outline0( "STA TMPPTR2" );
681 outline1( "LDA %s", address_displacement( _environment, _buffer, "1" ) );
682 outline0( "STA TMPPTR2+1" );
683 outline1( "LDA %s", _size );
684 outline0( "STA MATHPTR2" );
685
686 cpu_call( _environment, "FUJINETWRITE" );
687
688 if ( _result ) {
689 outline1( "STA %s", _result );
690 }
691
692}
693
694void atari_fujinet_writed( Environment * _environment, char * _buffer, char * _size, char * _result ) {
695
696 deploy( serial, src_hw_atari_serial_asm);
697 deploy( fujinet, src_hw_atari_fujinet_asm);
698
699 outline1( "LDA #<%s", _buffer );
700 outline0( "STA TMPPTR2" );
701 outline1( "LDA #>%s",_buffer );
702 outline0( "STA TMPPTR2+1" );
703 outline1( "LDA %s", _size );
704 outline0( "STA MATHPTR2" );
705
706 cpu_call( _environment, "FUJINETWRITE" );
707
708 if ( _result ) {
709 outline1( "STA %s", _result );
710 }
711
712}
713
714void atari_fujinet_writeds( Environment * _environment, char * _buffer, int _size, char * _result ) {
715
716 deploy( serial, src_hw_atari_serial_asm);
717 deploy( fujinet, src_hw_atari_fujinet_asm);
718
719 outline1( "LDA #<%s", _buffer );
720 outline0( "STA TMPPTR2" );
721 outline1( "LDA #>%s",_buffer );
722 outline0( "STA TMPPTR2+1" );
723 outline1( "LDA #%2.2x", _size );
724 outline0( "STA MATHPTR2" );
725
726 cpu_call( _environment, "FUJINETWRITE" );
727
728 if ( _result ) {
729 outline1( "STA %s", _result );
730 }
731
732}
733
734void atari_fujinet_set_channel_mode( Environment * _environment, int _mode, char * _result ) {
735
736 deploy( serial, src_hw_atari_serial_asm);
737 deploy( fujinet, src_hw_atari_fujinet_asm);
738
739 outline1( "LDA #$%2.2x", (unsigned char)(_mode & 0xff ) );
740 outline0( "STA MATHPTR2" );
741
742 cpu_call( _environment, "FUJINETSETCHANNELMODE" );
743
744 if ( _result ) {
745 outline1( "STA %s", _result );
746 }
747
748}
749
750void atari_fujinet_set_channel_mode_var( Environment * _environment, char * _mode, char * _result ) {
751
752 deploy( serial, src_hw_atari_serial_asm);
753 deploy( fujinet, src_hw_atari_fujinet_asm);
754
755 outline1( "LDA %s", _mode );
756 outline0( "STA MATHPTR2" );
757
758 cpu_call( _environment, "FUJINETSETCHANNELMODE" );
759
760 outline1( "STA %s", _result );
761
762}
763
764void atari_fujinet_parse_json( Environment * _environment, char * _result ) {
765
766 deploy( serial, src_hw_atari_serial_asm);
767 deploy( fujinet, src_hw_atari_fujinet_asm);
768
769 cpu_call( _environment, "FUJINETPARSEJSON" );
770
771 outline1( "STA %s", _result );
772
773}
774
775void atari_fujinet_json_query( Environment * _environment, char * _query, char * _size ) {
776
777 deploy( serial, src_hw_atari_serial_asm);
778 deploy( fujinet, src_hw_atari_fujinet_asm);
779
780 outline1( "LDA %s", _query );
781 outline0( "STA TMPPTR2" );
782 outline1( "LDA %s", address_displacement( _environment, _query, "1" ) );
783 outline0( "STA TMPPTR2+1" );
784 outline1( "LDA %s", _size );
785 outline0( "STA MATHPTR2" );
786
787 cpu_call( _environment, "FUJINETSETJSONQUERY" );
788
789}
790
791void atari_fujinet_login( Environment * _environment, char * _login, char * _size ) {
792
793 deploy( serial, src_hw_atari_serial_asm);
794 deploy( fujinet, src_hw_atari_fujinet_asm);
795
796 outline1( "LDA %s", _login );
797 outline0( "STA TMPPTR2" );
798 outline1( "LDA %s", address_displacement( _environment, _login, "1" ) );
799 outline0( "STA TMPPTR2+1" );
800 outline1( "LDA %s", _size );
801 outline0( "STA MATHPTR2" );
802
803 cpu_call( _environment, "FUJINETLOGIN" );
804
805}
806
807void atari_fujinet_password( Environment * _environment, char * _password, char * _size ) {
808
809 deploy( serial, src_hw_atari_serial_asm);
810 deploy( fujinet, src_hw_atari_fujinet_asm);
811
812 outline1( "LDA %s", _password );
813 outline0( "STA TMPPTR2" );
814 outline1( "LDA %s", address_displacement( _environment, _password, "1" ) );
815 outline0( "STA TMPPTR2+1" );
816 outline1( "LDA %s", _size );
817 outline0( "STA MATHPTR0" );
818
819 cpu_call( _environment, "FUJINETPASSWORD" );
820
821}
822
823void atari_dojo_serial_get_response0( Environment * _environment, char * _status ) {
824
825 deploy( serial, src_hw_atari_serial_asm);
826 deploy( dojo, src_hw_atari_dojo_asm);
827
828 outline0( "JSR DOJOSERIALGETRESPONSE0" );
829 if ( _status ) {
830 outline1( "STA %s", _status );
831 }
832
833}
834
835void atari_dojo_serial_get_response( Environment * _environment, char * _status, char * _address, char * _size ) {
836
837 deploy( serial, src_hw_atari_serial_asm);
838 deploy( dojo, src_hw_atari_dojo_asm);
839
840 outline1( "LDA %s", _address );
841 outline0( "STA TMPPTR2" );
842 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
843 outline0( "STA TMPPTR2+1" );
844
845 outline0( "JSR DOJOSERIALGETRESPONSE" );
846 if ( _status ) {
847 outline1( "STA %s", _status );
848 }
849 if ( _size ) {
850 outline1( "STX %s", _size );
851 }
852
853}
854
855void atari_dojo_serial_get_responsed( Environment * _environment, char * _status, char * _data, char * _size ) {
856
857 deploy( serial, src_hw_atari_serial_asm);
858 deploy( dojo, src_hw_atari_dojo_asm);
859
860 outline1( "LDA #<%s", _data );
861 outline0( "STA TMPPTR2" );
862 outline1( "LDA #>%s", _data );
863 outline0( "STA TMPPTR2+1" );
864
865 outline0( "JSR DOJOSERIALGETRESPONSE" );
866 if ( _status ) {
867 outline1( "STA %s", _status );
868 }
869 if ( _size ) {
870 outline1( "STX %s", _size );
871 }
872
873}
874
875void atari_dojo_serial_get_response_size( Environment * _environment, char * _status, char * _size ) {
876
877 deploy( serial, src_hw_atari_serial_asm);
878 deploy( dojo, src_hw_atari_dojo_asm);
879
880 outline0( "JSR DOJOSERIALGETRESPONSE0" );
881 if ( _status ) {
882 outline1( "STA %s", _status );
883 }
884 if ( _size ) {
885 outline1( "STX %s", _size );
886 }
887
888}
889
890void atari_dojo_serial_get_response_payload( Environment * _environment, char * _address ) {
891
892 deploy( serial, src_hw_atari_serial_asm);
893 deploy( dojo, src_hw_atari_dojo_asm);
894
895 outline1( "LDA %s", _address );
896 outline0( "STA TMPPTR2" );
897 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
898 outline0( "STA TMPPTR2+1" );
899
900 outline0( "JSR DOJOSERIALGETRESPONSEPAYLOAD" );
901
902}
903
904void atari_dojo_serial_get_response_payloadd( Environment * _environment, char * _data ) {
905
906 deploy( serial, src_hw_atari_serial_asm);
907 deploy( dojo, src_hw_atari_dojo_asm);
908
909 outline1( "LDA #<%s", _data );
910 outline0( "STA TMPPTR2" );
911 outline1( "LDA #>%s", _data );
912 outline0( "STA TMPPTR2+1" );
913
914 outline0( "JSR DOJOSERIALGETRESPONSEPAYLOAD" );
915
916}
917
918void atari_dojo_serial_put_request0( Environment * _environment, int _command, char * _param1, char * _param2, char * _result ) {
919
920 deploy( serial, src_hw_atari_serial_asm);
921 deploy( dojo, src_hw_atari_dojo_asm);
922
923 outline1( "LDA #$%2.2x", _command );
924 if ( _param1 ) {
925 outline1( "LDX %s", _param1 );
926 } else {
927 outline0( "LDX #0" );
928 }
929 if ( _param2 ) {
930 outline1( "LDY %s", _param2 );
931 } else {
932 outline0( "LDY #0" );
933 }
934 outline0( "JSR DOJOSERIALPUTREQUEST0" );
935 if ( _result ) {
936 outline1( "STA %s", _result );
937 }
938
939}
940
941void atari_dojo_serial_put_request( Environment * _environment, int _command, char * _param1, char * _param2, char * _address, char * _size, char * _result ) {
942
943 deploy( serial, src_hw_atari_serial_asm);
944 deploy( dojo, src_hw_atari_dojo_asm);
945
946 outline1( "LDA %s", _size );
947 outline0( "STA MATHPTR2" );
948 outline1( "LDA %s", _address );
949 outline0( "STA TMPPTR2" );
950 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
951 outline0( "STA TMPPTR2+1" );
952
953 outline1( "LDA #$%2.2x", _command );
954 if ( _param1 ) {
955 outline1( "LDX %s", _param1 );
956 } else {
957 outline0( "LDX #0" );
958 }
959 if ( _param2 ) {
960 outline1( "LDY %s", _param2 );
961 } else {
962 outline0( "LDY #0" );
963 }
964 outline0( "JSR DOJOSERIALPUTREQUEST" );
965 if ( _result ) {
966 outline1( "STA %s", _result );
967 }
968
969}
970
971void atari_dojo_serial_put_requestd( Environment * _environment, int _command, char * _param1, char * _param2, char * _data, char * _size, char * _result ) {
972
973 deploy( serial, src_hw_atari_serial_asm);
974 deploy( dojo, src_hw_atari_dojo_asm);
975
976 outline1( "LDA %s", _size );
977 outline0( "STA MATHPTR2" );
978 outline1( "LDA #<%s", _data );
979 outline0( "STA TMPPTR2" );
980 outline1( "LDA #>%s", _data );
981 outline0( "STA TMPPTR2+1" );
982
983 outline1( "LDA #$%2.2x", _command );
984 if ( _param1 ) {
985 outline1( "LDX %s", _param1 );
986 } else {
987 outline0( "LDX #0" );
988 }
989 if ( _param2 ) {
990 outline1( "LDY %s", _param2 );
991 } else {
992 outline0( "LDY #0" );
993 }
994 outline0( "JSR DOJOSERIALPUTREQUEST" );
995 if ( _result ) {
996 outline1( "STA %s", _result );
997 }
998
999}
1000
1001void atari_dojo_serial_put_requestds( Environment * _environment, int _command, char * _param1, char * _param2, char * _data, int _size, char * _result ) {
1002
1003 deploy( serial, src_hw_atari_serial_asm);
1004 deploy( dojo, src_hw_atari_dojo_asm);
1005
1006 outline1( "LDA #$%2.2x", _size );
1007 outline0( "STA MATHPTR2" );
1008 outline1( "LDA #<%s", _data );
1009 outline0( "STA TMPPTR2" );
1010 outline1( "LDA #>%s", _data );
1011 outline0( "STA TMPPTR2+1" );
1012
1013 outline1( "LDA #$%2.2x", _command );
1014 if ( _param1 ) {
1015 outline1( "LDX %s", _param1 );
1016 } else {
1017 outline0( "LDX #0" );
1018 }
1019 if ( _param2 ) {
1020 outline1( "LDY %s", _param2 );
1021 } else {
1022 outline0( "LDY #0" );
1023 }
1024 outline0( "JSR DOJOSERIALPUTREQUEST" );
1025 if ( _result ) {
1026 outline1( "STA %s", _result );
1027 }
1028
1029}
1030
1032
1033void atari_dojo_fujinet_get_response0( Environment * _environment, char * _status ) {
1034
1035 deploy( serial, src_hw_atari_serial_asm);
1036 deploy( fujinet, src_hw_atari_fujinet_asm);
1037 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1038
1039 outline0( "JSR DOJOFUJINETGETRESPONSE0" );
1040 if ( _status ) {
1041 outline1( "STA %s", _status );
1042 }
1043
1044}
1045
1046void atari_dojo_fujinet_get_response( Environment * _environment, char * _status, char * _address, char * _size ) {
1047
1048 deploy( serial, src_hw_atari_serial_asm);
1049 deploy( fujinet, src_hw_atari_fujinet_asm);
1050 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1051
1052 outline1( "LDA %s", _address );
1053 outline0( "STA MATHPTR4" );
1054 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
1055 outline0( "STA MATHPTR5" );
1056
1057 outline0( "JSR DOJOFUJINETGETRESPONSE" );
1058 if ( _status ) {
1059 outline1( "STA %s", _status );
1060 }
1061 if ( _size ) {
1062 outline1( "STX %s", _size );
1063 }
1064
1065}
1066
1067void atari_dojo_fujinet_get_responsed( Environment * _environment, char * _status, char * _data, char * _size ) {
1068
1069 deploy( serial, src_hw_atari_serial_asm);
1070 deploy( fujinet, src_hw_atari_fujinet_asm);
1071 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1072
1073 outline1( "LDA #<%s", _data );
1074 outline0( "STA MATHPTR4" );
1075 outline1( "LDA #>%s", _data );
1076 outline0( "STA MATHPTR5" );
1077
1078 outline0( "JSR DOJOFUJINETGETRESPONSE" );
1079 if ( _status ) {
1080 outline1( "STA %s", _status );
1081 }
1082 if ( _size ) {
1083 outline1( "STX %s", _size );
1084 }
1085
1086}
1087
1088void atari_dojo_fujinet_get_response_size( Environment * _environment, char * _status, char * _size ) {
1089
1090 deploy( serial, src_hw_atari_serial_asm);
1091 deploy( fujinet, src_hw_atari_fujinet_asm);
1092 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1093
1094 outline0( "JSR DOJOFUJINETGETRESPONSE0" );
1095 if ( _status ) {
1096 outline1( "STA %s", _status );
1097 }
1098 if ( _size ) {
1099 outline1( "STX %s", _size );
1100 }
1101
1102}
1103
1104void atari_dojo_fujinet_get_response_payload( Environment * _environment, char * _address ) {
1105
1106 deploy( serial, src_hw_atari_serial_asm);
1107 deploy( fujinet, src_hw_atari_fujinet_asm);
1108 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1109
1110 outline1( "LDA %s", _address );
1111 outline0( "STA MATHPTR4" );
1112 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
1113 outline0( "STA MATHPTR5" );
1114
1115 outline0( "JSR DOJOFUJINETGETRESPONSEPAYLOAD" );
1116
1117}
1118
1119void atari_dojo_fujinet_get_response_payloadd( Environment * _environment, char * _data ) {
1120
1121 deploy( serial, src_hw_atari_serial_asm);
1122 deploy( fujinet, src_hw_atari_fujinet_asm);
1123 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1124
1125 outline1( "LDA #<%s", _data );
1126 outline0( "STA MATHPTR4" );
1127 outline1( "LDA #>%s", _data );
1128 outline0( "STA MATHPTR5" );
1129
1130 outline0( "JSR DOJOFUJINETGETRESPONSEPAYLOAD" );
1131
1132}
1133
1134void atari_dojo_fujinet_put_request0( Environment * _environment, int _command, char * _param1, char * _param2, char * _result ) {
1135
1136 deploy( serial, src_hw_atari_serial_asm);
1137 deploy( fujinet, src_hw_atari_fujinet_asm);
1138 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1139
1140 outline1( "LDA #$%2.2x", _command );
1141 if ( _param1 ) {
1142 outline1( "LDX %s", _param1 );
1143 } else {
1144 outline0( "LDX #0" );
1145 }
1146 if ( _param2 ) {
1147 outline1( "LDY %s", _param2 );
1148 } else {
1149 outline0( "LDY #0" );
1150 }
1151 outline0( "JSR DOJOFUJINETPUTREQUEST0" );
1152 if ( _result ) {
1153 outline0( "LDA #0" );
1154 outline1( "STA %s", _result );
1155 }
1156
1157}
1158
1159void atari_dojo_fujinet_put_request( Environment * _environment, int _command, char * _param1, char * _param2, char * _address, char * _size, char * _result ) {
1160
1161 deploy( serial, src_hw_atari_serial_asm);
1162 deploy( fujinet, src_hw_atari_fujinet_asm);
1163 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1164
1165 outline1( "LDA %s", _size );
1166 outline0( "STA MATHPTR3" );
1167 outline1( "LDA %s", _address );
1168 outline0( "STA MATHPTR4" );
1169 outline1( "LDA %s", address_displacement( _environment, _address, "1" ) );
1170 outline0( "STA MATHPTR5" );
1171
1172 outline1( "LDA #$%2.2x", _command );
1173 if ( _param1 ) {
1174 outline1( "LDX %s", _param1 );
1175 } else {
1176 outline0( "LDX #0" );
1177 }
1178 if ( _param2 ) {
1179 outline1( "LDY %s", _param2 );
1180 } else {
1181 outline0( "LDY #0" );
1182 }
1183 outline0( "JSR DOJOFUJINETPUTREQUEST" );
1184 if ( _result ) {
1185 outline0( "LDA #0" );
1186 outline1( "STA %s", _result );
1187 }
1188
1189}
1190
1191void atari_dojo_fujinet_put_requestd( Environment * _environment, int _command, char * _param1, char * _param2, char * _data, char * _size, char * _result ) {
1192
1193 deploy( serial, src_hw_atari_serial_asm);
1194 deploy( fujinet, src_hw_atari_fujinet_asm);
1195 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1196
1197 outline1( "LDA %s", _size );
1198 outline0( "STA MATHPTR3" );
1199 outline1( "LDA #<%s", _data );
1200 outline0( "STA MATHPTR4" );
1201 outline1( "LDA #>%s", _data );
1202 outline0( "STA MATHPTR5" );
1203
1204 outline1( "LDA #$%2.2x", _command );
1205 if ( _param1 ) {
1206 outline1( "LDX %s", _param1 );
1207 } else {
1208 outline0( "LDX #0" );
1209 }
1210 if ( _param2 ) {
1211 outline1( "LDY %s", _param2 );
1212 } else {
1213 outline0( "LDY #0" );
1214 }
1215 outline0( "JSR DOJOFUJINETPUTREQUEST" );
1216 if ( _result ) {
1217 outline0( "LDA #0" );
1218 outline1( "STA %s", _result );
1219 }
1220
1221}
1222
1223void atari_dojo_fujinet_put_requestds( Environment * _environment, int _command, char * _param1, char * _param2, char * _data, int _size, char * _result ) {
1224
1225 deploy( serial, src_hw_atari_serial_asm);
1226 deploy( fujinet, src_hw_atari_fujinet_asm);
1227 deploy( dojo_fujinet, src_hw_atari_dojo_fujinet_asm);
1228
1229 outline1( "LDA #$%2.2x", _size );
1230 outline0( "STA MATHPTR3" );
1231 outline1( "LDA #<%s", _data );
1232 outline0( "STA MATHPTR4" );
1233 outline1( "LDA #>%s", _data );
1234 outline0( "STA MATHPTR5" );
1235
1236 outline1( "LDA #$%2.2x", _command );
1237 if ( _param1 ) {
1238 outline1( "LDX %s", _param1 );
1239 } else {
1240 outline0( "LDX #0" );
1241 }
1242 if ( _param2 ) {
1243 outline1( "LDY %s", _param2 );
1244 } else {
1245 outline0( "LDY #0" );
1246 }
1247 outline0( "JSR DOJOFUJINETPUTREQUEST" );
1248 if ( _result ) {
1249 outline0( "LDA #0" );
1250 outline1( "STA %s", _result );
1251 }
1252
1253}
1254
1255void atari_chain( Environment * _environment, char * _filename ) {
1256
1257 _environment->chainUsed = 1;
1258
1259 deploy_preferred( dcommon, src_hw_atari_dcommon_asm );
1260 deploy_preferred( dload, src_hw_atari_dload_asm );
1261 deploy_preferred( chain, src_hw_atari_chain_asm );
1262
1263 Variable * filename = variable_retrieve( _environment, _filename );
1264 Variable * tnaddress = variable_temporary( _environment, VT_ADDRESS, "(address of target_name)");
1265 Variable * tnsize = variable_temporary( _environment, VT_BYTE, "(size of target_name)");
1266
1267 switch( filename->type ) {
1268 case VT_STRING:
1269 cpu_move_8bit( _environment, filename->realName, tnsize->realName );
1270 cpu_addressof_16bit( _environment, filename->realName, tnaddress->realName );
1271 cpu_inc_16bit( _environment, tnaddress->realName );
1272 break;
1273 case VT_DSTRING:
1274 cpu_dsdescriptor( _environment, filename->realName, tnaddress->realName, tnsize->realName );
1275 break;
1276 }
1277
1278 outline1("LDA %s", tnaddress->realName);
1279 outline0("STA DCOMMONP1");
1280 outline1("LDA %s", address_displacement(_environment, tnaddress->realName, "1"));
1281 outline0("STA DCOMMONP1+1");
1282 outline1("LDA %s", tnsize->realName);
1283 outline0("STA DCOMMON0");
1284 outline0("JMP CHAIN");
1285
1286}
1287
1288#endif
cpu_addressof_16bit
void cpu_addressof_16bit(Environment *_environment, char *_source, char *_destination)
Definition 6309.c:1485
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_call
void cpu_call(Environment *_environment, char *_label)
Definition 6309.c:3755
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_inc_16bit
void cpu_inc_16bit(Environment *_environment, char *_variable)
Definition 6309.c:4565
cpu_ctoa
void cpu_ctoa(Environment *_environment)
Definition 6309.c:279
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_dsdescriptor
void cpu_dsdescriptor(Environment *_environment, char *_index, char *_address, char *_size)
Definition 6309.c:5977
src_hw_6502_timer_asm
unsigned char src_hw_6502_timer_asm[]
Definition 6502_timer.c:1
variable_retrieve
Variable * variable_retrieve(Environment *_environment, char *_name)
Definition _infrastructure.c:988
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
size
int size
Definition _optimizer.c:678
offset
int offset
Definition _optimizer.c:681
chain
void chain(Environment *_environment, char *_filename)
Definition chain.c:101
dload
void dload(Environment *_environment, char *_filename, char *_offset, char *_address, char *_bank, char *_size)
Emit code for DLOAD(...).
Definition dload.c:60
dsave
void dsave(Environment *_environment, char *_filename, char *_offset, char *_address, char *_size)
Emit code for DLOAD(...).
Definition dsave.c:58
wait_key_or_fire
void wait_key_or_fire(Environment *_environment, int _port, int _release)
Definition wait_key_or_fire.c:43
atari_inkey
void atari_inkey(Environment *_environment, char *_key)
Definition atari.c:66
atari_timer_set_status_off
void atari_timer_set_status_off(Environment *_environment, char *_timer)
Definition atari.c:272
atari_fujinet_get_status
void atari_fujinet_get_status(Environment *_environment)
Definition atari.c:649
atari_fujinet_get_error
void atari_fujinet_get_error(Environment *_environment, char *_error)
Definition atari.c:588
atari_chain
void atari_chain(Environment *_environment, char *_filename)
Definition atari.c:1255
atari_fujinet_write
void atari_fujinet_write(Environment *_environment, char *_buffer, char *_size, char *_result)
Definition atari.c:674
atari_dojo_fujinet_get_response
void atari_dojo_fujinet_get_response(Environment *_environment, char *_status, char *_address, char *_size)
Definition atari.c:1046
atari_keyshift
void atari_keyshift(Environment *_environment, char *_shifts)
Definition atari.c:233
atari_dojo_serial_get_response0
void atari_dojo_serial_get_response0(Environment *_environment, char *_status)
Definition atari.c:823
atari_dojo_fujinet_put_request0
void atari_dojo_fujinet_put_request0(Environment *_environment, int _command, char *_param1, char *_param2, char *_result)
Definition atari.c:1134
atari_fujinet_writeds
void atari_fujinet_writeds(Environment *_environment, char *_buffer, int _size, char *_result)
Definition atari.c:714
atari_fujinet_get_bytes_waiting
void atari_fujinet_get_bytes_waiting(Environment *_environment, char *_bytes_waiting)
Definition atari.c:570
atari_fujinet_password
void atari_fujinet_password(Environment *_environment, char *_password, char *_size)
Definition atari.c:807
atari_put_key
void atari_put_key(Environment *_environment, char *_string, char *_size)
Definition atari.c:513
atari_fujinet_set_channel_mode
void atari_fujinet_set_channel_mode(Environment *_environment, int _mode, char *_result)
Definition atari.c:734
atari_dojo_fujinet_get_response0
void atari_dojo_fujinet_get_response0(Environment *_environment, char *_status)
Definition atari.c:1033
atari_timer_set_counter
void atari_timer_set_counter(Environment *_environment, char *_timer, char *_counter)
Definition atari.c:286
atari_fujinet_close
void atari_fujinet_close(Environment *_environment)
Definition atari.c:640
atari_dojo_serial_get_response_size
void atari_dojo_serial_get_response_size(Environment *_environment, char *_status, char *_size)
Definition atari.c:875
atari_wait_fire_semivar
void atari_wait_fire_semivar(Environment *_environment, char *_port, int _release)
Definition atari.c:141
atari_ypen
void atari_ypen(Environment *_environment, char *_destination)
Definition atari.c:55
atari_dojo_fujinet_get_responsed
void atari_dojo_fujinet_get_responsed(Environment *_environment, char *_status, char *_data, char *_size)
Definition atari.c:1067
atari_dojo_serial_get_response
void atari_dojo_serial_get_response(Environment *_environment, char *_status, char *_address, char *_size)
Definition atari.c:835
atari_asciicode
void atari_asciicode(Environment *_environment, char *_result)
Definition atari.c:190
atari_timer_set_init
void atari_timer_set_init(Environment *_environment, char *_timer, char *_init)
Definition atari.c:309
atari_fujinet_is_ready
void atari_fujinet_is_ready(Environment *_environment, char *_ready)
Definition atari.c:597
atari_scanshift
void atari_scanshift(Environment *_environment, char *_shifts)
Definition atari.c:215
atari_dojo_fujinet_put_requestds
void atari_dojo_fujinet_put_requestds(Environment *_environment, int _command, char *_param1, char *_param2, char *_data, int _size, char *_result)
Definition atari.c:1223
atari_wait_key_or_fire_semivar
void atari_wait_key_or_fire_semivar(Environment *_environment, char *_port, int _release)
Definition atari.c:108
atari_fujinet_writed
void atari_fujinet_writed(Environment *_environment, char *_buffer, char *_size, char *_result)
Definition atari.c:694
atari_fujinet_set_device
void atari_fujinet_set_device(Environment *_environment, int _device_id)
Definition atari.c:552
atari_xpen
void atari_xpen(Environment *_environment, char *_destination)
Definition atari.c:43
atari_serial_read
void atari_serial_read(Environment *_environment, char *_address, char *_size)
Definition atari.c:524
atari_key_pressed
void atari_key_pressed(Environment *_environment, char *_scancode, char *_result)
Definition atari.c:201
atari_clear_key
void atari_clear_key(Environment *_environment)
Definition atari.c:244
atari_dojo_serial_put_requestds
void atari_dojo_serial_put_requestds(Environment *_environment, int _command, char *_param1, char *_param2, char *_data, int _size, char *_result)
Definition atari.c:1001
atari_sys_call
void atari_sys_call(Environment *_environment, int _destination)
Definition atari.c:252
atari_fujinet_open
void atari_fujinet_open(Environment *_environment, char *_url, char *_size, char *_mode, char *_trans, char *_result)
Definition atari.c:607
atari_wait_key
void atari_wait_key(Environment *_environment, int _release)
Definition atari.c:77
atari_fujinet_set_channel_mode_var
void atari_fujinet_set_channel_mode_var(Environment *_environment, char *_mode, char *_result)
Definition atari.c:750
atari_dload
void atari_dload(Environment *_environment, char *_filename, char *_offset, char *_address, char *_size)
Definition atari.c:343
atari_fujinet_parse_json
void atari_fujinet_parse_json(Environment *_environment, char *_result)
Definition atari.c:764
atari_fujinet_login
void atari_fujinet_login(Environment *_environment, char *_login, char *_size)
Definition atari.c:791
atari_timer_set_address
void atari_timer_set_address(Environment *_environment, char *_timer, char *_address)
Definition atari.c:326
atari_fujinet_is_connected
void atari_fujinet_is_connected(Environment *_environment, char *_is_connected)
Definition atari.c:579
atari_dojo_fujinet_put_requestd
void atari_dojo_fujinet_put_requestd(Environment *_environment, int _command, char *_param1, char *_param2, char *_data, char *_size, char *_result)
Definition atari.c:1191
atari_dojo_fujinet_get_response_size
void atari_dojo_fujinet_get_response_size(Environment *_environment, char *_status, char *_size)
Definition atari.c:1088
atari_dojo_serial_get_responsed
void atari_dojo_serial_get_responsed(Environment *_environment, char *_status, char *_data, char *_size)
Definition atari.c:855
atari_serial_write
void atari_serial_write(Environment *_environment, char *_address, char *_size, char *_result)
Definition atari.c:538
atari_fujinet_set_device_var
void atari_fujinet_set_device_var(Environment *_environment, char *_device_id)
Definition atari.c:561
atari_dojo_serial_get_response_payloadd
void atari_dojo_serial_get_response_payloadd(Environment *_environment, char *_data)
Definition atari.c:904
atari_dojo_serial_put_requestd
void atari_dojo_serial_put_requestd(Environment *_environment, int _command, char *_param1, char *_param2, char *_data, char *_size, char *_result)
Definition atari.c:971
atari_wait_key_or_fire
void atari_wait_key_or_fire(Environment *_environment, int _port, int _release)
Definition atari.c:91
atari_fujinet_read
void atari_fujinet_read(Environment *_environment, char *_buffer, char *_size)
Definition atari.c:658
atari_wait_fire
void atari_wait_fire(Environment *_environment, int _port, int _release)
Definition atari.c:125
atari_dojo_fujinet_put_request
void atari_dojo_fujinet_put_request(Environment *_environment, int _command, char *_param1, char *_param2, char *_address, char *_size, char *_result)
Definition atari.c:1159
atari_dojo_serial_put_request
void atari_dojo_serial_put_request(Environment *_environment, int _command, char *_param1, char *_param2, char *_address, char *_size, char *_result)
Definition atari.c:941
atari_dojo_fujinet_get_response_payloadd
void atari_dojo_fujinet_get_response_payloadd(Environment *_environment, char *_data)
Definition atari.c:1119
atari_dojo_serial_put_request0
void atari_dojo_serial_put_request0(Environment *_environment, int _command, char *_param1, char *_param2, char *_result)
Definition atari.c:918
atari_fujinet_json_query
void atari_fujinet_json_query(Environment *_environment, char *_query, char *_size)
Definition atari.c:775
atari_dsave
void atari_dsave(Environment *_environment, char *_filename, char *_offset, char *_address, char *_size)
Definition atari.c:428
atari_dojo_fujinet_get_response_payload
void atari_dojo_fujinet_get_response_payload(Environment *_environment, char *_address)
Definition atari.c:1104
atari_scancode
void atari_scancode(Environment *_environment, char *_result)
Definition atari.c:172
atari_key_state
void atari_key_state(Environment *_environment, char *_scancode, char *_result)
Definition atari.c:157
atari_dojo_serial_get_response_payload
void atari_dojo_serial_get_response_payload(Environment *_environment, char *_address)
Definition atari.c:890
atari_timer_set_status_on
void atari_timer_set_status_on(Environment *_environment, char *_timer)
Definition atari.c:258
_Environment::chainUsed
int chainUsed
Definition ugbc.h:3287
_Environment::bitmaskNeeded
int bitmaskNeeded
Definition ugbc.h:2659
_Environment::vestigialConfig
VestigialConfig vestigialConfig
Definition ugbc.h:2442
_Variable::type
VariableType type
Definition ugbc.h:988
_Variable::realName
char * realName
Definition ugbc.h:982
_VestigialConfig::rchack_falling_balls_1163
char rchack_falling_balls_1163
Definition ugbc.h:2052
Variable
struct _Variable Variable
Structure of a single variable.
Environment
struct _Environment Environment
Structure of compilation environment.
VT_STRING
@ VT_STRING
Definition ugbc.h:474
VT_BYTE
@ VT_BYTE
Definition ugbc.h:450
VT_ADDRESS
@ VT_ADDRESS
Definition ugbc.h:465
VT_DSTRING
@ VT_DSTRING
Definition ugbc.h:483
deploy_preferred
#define deploy_preferred(s, e)
Definition ugbc.h:4299
outline0
#define outline0(s)
Definition ugbc.h:4252
outline1
#define outline1(s, a)
Definition ugbc.h:4253
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