forked from mist64/c64ref
-
Notifications
You must be signed in to change notification settings - Fork 0
/
c64rom_de.txt
8915 lines (8526 loc) · 418 KB
/
c64rom_de.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
- Fully Commented Commodore 64 ROM Disassembly (German)
-
- CBMBASIC and KERNAL
-
- The comments have been taken from
- Baloui, Said.
- Das neue Commodore-64-intern-Buch.
- Düsseldorf: Data-Becker, 1990.
- ISBN 3890113079
-
- The ROM is the 901227-02 version ($FF80 = 0), except for the
- area $E57C-$E599, which is taken from the 901227-03 version
- ($FF80 = 3).
-
- OCRed and formatted by Michael Steil <mist64@mac.com>
-
- Corrections (typos as well as content), translations etc.
- welcome at: https://github.com/mist64/c64rom
-
------------------------------------------------------------
-
# This plain text file is formatted so that it can be automatically
# parsed in order to create cross-references etc.
# * Lines starting with "-" is top-level information. The first line
# is the title. Lines starting with "--" are separators.
# * Lines starting with "#" are internal comments.
# * Lines starting with ".," indicate code to be disassembled.
# * Lines starting with ".:" indicate bytes to be dumped.
# * Comments start at the 33rd column.
# * 32 leading spaces and "***" indicate a heading. (Please leave one
# line blank above every heading.)
# * Otherwise, 32 leading spaces indicate an overflow comment.
# The encoding is UTF-8.
.:A000 94 E3 Start-Vektor $E394
.:A002 7B E3 NMI-Vektor $E37B
.:A004 43 42 4D 42 41 53 49 43 'cbmbasic'
*** Adressen der BASIC-Befehle -1
*** (Interpreterkode Adresse Befehl)
.:A00C 30 A8 $80 $A831 END
.:A00E 41 A7 $81 $A742 FOR
.:A010 1D AD $82 $AD1E NEXT
.:A012 F7 A8 $83 $A8F8 DATA
.:A014 A4 AB $84 $ABA5 INPUT#
.:A016 BE AB $85 $ABBF INPUT
.:A018 80 B0 $86 $B081 DIM
.:A01A 05 AC $87 $AC06 READ
.:A01C A4 A9 $88 $A9A5 LET
.:A01E 9F A8 $89 $A8A0 GOTO
.:A020 70 A8 $8A $A871 RUN
.:A022 27 A9 $8B $A928 IF
.:A024 1C A8 $8C $A81D RESTORE
.:A026 82 A8 $8D $A883 GOSUB
.:A028 D1 A8 $8E $A8D2 RETURN
.:A02A 3A A9 $8F $A93B REM
.:A02C 2E A8 $90 $A82F STOP
.:A02E 4A A9 $91 $A94B ON
.:A030 2C B8 $92 $B82D WAIT
.:A032 67 E1 $93 $E168 LOAD
.:A034 55 E1 $94 $E156 SAVE
.:A036 64 E1 $95 $E165 VERIFY
.:A038 B2 B3 $96 $B3B3 DEF
.:A03A 23 B8 $97 $B824 POKE
.:A03C 7F AA $98 $AA80 PRINT#
.:A03E 9F AA $99 $AAA0 PRINT
.:A040 56 A8 $9A $A857 CONT
.:A042 9B A6 $9B $A69C LIST
.:A044 5D A6 $9C $A65E CLR
.:A046 85 AA $9D $AA86 CMD
.:A048 29 E1 $9E $E12A SYS
.:A04A BD E1 $9F $E1BE OPEN
.:A04C C6 E1 $A0 $E1C7 CLOSE
.:A04E 7A AB $A1 $AB7B GET
.:A050 41 A6 $A2 $A642 NEW
*** Adressen der BASIC-Funktionen
.:A052 39 BC $B4 $BC39 SGN
.:A054 CC BC $B5 $BCCC INT
.:A056 58 BC $B6 $BC58 ABS
.:A058 10 03 $B7 $0310 USR
.:A05A 7D B3 $B8 $B37D FRE
.:A05C 9E B3 $B9 $B39E POS
.:A05E 71 BF $BA $BF71 SQR
.:A060 97 E0 $BB $E097 RND
.:A062 EA B9 $BC $B9EA LOG
.:A064 ED BF $BD $BFED EXP
.:A066 64 E2 $BE $E264 COS
.:A068 6B E2 $BF $E26B SIN
.:A06A B4 E2 $C0 $E2B4 TAN
.:A06C 0E E3 $C1 $E30E ATN
.:A06E 0D B8 $C2 $B80D PEEK
.:A070 7C B7 $C3 $B77C LEN
.:A072 65 B4 $C4 $B465 STR$
.:A074 AD B7 $C5 $B7AD VAL
.:A076 8B B7 $C6 $B78B ASC
.:A078 EC B6 $C7 $B6EC CHR$
.:A07A 00 B7 $C8 $B700 LEFT$
.:A07C 2C B7 $C9 $B72C RIGHT$
.:A07E 37 B7 $CA $B737 MID$
*** Hierarchiecodes und
*** Adressen-1 der Operatoren
.:A080 79 69 B8 $79, $B86A Addition
.:A083 79 52 B8 $79, $B853 Subtraktion
.:A086 7B 2A BA $7B, $BA2B Multiplikation
.:A089 7B 11 BB $7B, $BB12 Division
.:A08C 7F 7A BF $7F, $BF7B Potenzierung
.:A08F 50 E8 AF $50, $AFE9 AND
.:A092 46 E5 AF $46, $AFE6 OR
.:A095 7D B3 BF $7D, $BFB4 Vorzeichenwechsel
.:A098 5A D3 AE $5A, $AED4 NOT
.:A09B 64 15 B0 $64, $B016 Vergleich
*** BASIC-Befehlsworte
.:A09E 45 4E end
.:A0A0 C4 46 4F D2 4E 45 58 D4 for next
.:A0A8 44 41 54 C1 49 4E 50 55 data input#
.:A0B0 54 A3 49 4E 50 55 D4 44 input dim
.:A0B8 49 CD 52 45 41 C4 4C 45 read let
.:A0C0 D4 47 4F 54 CF 52 55 CE goto run
.:A0C8 49 C6 52 45 53 54 4F 52 if restore
.:A0D0 C5 47 4F 53 55 C2 52 45 gosub return
.:A0D8 54 55 52 CE 52 45 CD 53 rem stop
.:A0E0 54 4F D0 4F CE 57 41 49 on wait
.:A0E8 D4 4C 4F 41 C4 53 41 56 load save
.:A0F0 C5 56 45 52 49 46 D9 44 verify def
.:A0F8 45 C6 50 4F 4B C5 50 52 poke print#
.:A100 49 4E 54 A3 50 52 49 4E print
.:A108 D4 43 4F 4E D4 4C 49 53 cont list
.:A110 D4 43 4C D2 43 4D C4 53 clr cmd sys
.:A118 59 D3 4F 50 45 CE 43 4C open close
.:A120 4F 53 C5 47 45 D4 4E 45 get new
.:A128 D7 54 41 42 A8 54 CF 46 tab( to
.:A130 CE 53 50 43 A8 54 48 45 spc( then
.:A138 CE 4E 4F D4 53 54 45 D0 not stop
.:A140 AB AD AA AF DE 41 4E C4 + - * / ' and
.:A148 4F D2 BE BD BC 53 47 CE or <=> sgn
.:A150 49 4E D4 41 42 D3 55 53 int abs usr
.:A158 D2 46 52 C5 50 4F D3 53 fre pos sqr
.:A160 51 D2 52 4E C4 4C 4F C7 rnd log
.:A168 45 58 D0 43 4F D3 53 49 exp cos sin
.:A170 CE 54 41 CE 41 54 CE 50 tan atn peek
.:A178 45 45 CB 4C 45 CE 53 54 len str$
.:A180 52 A4 56 41 CC 41 53 C3 val asc
.:A188 43 48 52 A4 4C 45 46 54 chr$ left$
.:A190 A4 52 49 47 48 54 A4 4D right$ mid$
.:A198 49 44 A4 47 CF 00 go
*** BASIC-Fehlermeldungen
.:A1A0 54 4F 1 too many files
.:A1A0 4F 20 4D 41 4E 59 20 46
.:A1A8 49 4C 45 D3 46 49 4C 45 2 file open
.:A1B0 20 4F 50 45 CE 46 49 4C 3 file not open
.:A1B8 45 20 4E 4F 54 20 4F 50
.:A1C0 45 CE 46 49 4C 45 20 4E 4 file not found
.:A1C8 4F 54 20 46 4F 55 4E C4 5 device not present
.:A1D0 44 45 56 49 43 45 20 4E
.:A1D8 4F 54 20 50 52 45 53 45
.:A1E0 4E D4 4E 4F 54 20 49 4E 6 not input file
.:A1E8 50 55 54 20 46 49 4C C5
.:A1F0 4E 4F 54 20 4F 55 54 50 7 not output file
.:A1F8 55 54 20 46 49 4C C5 4D
.:A200 49 53 53 49 4E 47 20 46 8 missing filename
.:A208 49 4C 45 20 4E 41 4D C5
.:A210 49 4C 4C 45 47 41 4C 20 9 illegal device number
.:A218 44 45 56 49 43 45 20 4E
.:A220 55 4D 42 45 D2 4E 45 58 10 next without for
.:A228 54 20 57 49 54 48 4F 55
.:A230 54 20 46 4F D2 53 59 4E 11 syntax
.:A238 54 41 D8 52 45 54 55 52 12 return without gosub
.:A240 4E 20 57 49 54 48 4F 55
.:A248 54 20 47 4F 53 55 C2 4F 13 out of data
.:A250 55 54 20 4F 46 20 44 41
.:A258 54 C1 49 4C 4C 45 47 41 14 illegal quantity
.:A260 4C 20 51 55 41 4E 54 49
.:A268 54 D9 4F 56 45 52 46 4C 15 overflow
.:A270 4F D7 4F 55 54 20 4F 46 16 out of memory
.:A278 20 4D 45 4D 4F 52 D9 55 17 undef'd statement
.:A280 4E 44 45 46 27 44 20 53
.:A288 54 41 54 45 4D 45 4E D4
.:A290 42 41 44 20 53 55 42 53 18 bad subscript
.:A298 43 52 49 50 D4 52 45 44 19 redim'd array
.:A2A0 49 4D 27 44 20 41 52 52
.:A2A8 41 D9 44 49 56 49 53 49 20 division by zero
.:A2B0 4F 4E 20 42 59 20 5A 45
.:A2B8 52 CF 49 4C 4C 45 47 41 21 illegal direct
.:A2C0 4C 20 44 49 52 45 43 D4
.:A2C8 54 59 50 45 20 4D 49 53 22 type mismatch
.:A2D0 4D 41 54 43 C8 53 54 52 23 string too long
.:A2D8 49 4E 47 20 54 4F 4F 20
.:A2E0 4C 4F 4E C7 46 49 4C 45 24 file data
.:A2E8 20 44 41 54 C1 46 4F 52 25 formula too complex
.:A2F0 4D 55 4C 41 20 54 4F 4F
.:A2F8 20 43 4F 4D 50 4C 45 D8
.:A300 43 41 4E 27 54 20 43 4F 26 can't continue
.:A308 4E 54 49 4E 55 C5 55 4E 27 undef'd function
.:A310 44 45 46 27 44 20 46 55
.:A318 4E 43 54 49 4F CE 56 45 28 verify
.:A320 52 49 46 D9 4C 4F 41 C4 29 load
*** Adressen der Fehlermeldungen
.:A328 9E A1 AC A1 B5 A1 C2 A1
.:A330 D0 A1 E2 A1 F0 A1 FF A1
.:A338 10 A2 25 A2 35 A2 3B A2
.:A340 4F A2 5A A2 6A A2 72 A2
.:A348 7F A2 90 A2 9D A2 AA A2
.:A350 BA A2 C8 A2 D5 A2 E4 A2
.:A358 ED A2 00 A3 0E A3 1E A3
.:A360 24 A3 83 A3
*** Meldungen des Interpreters
.:A364 0D 4F 4B 0D OK
.:A368 00 20 20 45 52 52 4F 52 ERROR
.:A370 00 20 49 4E 20 00 0D 0A IN
.:A378 52 45 41 44 59 2E 0D 0A READY.
.:A380 00 0D 0A 42 52 45 41 4B BREAK
.:A388 00 A0
*** Stapelsuch-Routine für
*** FOR-NEXT- und GOSUB-Befehl
.,A38A BA TSX Stapelzeiger in X-Register
.,A38B E8 INX 4 mal erhöhen
.,A38C E8 INX (nächsten zwei Rücksprung-
.,A38D E8 INX adressen, Interpreter und
.,A38E E8 INX Routine, übergehen)
.,A38F BD 01 01 LDA $0101,X nächstes Byte hoten
.,A392 C9 81 CMP #$81 Ist es FOR-Code ?
.,A394 D0 21 BNE $A3B7 Nein: dann RTS
.,A396 A5 4A LDA $4A Variablenzeiger holen
.,A398 D0 0A BNE $A3A4 keine Variable (NEXT):$A3A4
.,A39A BD 02 01 LDA $0102,X Variablenzeiger aus
.,A39D 85 49 STA $49 Stapel nach $49/4A
.,A39F BD 03 01 LDA $0103,X (Variablenzeiger)
.,A3A2 85 4A STA $4A holen
.,A3A4 DD 03 01 CMP $0103,X Mit Zeiger im Stapel vergl.
.,A3A7 D0 07 BNE $A3B0 Ungleich: nächste Schleife
.,A3A9 A5 49 LDA $49 Zeiger wieder holen
.,A3AB DD 02 01 CMP $0102,X Mit Zeiger im Stapel vergl.
.,A3AE F0 07 BEQ $A3B7 Gleich: Schleife gefunden,RTS
.,A3B0 8A TXA Suchzeiger in Akku
.,A3B1 18 CLC Carry für Addition löschen
.,A3B2 69 12 ADC #$12 Suchzeiger um 18 erhöhen
.,A3B4 AA TAX und wieder zurück ins X-Rg.
.,A3B5 D0 D8 BNE $A38F nächste Schleife prüfen
.,A3B7 60 RTS Rücksprung
*** Block-Verschiebe-Routine
.,A3B8 20 08 A4 JSR $A408 prüft auf Platz im Speicher
.,A3BB 85 31 STA $31 Ende des Arraybereichs
.,A3BD 84 32 STY $32 als Beginn für freien Platz
.,A3BF 38 SEC Carry setzen (Subtraktion)
.,A3C0 A5 5A LDA $5A Startadresse von Endad. des
.,A3C2 E5 5F SBC $5F Bereichs abziehen (LOW)
.,A3C4 85 22 STA $22 Ergebnis (=Länge) speichern
.,A3C6 A8 TAY Gleiches System für HIGH:
.,A3C7 A5 5B LDA $5B Altes Blockende (HIGH) und
.,A3C9 E5 60 SBC $60 davon alter Blockanfang sub
.,A3CB AA TAX Länge nach X bringen
.,A3CC E8 INX Ist ein Rest ( Länge nicht
.,A3CD 98 TYA 256 Bytes)?
.,A3CE F0 23 BEQ $A3F3 Nein: dann nur ganze Blöcke
.,A3D0 A5 5A LDA $5A Alte Endadresse (LOW) und
.,A3D2 38 SEC davon Länge des Restab-
.,A3D3 E5 22 SBC $22 schnitts subtrahieren ergibt
Adresse des
.,A3D5 85 5A STA $5A Restabschnitts
.,A3D7 B0 03 BCS $A3DC Berechnung für HIGH umgehen
.,A3D9 C6 5B DEC $5B Dasselbe System für HIGH
.,A3DB 38 SEC Carry setzen (Subtraktion)
.,A3DC A5 58 LDA $58 Alte Endadresse (HIGH) und
.,A3DE E5 22 SBC $22 davon Länge des Rests sub-
.,A3E0 85 58 STA $58 trahieren ergibt neue Adresse
.,A3E2 B0 08 BCS $A3EC Unbedingter Sprung zur
.,A3E4 C6 59 DEC $59 Kopierroutine für ganze
.,A3E6 90 04 BCC $A3EC Blöcke
.,A3E8 B1 5A LDA ($5A),Y Kopierroutine für Rest-
.,A3EA 91 58 STA ($58),Y abschnitt
.,A3EC 88 DEY Zähler vermindern
.,A3ED D0 F9 BNE $A3E8 Alles? wenn nicht: weiter
.,A3EF B1 5A LDA ($5A),Y Kopierroutine für ganze
.,A3F1 91 58 STA ($58),Y Blöcke
.,A3F3 C6 5B DEC $5B Adresszähler vermindern
.,A3F5 C6 59 DEC $59 Adresszähler vermindern
.,A3F7 CA DEX Zähler vermindern
.,A3F8 D0 F2 BNE $A3EC Alles? Wenn nicht: weiter
.,A3FA 60 RTS sonst Rücksprung
*** Prüfung auf Platz im Stapel
.,A3FB 0A ASL Akku muß die halbe Zahl an
.,A3FC 69 3E ADC #$3E erforderlichem Platz haben
.,A3FE B0 35 BCS $A435 gibt 'OUT OF MEMORY'
.,A400 85 22 STA $22 Wert merken
.,A402 BA TSX Ist Stapelzeiger kleiner
.,A403 E4 22 CPX $22 (2 * Akku + 62)?
.,A405 90 2E BCC $A435 Wenn ja, dann OUT OF MEMORY
.,A407 60 RTS Rücksprung
*** Schafft Platz im Speicher
.,A408 C4 34 CPY $34 für Zeileneinfügung
.,A40A 90 28 BCC $A434 und Variablen
.,A40C D0 04 BNE $A412 A/Y = Adresse, bis zu der
.,A40E C5 33 CMP $33 Platz benötigt wird.
.,A410 90 22 BCC $A434 Kleiner als Stringzeiger
.,A412 48 PHA Akku Zwischenspeichern
.,A413 A2 09 LDX #$09 Zähler setzen
.,A415 98 TYA Y-Register auf
.,A416 48 PHA Stapel retten
.,A417 B5 57 LDA $57,X Ab $57 Zwischenspeichern
.,A419 CA DEX Zähler vermindern
.,A41A 10 FA BPL $A416 Alle? sonst weiter
.,A41C 20 26 B5 JSR $B526 Garbage Collection
.,A41F A2 F7 LDX #$F7 Zähler setzen, um
.,A421 68 PLA Akku, Y-Register und andere
.,A422 95 61 STA $61,X Register zurückholen
.,A424 E8 INX Zähler vermindern
.,A425 30 FA BMI $A421 Fertig? Nein, dann weiter
.,A427 68 PLA Y-Register von Stapel
.,A428 A8 TAY zurückholen
.,A429 68 PLA Akku holen
.,A42A C4 34 CPY $34 Ist jetzt genügend Platz?
.,A42C 90 06 BCC $A434 Ja, dann Rücksprung
.,A42E D0 05 BNE $A435 kein Platz, dann Fehler-
.,A430 C5 33 CMP $33 meldung 1 out of memory 1
.,A432 B0 01 BCS $A435 ausgeben
.,A434 60 RTS Rücksprung
.,A435 A2 10 LDX #$10 Fehlernummer 'out of memory'
*** Fehlereinsprung
.,A437 6C 00 03 JMP ($0300) Zum BASIC-Warmstart ($E38B)
*** Fehlermeldung ausgeben
.,A43A 8A TXA Fehlernummer im X-Register
.,A43B 0A ASL Akku * 2
.,A43C AA TAX Akku als Zeiger nach X
.,A43D BD 26 A3 LDA $A326,X und Adresse der
.,A440 85 22 STA $22 Fehlernummer aus Tabelle
.,A442 BD 27 A3 LDA $A327,X holen und
.,A445 85 23 STA $23 abspeichern
.,A447 20 CC FF JSR $FFCC I/O Kanäle zurücksetzen
.,A44A A9 00 LDA #$00 und Eingabekanal auf
.,A44C 85 13 STA $13 Tastatur setzen
.,A44E 20 D7 AA JSR $AAD7 (CR) und (LF) ausgeben
.,A451 20 45 AB JSR $AB45 '?' ausgeben
.,A454 A0 00 LDY #$00 Zeiger setzen
.,A456 B1 22 LDA ($22),Y Fehlermeldungstext holen
.,A458 48 PHA Akku retten
.,A459 29 7F AND #$7F Bit 7 löschen und
.,A45B 20 47 AB JSR $AB47 Fehlermeldung ausgeben
.,A45E C8 INY Zähler vermindern
.,A45F 68 PLA Akku zurückholen
.,A460 10 F4 BPL $A456 Fertig? Nein, dann weiter
.,A462 20 7A A6 JSR $A67A BASIC-Zeiger initialisieren
.,A465 A9 69 LDA #$69 Zeiger A/Y auf Error-
.,A467 A0 A3 LDY #$A3 meldung stellen
.,A469 20 1E AB JSR $AB1E String ausgeben
.,A46C A4 3A LDY $3A Auf Programmodus
.,A46E C8 INY (prog/direkt) prüfen
.,A46F F0 03 BEQ $A474 Direkt: dann ausgeben
.,A471 20 C2 BD JSR $BDC2 'in Zeilennummer' ausgeben
.,A474 A9 76 LDA #$76 Zeiger auf Ready-Modus
.,A476 A0 A3 LDY #$A3 setzen und
.,A478 20 1E AB JSR $AB1E String ausgeben
.,A47B A9 80 LDA #$80 Wert für Direktmodus laden
.,A47D 20 90 FF JSR $FF90 und Flag setzen
*** Eingabe-Warteschleife
.,A480 6C 02 03 JMP ($0302) JMP $A483
.,A483 20 60 A5 JSR $A560 BASIC-Zeile nach
Eingabepuffer
.,A486 86 7A STX $7A CHRGET Zeiger auf
.,A488 84 7B STY $7B Eingabepuffer
.,A48A 20 73 00 JSR $0073 nächstes Zeichen holen
.,A48D AA TAX Puffer leer?
.,A48E F0 F0 BEQ $A480 Ja: dann weiter warten
.,A490 A2 FF LDX #$FF Wert für
.,A492 86 3A STX $3A Kennzeichen für Direktmodus
.,A494 90 06 BCC $A49C Ziffer? als Zeile einfügen
.,A496 20 79 A5 JSR $A579 BASIC-Zeile in Code wandeln
.,A499 4C E1 A7 JMP $A7E1 Befehl ausführen
*** Löschen und Einfügen von
*** Programmzeilen
.,A49C 20 6B A9 JSR $A96B Zeilenr. nach Adressformat
.,A49F 20 79 A5 JSR $A579 BASIC-Zeile in Code wandeln
.,A4A2 84 0B STY $0B Zeiger in Eingabepuffer
.,A4A4 20 13 A6 JSR $A613 Zeilenadresse berechnen
.,A4A7 90 44 BCC $A4ED Vorhanden? Ja: löschen
*** Programmzeile löschen
.,A4A9 A0 01 LDY #$01 Zeiger setzen
.,A4AB B1 5F LDA ($5F),Y Startadresse der nächsten
.,A4AD 85 23 STA $23 Zeile (HIGH) setzen
.,A4AF A5 2D LDA $2D Variablenanfangszeiger
.,A4B1 85 22 STA $22 (LOW) setzen
.,A4B3 A5 60 LDA $60 Startadresse der zu
.,A4B5 85 25 STA $25 löschenden Zeile (HIGH)
.,A4B7 A5 5F LDA $5F Startadresse der zu
.,A4B9 88 DEY löschenden Zeile (LOW)
.,A4BA F1 5F SBC ($5F),Y Startadresse der nächsten
.,A4BC 18 CLC Zeile (LOW)
.,A4BD 65 2D ADC $2D Variablenanfangszeiger (LOW)
.,A4BF 85 2D STA $2D ergibt neuen Variablenan-
.,A4C1 85 24 STA $24 fangszeiger (LOW)
.,A4C3 A5 2E LDA $2E Gleiches System für
.,A4C5 69 FF ADC #$FF HIGH-Byte des Variablenan-
.,A4C7 85 2E STA $2E fangszeigers
.,A4C9 E5 60 SBC $60 minus Startadresse der zu
.,A4CB AA TAX löschenden Zeile (LOW) ergibt
.,A4CC 38 SEC die zu verschiebenden Blöcke
.,A4CD A5 5F LDA $5F Startadresse (LOW) minus
.,A4CF E5 2D SBC $2D Variablenanfangszeiger (LOW)
.,A4D1 A8 TAY ergibt Länge des Restabschn.
.,A4D2 B0 03 BCS $A4D7 Größer als 255? Nein: $A4D7
.,A4D4 E8 INX Zähler für Blöcke erhöhen
.,A4D5 C6 25 DEC $25 Transportzeiger vermindern
.,A4D7 18 CLC Carry löschen
.,A4D8 65 22 ADC $22 Anfangszeiger (LOW)
.,A4DA 90 03 BCC $A4DF Verminderung überspringen
.,A4DC C6 23 DEC $23 Zeiger um 1 vermindern
.,A4DE 18 CLC Carry löschen
.,A4DF B1 22 LDA ($22),Y Verschiebeschleife
.,A4E1 91 24 STA ($24),Y Wert abspeichern
.,A4E3 C8 INY Zähler um 1 erhöhen
.,A4E4 D0 F9 BNE $A4DF Block fertig? Nein: weiter
.,A4E6 E6 23 INC $23 1.Adreßzeiger erhöhen (LOW)
.,A4E8 E6 25 INC $25 2.Adreßzeiger erhöhen (LOW)
.,A4EA CA DEX Blockzähter um 1 vermindern
.,A4EB D0 F2 BNE $A4DF Alle Blöcke? Nein: weiter
*** Programmzeile einfügen
.,A4ED 20 59 A6 JSR $A659 CLR-Befehl
.,A4F0 20 33 A5 JSR $A533 Programmzeilen neu binden
.,A4F3 AD 00 02 LDA $0200 Zeichen im Puffer ?
.,A4F6 F0 88 BEQ $A480 nein, dann zur Warteschleife
.,A4F8 18 CLC Carry löschen
.,A4F9 A5 2D LDA $2D Variablenanfangszeiger (LOW)
.,A4FB 85 5A STA $5A als Endadresse (Quellbereich)
.,A4FD 65 0B ADC $0B + Länge der Zeile als End-
.,A4FF 85 58 STA $58 adresse des Zielbereichs LOW
.,A501 A4 2E LDY $2E Variablenanfangszeiger als
.,A503 84 5B STY $5B Endadr. des Quellbereichs LOW
.,A505 90 01 BCC $A508 Kein Übertrag? dann $A508
.,A507 C8 INY Übertrag addieren
.,A508 84 59 STY $59 Als Endadresse
des Zielbereichs
.,A50A 20 B8 A3 JSR $A3B8 BASIC-Zeilen verschieben
.,A50D A5 14 LDA $14 Zeilennummer aus
.,A50F A4 15 LDY $15 $14/15 vor
.,A511 8D FE 01 STA $01FE BASIC-Eingabepuffer setzen
.,A514 8C FF 01 STY $01FF (ab $0200)
.,A517 A5 31 LDA $31 Neuer Variablen-
.,A519 A4 32 LDY $32 endzeiger
.,A51B 85 2D STA $2D als Zeiger auf Programm-
.,A51D 84 2E STY $2E ende speichern
.,A51F A4 0B LDY $0B Zeilenlänge holen
.,A521 88 DEY und um 1 vermindern
.,A522 B9 FC 01 LDA $01FC,Y Zeile aus Eingabepuffer
.,A525 91 5F STA ($5F),Y ins Programm kopieren
.,A527 88 DEY Schon alle Zeichen?
.,A528 10 F8 BPL $A522 Nein: dann weiterkopieren
.,A52A 20 59 A6 JSR $A659 CLR-Befehl
.,A52D 20 33 A5 JSR $A533 Programmzeilen neu binden
.,A530 4C 80 A4 JMP $A480 zur Eingabe-Warteschleife
*** BASIC-Zeilen neu binden
.,A533 A5 2B LDA $2B Zeiger auf BASIC-Programm-
.,A535 A4 2C LDY $2C start holen und
.,A537 85 22 STA $22 und als Suchzeiger nach
.,A539 84 23 STY $23 $22/23 speichern
.,A53B 18 CLC Carry löschen
.,A53C A0 01 LDY #$01 Zeiger laden
.,A53E B1 22 LDA ($22),Y Zeilenadresse holen
.,A540 F0 1D BEQ $A55F =0? Ja: dann RTS
.,A542 A0 04 LDY #$04 Zeiger auf erstes BASIC-
.,A544 C8 INY zeichen setzen
.,A545 B1 22 LDA ($22),Y Zeichen holen
.,A547 D0 FB BNE $A544 =0? (Zeilenende) nein: weiter
.,A549 C8 INY Zeilenlänge nach
.,A54A 98 TYA Akku schieben
.,A54B 65 22 ADC $22 + Zeiger auf aktuelle Zeile
.,A54D AA TAX (LOW) ins X-Register
.,A54E A0 00 LDY #$00 Zeiger laden
.,A550 91 22 STA ($22),Y Akku als Adr.zeiger (LOW)
.,A552 A5 23 LDA $23 Zeiger auf aktuelle
Zeile (HIGH)
.,A554 69 00 ADC #$00 Übertrag addieren
.,A556 C8 INY Zähler um 1 erhöhen
.,A557 91 22 STA ($22),Y Adresszeiger (HIGH) speichern
.,A559 86 22 STX $22 Startadresse der nächsten
.,A55B 85 23 STA $23 Zeile abspeichern
.,A55D 90 DD BCC $A53C Zum Zeilenanfang
.,A55F 60 RTS Rücksprung
*** Eingabe einer Zeile
.,A560 A2 00 LDX #$00 Zeiger setzen
.,A562 20 12 E1 JSR $E112 ein Zeichen holen
.,A565 C9 0D CMP #$0D RETURN-Taste ?
.,A567 F0 0D BEQ $A576 ja, dann Eingabe beenden
.,A569 9D 00 02 STA $0200,X Zeichen nach Eingabepuffer
.,A56C E8 INX Zeiger um 1 erhöhen
.,A56D E0 59 CPX #$59 89. Zeichen ?
.,A56F 90 F1 BCC $A562 nein, weitere Zeichen holen
.,A571 A2 17 LDX #$17 Nummer für 'string too long'
.,A573 4C 37 A4 JMP $A437 Fehlermeldung ausgeben
.,A576 4C CA AA JMP $AACA Puffer mit $0 abschließen, CR
*** Umwandlung einer Zeile in den
*** Interpreter-Code
.,A579 6C 04 03 JMP ($0304) JMP $A57C
.,A57C A6 7A LDX $7A Zeiger setzen, erstes Zeichen
.,A57E A0 04 LDY #$04 Wert für codierte Zeile
.,A580 84 0F STY $0F Flag für Hochkomma
.,A582 BD 00 02 LDA $0200,X Zeichen aus Puffer holen
.,A585 10 07 BPL $A58E kein BASIC-Code ? kleiner 128
.,A587 C9 FF CMP #$FF Code für Pi ?
.,A589 F0 3E BEQ $A5C9 Ja: dann speichern
.,A58B E8 INX Zeiger erhöhen
.,A58C D0 F4 BNE $A582 nächstes Zeichen überprüfen
.,A58E C9 20 CMP #$20 ' ' Leerzeichen?
.,A590 F0 37 BEQ $A5C9 Ja: dann speichern
.,A592 85 08 STA $08 in Hochkomma-Flag speichern
.,A594 C9 22 CMP #$22 "'" Hochkomma?
.,A596 F0 56 BEQ $A5EE Ja: dann speichern
.,A598 24 0F BIT $0F Überprüft auf Bit 6
.,A59A 70 2D BVS $A5C9 gesetzt: ASCII speichern
.,A59C C9 3F CMP #$3F '?' Fragezeichen?
.,A59E D0 04 BNE $A5A4 Nein: dann weiter prüfen
.,A5A0 A9 99 LDA #$99 PRINT-Code für ? laden
.,A5A2 D0 25 BNE $A5C9 und abspeichern
.,A5A4 C9 30 CMP #$30 Kleiner $30 ? (Code für 0)
.,A5A6 90 04 BCC $A5AC Ja: dann $A5AC
.,A5A8 C9 3C CMP #$3C Mit $3C vergleichen
.,A5AA 90 1D BCC $A5C9 wenn größer, dann $A5C9
.,A5AC 84 71 STY $71 Zeiger Zwischenspeichern
.,A5AE A0 00 LDY #$00 Zähler für Tokentabelle
.,A5B0 84 0B STY $0B initialisieren
.,A5B2 88 DEY
.,A5B3 86 7A STX $7A Zeiger auf Eingabepuffer
.,A5B5 CA DEX zwischenspeichern
.,A5B6 C8 INY X- und Y-Register
.,A5B7 E8 INX um 1 erhöhen
.,A5B8 BD 00 02 LDA $0200,X Zeichen aus Puffer laden
.,A5BB 38 SEC Carry für Subtr. löschen
.,A5BC F9 9E A0 SBC $A09E,Y Zeichen mit Befehlswort vergleichen
.,A5BF F0 F5 BEQ $A5B6 Gefunden? Ja: nächstes Zeich.
.,A5C1 C9 80 CMP #$80 mit $80 (128) vergleichen
.,A5C3 D0 30 BNE $A5F5 Befehl nicht gefunden: $A5F5
.,A5C5 05 0B ORA $0B BASIC-Code gleich Zähler +$80
.,A5C7 A4 71 LDY $71 Zeiger auf cod. Zeile holen
.,A5C9 E8 INX
.,A5CA C8 INY Zeiger erhöhen
.,A5CB 99 FB 01 STA $01FB,Y BASIC-Code speichern
.,A5CE B9 FB 01 LDA $01FB,Y und Statusregister setzen
.,A5D1 F0 36 BEQ $A609 =0 (Ende): dann fertig
.,A5D3 38 SEC Carry setzen (Subtraktion)
.,A5D4 E9 3A SBC #$3A ':' Trennzeichen?
.,A5D6 F0 04 BEQ $A5DC Ja: dann $A5DC
.,A5D8 C9 49 CMP #$49 DATA-Code ?
.,A5DA D0 02 BNE $A5DE Nein: Speichern überspringen
.,A5DC 85 0F STA $0F nach Hochkomma-Flag speichern
.,A5DE 38 SEC Carry setzen
.,A5DF E9 55 SBC #$55 REM-Code ?
.,A5E1 D0 9F BNE $A582 Nein: zum Schleifenanfang
.,A5E3 85 08 STA $08 0 in Hochkomma-Flag
.,A5E5 BD 00 02 LDA $0200,X nächstes Zeichen holen
.,A5E8 F0 DF BEQ $A5C9 =0 (Ende)? Ja: dann $A5C9
.,A5EA C5 08 CMP $08 Als ASCII speichern?
.,A5EC F0 DB BEQ $A5C9 Nein: dann $A5C9
.,A5EE C8 INY Zeiger erhöhen
.,A5EF 99 FB 01 STA $01FB,Y Code abspeichern
.,A5F2 E8 INX Zeiger erhöhen
.,A5F3 D0 F0 BNE $A5E5 Zum Schleifenanfang
.,A5F5 A6 7A LDX $7A Zeiger wieder auf Eingabep.
.,A5F7 E6 0B INC $0B Suchzähler erhöhen
.,A5F9 C8 INY Zähler erhöhen
.,A5FA B9 9D A0 LDA $A09D,Y nächsten Befehl suchen
.,A5FD 10 FA BPL $A5F9 Gefunden? Nein: weitersuchen
.,A5FF B9 9E A0 LDA $A09E,Y Ende der Tabelle?
.,A602 D0 B4 BNE $A5B8 Nein: dann weiter
.,A604 BD 00 02 LDA $0200,X nächstes Zeichen holen
.,A607 10 BE BPL $A5C7 kleiner $80? Ja: $A5C7
.,A609 99 FD 01 STA $01FD,Y im Eingabepuffer speichern
.,A60C C6 7B DEC $7B CHRGET-Zeiger zurücksetzen
.,A60E A9 FF LDA #$FF Zeiger auf Eingabepuffer -1
.,A610 85 7A STA $7A setzen (LOW)
.,A612 60 RTS Rücksprung
*** Startadresse einer
*** Programmzeile berechnen
.,A613 A5 2B LDA $2B Zeiger auf BASIC-
.,A615 A6 2C LDX $2C Programmstart laden
.,A617 A0 01 LDY #$01 Zähler setzen
.,A619 85 5F STA $5F BASIC-Programmstart als
.,A61B 86 60 STX $60 Zeiger nach $5F/60
.,A61D B1 5F LDA ($5F),Y Link-Adresse holen (HIGH)
.,A61F F0 1F BEQ $A640 gleich null: dann Ende
.,A621 C8 INY Zähler 2 mal erhöhen ( LOW-
.,A622 C8 INY Byte übergehen)
.,A623 A5 15 LDA $15 gesuchte Zeilennummer (HIGH)
.,A625 D1 5F CMP ($5F),Y mit aktueller vergleichen
.,A627 90 18 BCC $A641 kleiner: dann nicht gefunden
.,A629 F0 03 BEQ $A62E gleich: Nummer LOW prüfen
.,A62B 88 DEY Zähler um 1 vermindern
.,A62C D0 09 BNE $A637 unbedingter Sprung
.,A62E A5 14 LDA $14 gesuchte Zeilennummer (LOW)
.,A630 88 DEY Zeiger um 1 vermindern
.,A631 D1 5F CMP ($5F),Y Zeilennummer LOW vergleichen
.,A633 90 0C BCC $A641 kleiner: Zeile nicht gefunden
.,A635 F0 0A BEQ $A641 oder gleich: C=1 und RTS
.,A637 88 DEY Y-Register auf 1 setzen
.,A638 B1 5F LDA ($5F),Y Adresse der nächsten Zeile
.,A63A AA TAX in das X-Register laden
.,A63B 88 DEY Register vermindern (auf 0)
.,A63C B1 5F LDA ($5F),Y Link-Adresse holen (LOW)
.,A63E B0 D7 BCS $A617 weiter suchen
.,A640 18 CLC Carry löschen
.,A641 60 RTS Rücksprung
*** BASIC-Befehl NEW
.,A642 D0 FD BNE $A641 Kein Trennzeichen: SYNTAX
ERROR
.,A644 A9 00 LDA #$00 Nullcode laden
.,A646 A8 TAY und als Zähler ins Y-Reg.
.,A647 91 2B STA ($2B),Y Nullcode an Programmanfang
.,A649 C8 INY Zähler erhöhen
.,A64A 91 2B STA ($2B),Y noch einen Nullcode dahinter
.,A64C A5 2B LDA $2B Zeiger auf Programmst. (LOW)
.,A64E 18 CLC Carry löschen
.,A64F 69 02 ADC #$02 Programmstart + 2 ergibt
.,A651 85 2D STA $2D neuen Variablenstart (LOW)
.,A653 A5 2C LDA $2C Zeiger auf Programmst. (HIGH)
.,A655 69 00 ADC #$00 + Übertrag ergibt neuen
.,A657 85 2E STA $2E Variablenstart (HIGH)
.,A659 20 8E A6 JSR $A68E CHRGET, Routine neu setzen
.,A65C A9 00 LDA #$00 Zero-Flag für CLR = 1 setzen
*** BASIC-Befehl CLR
.,A65E D0 2D BNE $A68D Kein Trennzeichen: SYNTAX
ERROR
.,A660 20 E7 FF JSR $FFE7 alle I/O Kanäle zurücksetzen
.,A663 A5 37 LDA $37 Zeiger auf BASIC-RAM-Ende
.,A665 A4 38 LDY $38 (LOW/HIGH) laden
.,A667 85 33 STA $33 String-Start auf BASIC-
.,A669 84 34 STY $34 RAM-Ende setzen
.,A66B A5 2D LDA $2D Zeiger auf Variablen-
.,A66D A4 2E LDY $2E start laden
.,A66F 85 2F STA $2F und in Array-Anfangs-
.,A671 84 30 STY $30 zeiger setzen
.,A673 85 31 STA $31 und in Zeiger auf Array-
.,A675 84 32 STY $32 Ende speichern
.,A677 20 1D A8 JSR $A81D RESTORE-Befehl
.,A67A A2 19 LDX #$19 Wert laden und String-
.,A67C 86 16 STX $16 Descriptor-Index zurücksetzen
.,A67E 68 PLA 2 Bytes vom Stapel in das
.,A67F A8 TAY Y-Register und den
.,A680 68 PLA Akku holen
.,A681 A2 FA LDX #$FA Wert laden und damit
.,A683 9A TXS Stapelzeiger initialisieren
.,A684 48 PHA 2 Bytes aus dem Y-Register
.,A685 98 TYA und dem Akku wieder auf
.,A686 48 PHA den Stapel schieben
.,A687 A9 00 LDA #$00 Wert laden und damit
.,A689 85 3E STA $3E CONT sperren
.,A68B 85 10 STA $10 und in FN-Flag speichern
.,A68D 60 RTS Rücksprung
*** Programmzeiger auf
*** BASIC-Start
.,A68E 18 CLC Carry löschen (Addition)
.,A68F A5 2B LDA $2B Zeiger auf Programmstart (LOW)
.,A691 69 FF ADC #$FF minus 1 ergibt
.,A693 85 7A STA $7A neuen CHRGET-Zeiger (LOW)
.,A695 A5 2C LDA $2C Programmstart (HIGH)
.,A697 69 FF ADC #$FF minus 1 ergibt
.,A699 85 7B STA $7B CHRGET-Zeiger (HIGH)
.,A69B 60 RTS Rücksprung
*** BASIC Befehl LIST
.,A69C 90 06 BCC $A6A4 Ziffer ? (Zeilennummer)
.,A69E F0 04 BEQ $A6A4 nur LIST ?
.,A6A0 C9 AB CMP #$AB Code für '-'?
.,A6A2 D0 E9 BNE $A68D anderer Code, dann SYNTAX ERR
.,A6A4 20 6B A9 JSR $A96B Zeilennummer holen
.,A6A7 20 13 A6 JSR $A613 Startadresse berechnen
.,A6AA 20 79 00 JSR $0079 CHRGOT letztes Zeichen holen
.,A6AD F0 0C BEQ $A6BB keine Zeilennummer
.,A6AF C9 AB CMP #$AB Code für '-'?
.,A6B1 D0 8E BNE $A641 nein: SYNTAX ERROR
.,A6B3 20 73 00 JSR $0073 CHRGET nächstes Zeichen holen
.,A6B6 20 6B A9 JSR $A96B Zeilennummer holen
.,A6B9 D0 86 BNE $A641 kein Trennzeichen: SYNTAX ERR
.,A6BB 68 PLA 2 Bytes von Stapel holen
.,A6BC 68 PLA (Rücksprungadresse übergehen)
.,A6BD A5 14 LDA $14 zweite Zeilennummer laden
.,A6BF 05 15 ORA $15 gleich null ?
.,A6C1 D0 06 BNE $A6C9 Nein: $A6C9
.,A6C3 A9 FF LDA #$FF Wert laden und
.,A6C5 85 14 STA $14 zweite Zeilennummer Maximal-
.,A6C7 85 15 STA $15 wert $FFFF (65535)
.,A6C9 A0 01 LDY #$01 Zeiger setzen
.,A6CB 84 0F STY $0F und Quote Modus abschalten
.,A6CD B1 5F LDA ($5F),Y Linkadresse HIGH holen
.,A6CF F0 43 BEQ $A714 Ja: dann fertig
.,A6D1 20 2C A8 JSR $A82C prüft auf Stop-Taste
.,A6D4 20 D7 AA JSR $AAD7 "CR" ausgeben, neue Zeile
.,A6D7 C8 INY Zeiger erhöhen
.,A6D8 B1 5F LDA ($5F),Y Zeilenadresse holen (LOW)
.,A6DA AA TAX und in das X-Reg. schieben
.,A6DB C8 INY Zeiger erhöhen
.,A6DC B1 5F LDA ($5F),Y Zeilenadresse holen (HIGH)
.,A6DE C5 15 CMP $15 mit Endnummer vergleichen
.,A6E0 D0 04 BNE $A6E6 Gleich? Nein: $A6E6
.,A6E2 E4 14 CPX $14 LOW-Nummer vergleichen
.,A6E4 F0 02 BEQ $A6E8 Gleich? Ja: $A6E8
.,A6E6 B0 2C BCS $A714 Größer: dann fertig
.,A6E8 84 49 STY $49 Y-Reg. Zwischenspeichern
.,A6EA 20 CD BD JSR $BDCD Zeilennnummer ausgeben
.,A6ED A9 20 LDA #$20 ' ' Leerzeichen
.,A6EF A4 49 LDY $49 Y-Reg. wiederholen
.,A6F1 29 7F AND #$7F Bit 7 löschen
.,A6F3 20 47 AB JSR $AB47 Zeichen ausgeben
.,A6F6 C9 22 CMP #$22 '"' Hochkomma ?
.,A6F8 D0 06 BNE $A700 Nein: $A700
.,A6FA A5 0F LDA $0F Hochkomma-Flag laden,
.,A6FC 49 FF EOR #$FF umdrehen (NOT)
.,A6FE 85 0F STA $0F und wieder abspeichern
.,A700 C8 INY Zeilenende nach 255 Zeichen ?
.,A701 F0 11 BEQ $A714 Nein: dann aufhören
.,A703 B1 5F LDA ($5F),Y Zeichen holen
.,A705 D0 10 BNE $A717 kein Zeilenende, dann listen
.,A707 A8 TAY Akku als Zeiger nach Y
.,A708 B1 5F LDA ($5F),Y Startadresse der nächsten
.,A70A AA TAX Zeile holen (LOW) und nach X
.,A70B C8 INY Zeiger erhöhen
.,A70C B1 5F LDA ($5F),Y Adresse der Zeile (HIGH)
.,A70E 86 5F STX $5F als Zeiger merken
.,A710 85 60 STA $60 (speichern nach $5F/60) und
.,A712 D0 B5 BNE $A6C9 weitermachen
.,A714 4C 86 E3 JMP $E386 zum BASIC-Warmstart
*** BASIC Code in Klartext
*** umwandlen
.,A717 6C 06 03 JMP ($0306) JMP $A71A
.,A71A 10 D7 BPL $A6F3 kein Interpretercode:ausgeben
.,A71C C9 FF CMP #$FF Code für Pi?
.,A71E F0 D3 BEQ $A6F3 Ja: so ausgeben
.,A720 24 0F BIT $0F Hochkommamodus ?
.,A722 30 CF BMI $A6F3 dann Zeichen so ausgeben
.,A724 38 SEC Carry setzen (Subtraktion)
.,A725 E9 7F SBC #$7F Offset abziehen
.,A727 AA TAX Code nach X
.,A728 84 49 STY $49 Zeichenzeiger merken
.,A72A A0 FF LDY #$FF Zeiger auf Befehlstabelle
.,A72C CA DEX erstes Befehlswort?
.,A72D F0 08 BEQ $A737 Ja: ausgeben
.,A72F C8 INY Zeiger erhöhen
.,A730 B9 9E A0 LDA $A09E,Y Offset für X-tes Befehlswort
.,A733 10 FA BPL $A72F alle Zeichen bis zum letzen
.,A735 30 F5 BMI $A72C überlesen (Bit 7 gesetzt)
.,A737 C8 INY Zeiger erhöhen
.,A738 B9 9E A0 LDA $A09E,Y Befehlswort aus Tabelle holen
.,A73B 30 B2 BMI $A6EF letzter Buchstabe: fertig
.,A73D 20 47 AB JSR $AB47 Zeichen ausgeben
.,A740 D0 F5 BNE $A737 nächsten Buchstaben ausgeben
*** BASIC-Befehl FOR
.,A742 A9 80 LDA #$80 Wert laden und
.,A744 85 10 STA $10 Integer sperren
.,A746 20 A5 A9 JSR $A9A5 LET, setzt FOR-Variable
.,A749 20 8A A3 JSR $A38A sucht offene FOR-NEXT-Schlei.
.,A74C D0 05 BNE $A753 nicht gefunden: $A753
.,A74E 8A TXA X-Reg. nach Akku
.,A74F 69 0F ADC #$0F Stapelzejger erhöhen
.,A751 AA TAX Akku zurück nach X-Reg. und
.,A752 9A TXS in den Stapelzeiger
.,A753 68 PLA Rücksprungadresse vom Stapel
.,A754 68 PLA holen (LOW und HIGH)
.,A755 A9 09 LDA #$09 Wert für Prüfung laden
.,A757 20 FB A3 JSR $A3FB prüft auf Platz im Stapel
.,A75A 20 06 A9 JSR $A906 sucht nächstes BAS.-Statement
.,A75D 18 CLC Carry löschen (Addition)
.,A75E 98 TYA CHRGET-Zeiger und Offset
.,A75F 65 7A ADC $7A = Startadresse der Schleife
.,A761 48 PHA auf Stapel speichern
.,A762 A5 7B LDA $7B HIGH-Byte holen und
.,A764 69 00 ADC #$00 Übertrag addieren und
.,A766 48 PHA auf den Stapel legen
.,A767 A5 3A LDA $3A Aktuelle
.,A769 48 PHA Zeilennummer laden und auf
.,A76A A5 39 LDA $39 den Stapel schieben
.,A76C 48 PHA (LOW und HIGH-Byte)
.,A76D A9 A4 LDA #$A4 'TO' - Code
.,A76F 20 FF AE JSR $AEFF prüft auf Code
.,A772 20 8D AD JSR $AD8D prüft ob numerische Variable
.,A775 20 8A AD JSR $AD8A numerischer Ausdruck nach FAC
.,A778 A5 66 LDA $66 Vorzeichenbyte von FAC holen
.,A77A 09 7F ORA #$7F Bit 0 bis 6 setzen
.,A77C 25 62 AND $62 mit $62 angleichen
.,A77E 85 62 STA $62 und abspeichern
.,A780 A9 8B LDA #$8B Rücksprungadresse laden
.,A782 A0 A7 LDY #$A7 (LOW und HIGH)
.,A784 85 22 STA $22 und Zwischenspeichern
.,A786 84 23 STY $23 (LOW und HIGH)
.,A788 4C 43 AE JMP $AE43 Schleifenendwert auf Stapel
.,A78B A9 BC LDA #$BC Zeiger auf Konstante 1 setzen
.,A78D A0 B9 LDY #$B9 (Ersatzwert für STEP)
.,A78F 20 A2 BB JSR $BBA2 als Default-STEP-Wert in FAC
.,A792 20 79 00 JSR $0079 CHRGOT: letztes Zeichen holen
.,A795 C9 A9 CMP #$A9 'STEP' - Code?
.,A797 D0 06 BNE $A79F kein STEP-Wert: $A79F
.,A799 20 73 00 JSR $0073 CHRGET nächstes Zeichen holen
.,A79C 20 8A AD JSR $AD8A numerischer Ausdruck nach FAC
.,A79F 20 2B BC JSR $BC2B holt Vorzeichenbyte
.,A7A2 20 38 AE JSR $AE38 Vorz. und STEP-Wert auf Stack
.,A7A5 A5 4A LDA $4A Zeiger auf Variablenwert
.,A7A7 48 PHA (LOW) auf den Stapel
.,A7A8 A5 49 LDA $49 Zeiger (HIGH)
.,A7AA 48 PHA auf den Stapel
.,A7AB A9 81 LDA #$81 und FOR-Code
.,A7AD 48 PHA auf den Stapel legen
*** Interpreterschleife
.,A7AE 20 2C A8 JSR $A82C prüft auf Stop-Taste
.,A7B1 A5 7A LDA $7A CHRGET Zeiger (LOW und HIGH)
.,A7B3 A4 7B LDY $7B laden
.,A7B5 C0 02 CPY #$02 Direkt-Modus?
.,A7B7 EA NOP No OPeration
.,A7B8 F0 04 BEQ $A7BE ja: $A7BE
.,A7BA 85 3D STA $3D als Zeiger für CONT
.,A7BC 84 3E STY $3E merken
.,A7BE A0 00 LDY #$00 Zeiger setzen
.,A7C0 B1 7A LDA ($7A),Y laufendes Zeichen holen
.,A7C2 D0 43 BNE $A807 nicht Zeilenende?
.,A7C4 A0 02 LDY #$02 Zeiger neu setzen
.,A7C6 B1 7A LDA ($7A),Y Programmende?
.,A7C8 18 CLC Flag für END setzen
.,A7C9 D0 03 BNE $A7CE Kein Programmende: $A7CE
.,A7CB 4C 4B A8 JMP $A84B ja: dann END ausführen
.,A7CE C8 INY Zeiger erhöhen
.,A7CF B1 7A LDA ($7A),Y laufende Zeilennummer
.,A7D1 85 39 STA $39 (LOW) nach $39
.,A7D3 C8 INY Zeiger auf nächstes Byte
.,A7D4 B1 7A LDA ($7A),Y laufende Zeilennummer
.,A7D6 85 3A STA $3A (HIGH) nach $3A
.,A7D8 98 TYA Zeiger nach Akku
.,A7D9 65 7A ADC $7A Programmzeiger auf
.,A7DB 85 7A STA $7A Programmzeile setzen
.,A7DD 90 02 BCC $A7E1 C=0: Erhöhung umgehen
.,A7DF E6 7B INC $7B Programmzeiger (HIGH) erhöhen
.,A7E1 6C 08 03 JMP ($0308) Statement ausführen
.,A7E4 20 73 00 JSR $0073 CHRGET nächstes Zeichen holen
.,A7E7 20 ED A7 JSR $A7ED Statement ausführen
.,A7EA 4C AE A7 JMP $A7AE zurück zur Interpreterschlei.
*** BASIC-Statement ausführen
.,A7ED F0 3C BEQ $A82B Zeilenende, dann fertig
.,A7EF E9 80 SBC #$80 Token?
.,A7F1 90 11 BCC $A804 nein: dann zum LET-Befehl
.,A7F3 C9 23 CMP #$23 NEW?
.,A7F5 B0 17 BCS $A80E Funktions-Token oder GO TO
.,A7F7 0A ASL BASIC-Befehl, Code mal 2
.,A7F8 A8 TAY als Zeiger ins Y-Reg.
.,A7F9 B9 0D A0 LDA $A00D,Y Befehlsadresse (LOW und
.,A7FC 48 PHA HIGH) aus Tabelle
.,A7FD B9 0C A0 LDA $A00C,Y holen und als
.,A800 48 PHA Rücksprungadresse auf Stapel
.,A801 4C 73 00 JMP $0073 Zeichen und Befehl ausführen
.,A804 4C A5 A9 JMP $A9A5 zum LET-Befehl
.,A807 C9 3A CMP #$3A ':' ist es Doppelpunkt?
.,A809 F0 D6 BEQ $A7E1 ja: $A7E1
.,A80B 4C 08 AF JMP $AF08 sonst 'SYNTAX ERROR'
*** prüft auf 'GO' 'TO' Code
.,A80E C9 4B CMP #$4B 'GO' (minus $80)
.,A810 D0 F9 BNE $A80B nein: 'SYNTAX ERROR'
.,A812 20 73 00 JSR $0073 nächstes Zeichen holen
.,A815 A9 A4 LDA #$A4 'TO'
.,A817 20 FF AE JSR $AEFF prüft auf Code
.,A81A 4C A0 A8 JMP $A8A0 zum GOTO-Befehl
*** BASIC-Befehl RESTORE
.,A81D 38 SEC Carry setzen (Subtraktion)
.,A81E A5 2B LDA $2B Programmstartzeiger (LOW)
.,A820 E9 01 SBC #$01 laden und davon 1 abziehen
.,A822 A4 2C LDY $2C und HIGH-Byte holen
.,A824 B0 01 BCS $A827
.,A826 88 DEY LOW-Byte -1
.,A827 85 41 STA $41 als DATA-Zeiger
.,A829 84 42 STY $42 abspeichern
.,A82B 60 RTS Rücksprung
*** prüft auf Stop-Taste
.,A82C 20 E1 FF JSR $FFE1 Stop-Taste abfragen
*** BASIC-Befehl STOP
.,A82F B0 01 BCS $A832 C=1: Flag für STOP
*** BASIC-Befehl END
.,A831 18 CLC C=0 Flag für END
.,A832 D0 3C BNE $A870 RUN/STOP nicht gedrückt: RTS
.,A834 A5 7A LDA $7A Programmzeiger laden
.,A836 A4 7B LDY $7B (LOW und HIGH-Byte)
.,A838 A6 3A LDX $3A Direkt-Modus?
.,A83A E8 INX (Zeilennummer -1)
.,A83B F0 0C BEQ $A849 ja: $A849
.,A83D 85 3D STA $3D als Zeiger für CONT setzen
.,A83F 84 3E STY $3E (LOW und HIGH)
.,A841 A5 39 LDA $39 Nummer der laufenden Zeile
.,A843 A4 3A LDY $3A holen (LOW und HIGH)
.,A845 85 3B STA $3B und als Zeilennummer für
.,A847 84 3C STY $3C CONT merken
.,A849 68 PLA Rücksprungadresse
.,A84A 68 PLA vom Stapel entfernen
.,A84B A9 81 LDA #$81 Zeiger auf Startadresse
.,A84D A0 A3 LDY #$A3 BREAK setzen
.,A84F 90 03 BCC $A854 END Flag?
.,A851 4C 69 A4 JMP $A469 nein: 'BREAK IN XXX' ausgeben
.,A854 4C 86 E3 JMP $E386 zum BASIC-Warmstart
*** BASIC-Befehl CONT
.,A857 D0 17 BNE $A870 Kein Trennzeichen: SYNTAX ERR
.,A859 A2 1A LDX #$1A Fehlernr. für 'CAN'T CONTINUE
.,A85B A4 3E LDY $3E CONT gesperrt?
.,A85D D0 03 BNE $A862 nein: $A862
.,A85F 4C 37 A4 JMP $A437 Fehlermeldung ausgeben
.,A862 A5 3D LDA $3D CONT-Zeiger (LOW) laden
.,A864 85 7A STA $7A und CONT-Zeiger als Programm-
.,A866 84 7B STY $7B zeiger abspeichern
.,A868 A5 3B LDA $3B und
.,A86A A4 3C LDY $3C Zeilennummer wieder
.,A86C 85 39 STA $39 setzen
.,A86E 84 3A STY $3A (LOW- und HIGH-Byte)
.,A870 60 RTS Rücksprung
*** BASIC-Befehl RUN
.,A871 08 PHP Statusregister retten
.,A872 A9 00 LDA #$00 Wert laden und
.,A874 20 90 FF JSR $FF90 Flag für Programmodus setzen
.,A877 28 PLP Statusregister zurückholen
.,A878 D0 03 BNE $A87D weitere Zeichen (Zeilennr.)?
.,A87A 4C 59 A6 JMP $A659 Programmzeiger setzen, CLR
.,A87D 20 60 A6 JSR $A660 CLR-Befehl
.,A880 4C 97 A8 JMP $A897 GOTO-Befehl
*** BASIC-Befehl GOSUB
.,A883 A9 03 LDA #$03 Wert für Prüfung
.,A885 20 FB A3 JSR $A3FB prüft auf Platz im Stapel
.,A888 A5 7B LDA $7B Programmzeiger (LOW-
.,A88A 48 PHA und HIGH-Byte) laden
.,A88B A5 7A LDA $7A und auf den
.,A88D 48 PHA Stapel retten
.,A88E A5 3A LDA $3A Zeilennummer laden (HIGH)
.,A890 48 PHA und auf den Stapel legen
.,A891 A5 39 LDA $39 Zeilennummer LOW laden
.,A893 48 PHA und auf den Stapel legen
.,A894 A9 8D LDA #$8D 'GOSUB'-Code laden
.,A896 48 PHA und auf den Stapel legen
.,A897 20 79 00 JSR $0079 CHRGOT: letztes Zeichen holen
.,A89A 20 A0 A8 JSR $A8A0 GOTO-Befehl
.,A89D 4C AE A7 JMP $A7AE zur Interpreterschleife
*** BASIC-Befehl GOTO
.,A8A0 20 6B A9 JSR $A96B Zeilennummer nach $14/$15
.,A8A3 20 09 A9 JSR $A909 nächsten Zeilenanfang suchen
.,A8A6 38 SEC Carry setzen (Subtraktion)
.,A8A7 A5 39 LDA $39 aktuelle Zeilennummer (LOW)
.,A8A9 E5 14 SBC $14 kleiner als laufende Zeile?
.,A8AB A5 3A LDA $3A aktuelle Zeilennummer (HIGH)
.,A8AD E5 15 SBC $15 kleiner als laufende Zeile?
.,A8AF B0 0B BCS $A8BC nein: $A8BC
.,A8B1 98 TYA Differenz in Akku
.,A8B2 38 SEC Carry setzen (Addition)
.,A8B3 65 7A ADC $7A Programmzeiger addieren
.,A8B5 A6 7B LDX $7B sucht ab laufender Zeile
.,A8B7 90 07 BCC $A8C0 unbedingter
.,A8B9 E8 INX Sprung
.,A8BA B0 04 BCS $A8C0 zu $A8C0
.,A8BC A5 2B LDA $2B sucht ab Programmstart
.,A8BE A6 2C LDX $2C
.,A8C0 20 17 A6 JSR $A617 sucht Programmzeile
.,A8C3 90 1E BCC $A8E3 nicht gefunden: 'undef'd st.'
.,A8C5 A5 5F LDA $5F von der Startadresse (Zeile)
.,A8C7 E9 01 SBC #$01 eins subtrahieren und als
.,A8C9 85 7A STA $7A Programmzeiger (LOW)
.,A8CB A5 60 LDA $60 HIGH-Byte der Zeile laden
.,A8CD E9 00 SBC #$00 Übertrag berücksichtigen
.,A8CF 85 7B STA $7B und als Programmzeiger
.,A8D1 60 RTS Rücksprung
*** BASIC-Befehl RETURN
.,A8D2 D0 FD BNE $A8D1 Kein Trennzeichen: SYNTAX ERR
.,A8D4 A9 FF LDA #$FF Wert laden und
.,A8D6 85 4A STA $4A FOR-NEXT-ZEIGER neu setzen
.,A8D8 20 8A A3 JSR $A38A GOSUB-Datensatz suchen
.,A8DB 9A TXS
.,A8DC C9 8D CMP #$8D 'GOSUB'-Code?
.,A8DE F0 0B BEQ $A8EB ja: $A8E8