home *** CD-ROM | disk | FTP | other *** search
/ The AGA Experience 2 / agavol2.iso / software / utilities / emulation / frodo / src / 6510.asm < prev    next >
Assembly Source File  |  1996-01-29  |  61KB  |  3,396 lines
  1. *
  2. * 6510.asm - 6510-Emulation (eigener Task)
  3. *
  4. * Copyright (C) 1994-1996 by Christian Bauer
  5. *
  6.  
  7. *
  8. * Anmerkungen:
  9. * ------------
  10. *
  11. * Register d0/d1/a4 - WICHTIG:
  12. *  - Der Emulator geht davon aus, daß die MSWs von d0 und d1 immer Null
  13. *    sind. Denn dadurch kann das C64-RAM mittels (RAMPTR,d0.l) ohne
  14. *    Vorzeichen indiziert angesprochen werden.
  15. *  - Die Makros Read#?Zero#? und Read#?Ind#? gehen zusätlich davon aus,
  16. *    daß nur das untere Byte von d0 Null ist, da diese Makros immer nur
  17. *    am Anfang eines Befehls stehen und d0 vom Next-Makro noch gelöscht
  18. *    ist
  19. *  - Register a4 wird zur Near-Adressierung verwendet
  20. *
  21. * Speicherkonfigurationen:
  22. *
  23. * $01  $a000-$bfff  $d000-$dfff  $e000-$ffff
  24. * -----------------------------------------------
  25. *  0       RAM          RAM          RAM
  26. *  1       RAM       Char-ROM        RAM
  27. *  2       RAM       Char-ROM    Kernal-ROM
  28. *  3    Basic-ROM    Char-ROM    Kernal-ROM
  29. *  4       RAM          RAM          RAM
  30. *  5       RAM          I/O          RAM
  31. *  6       RAM          I/O      Kernal-ROM
  32. *  7    Basic-ROM       I/O      Kernal-ROM
  33. *
  34. * Zugriff auf den C64-Speicher:
  35. *  - Fast alle Speicherzugriffe laufen über die ReadByte/WriteByte-Makros,
  36. *    die die eingestellte Speicherkonfiguration dadurch berücksichtigen,
  37. *    daß die oberen 8 Adreßbits als Index in eine Sprungtabelle
  38. *    (ReadWriteTab) dienen, die Zeiger auf die ReadByte*/WriteByte*-
  39. *    Routinen enthalten, über die der tatsächliche Zugriff erfolgt.
  40. *    Für jede der 8 Speicherkonfigurationen existiert jeweils eine solche
  41. *    Tabelle Bei einer Änderung der Speicherkonfiguration (NewConfig)
  42. *    wird der Zeiger auf die Tabelle (RWTAB) geändert.
  43. *  - Das LESEN aus der Zero-Page geschieht immer direkt,
  44. *    da dort keine Register liegen ($00/$01 werden auch im RAM abgelegt)
  45. *  - Beim Schreiben in die Zero-Page wird nur auf $00/$01 getestet,
  46. *    ansonsten direkt zugegriffen
  47. *  - Der Stack wird immer direkt angesprochen
  48. *  - Die ReadByte-/WriteByte-Routinen dürfen nur d0-d1/a0-a1 verändern
  49. *
  50. * Programmzähler:
  51. *  - Aus Geschwindigkeitsgründen wird der PC durch einen 32-Bit-
  52. *    Amiga-Zeiger repräsentiert und über diesen direkt auf den
  53. *    Speicher zugegriffen (und nicht über ReadByte). Bei einem
  54. *    Sprungbefehl wird aus dem 16-Bit Sprungziel und der aktuellen
  55. *    Speicherkonfiguration die neue 32-Bit-Adresse berechnet,
  56. *    indem ähnlich zur ReadWriteTab die oberen 8 Bit des Sprungziels
  57. *    als Index in die JumpTab verwendet werden. Die darüber aufgerufenen
  58. *    Routinen führen die Umrechnung durch.
  59. *  - Durch die Art, wie das Hauptprogramm den Speicher anfordert,
  60. *    entsprechen die unteren 16 Bit des 32-Bit-PCs immer der
  61. *    16-Bit-C64-Adresse. Das erleichtert erheblich das Ablegen des
  62. *    PC auf dem Stack, da dazu einfach nur die unteren 16 Bit
  63. *    genommen werden müssen (ansonsten müßte man je nach RAM/ROM-
  64. *    Bereich erst die jeweilige Basisadresse subtrahieren).
  65. *  - Im RAM-Bereich $10000-$100ff wird der Opcode $d2 installiert,
  66. *    der den PC auf $0000-$00ff umrechnet, falls ein Programm den
  67. *    Wraparound macht
  68. *  - Durch diese Art der PC-Verwaltung bestehen folgende Inkompatibilitäten:
  69. *     - Ein Branch oder ein Hineinlaufen in einen anderen Speicherbereich
  70. *       (z.B. RAM->ROM) funktioniert nicht. Das sollte allerdings kein
  71. *       Problem darstellen.
  72. *     - Ein Sprung in den I/O-Bereich ist z.Z. nicht möglich
  73. *
  74. * Condition-Codes:
  75. *  - Die Emulation verwendet zwei Register, um die Prozessorflags zu
  76. *    speichern: RCCR und RP.
  77. *  - RCCR ist ein Abbild des 680x0-CCR und wird nach den entsprechenden
  78. *    Operationen mit "move ccr,RCCR" gelesen. Von RCCR werden nur das N-
  79. *    und das Z-Flag verwendet.
  80. *  - Die einzigen Opcodes, die V ändern, sind ADC, SBC, CLV, PLP und RTI.
  81. *    Darum wird das V-Flag nicht aus dem 680x0-V-Flag erzeugt, sondern
  82. *    gegebenenfalls von Hand gesetzt.
  83. *  - Im oberen Byte (Bit 8-15) von RP sind die 6510-Flags V,B,D und I
  84. *    in der selben Anordnung wie beim 6510 gespeichert. Das untere Byte
  85. *    enthält in Bit 0 das Carry-Flag in 6510-Interpretation (bei SBC und
  86. *    CMP/CPX/CPY inverse Bedeutung zum 680x0), das bei den entsprechenden
  87. *    Opcodes aus dem CCR gelesen (und ggf. invertiert) wird. Der Einfachheit
  88. *    halber wird immer das ganze untere Byte von CCR gelesen, da nur Bit 0
  89. *    interessant ist.
  90. *
  91. * Opcode-Ausführung:
  92. *  - Es gibt keine Fetch-Decode-Schleife, sondern jede Opcode-Routine
  93. *    enthält am Schluß den Code, der den nächsten Befehl ausführt
  94. *    ("Next"-Makro).
  95. *  - Die Verzweigung in die einzelnen Opcode-Routinen geschieht über
  96. *    eine Sprungtabelle, die OpcodeTable.
  97. *
  98. * Zyklenzähler/Periodic/Interrupts:
  99. *  - Die Variable CyclesLeft enthält die Anzahl Zyklen, die dem 6510 in
  100. *    der augenblicklichen Rasterzeile noch zur Verfügung stehen.
  101. *  - Ein Zeiger auf CyclesLeft steht in (CYCPTR) (wg. schnellerer
  102. *    Adressierung).
  103. *  - Nach jeder Opcode-Ausführung wird dieser Zähler um die Zyklenzahl
  104. *    des gerade ausgeführten Befehls erniedrigt. Dazu wird dem Next-Makro
  105. *    die Anzahl Zyklen übergeben. Unterschreitet der Zähler Null, wird
  106. *    die Routine "Periodic" aufgerufen.
  107. *  - In dieser Routine werden die Unterroutinen von VIC und CIA
  108. *    ausgeführt, die die Aktionen für eine Rasterzeile durchführen
  109. *    (VIC (Periodic6569): Eine Bildschirmzeile aufbauen, CIA
  110. *    (Periodic6526): Timer zählen)
  111. *  - In Periodic6569 wird der Zyklenzähler neu gesetzt (der Wert hängt
  112. *    davon ab, ob eine Bad Line stattfand oder nicht)
  113. *
  114. * Interrupts:
  115. *  - Die Haupt-Interruptquellen sind VIC und CIA, daher prüft der
  116. *    Emulator das Auftreten eines Interrupts im Rahmen der Periodic-
  117. *    Routine
  118. *  - Es gibt folgende Interrupt-Möglichkeiten (Prioritäten):
  119. *     - RESET, Sprung nach ($FFFC) oder 6510-Task beenden (RESETIsEXIT-Flag)
  120. *     - NMI, Sprung nach ($FFFA)
  121. *     - VIC-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  122. *     - CIA-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  123. *  - Die Aufteilung in VIC- und CIA-IRQ erleichtert die Handhabung, wenn
  124. *    beide IRQs gleichzeitig auftreten
  125. *  - Die einzige Möglichkeit, außerhalb des Periodic einen Interrupt
  126. *    auszulösen, ist das Löschen des I-Flags, wenn ein IRQ ansteht.
  127. *    Die Opcode-Routinen für PLP, RTI und CLI enthalten deswegen besondere
  128. *    Abfragen, die ggf. in den Interrupt-Handler verzweigen.
  129. *
  130. * Erweiterungen:
  131. *  - Über den Opcode $f2 sind die IEC-Routinen implementiert. Dem Opcode
  132. *    folgt ein Byte, das die Nummer der auzurufenden Routine angibt.
  133. *
  134. * Inkompatibilitäten:
  135. *  - ($ff),Y-Adressierung liest das zweite Byte der indirekten Adresse
  136. *    aus $0100 statt $0000. Dies geschieht aus Geschwindigkeitsgründen,
  137. *    der korrekte Code ist im Makro ReadAdrIndY auskommentiert.
  138. *  - In der Verwaltung des PCs bestehen einige Ungenauigkeiten (siehe
  139. *    Abschnitt "Programmzähler")
  140. *  - RMW-Befehle sollten erst die Originaldaten und dann die geänderten
  141. *    schreiben, aber das spielt nur eine Rolle für Register wie das
  142. *    VIC-IRQFLAG-Register, das in 6569.asm deswegen speziell behandelt wird
  143. *  - Zyklen werden nur für ganze Befehle gezählt, Extra-Zyklen für
  144. *    Seitenüberschreitungen werden nicht berechnet (dies betrifft die
  145. *    Adressierungsarten xxxx,X xxxx,Y (xx),Y und die Branch-Befehle)
  146. *  - Der Kassettenschalter ist immer geschlossen
  147. *  - RRA und ISB kennen keinen Dezimalmodus
  148. *
  149.  
  150.         MACHINE    68020
  151.  
  152.         INCLUDE    "exec/types.i"
  153.         INCLUDE    "exec/macros.i"
  154.         INCLUDE    "exec/execbase.i"
  155.         INCLUDE    "exec/nodes.i"
  156.         INCLUDE    "dos/dos.i"
  157.         INCLUDE    "dos/dostags.i"
  158.         INCLUDE    "Frodo_rev.i"
  159. CATCOMP_NUMBERS    = 1
  160.         INCLUDE    "LocStrings.i"
  161.  
  162.         XREF    _SysBase
  163.         XREF    _DOSBase
  164.         XREF    _IntuitionBase
  165.  
  166.         XREF    GetString    ;Strings.o
  167.         XREF    TheLocale
  168.  
  169.         XDEF    TheRAM        ;Main.asm
  170.         XDEF    TheBasic
  171.         XDEF    TheKernal
  172.         XDEF    TheChar
  173.         XDEF    TheColor
  174.         XREF    MainTask
  175.         XREF    Random
  176.         XREF    ResetC64
  177.  
  178.         XREF    _InitDisplayFrom6510    ;Display.c
  179.         XREF    _ExitDisplayFrom6510
  180.         XREF    _EmulToBack
  181.         XREF    _EmulToFront
  182.  
  183.         XREF    ReadFrom6526A    ;6526.asm
  184.         XREF    ReadFrom6526B
  185.         XREF    WriteTo6526A
  186.         XREF    WriteTo6526B
  187.  
  188.         XREF    ReadFrom6569    ;6569.asm
  189.         XREF    WriteTo6569
  190.         XREF    Periodic6569
  191.  
  192.         XREF    ReadFrom6581    ;6581.asm
  193.         XREF    WriteTo6581
  194.  
  195.         XREF    IECOut        ;IEC.asm
  196.         XREF    IECOutATN
  197.         XREF    IECOutSec
  198.         XREF    IECIn
  199.         XREF    IECSetATN
  200.         XREF    IECRelATN
  201.         XREF    IECTurnaround
  202.         XREF    IECRelease
  203.  
  204.         XDEF    Init6510
  205.         XDEF    Reset6510
  206.         XDEF    Start6510
  207.         XDEF    Stop6510
  208.         XDEF    _Pause6510
  209.         XDEF    _Resume6510
  210.         XDEF    _SAMReadByte
  211.         XDEF    _SAMWriteByte
  212.         XDEF    Localize6510
  213.         XDEF    IntIsRESET
  214.         XDEF    IntIsNMI
  215.         XDEF    IntIsVICIRQ
  216.         XDEF    IntIsCIAIRQ
  217.         XDEF    NMIState
  218.         XDEF    CyclesLeft
  219.         XDEF    CPUTask
  220.         XDEF    Peri6569Cont
  221.         XDEF    Peri6526Cont
  222.         XDEF    IsFrodoSC
  223.         XDEF    _IsFrodoSC
  224.         XDEF    _InvokeSAMSet
  225.  
  226.         NEAR    a4,-2
  227.         XREF    _DATA_BAS_
  228.  
  229.         SECTION    "text",CODE
  230.  
  231.         FAR
  232.  
  233.  
  234. **
  235. ** Definitionen
  236. **
  237.  
  238. ; Bitdefinitionen für RP (6510-Statusregister)
  239. InterruptBit    = 10    ;Interrupts abgeschaltet
  240. InterruptMask    = $0400
  241. DecimalBit    = 11    ;Dezimalmodus
  242. DecimalMask    = $0800
  243. OverflowBit    = 14    ;Arith. Überlauf
  244. OverflowMask    = $4000
  245.  
  246. ; Registerbelegung
  247. RA        EQUR    d2    ;A
  248. RX        EQUR    d3    ;X
  249. RY        EQUR    d4    ;Y
  250. RS        EQUR    d5    ;S (16-Bit, $01xx)
  251. RCCR        EQUR    d6    ;CCR, nur N und Z
  252. RP        EQUR    d7    ;Oberes Byte: 6510-Status ohne N,Z und C
  253.                 ;Unteres Byte: Carry in 6510-Interpretation
  254. RWTAB        EQUR    a2    ;Zeiger auf ReadByte/WriteByte-Sprungtabelle
  255.                 ;256*8*8+RWTAB zeigt auf JumpTab
  256. CYCPTR        EQUR    a3    ;Zeiger auf CyclesLeft
  257. RAMPTR        EQUR    a5    ;Zeiger auf C64-RAM
  258. RPC        EQUR    a6    ;PC (32-Bit Amiga-Adresse, untere 16 Bit
  259.                 ;    stimmen mit C64-PC überein)
  260.  
  261.  
  262. **
  263. ** Emulation vorbereiten (Sprungtabellen aufbauen)
  264. **
  265.  
  266. ; ReadWriteTabs aufbauen
  267. Init6510    lea    ReadWriteTab0,a0    ;Alle mit RAM vorbelegen
  268.         move.w    #256*8-1,d0
  269. 1$        move.l    #ReadByteRAM,(a0)+
  270.         move.l    #WriteByteRAM,(a0)+
  271.         dbra    d0,1$
  272.  
  273.         move.l    #WriteBytePage0,ReadWriteTab0+4 ;Zeropage immer speziell
  274.         move.l    #WriteBytePage0,ReadWriteTab1+4
  275.         move.l    #WriteBytePage0,ReadWriteTab2+4
  276.         move.l    #WriteBytePage0,ReadWriteTab3+4
  277.         move.l    #WriteBytePage0,ReadWriteTab4+4
  278.         move.l    #WriteBytePage0,ReadWriteTab5+4
  279.         move.l    #WriteBytePage0,ReadWriteTab6+4
  280.         move.l    #WriteBytePage0,ReadWriteTab7+4
  281.  
  282.         lea    ReadWriteTab3+160*8,a0    ;Basic-ROM
  283.         moveq    #31,d0
  284. 21$        move.l    #ReadByteBasic,(a0)+
  285.         addq.l    #4,a0
  286.         dbra    d0,21$
  287.  
  288.         lea    ReadWriteTab7+160*8,a0
  289.         moveq    #31,d0
  290. 22$        move.l    #ReadByteBasic,(a0)+
  291.         addq.l    #4,a0
  292.         dbra    d0,22$
  293.  
  294.         lea    ReadWriteTab2+224*8,a0    ;Kernal-ROM
  295.         moveq    #31,d0
  296. 31$        move.l    #ReadByteKernal,(a0)+
  297.         addq.l    #4,a0
  298.         dbra    d0,31$
  299.  
  300.         lea    ReadWriteTab3+224*8,a0
  301.         moveq    #31,d0
  302. 32$        move.l    #ReadByteKernal,(a0)+
  303.         addq.l    #4,a0
  304.         dbra    d0,32$
  305.  
  306.         lea    ReadWriteTab6+224*8,a0
  307.         moveq    #31,d0
  308. 33$        move.l    #ReadByteKernal,(a0)+
  309.         addq.l    #4,a0
  310.         dbra    d0,33$
  311.  
  312.         lea    ReadWriteTab7+224*8,a0
  313.         moveq    #31,d0
  314. 34$        move.l    #ReadByteKernal,(a0)+
  315.         addq.l    #4,a0
  316.         dbra    d0,34$
  317.  
  318.         lea    ReadWriteTab5+208*8,a0    ;I/O-Bereich
  319.         bsr    InitIOPages
  320.  
  321.         lea    ReadWriteTab6+208*8,a0
  322.         bsr    InitIOPages
  323.  
  324.         lea    ReadWriteTab7+208*8,a0
  325.         bsr    InitIOPages
  326.  
  327.         lea    ReadWriteTab1+208*8,a0    ;Char-ROM
  328.         moveq    #15,d0
  329. 41$        move.l    #ReadByteChar,(a0)+
  330.         addq.l    #4,a0
  331.         dbra    d0,41$
  332.  
  333.         lea    ReadWriteTab2+208*8,a0
  334.         moveq    #15,d0
  335. 42$        move.l    #ReadByteChar,(a0)+
  336.         addq.l    #4,a0
  337.         dbra    d0,42$
  338.  
  339.         lea    ReadWriteTab3+208*8,a0
  340.         moveq    #15,d0
  341. 43$        move.l    #ReadByteChar,(a0)+
  342.         addq.l    #4,a0
  343.         dbra    d0,43$
  344.  
  345. ; JumpTabs aufbauen
  346.         lea    JumpTab0,a0        ;Alle mit RAM vorbelegen
  347.         move.w    #256*8-1,d0
  348. 6$        move.l    #JumpToRAM,(a0)+
  349.         addq.l    #4,a0
  350.         dbra    d0,6$
  351.  
  352.         lea    JumpTab3+160*8,a0    ;Basic-ROM
  353.         moveq    #31,d0
  354. 71$        move.l    #JumpToBasic,(a0)+
  355.         addq.l    #4,a0
  356.         dbra    d0,71$
  357.  
  358.         lea    JumpTab7+160*8,a0
  359.         moveq    #31,d0
  360. 72$        move.l    #JumpToBasic,(a0)+
  361.         addq.l    #4,a0
  362.         dbra    d0,72$
  363.  
  364.         lea    JumpTab2+224*8,a0    ;Kernal-ROM
  365.         moveq    #31,d0
  366. 81$        move.l    #JumpToKernal,(a0)+
  367.         addq.l    #4,a0
  368.         dbra    d0,81$
  369.  
  370.         lea    JumpTab3+224*8,a0
  371.         moveq    #31,d0
  372. 82$        move.l    #JumpToKernal,(a0)+
  373.         addq.l    #4,a0
  374.         dbra    d0,82$
  375.  
  376.         lea    JumpTab6+224*8,a0
  377.         moveq    #31,d0
  378. 83$        move.l    #JumpToKernal,(a0)+
  379.         addq.l    #4,a0
  380.         dbra    d0,83$
  381.  
  382.         lea    JumpTab7+224*8,a0
  383.         moveq    #31,d0
  384. 84$        move.l    #JumpToKernal,(a0)+
  385.         addq.l    #4,a0
  386.         dbra    d0,84$
  387.  
  388.         lea    JumpTab1+208*8,a0    ;Char-ROM
  389.         moveq    #15,d0
  390. 85$        move.l    #JumpToChar,(a0)+
  391.         addq.l    #4,a0
  392.         dbra    d0,85$
  393.  
  394.         lea    JumpTab2+208*8,a0
  395.         moveq    #15,d0
  396. 86$        move.l    #JumpToChar,(a0)+
  397.         addq.l    #4,a0
  398.         dbra    d0,86$
  399.  
  400.         lea    JumpTab3+208*8,a0
  401.         moveq    #15,d0
  402. 87$        move.l    #JumpToChar,(a0)+
  403.         addq.l    #4,a0
  404.         dbra    d0,87$
  405.  
  406.         lea    JumpTab5+208*8,a0    ;I/O-Bereich
  407.         moveq    #15,d0
  408. 88$        move.l    #JumpToIO,(a0)+
  409.         addq.l    #4,a0
  410.         dbra    d0,88$
  411.  
  412.         lea    JumpTab6+208*8,a0
  413.         moveq    #15,d0
  414. 89$        move.l    #JumpToIO,(a0)+
  415.         addq.l    #4,a0
  416.         dbra    d0,89$
  417.  
  418.         lea    JumpTab7+208*8,a0
  419.         moveq    #15,d0
  420. 810$        move.l    #JumpToIO,(a0)+
  421.         addq.l    #4,a0
  422.         dbra    d0,810$
  423.         rts
  424.  
  425. InitIOPages    move.l    #ReadByteVIC,(a0)+
  426.         move.l    #WriteByteVIC,(a0)+
  427.         move.l    #ReadByteVIC,(a0)+
  428.         move.l    #WriteByteVIC,(a0)+
  429.         move.l    #ReadByteVIC,(a0)+
  430.         move.l    #WriteByteVIC,(a0)+
  431.         move.l    #ReadByteVIC,(a0)+
  432.         move.l    #WriteByteVIC,(a0)+
  433.         move.l    #ReadByteSID,(a0)+
  434.         move.l    #WriteByteSID,(a0)+
  435.         move.l    #ReadByteSID,(a0)+
  436.         move.l    #WriteByteSID,(a0)+
  437.         move.l    #ReadByteSID,(a0)+
  438.         move.l    #WriteByteSID,(a0)+
  439.         move.l    #ReadByteSID,(a0)+
  440.         move.l    #WriteByteSID,(a0)+
  441.         move.l    #ReadByteColor,(a0)+
  442.         move.l    #WriteByteColor,(a0)+
  443.         move.l    #ReadByteColor,(a0)+
  444.         move.l    #WriteByteColor,(a0)+
  445.         move.l    #ReadByteColor,(a0)+
  446.         move.l    #WriteByteColor,(a0)+
  447.         move.l    #ReadByteColor,(a0)+
  448.         move.l    #WriteByteColor,(a0)+
  449.         move.l    #ReadByteCIA1,(a0)+
  450.         move.l    #WriteByteCIA1,(a0)+
  451.         move.l    #ReadByteCIA2,(a0)+
  452.         move.l    #WriteByteCIA2,(a0)+
  453.         move.l    #ReadByteUndef,(a0)+
  454.         move.l    #WriteByteUndef,(a0)+
  455.         move.l    #ReadByteUndef,(a0)+
  456.         move.l    #WriteByteUndef,(a0)
  457.         rts
  458.  
  459.  
  460. **
  461. ** 6510 zurücksetzen
  462. **
  463.  
  464. Reset6510    st.b    IntIsRESET
  465.         rts
  466.  
  467.  
  468. **
  469. ** 6510-Task starten
  470. ** Rückgabe: d0#0 = Fehler
  471. **
  472.  
  473. ; Signale einrichten
  474. Start6510    move.l    _SysBase,a6
  475.         moveq    #-1,d0
  476.         JSRLIB    AllocSignal
  477.         move.b    d0,ReadySig
  478.         moveq    #0,d1
  479.         bset    d0,d1
  480.         move.l    d1,ReadySet
  481.  
  482.         moveq    #-1,d0
  483.         JSRLIB    AllocSignal
  484.         move.b    d0,InvokeSAMSig
  485.         moveq    #0,d1
  486.         bset    d0,d1
  487.         move.l    d1,InvokeSAMSet
  488.  
  489. ; Task starten
  490.         move.l    _DOSBase,a6
  491.         move.l    #ProcTags,d1
  492.         JSRLIB    CreateNewProc
  493.         move.l    d0,CPUProc
  494.         beq    1$
  495.  
  496. ; Auf Signal warten
  497.         move.l    _SysBase,a6
  498.         move.l    ReadySet,d0
  499.         JSRLIB    Wait
  500.         moveq    #0,d0        ;Alles OK
  501.         rts
  502.  
  503. ; Fehler aufgetreten
  504. 1$        moveq    #-1,d0
  505.         rts
  506.  
  507.  
  508. **
  509. ** 6510-Task stoppen
  510. **
  511.  
  512. ; Task stoppen
  513. Stop6510    move.l    _SysBase,a6
  514.         tst.l    CPUProc
  515.         beq    1$
  516.         st.b    RESETIsEXIT    ;EXIT-Reset auslösen
  517.         st.b    IntIsRESET
  518.         move.l    ReadySet,d0
  519.         JSRLIB    Wait
  520.  
  521. ; Signale freigeben
  522. 1$        move.b    InvokeSAMSig,d0
  523.         JSRLIB    FreeSignal
  524.  
  525.         move.b    ReadySig,d0
  526.         JMPLIB    FreeSignal
  527.  
  528.  
  529. **
  530. ** 6510-Task anhalten, Zustand sichern
  531. **
  532.  
  533. _Pause6510    move.l    a6,-(sp)
  534.         move.l    _SysBase,a6
  535.         st.b    RESETIsPause    ;Pause-Reset auslösen
  536.         st.b    IntIsRESET
  537.         move.l    ReadySet,d0
  538.         JSRLIB    Wait
  539.         move.l    (sp)+,a6
  540.         rts
  541.  
  542.  
  543. **
  544. ** 6510-Task fortsetzen, Zustand übernehmen
  545. **
  546.  
  547. _Resume6510    move.l    a6,-(sp)
  548.         move.l    _SysBase,a6
  549.         move.l    CPUTask,a1    ;Continue-Signal schicken
  550.         move.l    ContinueSet,d0
  551.         JSRLIB    Signal
  552.         move.l    (sp)+,a6
  553.         rts
  554.  
  555.  
  556. **
  557. ** Byte lesen (für SAM)
  558. **
  559.  
  560. _SAMReadByte    moveq    #0,d0
  561.         move.w    6(sp),d0
  562.         movem.l    d2/a4/RAMPTR,-(sp)
  563.         lea    _DATA_BAS_,a4
  564.         lea    32766(a4),a4
  565.         move.l    TheRAM,RAMPTR
  566.         move.l    d0,d1
  567.         lsr.w    #8,d1
  568.         move.b    _SAMMemConfig,d2
  569.         and.w    #7,d2
  570.         move.l    (ConfigTab,d2.w*4),a0
  571.         move.l    (a0,d1.w*8),a0
  572.         jsr    (a0)
  573.         movem.l    (sp)+,d2/a4/RAMPTR
  574.         rts
  575.  
  576.  
  577. **
  578. ** Byte schreiben (für SAM)
  579. **
  580.  
  581. _SAMWriteByte    moveq    #0,d0
  582.         move.w    6(sp),d0
  583.         move.l    8(sp),d1
  584.         cmp.w    #$d000,d0
  585.         blo    1$
  586.         movem.l    d2/a4/RAMPTR,-(sp)
  587.         lea    _DATA_BAS_,a4
  588.         lea    32766(a4),a4
  589.         move.l    TheRAM,RAMPTR
  590.         move.l    d0,a1
  591.         lsr.w    #8,d0
  592.         move.b    _SAMMemConfig,d2
  593.         and.w    #7,d2
  594.         move.l    (ConfigTab,d2.w*4),a0
  595.         move.l    (4,a0,d0.w*8),a0
  596.         jsr    (a0)
  597.         movem.l    (sp)+,d2/a4/RAMPTR
  598.         rts
  599. 1$        move.l    TheRAM,a0
  600.         move.b    d1,(a0,d0.l)
  601.         rts
  602.  
  603.  
  604. **
  605. ** Strings in Datenstrukturen lokalisieren
  606. **
  607.  
  608. GetStr        MACRO    ;Label
  609.         lea    TheLocale,a0
  610.         move.l    #\1,d0
  611.         jsr    GetString
  612.         ENDM
  613.  
  614. Localize6510    GetStr    MSG_REQTITLE
  615.         move.l    d0,IllegalOpReq+8
  616.         move.l    d0,JumpToIOReq+8
  617.  
  618.         GetStr    MSG_REQGADS6
  619.         move.l    d0,IllegalOpReq+16
  620.  
  621.         GetStr    MSG_REQGADS4
  622.         move.l    d0,JumpToIOReq+16
  623.  
  624.         GetStr    MSG_ILLEGALOP
  625.         move.l    d0,IllegalOpReq+12
  626.  
  627.         GetStr    MSG_JUMPTOIO
  628.         move.l    d0,JumpToIOReq+12
  629.         rts
  630.  
  631.  
  632. **
  633. ** 6510-Emulator
  634. **
  635. ** Register:
  636. **  d0: Scratch (Oberes Wort muß IMMER Null sein!)
  637. **  d1: Scratch (Oberes Wort muß IMMER Null sein!)
  638. **  a4: Zeiger auf Variablen
  639. **
  640.  
  641.         NEAR
  642.  
  643. *
  644. * Makros für Speicherzugriffe und Adreßberechnungen
  645. *
  646.  
  647. ; Ein C64-Byte lesen
  648. ; -> d0.w: Adresse
  649. ; <- d0.b: Byte
  650. ReadByte    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  651.         cmp.w    #$a000,d0    ;Unterhalb von $a000 ist nur Speicher
  652.         blo    \@1$
  653.         move.w    d0,d1
  654.         lsr.w    #8,d1
  655.         move.l    (RWTAB,d1.l*8),a0
  656.         jsr    (a0)
  657.     IFGE    NARG-1
  658.         move.b    d0,\1
  659.     ENDC
  660.         bra    \@2$
  661. \@1$
  662.     IFGE    NARG-1
  663.         move.b    (RAMPTR,d0.l),\1
  664.     ELSE
  665.         move.b    (RAMPTR,d0.l),d0
  666.     ENDC
  667. \@2$
  668.         ENDM
  669.  
  670. ; Ein C64-Wort lesen (Als Makro schneller)
  671. ; -> d0.w: Adresse
  672. ; <- d0.w: Wort (Bytefolge korrigiert)
  673. ReadWord    MACRO
  674.         move.l    d2,RegStore
  675.         move.l    d0,d2        ;Adresse merken
  676.         ReadByte d1
  677.         move.l    d2,d0        ;Adresse zurückholen
  678.         addq.w    #1,d0        ;Nächstes Byte
  679.         move.b    d1,d2        ;Lo-Byte merken
  680.         ReadByte
  681.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  682.         move.b    d2,d0        ;Lo-Byte dazunehmen
  683.         move.l    RegStore,d2
  684.         ENDM
  685.  
  686. ; Ein C64-Byte schreiben
  687. ; -> d0.w: Adresse (16 bit)
  688. ; -> d1.b: Byte
  689. ; Adresse steht dann in a1
  690. WriteByte    MACRO
  691.         cmp.w    #$d000,d0    ;Unterhalb von $d000 ist nur Speicher
  692.         blo    \@1$
  693.         move.l    d0,a1
  694.         lsr.w    #8,d0
  695.         move.l    (4,RWTAB,d0.l*8),a0
  696.         jsr    (a0)
  697.         bra    \@2$
  698. \@1$        move.b    d1,(RAMPTR,d0.l)
  699.         cmp.b    #2,d0
  700.         bhs    \@2$
  701.         NewConfig
  702. \@2$
  703.         ENDM
  704.  
  705. ; Ein C64-Wort am PC lesen und PC erhöhen
  706. ReadPCWord    MACRO
  707.         move.w    (RPC)+,d0
  708.         rol.w    #8,d0
  709.         ENDM
  710.  
  711. ; Relative Adressierung
  712. ReadByteRel    MACRO
  713.         move.b    (RPC)+,d0
  714.         ext.w    d0
  715.         ENDM
  716.  
  717. ; Absolute Adressierung
  718. ReadAdrAbs    MACRO
  719.         ReadPCWord
  720.         ENDM
  721.  
  722. ReadByteAbs    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  723.         ReadAdrAbs
  724.         ReadByte \1
  725.         ENDM
  726.  
  727. ; Indirekte Adressierung
  728. ReadAdrInd    MACRO
  729.         ReadPCWord
  730.         move.l    d2,RegStore
  731.         move.l    d0,d2        ;Adresse merken
  732.         ReadByte d1
  733.         move.l    d2,d0        ;Adresse zurückholen
  734.         addq.b    #1,d0        ;Nächstes Byte OHNE Page-Crossing
  735.         move.b    d1,d2        ;Lo-Byte merken
  736.         ReadByte
  737.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  738.         move.b    d2,d0        ;Lo-Byte dazunehmen
  739.         move.l    RegStore,d2
  740.         ENDM
  741.  
  742. ; Zero-Page Adressierung
  743. ReadAdrZero    MACRO
  744.         move.b    (RPC)+,d0
  745.         ENDM
  746.  
  747. ReadByteZero    MACRO    ;Ziel (CCR ist gültig)
  748.         ReadAdrZero
  749.         move.b    (RAMPTR,d0.l),\1
  750.         ENDM
  751.  
  752. ; Absolut,X
  753. ReadAdrAbsX    MACRO
  754.         ReadPCWord
  755.         add.w    RX,d0
  756.         ENDM
  757.  
  758. ReadByteAbsX    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  759.         ReadAdrAbsX
  760.         ReadByte \1
  761.         ENDM
  762.  
  763. ; Absolut,Y
  764. ReadAdrAbsY    MACRO
  765.         ReadPCWord
  766.         add.w    RY,d0
  767.         ENDM
  768.  
  769. ReadByteAbsY    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  770.         ReadAdrAbsY
  771.         ReadByte \1
  772.         ENDM
  773.  
  774. ; Zero-Page,X
  775. ReadAdrZeroX    MACRO
  776.         move.b    (RPC)+,d0
  777.         add.b    RX,d0
  778.         ENDM
  779.  
  780. ReadByteZeroX    MACRO    ;Ziel (CCR ist gültig)
  781.         ReadAdrZeroX
  782.         move.b    (RAMPTR,d0.l),\1
  783.         ENDM
  784.  
  785. ; Zero-Page,Y
  786. ReadAdrZeroY    MACRO
  787.         move.b    (RPC)+,d0
  788.         add.b    RY,d0
  789.         ENDM
  790.  
  791. ReadByteZeroY    MACRO    ;Ziel (CCR ist gültig)
  792.         ReadAdrZeroY
  793.         move.b    (RAMPTR,d0.l),\1
  794.         ENDM
  795.  
  796. ; (Ind,X)
  797. ReadAdrIndX    MACRO
  798.         move.b    (RPC)+,d0
  799.         add.b    RX,d0
  800.         move.b    (RAMPTR,d0.l),d1    ;LSB lesen
  801.         addq.b    #1,d0
  802.         move.b    (RAMPTR,d0.l),d0    ;MSB lesen
  803.         lsl.w    #8,d0
  804.         move.b    d1,d0            ;LSB einfügen
  805.         ENDM
  806.  
  807. ReadByteIndX    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  808.         ReadAdrIndX
  809.         ReadByte \1
  810.         ENDM
  811.  
  812. ; (Ind),Y
  813. ReadAdrIndY    MACRO
  814.         move.b    (RPC)+,d0
  815.  
  816. ;(Korrekt)    move.b    (RAMPTR,d0.l),d1    ;LSB lesen
  817. ;        addq.b    #1,d0
  818. ;        move.b    (RAMPTR,d0.l),d0    ;MSB lesen
  819. ;        lsl.w    #8,d0
  820. ;        move.b    d1,d0            ;LSB einfügen
  821.  
  822.         move.w    (RAMPTR,d0.l),d0    ;(Abgekürzt)
  823.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  824.  
  825.         add.w    RY,d0
  826.         ENDM
  827.  
  828. ReadByteIndY    MACRO    ;[Ziel] (wird ein Ziel angegeben, ist das CCR gültig)
  829.         ReadAdrIndY
  830.         ReadByte \1
  831.         ENDM
  832.  
  833. ; Ein Byte auf den Stapel schieben
  834. PushByte    MACRO    ;Quelle
  835.         move.b    \1,(RAMPTR,RS.l)
  836.         subq.b    #1,RS
  837.         ENDM
  838.  
  839. ; PC auf Stack schieben
  840. PushPC        MACRO
  841.         move.w    RPC,d0
  842.         move.w    d0,d1
  843.         lsr.w    #8,d0
  844.         PushByte d0
  845.         PushByte d1
  846.         ENDM
  847.  
  848. ; PC+1 auf den Stack schieben
  849. PushPCPlus1    MACRO
  850.         move.w    RPC,d0
  851.         addq.w    #1,d0
  852.         move.w    d0,d1
  853.         lsr.w    #8,d0
  854.         PushByte    d0
  855.         PushByte    d1
  856.         ENDM
  857.  
  858. ; Status auf Stack schieben
  859. PushP        MACRO    ;Break-Bit
  860.         move.w    RP,d0        ;6510-Status holen
  861.         lsr.w    #8,d0
  862.         and.b    #$4c,d0        ;V,D,I behalten
  863.     IFEQ    \1
  864.         or.b    #$20,d0        ;1-Bit setzen
  865.     ELSE
  866.         or.b    #$30,d0        ;B und 1-Bit setzen
  867.     ENDC
  868.         tst.b    RP        ;C dazunehmen
  869.         beq    \@1$
  870.         or.b    #$01,d0
  871. \@1$        btst    #3,RCCR        ;N dazunehmen
  872.         beq    \@2$
  873.         or.b    #$80,d0
  874. \@2$        btst    #2,RCCR        ;Z dazunehmen
  875.         beq    \@3$
  876.         or.b    #$02,d0
  877. \@3$        PushByte d0
  878.         ENDM
  879.  
  880. ; Ein Byte vom Stapel lesen
  881. PopByte        MACRO    ;Ziel (CCR ist gültig)
  882.         addq.b    #1,RS
  883.         move.b    (RAMPTR,RS.l),\1
  884.         ENDM
  885.  
  886. ; Status vom Stack holen
  887. PopP        MACRO
  888.         PopByte    d0
  889.         move    ccr,RCCR
  890.         and.b    #$08,RCCR    ;N holen
  891.         move.b    d0,RP
  892.         and.b    #$4c,RP        ;V,D,I behalten
  893.         lsl.w    #8,RP
  894.         btst    #1,d0        ;Z holen
  895.         beq    \@1$
  896.         or.b    #$04,RCCR
  897. \@1$        btst    #0,d0        ;C holen
  898.         sne    RP
  899.         ENDM
  900.  
  901. ; PC setzen
  902. ; -> d0.w: 16-Bit-Adresse
  903. ; <- RPC.l: Amiga-Adresse
  904. Jump        MACRO
  905.         move.w    d0,d1
  906.         lsr.w    #8,d1
  907.         move.l    (256*8*8,RWTAB,d1.l*8),a0 ;JumpTab
  908.         jsr    (a0)
  909.         ENDM
  910.  
  911. ; Nächsten Befehl ausführen
  912. Next        MACRO    ;Zyklenzahl
  913.     IFNE    \1
  914.         subq.w    #\1,(CYCPTR)    ;Anzahl Zyklen abziehen
  915.         bmi    Periodic    ;Alle verbraucht: Periodic
  916.     ENDC
  917.  
  918.         moveq    #0,d0
  919.         move.b    (RPC)+,d0    ;Opcode lesen
  920.         move.l    (OpcodeTable,d0.l*4),a0 ;Zeiger auf die Opcode-Routine holen
  921.         jmp    (a0)        ;Routine aufrufen
  922.         ENDM
  923.  
  924. ; Speicherkonfiguration anpassen
  925. NewConfig    MACRO
  926.     ;!!    move.b    (RAMPTR),d0    ;Gelesenes PR richtig berechnen
  927.     ;    move.b    d0,d1
  928.     ;    not.b    d1
  929.     ;    and.b    1(RAMPTR),d0
  930.     ;    and.b    #%00010111,d1    ;Eingabepins
  931.     ;    or.b    d1,d0
  932.     ;    move.b    d0,1(RAMPTR)
  933.  
  934.         move.b    (RAMPTR),d0    ;Zustand der Ausgabepins lesen
  935.         not.b    d0        ;Eingabepins sind 1
  936.         or.b    1(RAMPTR),d0
  937.         and.w    #7,d0        ;Relevante Bits maskieren
  938.         move.l    (ConfigTab,d0.l*4),RWTAB
  939.         ENDM
  940.  
  941. ; Ein C64-Byte in die Zero-Page schreiben und nächsten Befehl ausführen.
  942. ; Prüfen, ob sich die Speicherkonfiguration geändert hat.
  943. ; -> d0.w: Adresse (16 bit)
  944. ; -> Arg1: Byte
  945. WriteZeroNext    MACRO    ;Register, Zyklenzahl
  946.         move.b    \1,(RAMPTR,d0.l)
  947.         cmp.b    #2,d0
  948.         bhs    \@1$
  949.         NewConfig
  950. \@1$        Next    \2
  951.         ENDM
  952.  
  953.  
  954. *
  955. * Initialisierung
  956. *
  957.  
  958. ; Near-Adressierung initialisieren
  959. CPUTaskProc    lea    _DATA_BAS_,a4
  960.         lea    32766(a4),a4
  961.  
  962. ; Task ermitteln
  963.         move.l    _SysBase,a6
  964.         sub.l    a1,a1
  965.         JSRLIB    FindTask
  966.         move.l    d0,CPUTask
  967.  
  968. ; Continue-Signal holen
  969.         moveq    #-1,d0
  970.         JSRLIB    AllocSignal
  971.         move.b    d0,ContinueSig
  972.         moveq    #0,d1
  973.         bset    d0,d1
  974.         move.l    d1,ContinueSet
  975.  
  976. ; Grafik initialisieren
  977.         jsr    _InitDisplayFrom6510
  978.  
  979. ; Signal an den Emulator schicken
  980.         move.l    _SysBase,a6
  981.         move.l    MainTask,a1
  982.         move.l    ReadySet,d0
  983.         JSRLIB    Signal
  984.  
  985. ; Variablen initilisieren
  986.         clr.l    Interrupt
  987.         clr.b    RESETIsEXIT
  988.         clr.b    RESETIsPause
  989.         clr.b    NMIState
  990.         move.w    #63,CyclesLeft
  991.  
  992. ; RAM mit Einschaltmuster initialisieren
  993.         move.l    TheRAM,a0
  994.         move.w    #511,d1
  995. 3$        moveq    #63,d0
  996. 1$        clr.b    (a0)+        ;Abwechselnd 64 Bytes $00
  997.         dbra    d0,1$
  998.         moveq    #63,d0
  999. 2$        st    (a0)+        ;Und 64 Bytes $ff
  1000.         dbra    d0,2$
  1001.         dbra    d1,3$
  1002.  
  1003. ; Farb-RAM mit Zufallswerten initialisieren
  1004.         move.l    TheColor,a2
  1005.         move.w    #$03ff,d2
  1006. 4$        jsr    Random
  1007.         move.b    d0,(a2)+
  1008.         dbra    d2,4$
  1009.  
  1010. ; Speicherkonfiguration initialisieren
  1011.         move.l    TheRAM,RAMPTR
  1012.         move.b    #$00,(RAMPTR)    ;Port auf Eingabe
  1013.         NewConfig
  1014.  
  1015. ; Register setzen
  1016.         moveq    #0,d0
  1017.         moveq    #0,d1
  1018.         moveq    #0,RA
  1019.         moveq    #0,RX
  1020.         moveq    #0,RY
  1021.         move.l    #$01ff,RS
  1022.         moveq    #0,RCCR
  1023.         move.l    #InterruptMask,RP
  1024.         lea    CyclesLeft,CYCPTR
  1025.  
  1026. ; Reset-Vektor lesen, PC setzen und ersten Befehl ausführen
  1027.         move.w    #$fffc,d0
  1028.         ReadWord
  1029.         Jump
  1030.         Next    0
  1031.  
  1032. ; Unbekannten Opcode entdeckt: Requester darstellen
  1033. IllegalOp    subq.w    #1,RPC            ;PC korrigieren
  1034.         movem.l    a2-a6,-(sp)
  1035.  
  1036.         and.w    #$00ff,d0        ;Opcode
  1037.         move.w    d0,RequestStream
  1038.         move.l    RPC,d0            ;und PC anzeigen
  1039.         move.w    d0,RequestStream+2
  1040.  
  1041.         jsr    _EmulToBack
  1042.  
  1043.         move.l    _IntuitionBase,a6
  1044.         sub.l    a0,a0
  1045.         lea    IllegalOpReq,a1
  1046.         move.l    a0,a2
  1047.         lea    RequestStream,a3
  1048.         JSRLIB    EasyRequestArgs
  1049.  
  1050.         move.l    d0,-(sp)
  1051.         jsr    _EmulToFront
  1052.         move.l    (sp)+,d0
  1053.  
  1054.         movem.l    (sp)+,a2-a6
  1055.  
  1056.         tst.l    d0            ;Resetten?
  1057.         beq    1$
  1058.  
  1059.         jsr    ResetC64        ;Ja
  1060.         moveq    #0,d0
  1061.         moveq    #0,d1
  1062.         bra    HandleRESET
  1063.  
  1064. 1$        move.l    a6,-(sp)        ;Nein, SAM aufrufen
  1065.         move.l    _SysBase,a6
  1066.         move.l    MainTask,a1        ;Den Haupttask benachrichtigen
  1067.         move.l    InvokeSAMSet,d0
  1068.         JSRLIB    Signal
  1069.         move.l    (sp)+,a6
  1070.         bsr    Pause            ;In Pause-Zustand gehen
  1071.         clr.b    IntIsRESET
  1072.         clr.b    RESETIsPause
  1073.         moveq    #0,d0
  1074.         moveq    #0,d1
  1075.         NewConfig
  1076.         move.w    _RPC,d0
  1077.         Jump
  1078.         Next    0
  1079.  
  1080.  
  1081. *
  1082. * Speicherzugriff Lesen
  1083. *
  1084.  
  1085. ; Lesen aus dem RAM
  1086. ReadByteRAM    move.b    (RAMPTR,d0.l),d0
  1087.         rts
  1088.  
  1089. ; Lesen aus dem Basic-ROM
  1090. ReadByteBasic    and.w    #$1fff,d0
  1091.         move.l    TheBasic,a0
  1092.         move.b    (a0,d0.l),d0
  1093.         rts
  1094.  
  1095. ; Lesen aus einem VIC-Register
  1096. ReadByteVIC    and.w    #$3f,d0
  1097.         bra    ReadFrom6569
  1098.  
  1099. ; Lesen aus einem SID-Register
  1100. ReadByteSID    and.w    #$1f,d0
  1101.         bra    ReadFrom6581
  1102.  
  1103. ; Lesen aus dem Farb-RAM
  1104. ReadByteColor    and.w    #$03ff,d0
  1105.         move.l    TheColor,a0
  1106.         move.b    (a0,d0.l),d1
  1107.         and.b    #$0f,d1
  1108.  
  1109.         move.l    d1,-(sp)
  1110.         jsr    Random        ;Oberes Nibble ist Zufallswert
  1111.         and.b    #$f0,d0
  1112.         move.l    (sp)+,d1
  1113.  
  1114.         or.b    d1,d0
  1115.         rts
  1116.  
  1117. ; Lesen aus einem CIA 1-Register
  1118. ReadByteCIA1    and.w    #$0f,d0
  1119.         bra    ReadFrom6526A
  1120.  
  1121. ; Lesen aus einem CIA 2-Register
  1122. ReadByteCIA2    and.w    #$0f,d0
  1123.         bra    ReadFrom6526B
  1124.  
  1125. ; Lesen einer offenen Adresse
  1126. ReadByteUndef    cmp.l    #$dfa0,d0
  1127.         bhs    1$
  1128.         jsr    Random        ;Zufallswert
  1129.         moveq    #0,d1        ;MSW löschen
  1130.         rts
  1131.  
  1132. ; $dfa0-$dfff: Emulator-Identifikation
  1133. 1$        cmp.w    #$dfff,d0    ;$dfff liest abwechselnd $55/$aa
  1134.         bne    2$
  1135.         move.b    DFFFByte,d0
  1136.         not.b    DFFFByte
  1137.         rts
  1138.  
  1139. 2$        cmp.w    #$dffe,d0    ;$dffe liest "F" (Frodo-Kennung)
  1140.         bne    3$
  1141.         moveq    #'F',d0
  1142.         rts
  1143.  
  1144. 3$        cmp.w    #$dffd,d0    ;$dffd: Version
  1145.         bne    4$
  1146.         move.b    #VERSION,d0
  1147.         rts
  1148.  
  1149. 4$        cmp.w    #$dffc,d0    ;$dffc: Revision
  1150.         bne    5$
  1151.         move.b    #REVISION<<4,d0
  1152.         rts
  1153.  
  1154. 5$        sub.w    #$dfa0,d0    ;$dfa0-$dffb: ID-String
  1155.         move.b    IDString(pc,d0.w),d0
  1156.         rts
  1157.  
  1158. ; Lesen aus dem Kernal-ROM
  1159. ReadByteKernal    and.w    #$1fff,d0
  1160.         move.l    TheKernal,a0
  1161.         move.b    (a0,d0.l),d0
  1162.         rts
  1163.  
  1164. ; Lesen aus dem Char-ROM
  1165. ReadByteChar    and.w    #$0fff,d0
  1166.         move.l    TheChar,a0
  1167.         move.b    (a0,d0.l),d0
  1168.         rts
  1169.  
  1170.  
  1171. *
  1172. * Speicherzugriff Schreiben
  1173. * In a1 steht die 16-Bit-Adresse
  1174. *
  1175.  
  1176. ; Schreiben in Seite 0
  1177. WriteBytePage0    move.l    a1,d0
  1178.         move.b    d1,(RAMPTR,d0.l)
  1179.         cmp.b    #2,d0
  1180.         bhs    1$
  1181.         NewConfig
  1182. 1$        rts
  1183.  
  1184. ; Schreiben ins RAM
  1185. WriteByteRAM    move.b    d1,(RAMPTR,a1.l)
  1186.         rts
  1187.  
  1188. ; Schreiben in ein VIC-Register
  1189. WriteByteVIC    move.l    a1,d0
  1190.         and.w    #$3f,d0
  1191.         bra    WriteTo6569
  1192.  
  1193. ; Schreiben in ein SID-Register
  1194. WriteByteSID    move.l    a1,d0
  1195.         and.w    #$1f,d0
  1196.         bra    WriteTo6581
  1197.  
  1198. ; Schreiben ins Farb-RAM
  1199. WriteByteColor    move.l    a1,d0
  1200.         and.w    #$03ff,d0
  1201.         move.l    TheColor,a0
  1202.         move.b    d1,(a0,d0.l)
  1203.         rts
  1204.  
  1205. ; Schreiben in ein CIA 1-Register
  1206. WriteByteCIA1    move.l    a1,d0
  1207.         and.w    #$0f,d0
  1208.         bra    WriteTo6526A
  1209.  
  1210. ; Schreiben in ein CIA 2-Register
  1211. WriteByteCIA2    move.l    a1,d0
  1212.         and.w    #$0f,d0
  1213.         bra    WriteTo6526B
  1214.  
  1215. ; Schreiben an einer offenen Adresse
  1216. WriteByteUndef    rts
  1217.  
  1218.  
  1219. *
  1220. * Sprungbefehle
  1221. *
  1222.  
  1223. ; Sprung ins RAM
  1224. JumpToRAM    lea    (RAMPTR,d0.l),RPC
  1225.         rts
  1226.  
  1227. ; Sprung ins Basic-ROM
  1228. JumpToBasic    move.l    TheBasic,RPC
  1229.         and.w    #$1fff,d0
  1230.         add.l    d0,RPC
  1231.         rts
  1232.  
  1233. ; Sprung ins Kernal-ROM
  1234. JumpToKernal    move.l    TheKernal,RPC
  1235.         and.w    #$1fff,d0
  1236.         add.l    d0,RPC
  1237.         rts
  1238.  
  1239. ; Sprung ins Char-ROM (warum sollte jemand sowas tun? Aber egal.)
  1240. JumpToChar    move.l    TheChar,RPC
  1241.         and.w    #$0fff,d0
  1242.         add.l    d0,RPC
  1243.         rts
  1244.  
  1245. ; Sprung in den I/O-Bereich (in VIC-Register wird ab und zu gerne gesprungen,
  1246. ;  $de00 und das Farb-RAM sind auch sehr beliebt :-)
  1247. JumpToIO    movem.l    a2-a6,-(sp)
  1248.  
  1249.         move.w    d0,RequestStream    ;PC anzeigen
  1250.  
  1251.         jsr    _EmulToBack
  1252.  
  1253.         move.l    _IntuitionBase,a6
  1254.         sub.l    a0,a0
  1255.         lea    JumpToIOReq,a1
  1256.         move.l    a0,a2
  1257.         lea    RequestStream,a3
  1258.         JSRLIB    EasyRequestArgs
  1259.  
  1260.         jsr    _EmulToFront
  1261.  
  1262.         movem.l    (sp)+,a2-a6
  1263.  
  1264.         jsr    ResetC64
  1265.         moveq    #0,d0            ;MSWs von d0 und d1
  1266.         moveq    #0,d1            ; müssen Null sein
  1267.  
  1268.         addq.l    #4,sp            ;Rücksprungadresse löschen
  1269.         bra    HandleRESET
  1270.  
  1271.  
  1272. **
  1273. ** Opcode-Routinen
  1274. **
  1275.  
  1276. *
  1277. * Interrupts handhaben
  1278. *
  1279.  
  1280. ; Art des Interrupt feststellen (Priorität)
  1281. HandleInt    tst.b    IntIsRESET
  1282.         bne    HandleRESET
  1283.         tst.b    IntIsNMI
  1284.         bne    HandleNMI
  1285.         tst.w    IntIsIRQ
  1286.         bne    HandleIRQ
  1287.  
  1288. ; Kein Interrupt, nächsten Befehl ausführen
  1289. HandleIntDone    Next    0
  1290.  
  1291. ; IRQ: Interrupt-Bit testen, nach ($fffe) springen
  1292. HandleIRQ    btst    #InterruptBit,RP
  1293.         beq    IRQDoIt
  1294.         Next    0
  1295.  
  1296. IRQDoIt        PushPC
  1297.         PushP    0
  1298.  
  1299.         or.w    #InterruptMask,RP
  1300.         move.w    #$fffe,d0    ;IRQ-Vektor
  1301.         ReadWord
  1302.         Jump
  1303.         Next    7
  1304.  
  1305. ; NMI: Nach ($fffa) springen
  1306. HandleNMI    clr.b    IntIsNMI    ;Simuliert einen flankengetriggerten Eingang
  1307.  
  1308.         PushPC
  1309.         PushP    0
  1310.  
  1311.         or.w    #InterruptMask,RP
  1312.         move.w    #$fffa,d0    ;NMI-Vektor
  1313.         ReadWord
  1314.         Jump
  1315.         Next    7
  1316.  
  1317. ; RESET: Emulator beenden, anhalten oder nach ($fffc) springen
  1318. HandleRESET    tst.b    RESETIsEXIT    ;Beenden?
  1319.         bne    HandleEXIT
  1320.         tst.b    RESETIsPause    ;Pause?
  1321.         bne    HandlePause
  1322.  
  1323.         clr.l    Interrupt    ;Nein, RESET
  1324.         clr.b    NMIState
  1325.  
  1326.         cmp.l    #$c3c2cd38,$8004(RAMPTR)
  1327.         bne    1$
  1328.         cmp.b    #$30,$8008(RAMPTR)
  1329.         bne    1$
  1330.         clr.b    $8004(RAMPTR)    ;CBM80 löschen, wenn vorhanden
  1331.  
  1332. 1$        move.b    #$00,(RAMPTR)    ;Speicherkonfiguration initialisieren (Port auf Eingabe)
  1333.         NewConfig
  1334.  
  1335.         move.w    #$fffc,d0    ;RESET-Vektor
  1336.         ReadWord
  1337.         Jump
  1338.         Next    0
  1339.  
  1340. ; EXIT: Signal an den Emulator schicken
  1341. HandleEXIT    jsr    _ExitDisplayFrom6510    ;Grafik aufräumen
  1342.  
  1343.         move.l    _SysBase,a6
  1344.  
  1345.         moveq    #0,d0
  1346.         move.b    ContinueSig,d0
  1347.         JSRLIB    FreeSignal
  1348.  
  1349.         JSRLIB    Forbid
  1350.         move.l    MainTask,a1
  1351.         move.l    ReadySet,d0
  1352.         JSRLIB    Signal
  1353.         moveq    #0,d0
  1354.         rts
  1355.  
  1356. ; Pause: Signal an den Emulator schicken und dann selbst auf
  1357. ;  ein Signal warten, Zustand retten und wiederherstellen
  1358. HandlePause    bsr    Pause
  1359.         moveq    #0,d0
  1360.         moveq    #0,d1
  1361.         NewConfig
  1362.         move.w    _RPC,d0
  1363.         Jump
  1364.         Next    0
  1365.  
  1366. Pause        clr.b    IntIsRESET
  1367.         clr.b    RESETIsPause
  1368.  
  1369.         move.b    RA,_RA        ;Register für SAM bereitstellen
  1370.         move.b    RX,_RX
  1371.         move.b    RY,_RY
  1372.         move.w    RP,d0
  1373.         lsr.w    #8,d0
  1374.         and.b    #$5c,d0        ;V, B, D, I
  1375.         or.b    #$20,d0        ;1-Bit setzen
  1376.         tst.b    RP        ;C dazunehmen
  1377.         beq    1$
  1378.         or.b    #$01,d0
  1379. 1$        btst    #3,RCCR        ;N dazunehmen
  1380.         beq    2$
  1381.         or.b    #$80,d0
  1382. 2$        btst    #2,RCCR        ;Z dazunehmen
  1383.         beq    3$
  1384.         or.b    #$02,d0
  1385. 3$        move.b    d0,_RP
  1386.  
  1387.         move.b    (RAMPTR),_RDDR
  1388.         move.b    1(RAMPTR),d0
  1389.         and.b    #$3f,d0
  1390.         move.b    d0,_RPR
  1391.  
  1392.         move.b    (RAMPTR),d0
  1393.         not.b    d0
  1394.         or.b    1(RAMPTR),d0
  1395.         and.b    #$07,d0
  1396.         move.b    d0,_SAMMemConfig
  1397.  
  1398.         move.w    RPC,_RPC
  1399.         move.w    RS,_RS
  1400.  
  1401.         move.l    _SysBase,a6
  1402.         move.l    MainTask,a1
  1403.         move.l    ReadySet,d0
  1404.         JSRLIB    Signal
  1405.         move.l    ContinueSet,d0
  1406.         JSRLIB    Wait
  1407.  
  1408.         move.l    TheRAM,RAMPTR
  1409.         lea    CyclesLeft,CYCPTR
  1410.         moveq    #0,RA        ;Register von SAM lesen
  1411.         move.b    _RA,RA
  1412.         moveq    #0,RX
  1413.         move.b    _RX,RX
  1414.         moveq    #0,RY
  1415.         move.b    _RY,RY
  1416.  
  1417.         moveq    #0,RCCR
  1418.         btst    #7,_RP        ;N holen
  1419.         beq    4$
  1420.         or.b    #$08,RCCR
  1421. 4$        btst    #1,_RP        ;Z holen
  1422.         beq    5$
  1423.         or.b    #$04,RCCR
  1424. 5$
  1425.         moveq    #0,RP
  1426.         move.b    _RP,RP
  1427.         and.b    #$4c,RP        ;V,D,I behalten
  1428.         lsl.w    #8,RP
  1429.         btst    #0,_RP        ;C holen
  1430.         sne    RP
  1431.  
  1432.         move.l    #$0100,RS
  1433.         move.b    _RS+1,RS
  1434.         move.b    _RDDR,(RAMPTR)
  1435.         move.b    _RPR,1(RAMPTR)
  1436.         rts
  1437.  
  1438.  
  1439. *
  1440. * Opcodes
  1441. *
  1442.  
  1443. ; Laden
  1444. LoadA        MACRO    ;Quelle, Zyklenzahl
  1445.         move.b    \1,RA
  1446.         move    ccr,RCCR
  1447.         Next    \2
  1448.         ENDM
  1449.  
  1450. LoadX        MACRO    ;Quelle, Zyklenzahl
  1451.         move.b    \1,RX
  1452.         move    ccr,RCCR
  1453.         Next    \2
  1454.         ENDM
  1455.  
  1456. LoadY        MACRO    ;Quelle, Zyklenzahl
  1457.         move.b    \1,RY
  1458.         move    ccr,RCCR
  1459.         Next    \2
  1460.         ENDM
  1461.  
  1462. LoadAX        MACRO    ;Quelle, Zyklenzahl
  1463.         move.b    \1,RA
  1464.         move.b    RA,RX
  1465.         move    ccr,RCCR
  1466.         Next    \2
  1467.         ENDM
  1468.  
  1469. LDAImm        LoadA    (RPC)+,2
  1470.  
  1471. LDAZero        ReadAdrZero
  1472.         LoadA    (RAMPTR,d0.l),3
  1473.  
  1474. LDAZeroX    ReadAdrZeroX
  1475.         LoadA    (RAMPTR,d0.l),4
  1476.  
  1477. LDAAbs        ReadByteAbs RA
  1478.         move    ccr,RCCR
  1479.         Next    4
  1480.  
  1481. LDAAbsX        ReadByteAbsX RA
  1482.         move    ccr,RCCR
  1483.         Next    4
  1484.  
  1485. LDAAbsY        ReadByteAbsY RA
  1486.         move    ccr,RCCR
  1487.         Next    4
  1488.  
  1489. LDAIndX        ReadByteIndX RA
  1490.         move    ccr,RCCR
  1491.         Next    6
  1492.  
  1493. LDAIndY        ReadByteIndY RA
  1494.         move    ccr,RCCR
  1495.         Next    5
  1496.  
  1497. LDXImm        LoadX    (RPC)+,2
  1498.  
  1499. LDXZero        ReadAdrZero
  1500.         LoadX    (RAMPTR,d0.l),3
  1501.  
  1502. LDXZeroY    ReadAdrZeroY
  1503.         LoadX    (RAMPTR,d0.l),4
  1504.  
  1505. LDXAbs        ReadByteAbs RX
  1506.         move    ccr,RCCR
  1507.         Next    4
  1508.  
  1509. LDXAbsY        ReadByteAbsY RX
  1510.         move    ccr,RCCR
  1511.         Next    4
  1512.  
  1513. LDYImm        LoadY    (RPC)+,2
  1514.  
  1515. LDYZero        ReadAdrZero
  1516.         LoadY    (RAMPTR,d0.l),3
  1517.  
  1518. LDYZeroX    ReadAdrZeroX
  1519.         LoadY    (RAMPTR,d0.l),4
  1520.  
  1521. LDYAbs        ReadByteAbs RY
  1522.         move    ccr,RCCR
  1523.         Next    4
  1524.  
  1525. LDYAbsX        ReadByteAbsX RY
  1526.         move    ccr,RCCR
  1527.         Next    4
  1528.  
  1529. LAXZero        ReadAdrZero
  1530.         LoadAX    (RAMPTR,d0.l),3
  1531.  
  1532. LAXZeroY    ReadAdrZeroY
  1533.         LoadAX    (RAMPTR,d0.l),4
  1534.  
  1535. LAXAbs        ReadByteAbs RA
  1536.         move.b    RA,RX
  1537.         move    ccr,RCCR
  1538.         Next    4
  1539.  
  1540. LAXAbsY        ReadByteAbsY RA
  1541.         move.b    RA,RX
  1542.         move    ccr,RCCR
  1543.         Next    4
  1544.  
  1545. LAXIndX        ReadByteIndX RA
  1546.         move.b    RA,RX
  1547.         move    ccr,RCCR
  1548.         Next    6
  1549.  
  1550. LAXIndY        ReadByteIndY RA
  1551.         move.b    RA,RX
  1552.         move    ccr,RCCR
  1553.         Next    5
  1554.  
  1555. ; Speichern
  1556. StoreA        MACRO    ;Zyklenzahl
  1557.         move.b    RA,d1
  1558.         WriteByte
  1559.         Next    \1
  1560.         ENDM
  1561.  
  1562. StoreAX        MACRO    ;Zyklenzahl
  1563.         move.b    RA,d1
  1564.         and.b    RX,d1
  1565.         WriteByte
  1566.         Next    \1
  1567.         ENDM
  1568.  
  1569. STAZero        ReadAdrZero
  1570.         WriteZeroNext    RA,3
  1571.  
  1572. STAZeroX    ReadAdrZeroX
  1573.         WriteZeroNext    RA,4
  1574.  
  1575. STAAbs        ReadAdrAbs
  1576.         StoreA    4
  1577.  
  1578. STAAbsX        ReadAdrAbsX
  1579.         StoreA    5
  1580.  
  1581. STAAbsY        ReadAdrAbsY
  1582.         StoreA    5
  1583.  
  1584. STAIndX        ReadAdrIndX
  1585.         StoreA    6
  1586.  
  1587. STAIndY        ReadAdrIndY
  1588.         StoreA    6
  1589.  
  1590. STXZero        ReadAdrZero
  1591.         WriteZeroNext    RX,3
  1592.  
  1593. STXZeroY    ReadAdrZeroY
  1594.         WriteZeroNext    RX,4
  1595.  
  1596. STXAbs        ReadAdrAbs
  1597.         move.b    RX,d1
  1598.         WriteByte
  1599.         Next    4
  1600.  
  1601. STYZero        ReadAdrZero
  1602.         WriteZeroNext    RY,3
  1603.  
  1604. STYZeroX    ReadAdrZeroX
  1605.         WriteZeroNext    RY,4
  1606.  
  1607. STYAbs        ReadAdrAbs
  1608.         move.b    RY,d1
  1609.         WriteByte
  1610.         Next    4
  1611.  
  1612. SAXZero        ReadAdrZero
  1613.         StoreAX    3
  1614.  
  1615. SAXZeroY    ReadAdrZeroY
  1616.         StoreAX    4
  1617.  
  1618. SAXAbs        ReadAdrAbs
  1619.         StoreAX    4
  1620.  
  1621. SAXIndX        ReadAdrIndX
  1622.         StoreAX    6
  1623.  
  1624. ; Datentransport zwischen Registern
  1625. TAX        move.b    RA,RX
  1626.         move    ccr,RCCR
  1627.         Next    2
  1628.  
  1629. TAY        move.b    RA,RY
  1630.         move    ccr,RCCR
  1631.         Next    2
  1632.  
  1633. TXA        move.b    RX,RA
  1634.         move    ccr,RCCR
  1635.         Next    2
  1636.  
  1637. TYA        move.b    RY,RA
  1638.         move    ccr,RCCR
  1639.         Next    2
  1640.  
  1641. TXS        move.b    RX,RS
  1642.         Next    2
  1643.  
  1644. TSX        move.b    RS,RX
  1645.         move    ccr,RCCR
  1646.         Next    2
  1647.  
  1648. ; Stack
  1649. PHA        PushByte RA
  1650.         Next    3
  1651.  
  1652. PLA        PopByte    RA
  1653.         move    ccr,RCCR
  1654.         Next    4
  1655.  
  1656. PHP        PushP    1        ;Break-Flag setzen
  1657.         Next    3
  1658.  
  1659. PLP        PopP
  1660.         tst.w    IntIsIRQ    ;Steht ein IRQ an?
  1661.         beq    1$
  1662.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  1663.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  1664. 1$        Next    4
  1665.  
  1666. ; Vergleiche
  1667. CompareA    MACRO    ;Quelle, Zyklenzahl
  1668.         cmp.b    \1,RA
  1669.         move    ccr,RCCR
  1670.         scc    RP        ;Inverses Carry holen
  1671.         Next    \2
  1672.         ENDM
  1673.  
  1674. CMPImm        CompareA    (RPC)+,2
  1675.  
  1676. CMPZero        ReadAdrZero
  1677.         CompareA    (RAMPTR,d0.l),3
  1678.  
  1679. CMPZeroX    ReadAdrZeroX
  1680.         CompareA    (RAMPTR,d0.l),4
  1681.  
  1682. CMPAbs        ReadByteAbs
  1683.         CompareA    d0,4
  1684.  
  1685. CMPAbsX        ReadByteAbsX
  1686.         CompareA    d0,4
  1687.  
  1688. CMPAbsY        ReadByteAbsY
  1689.         CompareA    d0,4
  1690.  
  1691. CMPIndX        ReadByteIndX
  1692.         CompareA    d0,6
  1693.  
  1694. CMPIndY        ReadByteIndY
  1695.         CompareA    d0,5
  1696.  
  1697. CPXImm        cmp.b    (RPC)+,RX
  1698.         move    ccr,RCCR
  1699.         scc    RP        ;Inverses Carry holen
  1700.         Next    2
  1701.  
  1702. CPXZero        ReadAdrZero
  1703.         cmp.b    (RAMPTR,d0.l),RX
  1704.         move    ccr,RCCR
  1705.         scc    RP        ;Inverses Carry holen
  1706.         Next    3
  1707.  
  1708. CPXAbs        ReadByteAbs
  1709.         cmp.b    d0,RX
  1710.         move    ccr,RCCR
  1711.         scc    RP        ;Inverses Carry holen
  1712.         Next    4
  1713.  
  1714. CPYImm        cmp.b    (RPC)+,RY
  1715.         move    ccr,RCCR
  1716.         scc    RP        ;Inverses Carry holen
  1717.         Next    2
  1718.  
  1719. CPYZero        ReadAdrZero
  1720.         cmp.b    (RAMPTR,d0.l),RY
  1721.         move    ccr,RCCR
  1722.         scc    RP        ;Inverses Carry holen
  1723.         Next    3
  1724.  
  1725. CPYAbs        ReadByteAbs
  1726.         cmp.b    d0,RY
  1727.         move    ccr,RCCR
  1728.         scc    RP        ;Inverses Carry holen
  1729.         Next    4
  1730.  
  1731. ; Arithmetische Operationen
  1732. AdcA        MACRO    ;Zyklenzahl
  1733.         and.w    #~OverflowMask,RP
  1734.         btst    #DecimalBit,RP
  1735.         bne    \@2$
  1736.  
  1737.         add.b    RP,RP        ;Carry -> X
  1738.         addx.b    d0,RA
  1739.         scs    RP        ;Carry holen
  1740.         bvc    \@1$        ;Overflow holen
  1741.         or.w    #OverflowMask,RP
  1742. \@1$        tst.b    RA        ;N und Z holen (wegen addx)
  1743.         move    ccr,RCCR
  1744.         Next    \1
  1745.  
  1746. \@2$        bsr    AdcDec
  1747.         Next    \1
  1748.         ENDM
  1749.  
  1750. AdcDec        move.b    d0,TMPS        ;Dezimalmodus
  1751.         move.b    RA,TMPA
  1752.  
  1753.         clr.b    RCCR
  1754.  
  1755.         move.b    RA,d1        ;Unteres Nybble berechnen
  1756.         and.b    #$0f,d0
  1757.         and.b    #$0f,d1
  1758.         add.b    RP,RP        ;Carry -> X
  1759.         addx.b    d0,d1        ; -> d1
  1760.  
  1761.         cmp.b    #10,d1        ;BCD-Fixup für das untere Nybble
  1762.         blo    2$
  1763.         addq.b    #6,d1
  1764. 2$        move.b    d1,TMPAL
  1765.  
  1766.         move.b    TMPS,d0        ;Oberes Nybble berechnen
  1767.         lsr.b    #4,d0
  1768.         lsr.b    #4,RA
  1769.         add.b    d0,RA
  1770.         cmp.b    #$10,d1
  1771.         blo    1$
  1772.         addq.b    #1,RA        ; -> d2
  1773. 1$
  1774.         move.b    TMPS,d0        ;Z holen (wie im Binärmodus)
  1775.         move.b    TMPA,d1
  1776.         add.b    RP,RP        ;Carry -> X
  1777.         addx.b    d0,d1
  1778.         tst.b    d1        ;Wegen addx
  1779.         bne    6$
  1780.         or.b    #$04,RCCR
  1781. 6$
  1782.         btst    #3,RA        ;N berechnen
  1783.         beq    4$
  1784.         or.b    #$08,RCCR
  1785. 4$
  1786.         move.b    RA,d0        ;V berechnen
  1787.         lsl.b    #4,d0
  1788.         move.b    TMPA,d1
  1789.         eor.b    d1,d0
  1790.         bpl    5$
  1791.         move.b    TMPS,d0
  1792.         eor.b    d1,d0
  1793.         bmi    5$
  1794.         or.w    #OverflowMask,RP
  1795. 5$
  1796.         cmp.b    #10,RA        ;BCD-Fixup für das obere Nybble
  1797.         blo    3$
  1798.         addq.b    #6,RA
  1799. 3$
  1800.         cmp.b    #$10,RA        ;Carry holen
  1801.         shs    RP
  1802.  
  1803.         move.b    TMPAL,d0    ;Ergebnis zusammensetzen
  1804.         and.b    #$0f,d0
  1805.         lsl.b    #4,RA
  1806.         or.b    d0,RA
  1807.         rts
  1808.  
  1809. ADCImm        move.b    (RPC)+,d0
  1810.         AdcA    2
  1811.  
  1812. ADCZero        ReadByteZero    d0
  1813.         AdcA    3
  1814.  
  1815. ADCZeroX    ReadByteZeroX    d0
  1816.         AdcA    4
  1817.  
  1818. ADCAbs        ReadByteAbs
  1819.         AdcA    4
  1820.  
  1821. ADCAbsX        ReadByteAbsX
  1822.         AdcA    4
  1823.  
  1824. ADCAbsY        ReadByteAbsY
  1825.         AdcA    4
  1826.  
  1827. ADCIndX        ReadByteIndX
  1828.         AdcA    6
  1829.  
  1830. ADCIndY        ReadByteIndY
  1831.         AdcA    5
  1832.  
  1833. SbcA        MACRO    ;Zyklenzahl
  1834.         not.b    RP
  1835.         and.w    #~OverflowMask,RP
  1836.         btst    #DecimalBit,RP
  1837.         bne    \@2$
  1838.  
  1839.         add.b    RP,RP        ;Inverses Carry -> X
  1840.         subx.b    d0,RA
  1841.         scc    RP        ;Inverses Carry holen
  1842.         bvc    \@1$        ;Overflow holen
  1843.         or.w    #OverflowMask,RP
  1844. \@1$        tst.b    RA
  1845.         move    ccr,RCCR    ;N und Z holen (wegen subx)
  1846.         Next    \1
  1847.  
  1848. \@2$        bsr    SbcDec
  1849.         Next    \1
  1850.         ENDM
  1851.  
  1852. SbcDec        move.b    d0,TMPS        ;Dezimalmodus
  1853.         move.b    RA,TMPA
  1854.  
  1855.         and.b    #$0f,d0        ;Unteres Nybble berechnen
  1856.         and.b    #$0f,RA
  1857.         add.b    RP,RP        ;Inverses Carry -> X
  1858.         subx.b    d0,RA
  1859.         move    ccr,d1
  1860.         bcc    1$        ;BCD-Fixup
  1861.         subq.b    #6,RA
  1862.         st    d1
  1863. 1$        and.b    #$0f,RA
  1864.         move.b    RA,TMPAL
  1865.  
  1866.         move.b    TMPS,d0        ;Oberes Nybble berechnen
  1867.         move.b    TMPA,RA
  1868.         and.b    #$f0,d0
  1869.         and.b    #$f0,RA
  1870.         sub.b    d0,RA
  1871.         bcc    2$        ;BCD-Fixup
  1872.         and.b    #$f0,RA
  1873.         sub.b    #$60,RA
  1874.         btst    #0,d1
  1875.         beq    3$
  1876.         sub.b    #$10,RA
  1877.         bra    3$
  1878. 2$        and.b    #$f0,RA
  1879.         btst    #0,d1
  1880.         beq    3$
  1881.         sub.b    #$10,RA
  1882.         bcc    3$
  1883.         sub.b    #$60,RA
  1884. 3$        or.b    TMPAL,RA    ;Ergebnis zusammenbauen
  1885.  
  1886.         add.b    RP,RP        ;Inverses Carry -> X
  1887.         move.b    TMPS,d0        ;Flags berechnen (wie im Binärmodus)
  1888.         move.b    TMPA,d1
  1889.         subx.b    d0,d1        ;Flags berechnen
  1890.         scc    RP        ;Inverses Carry holen
  1891.         bvc    4$        ;Overflow holen
  1892.         or.w    #OverflowMask,RP
  1893. 4$        tst.b    d1        ;N und Z holen (wegen subx)
  1894.         move    ccr,RCCR
  1895.         rts
  1896.  
  1897. SBCImm        move.b    (RPC)+,d0
  1898.         SbcA    2
  1899.  
  1900. SBCZero        ReadByteZero    d0
  1901.         SbcA    3
  1902.  
  1903. SBCZeroX    ReadByteZeroX    d0
  1904.         SbcA    4
  1905.  
  1906. SBCAbs        ReadByteAbs
  1907.         SbcA    4
  1908.  
  1909. SBCAbsX        ReadByteAbsX
  1910.         SbcA    4
  1911.  
  1912. SBCAbsY        ReadByteAbsY
  1913.         SbcA    4
  1914.  
  1915. SBCIndX        ReadByteIndX
  1916.         SbcA    6
  1917.  
  1918. SBCIndY        ReadByteIndY
  1919.         SbcA    5
  1920.  
  1921. Increment    MACRO    ;Zyklenzahl
  1922.         move.l    d0,-(sp)
  1923.         ReadByte d1
  1924.         addq.b    #1,d1
  1925.         move    ccr,RCCR
  1926.         move.l    (sp)+,d0
  1927.         WriteByte
  1928.         Next    \1
  1929.         ENDM
  1930.  
  1931. IncrementZero    MACRO    ;Zyklenzahl
  1932.         addq.b    #1,(RAMPTR,d0.l)
  1933.         move    ccr,RCCR
  1934.         cmp.b    #2,d0
  1935.         bhs    \@1$
  1936.         NewConfig
  1937. \@1$        Next    \1
  1938.         ENDM
  1939.  
  1940. INCZero        ReadAdrZero
  1941.         IncrementZero    5
  1942.  
  1943. INCZeroX    ReadAdrZeroX
  1944.         IncrementZero    6
  1945.  
  1946. INCAbs        ReadAdrAbs
  1947.         Increment    6
  1948.  
  1949. INCAbsX        ReadAdrAbsX
  1950.         Increment    7
  1951.  
  1952. Decrement    MACRO    ;Zyklenzahl
  1953.         move.l    d0,-(sp)
  1954.         ReadByte d1
  1955.         subq.b    #1,d1
  1956.         move    ccr,RCCR
  1957.         move.l    (sp)+,d0
  1958.         WriteByte
  1959.         Next    \1
  1960.         ENDM
  1961.  
  1962. DecrementZero    MACRO    ;Zyklenzahl
  1963.         subq.b    #1,(RAMPTR,d0.l)
  1964.         move    ccr,RCCR
  1965.         cmp.b    #2,d0
  1966.         bhs    \@1$
  1967.         NewConfig
  1968. \@1$        Next    \1
  1969.         ENDM
  1970.  
  1971. DECZero        ReadAdrZero
  1972.         DecrementZero    5
  1973.         
  1974. DECZeroX    ReadAdrZeroX
  1975.         DecrementZero    6
  1976.  
  1977. DECAbs        ReadAdrAbs
  1978.         Decrement    6
  1979.  
  1980. DECAbsX        ReadAdrAbsX
  1981.         Decrement    7
  1982.  
  1983. INX        addq.b    #1,RX
  1984.         move    ccr,RCCR
  1985.         Next    2
  1986.  
  1987. DEX        subq.b    #1,RX
  1988.         move    ccr,RCCR
  1989.         Next    2
  1990.  
  1991. INY        addq.b    #1,RY
  1992.         move    ccr,RCCR
  1993.         Next    2
  1994.  
  1995. DEY        subq.b    #1,RY
  1996.         move    ccr,RCCR
  1997.         Next    2
  1998.  
  1999. ; Logische Operationen
  2000. AndA        MACRO    ;Quelle, Zyklenzahl
  2001.         and.b    \1,RA
  2002.         move    ccr,RCCR
  2003.         Next    \2
  2004.         ENDM
  2005.  
  2006. ANDImm        AndA    (RPC)+,2
  2007.  
  2008. ANDZero        ReadAdrZero
  2009.         AndA    (RAMPTR,d0.l),3
  2010.  
  2011. ANDZeroX    ReadAdrZeroX
  2012.         AndA    (RAMPTR,d0.l),4
  2013.  
  2014. ANDAbs        ReadByteAbs
  2015.         AndA    d0,4
  2016.  
  2017. ANDAbsX        ReadByteAbsX
  2018.         AndA    d0,4
  2019.  
  2020. ANDAbsY        ReadByteAbsY
  2021.         AndA    d0,4
  2022.  
  2023. ANDIndX        ReadByteIndX
  2024.         AndA    d0,6
  2025.  
  2026. ANDIndY        ReadByteIndY
  2027.         AndA    d0,5
  2028.  
  2029. OrA        MACRO    ;Quelle, Zyklenzahl
  2030.         or.b    \1,RA
  2031.         move    ccr,RCCR
  2032.         Next    \2
  2033.         ENDM
  2034.  
  2035. ORAImm        OrA    (RPC)+,2
  2036.  
  2037. ORAZero        ReadAdrZero
  2038.         OrA    (RAMPTR,d0.l),3
  2039.  
  2040. ORAZeroX    ReadAdrZeroX
  2041.         OrA    (RAMPTR,d0.l),4
  2042.  
  2043. ORAAbs        ReadByteAbs
  2044.         OrA    d0,4
  2045.  
  2046. ORAAbsX        ReadByteAbsX
  2047.         OrA    d0,4
  2048.  
  2049. ORAAbsY        ReadByteAbsY
  2050.         OrA    d0,4
  2051.  
  2052. ORAIndX        ReadByteIndX
  2053.         OrA    d0,6
  2054.  
  2055. ORAIndY        ReadByteIndY
  2056.         OrA    d0,5
  2057.  
  2058. EorA        MACRO    ;Zyklenzahl
  2059.         eor.b    d0,RA        ;eor.b (ea),RA geht nicht
  2060.         move    ccr,RCCR    ;(Warum nicht, Motorola ?) :-(
  2061.         Next    \1
  2062.         ENDM
  2063.  
  2064. EORImm        move.b    (RPC)+,d0
  2065.         EorA    2
  2066.  
  2067. EORZero        ReadByteZero d0
  2068.         EorA    3
  2069.  
  2070. EORZeroX    ReadByteZeroX d0
  2071.         EorA    4
  2072.  
  2073. EORAbs        ReadByteAbs
  2074.         EorA    4
  2075.  
  2076. EORAbsX        ReadByteAbsX
  2077.         EorA    4
  2078.  
  2079. EORAbsY        ReadByteAbsY
  2080.         EorA    4
  2081.  
  2082. EORIndX        ReadByteIndX
  2083.         EorA    6
  2084.  
  2085. EORIndY        ReadByteIndY
  2086.         EorA    5
  2087.  
  2088. BitTest        MACRO    ;Zyklenzahl
  2089.         clr.b    RCCR
  2090.         and.w    #~OverflowMask,RP
  2091.  
  2092.         tst.b    d0        ;Bit 7 -> N
  2093.         bpl    \@1$
  2094.         or.b    #$08,RCCR
  2095. \@1$
  2096.         btst    #6,d0        ;Bit 6 -> V
  2097.         beq    \@2$
  2098.         or.w    #OverflowMask,RP
  2099. \@2$
  2100.         and.b    RA,d0        ;A AND M -> Z
  2101.         bne    \@3$
  2102.         or.b    #$04,RCCR
  2103. \@3$        Next    \1
  2104.         ENDM
  2105.  
  2106. BITZero        ReadByteZero    d0
  2107.         BitTest    3
  2108.  
  2109. BITAbs        ReadByteAbs
  2110.         BitTest    4
  2111.  
  2112. ; Verschiebungen
  2113. ShiftLeft    MACRO    ;Zyklenzahl
  2114.         move.l    d0,-(sp)
  2115.         ReadByte d1
  2116.         add.b    d1,d1
  2117.         scs    RP        ;Carry holen
  2118.         move    ccr,RCCR
  2119.         move.l    (sp)+,d0
  2120.         WriteByte
  2121.         Next    \1
  2122.         ENDM
  2123.  
  2124. ShiftLeftZero    MACRO    ;Zyklenzahl
  2125.         lea    (RAMPTR,d0.l),a0
  2126.         move.b    (a0),d1
  2127.         add.b    d1,d1
  2128.         scs    RP        ;Carry holen
  2129.         move.b    d1,(a0)
  2130.         move    ccr,RCCR
  2131.         cmp.b    #2,d0
  2132.         bhs    \@1$
  2133.         NewConfig
  2134. \@1$        Next    \1
  2135.         ENDM
  2136.  
  2137. ASLA        add.b    RA,RA
  2138.         move    ccr,RCCR
  2139.         scs    RP        ;Carry holen
  2140.         Next    2
  2141.  
  2142. ASLZero        ReadAdrZero
  2143.         ShiftLeftZero    5
  2144.  
  2145. ASLZeroX    ReadAdrZeroX
  2146.         ShiftLeftZero    6
  2147.  
  2148. ASLAbs        ReadAdrAbs
  2149.         ShiftLeft    6
  2150.  
  2151. ASLAbsX        ReadAdrAbsX
  2152.         ShiftLeft    7
  2153.  
  2154. ShiftRight    MACRO    ;Zyklenzahl
  2155.         move.l    d0,-(sp)
  2156.         ReadByte d1
  2157.         lsr.b    #1,d1
  2158.         scs    RP        ;Carry holen
  2159.         move    ccr,RCCR
  2160.         move.l    (sp)+,d0
  2161.         WriteByte
  2162.         Next    \1
  2163.         ENDM
  2164.  
  2165. ShiftRightZero    MACRO    ;Zyklenzahl
  2166.         lea    (RAMPTR,d0.l),a0
  2167.         move.b    (a0),d1
  2168.         lsr.b    #1,d1
  2169.         scs    RP        ;Carry holen
  2170.         move.b    d1,(a0)
  2171.         move    ccr,RCCR
  2172.         cmp.b    #2,d0
  2173.         bhs    \@1$
  2174.         NewConfig
  2175. \@1$        Next    \1
  2176.         ENDM
  2177.  
  2178. LSRA        lsr.b    #1,RA
  2179.         move    ccr,RCCR
  2180.         scs    RP        ;Carry holen
  2181.         Next    2
  2182.  
  2183. LSRZero        ReadAdrZero
  2184.         ShiftRightZero    5
  2185.  
  2186. LSRZeroX    ReadAdrZeroX
  2187.         ShiftRightZero    6
  2188.  
  2189. LSRAbs        ReadAdrAbs
  2190.         ShiftRight    6
  2191.  
  2192. LSRAbsX        ReadAdrAbsX
  2193.         ShiftRight    7
  2194.  
  2195. RotateLeft    MACRO    ;Zyklenzahl
  2196.         move.l    d0,-(sp)
  2197.         ReadByte d1
  2198.         add.b    RP,RP        ;Carry -> X
  2199.         roxl.b    #1,d1
  2200.         scs    RP        ;Carry holen
  2201.         move    ccr,RCCR
  2202.         move.l    (sp)+,d0
  2203.         WriteByte
  2204.         Next    \1
  2205.         ENDM
  2206.  
  2207. RotateLeftZero    MACRO    ;Zyklenzahl
  2208.         lea    (RAMPTR,d0.l),a0
  2209.         move.b    (a0),d1
  2210.         add.b    RP,RP        ;Carry -> X
  2211.         roxl.b    #1,d1
  2212.         scs    RP        ;Carry holen
  2213.         move.b    d1,(a0)
  2214.         move    ccr,RCCR
  2215.         cmp.b    #2,d0
  2216.         bhs    \@1$
  2217.         NewConfig
  2218. \@1$        Next    \1
  2219.         ENDM
  2220.  
  2221. ROLA        add.b    RP,RP        ;Carry -> X
  2222.         roxl.b    #1,RA
  2223.         move    ccr,RCCR
  2224.         scs    RP        ;Carry holen
  2225.         Next    2
  2226.  
  2227. ROLZero        ReadAdrZero
  2228.         RotateLeftZero    5
  2229.  
  2230. ROLZeroX    ReadAdrZeroX
  2231.         RotateLeftZero    6
  2232.  
  2233. ROLAbs        ReadAdrAbs
  2234.         RotateLeft    6
  2235.  
  2236. ROLAbsX        ReadAdrAbsX
  2237.         RotateLeft    7
  2238.  
  2239. RotateRight    MACRO    ;Zyklenzahl
  2240.         move.l    d0,-(sp)
  2241.         ReadByte d1
  2242.         add.b    RP,RP        ;Carry -> X
  2243.         roxr.b    #1,d1
  2244.         scs    RP        ;Carry holen
  2245.         move    ccr,RCCR
  2246.         move.l    (sp)+,d0
  2247.         WriteByte
  2248.         Next    \1
  2249.         ENDM
  2250.  
  2251. RotateRightZero    MACRO    ;Zyklenzahl
  2252.         lea    (RAMPTR,d0.l),a0
  2253.         move.b    (a0),d1
  2254.         add.b    RP,RP        ;Carry -> X
  2255.         roxr.b    #1,d1
  2256.         scs    RP        ;Carry holen
  2257.         move.b    d1,(a0)
  2258.         move    ccr,RCCR
  2259.         cmp.b    #2,d0
  2260.         bhs    \@1$
  2261.         NewConfig
  2262. \@1$        Next    \1
  2263.         ENDM
  2264.  
  2265. RORA        add.b    RP,RP        ;Carry -> X
  2266.         roxr.b    #1,RA
  2267.         move    ccr,RCCR
  2268.         scs    RP        ;Carry holen
  2269.         Next    2
  2270.  
  2271. RORZero        ReadAdrZero
  2272.         RotateRightZero    5
  2273.  
  2274. RORZeroX    ReadAdrZeroX
  2275.         RotateRightZero    6
  2276.  
  2277. RORAbs        ReadAdrAbs
  2278.         RotateRight    6
  2279.  
  2280. RORAbsX        ReadAdrAbsX
  2281.         RotateRight    7
  2282.  
  2283. ; Sprünge/Verzweigungen
  2284. JMPAbs        ReadAdrAbs
  2285.         Jump
  2286.         Next    3
  2287.  
  2288. JMPInd        ReadAdrInd
  2289.         Jump
  2290.         Next    5
  2291.  
  2292. JSRAbs        PushPCPlus1
  2293.         ReadAdrAbs
  2294.         Jump
  2295.         Next    6
  2296.  
  2297. RTSImpl        PopByte    d1        ;LSB
  2298.         PopByte    d0        ;MSB
  2299.         lsl.w    #8,d0        ;schieben
  2300.         move.b    d1,d0        ;LSB dazunehmen
  2301.         addq.w    #1,d0        ;Adresse um eins erhöhen
  2302.         Jump
  2303.         Next    6
  2304.  
  2305. RTIImpl        PopP
  2306.         PopByte    d1        ;LSB
  2307.         PopByte    d0        ;MSB
  2308.         lsl.w    #8,d0        ;schieben
  2309.         move.b    d1,d0        ;LSB dazunehmen
  2310.         Jump
  2311.         tst.w    IntIsIRQ    ;Steht ein IRQ an?
  2312.         beq    1$
  2313.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  2314.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  2315. 1$        Next    6
  2316.  
  2317. BRK        PushPC
  2318.         PushP    1
  2319.         or.w    #InterruptMask,RP
  2320.         move.w    #$fffe,d0    ;IRQ-Vektor
  2321.         ReadWord
  2322.         Jump
  2323.         Next    7
  2324.  
  2325. Branch        MACRO
  2326.         ReadByteRel
  2327.         move.l    RPC,d1
  2328.         add.w    d0,d1
  2329.         move.l    d1,RPC
  2330.         moveq    #0,d1
  2331.         Next    3
  2332.         ENDM
  2333.  
  2334. BVCRel        btst    #OverflowBit,RP
  2335.         bne    BVCNot
  2336.         Branch
  2337. BVCNot        addq.l    #1,RPC
  2338.         Next    2
  2339.  
  2340. BVSRel        btst    #OverflowBit,RP
  2341.         beq    BVSNot
  2342.         Branch
  2343. BVSNot        addq.l    #1,RPC
  2344.         Next    2
  2345.  
  2346. BEQRel        btst    #2,RCCR
  2347.         beq    BEQNot
  2348.         Branch
  2349. BEQNot        addq.l    #1,RPC
  2350.         Next    2
  2351.  
  2352. BNERel        btst    #2,RCCR
  2353.         bne    BNENot
  2354.         Branch
  2355. BNENot        addq.l    #1,RPC
  2356.         Next    2
  2357.  
  2358. BPLRel        btst    #3,RCCR
  2359.         bne    BPLNot
  2360.         Branch
  2361. BPLNot        addq.l    #1,RPC
  2362.         Next    2
  2363.  
  2364. BMIRel        btst    #3,RCCR
  2365.         beq    BMINot
  2366.         Branch
  2367. BMINot        addq.l    #1,RPC
  2368.         Next    2
  2369.  
  2370. BCCRel        tst.b    RP
  2371.         bne    BCCNot
  2372.         Branch
  2373. BCCNot        addq.l    #1,RPC
  2374.         Next    2
  2375.  
  2376. BCSRel        tst.b    RP
  2377.         beq    BCSNot
  2378.         Branch
  2379. BCSNot        addq.l    #1,RPC
  2380.         Next    2
  2381.  
  2382. ; Statusregister
  2383. SEI        or.w    #InterruptMask,RP
  2384.         Next    2
  2385.  
  2386. CLI        and.w    #~InterruptMask,RP
  2387.         tst.w    IntIsIRQ    ;Steht ein IRQ an?
  2388.         bne    HandleIRQ    ;Ja, auslösen
  2389.         Next    2
  2390.  
  2391. CLC        clr.b    RP
  2392.         Next    2
  2393.  
  2394. SEC        st.b    RP
  2395.         Next    2
  2396.  
  2397. SED        or.w    #DecimalMask,RP
  2398.         Next    2
  2399.  
  2400. CLD        and.w    #~DecimalMask,RP
  2401.         Next    2
  2402.  
  2403. CLV        and.w    #~OverflowMask,RP
  2404.         Next    2
  2405.  
  2406. *
  2407. * Periodic: Wird über den Opcode-Fetch aufgerufen,
  2408. *  wenn der Zyklenzähler unterläuft
  2409. * Sitzt hier in der Mitte, um kurze Branches ausnutzen zu können
  2410. *
  2411.  
  2412. ; VIC und CIA aufrufen
  2413. Periodic    lea    RegStore+20,a0
  2414.         movem.w    d2-d7,-(a0)    ;Gerade Anzahl von Registern
  2415.         movem.l    RWTAB/RPC,-(a0)
  2416.         bra    Periodic6569    ;Springt nach Periodic6526 und hierher zurück
  2417. Peri6526Cont    lea    _DATA_BAS_,a4
  2418.         lea    32766(a4),a4
  2419.         movem.l    RegStore,RWTAB/RPC
  2420.         movem.w    RegStore+8,d2-d7
  2421.         move.l    TheRAM,RAMPTR
  2422.         lea    CyclesLeft,CYCPTR
  2423.         moveq    #0,d0
  2424.         moveq    #0,d1
  2425.  
  2426. ; Interrupt aufgetreten?
  2427.         tst.l    Interrupt
  2428.         bne    HandleInt
  2429.  
  2430. ; Nein, Nächsten Befehl ausführen
  2431.         Next    0
  2432.  
  2433.  
  2434. ; Leerbefehle
  2435. NOPImpl        Next    2
  2436.  
  2437. NOPZero        addq.w    #1,RPC
  2438.         Next    3
  2439.  
  2440. NOPZeroX    addq.w    #1,RPC
  2441.         Next    4
  2442.  
  2443. NOPAbsX
  2444. NOPAbs        addq.w    #2,RPC
  2445.         Next    4
  2446.  
  2447. ; ASL/ORA-Gruppe
  2448. ShLeftOr    MACRO    ;Zyklenzahl
  2449.         move.l    d0,-(sp)
  2450.         ReadByte d1
  2451.         add.b    d1,d1
  2452.         scs    RP        ;Carry holen
  2453.         or.b    d1,RA
  2454.         move    ccr,RCCR
  2455.         move.l    (sp)+,d0
  2456.         WriteByte
  2457.         Next    \1
  2458.         ENDM
  2459.  
  2460. ShLeftOrZero    MACRO    ;Zyklenzahl
  2461.         lea    (RAMPTR,d0.l),a0
  2462.         move.b    (a0),d1
  2463.         add.b    d1,d1
  2464.         scs    RP        ;Carry holen
  2465.         or.b    d1,RA
  2466.         move    ccr,RCCR
  2467.         move.b    d1,(a0)
  2468.         cmp.b    #2,d0
  2469.         bhs    \@1$
  2470.         NewConfig
  2471. \@1$        Next    \1
  2472.         ENDM
  2473.  
  2474. SLOZero        ReadAdrZero
  2475.         ShLeftOrZero    5
  2476.  
  2477. SLOZeroX    ReadAdrZeroX
  2478.         ShLeftOrZero    6
  2479.  
  2480. SLOAbs        ReadAdrAbs
  2481.         ShLeftOr    6
  2482.  
  2483. SLOAbsX        ReadAdrAbsX
  2484.         ShLeftOr    7
  2485.  
  2486. SLOAbsY        ReadAdrAbsY
  2487.         ShLeftOr    7
  2488.  
  2489. SLOIndX        ReadAdrIndX
  2490.         ShLeftOr    8
  2491.  
  2492. SLOIndY        ReadAdrIndY
  2493.         ShLeftOr    8
  2494.  
  2495. ; ROL/AND-Gruppe
  2496. RoLeftAnd    MACRO    ;Zyklenzahl
  2497.         move.l    d0,-(sp)
  2498.         ReadByte d1
  2499.         add.b    RP,RP        ;Carry -> X
  2500.         roxl.b    #1,d1
  2501.         scs    RP        ;Carry holen
  2502.         and.b    d1,RA
  2503.         move    ccr,RCCR    ;N und Z holen
  2504.         move.l    (sp)+,d0
  2505.         WriteByte
  2506.         Next    \1
  2507.         ENDM
  2508.  
  2509. RoLeftAndZero    MACRO    ;Zyklenzahl
  2510.         lea    (RAMPTR,d0.l),a0
  2511.         move.b    (a0),d1
  2512.         add.b    RP,RP        ;Carry -> X
  2513.         roxl.b    #1,d1
  2514.         scs    RP        ;Carry holen
  2515.         and.b    d1,RA
  2516.         move    ccr,RCCR    ;N und Z holen
  2517.         move.b    d1,(a0)
  2518.         cmp.b    #2,d0
  2519.         bhs    \@1$
  2520.         NewConfig
  2521. \@1$        Next    \1
  2522.         ENDM
  2523.  
  2524. RLAZero        ReadAdrZero
  2525.         RoLeftAndZero    5
  2526.  
  2527. RLAZeroX    ReadAdrZeroX
  2528.         RoLeftAndZero    6
  2529.  
  2530. RLAAbs        ReadAdrAbs
  2531.         RoLeftAnd    6
  2532.  
  2533. RLAAbsX        ReadAdrAbsX
  2534.         RoLeftAnd    7
  2535.  
  2536. RLAAbsY        ReadAdrAbsY
  2537.         RoLeftAnd    7
  2538.  
  2539. RLAIndX        ReadAdrIndX
  2540.         RoLeftAnd    8
  2541.  
  2542. RLAIndY        ReadAdrIndY
  2543.         RoLeftAnd    8
  2544.  
  2545. ; LSR/EOR-Gruppe
  2546. ShRightEor    MACRO    ;Zyklenzahl
  2547.         move.l    d0,-(sp)
  2548.         ReadByte d1
  2549.         lsr.b    #1,d1
  2550.         scs    RP        ;Carry holen
  2551.         eor.b    d1,RA
  2552.         move    ccr,RCCR
  2553.         move.l    (sp)+,d0
  2554.         WriteByte
  2555.         Next    \1
  2556.         ENDM
  2557.  
  2558. ShRightEorZero    MACRO    ;Zyklenzahl
  2559.         lea    (RAMPTR,d0.l),a0
  2560.         move.b    (a0),d1
  2561.         lsr.b    #1,d1
  2562.         scs    RP        ;Carry holen
  2563.         eor.b    d1,RA
  2564.         move    ccr,RCCR
  2565.         move.b    d1,(a0)
  2566.         cmp.b    #2,d0
  2567.         bhs    \@1$
  2568.         NewConfig
  2569. \@1$        Next    \1
  2570.         ENDM
  2571.  
  2572. SREZero        ReadAdrZero
  2573.         ShRightEorZero    5
  2574.  
  2575. SREZeroX    ReadAdrZeroX
  2576.         ShRightEorZero    6
  2577.  
  2578. SREAbs        ReadAdrAbs
  2579.         ShRightEor    6
  2580.  
  2581. SREAbsX        ReadAdrAbsX
  2582.         ShRightEor    7
  2583.  
  2584. SREAbsY        ReadAdrAbsY
  2585.         ShRightEor    7
  2586.  
  2587. SREIndX        ReadAdrIndX
  2588.         ShRightEor    8
  2589.  
  2590. SREIndY        ReadAdrIndY
  2591.         ShRightEor    8
  2592.  
  2593. ; ROR/ADC-Gruppe
  2594. RoRightAdc    MACRO    ;Zyklenzahl
  2595.         move.l    d0,-(sp)
  2596.         ReadByte d1
  2597.         add.b    RP,RP        ;Carry -> X
  2598.         roxr.b    #1,d1
  2599.         scs    RP        ;Carry holen
  2600.         addx.b    d1,RA
  2601.         bvc    \@2$        ;Overflow holen
  2602.         or.w    #OverflowMask,RP
  2603.         bra    \@3$
  2604. \@2$        and.w    #~OverflowMask,RP
  2605. \@3$        tst.b    RA
  2606.         move    ccr,RCCR    ;N und Z holen
  2607.         move.l    (sp)+,d0
  2608.         WriteByte
  2609.         Next    \1
  2610.         ENDM
  2611.  
  2612. RoRightAdcZero    MACRO    ;Zyklenzahl
  2613.         lea    (RAMPTR,d0.l),a0
  2614.         move.b    (a0),d1
  2615.         add.b    RP,RP        ;Carry -> X
  2616.         roxr.b    #1,d1
  2617.         addx.b    d1,RA
  2618.         scs    RP        ;Carry holen
  2619.         bvc    \@2$        ;Overflow holen
  2620.         or.w    #OverflowMask,RP
  2621.         bra    \@3$
  2622. \@2$        and.w    #~OverflowMask,RP
  2623. \@3$        tst.b    RA
  2624.         move    ccr,RCCR    ;N und Z holen
  2625.         move.b    d1,(a0)
  2626.         cmp.b    #2,d0
  2627.         bhs    \@1$
  2628.         NewConfig
  2629. \@1$        Next    \1
  2630.         ENDM
  2631.  
  2632. RRAZero        ReadAdrZero
  2633.         RoRightAdcZero    5
  2634.  
  2635. RRAZeroX    ReadAdrZeroX
  2636.         RoRightAdcZero    6
  2637.  
  2638. RRAAbs        ReadAdrAbs
  2639.         RoRightAdc    6
  2640.  
  2641. RRAAbsX        ReadAdrAbsX
  2642.         RoRightAdc    7
  2643.  
  2644. RRAAbsY        ReadAdrAbsY
  2645.         RoRightAdc    7
  2646.  
  2647. RRAIndX        ReadAdrIndX
  2648.         RoRightAdc    8
  2649.  
  2650. RRAIndY        ReadAdrIndY
  2651.         RoRightAdc    8
  2652.  
  2653. ; DEC/CMP-Gruppe
  2654. DecCompare    MACRO    ;Zyklenzahl
  2655.         move.l    d0,-(sp)
  2656.         ReadByte d1
  2657.         subq.b    #1,d1
  2658.         cmp.b    d1,RA
  2659.         move    ccr,RCCR
  2660.         scc    RP        ;Inverses Carry holen
  2661.         move.l    (sp)+,d0
  2662.         WriteByte
  2663.         Next    \1
  2664.         ENDM
  2665.  
  2666. DecCompareZero    MACRO    ;Zyklenzahl
  2667.         lea    (RAMPTR,d0.l),a0
  2668.         move.b    (a0),d1
  2669.         subq.b    #1,d1
  2670.         cmp.b    d1,RA
  2671.         move    ccr,RCCR
  2672.         scc    RP        ;Inverses Carry holen
  2673.         move.b    d1,(a0)
  2674.         cmp.b    #2,d0
  2675.         bhs    \@1$
  2676.         NewConfig
  2677. \@1$        Next    \1
  2678.         ENDM
  2679.  
  2680. DCPZero        ReadAdrZero
  2681.         DecCompareZero    5
  2682.  
  2683. DCPZeroX    ReadAdrZeroX
  2684.         DecCompareZero    6
  2685.  
  2686. DCPAbs        ReadAdrAbs
  2687.         DecCompare    6
  2688.  
  2689. DCPAbsX        ReadAdrAbsX
  2690.         DecCompare    7
  2691.  
  2692. DCPAbsY        ReadAdrAbsY
  2693.         DecCompare    7
  2694.  
  2695. DCPIndX        ReadAdrIndX
  2696.         DecCompare    8
  2697.  
  2698. DCPIndY        ReadAdrIndY
  2699.         DecCompare    8
  2700.  
  2701. ; INC/SBC-Gruppe
  2702. IncSbc        MACRO    ;Zyklenzahl
  2703.         move.l    d0,-(sp)
  2704.         ReadByte d1
  2705.         addq.b    #1,d1
  2706.         not.b    RP
  2707.         add.b    RP,RP        ;Inverses Carry -> X
  2708.         subx.b    d1,RA
  2709.         scc    RP        ;Inverses Carry holen
  2710.         bvc    \@2$        ;Overflow holen
  2711.         or.w    #OverflowMask,RP
  2712.         bra    \@3$
  2713. \@2$        and.w    #~OverflowMask,RP
  2714. \@3$        tst.b    RA        ;N und Z holen
  2715.         move    ccr,RCCR
  2716.         move.l    (sp)+,d0
  2717.         WriteByte
  2718.         Next    \1
  2719.         ENDM
  2720.  
  2721. IncSbcZero    MACRO    ;Zyklenzahl
  2722.         lea    (RAMPTR,d0.l),a0
  2723.         move.b    (a0),d1
  2724.         addq.b    #1,d1
  2725.         not.b    RP
  2726.         add.b    RP,RP        ;Inverses Carry -> X
  2727.         subx.b    d1,RA
  2728.         scc    RP        ;Inverses Carry holen
  2729.         bvc    \@2$        ;Overflow holen
  2730.         or.w    #OverflowMask,RP
  2731.         bra    \@3$
  2732. \@2$        and.w    #~OverflowMask,RP
  2733. \@3$        tst.b    RA        ;N und Z holen
  2734.         move    ccr,RCCR
  2735.         move.b    d1,(a0)
  2736.         cmp.b    #2,d0
  2737.         bhs    \@1$
  2738.         NewConfig
  2739. \@1$        Next    \1
  2740.         ENDM
  2741.  
  2742. ISBZero        ReadAdrZero
  2743.         IncSbcZero    5
  2744.  
  2745. ISBZeroX    ReadAdrZeroX
  2746.         IncSbcZero    6
  2747.  
  2748. ISBAbs        ReadAdrAbs
  2749.         IncSbc    6
  2750.  
  2751. ISBAbsX        ReadAdrAbsX
  2752.         IncSbc    7
  2753.  
  2754. ISBAbsY        ReadAdrAbsY
  2755.         IncSbc    7
  2756.  
  2757. ISBIndX        ReadAdrIndX
  2758.         IncSbc    8
  2759.  
  2760. ISBIndY        ReadAdrIndY
  2761.         IncSbc    8
  2762.  
  2763. ; Komplexe (undokumentierte) Funktionen
  2764. ANCImm        and.b    (RPC)+,RA    ;??? ($0b, $2b)
  2765.         move    ccr,RCCR
  2766.         smi.b    RP        ;N -> C (??)
  2767.         Next    2
  2768.  
  2769. ASRImm        and.b    (RPC)+,RA
  2770.         lsr.b    #1,RA
  2771.         move    ccr,RCCR
  2772.         scs    RP        ;Carry holen
  2773.         Next    2
  2774.  
  2775. ARRImm        and.b    (RPC)+,RA
  2776.         add.b    RP,RP        ;Carry -> X
  2777.         roxr.b    #1,RA
  2778.         move    ccr,RCCR
  2779.         scs    RP        ;Carry holen
  2780.         Next    2
  2781.  
  2782. ANEImm        or.b    #$ee,RA
  2783.         and.b    (RPC)+,RA
  2784.         and.b    RX,RA
  2785.         move    ccr,RCCR
  2786.         Next    2
  2787.  
  2788. LXAImm        and.b    (RPC)+,RA
  2789.         move.b    RA,RX
  2790.         move    ccr,RCCR
  2791.         Next    2
  2792.  
  2793. LASAbsY        ReadByteAbsY        ;??? ($bb)
  2794.         and.b    RS,d0
  2795.         move.b    d0,RX
  2796.         move.b    d0,RA
  2797.         move    ccr,RCCR
  2798.         Next    4
  2799.  
  2800. SHAAbsY        ReadPCWord
  2801.         move.w    d0,d1
  2802.         lsr.w    #8,d1
  2803.         addq.b    #1,d1
  2804.         and.b    RX,d1
  2805.         and.b    RA,d1
  2806.         add.w    RY,d0
  2807.         WriteByte
  2808.         Next    5
  2809.  
  2810. SHAIndY        moveq    #0,d0
  2811.         move.b    (RPC)+,d0
  2812.         move.w    (RAMPTR,d0.l),d0    ;(Abgekürzt)
  2813.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  2814.         move.w    d0,d1
  2815.         lsr.w    #8,d1
  2816.         addq.b    #1,d1
  2817.         and.b    RX,d1
  2818.         and.b    RA,d1
  2819.         add.w    RY,d0
  2820.         WriteByte
  2821.         Next    6
  2822.  
  2823. SHXAbsY        ReadPCWord
  2824.         move.w    d0,d1
  2825.         lsr.w    #8,d1
  2826.         addq.b    #1,d1
  2827.         and.b    RY,d1
  2828.         add.w    RY,d0
  2829.         WriteByte
  2830.         Next    5
  2831.  
  2832. SHYAbsX        ReadPCWord
  2833.         move.w    d0,d1
  2834.         lsr.w    #8,d1
  2835.         addq.b    #1,d1
  2836.         and.b    RX,d1
  2837.         add.w    RX,d0
  2838.         WriteByte
  2839.         Next    5
  2840.  
  2841. SHSAbsY        move.b    RA,RS
  2842.         and.b    RX,RS
  2843.         ReadPCWord
  2844.         move.w    d0,d1
  2845.         lsr.w    #8,d1
  2846.         addq.b    #1,d1
  2847.         and.b    RS,d1
  2848.         WriteByte
  2849.         Next    5
  2850.  
  2851. SBXImm        and.b    RA,RX
  2852.         sub.b    (RPC)+,RX
  2853.         move    ccr,RCCR
  2854.         scc    RP        ;Inverses Carry holen
  2855.         Next    2
  2856.  
  2857. *
  2858. * Erweiterte Opcodes
  2859. *
  2860.  
  2861. ; $d2
  2862. OpWrap        move.l    RPC,d1        ;Wraparound nach $100xx?
  2863.         sub.l    RAMPTR,d1
  2864.         swap    d1
  2865.         cmp.w    #1,d1
  2866.         bne    IllegalOp
  2867.         sub.l    #$10001,RPC    ;Ja, zu $00xx umleiten
  2868.         moveq    #0,d1
  2869.         Next    0
  2870.  
  2871. ; $f2 $xx
  2872. OpIEC        move.b    (RPC)+,d0    ;Selektor holen
  2873.         beq    OpIECOut
  2874.         cmp.b    #1,d0
  2875.         beq    OpIECOutATN
  2876.         cmp.b    #2,d0
  2877.         beq    OpIECOutSec
  2878.         cmp.b    #3,d0
  2879.         beq    OpIECIn
  2880.         cmp.b    #4,d0
  2881.         beq    OpIECSetATN
  2882.         cmp.b    #5,d0
  2883.         beq    OpIECRelATN
  2884.         cmp.b    #6,d0
  2885.         beq    OpIECTurnaround
  2886.         cmp.b    #7,d0
  2887.         beq    OpIECRelease
  2888.         bra    IllegalOp
  2889.  
  2890. OpIECOut    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2891.         move.b    $a3(RAMPTR),d1    ;EOI-Flag holen
  2892.         bsr    IECOut
  2893.         bra    IECSetST
  2894.  
  2895. OpIECOutATN    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2896.         bsr    IECOutATN
  2897.         bra    IECSetST
  2898.  
  2899. OpIECOutSec    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2900.         bsr    IECOutSec
  2901.         bra    IECSetST
  2902.  
  2903. OpIECIn        bsr    IECIn
  2904.         move.b    d1,RA        ;Byte in den Akku
  2905.         move    ccr,RCCR    ;Flags entsprechend setzen
  2906.         bra    IECSetST
  2907.  
  2908. OpIECSetATN    bsr    IECSetATN
  2909.         moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2910.         moveq    #0,d1
  2911.         move.w    #$edfb,d0    ;Nach $edfb springen
  2912.         Jump
  2913.         Next    0
  2914.  
  2915. OpIECRelATN    bsr    IECRelATN
  2916.         bra    IECReturn
  2917.  
  2918. OpIECTurnaround    bsr    IECTurnaround
  2919.         bra    IECReturn
  2920.  
  2921. OpIECRelease    bsr    IECRelease
  2922.         bra    IECReturn
  2923.  
  2924. IECSetST    or.b    d0,$90(RAMPTR)    ;Status setzen
  2925.         clr.b    RP        ;Carry löschen
  2926. IECReturn    moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2927.         moveq    #0,d1
  2928.         bra    RTSImpl        ;RTS ausführen
  2929.  
  2930.  
  2931. **
  2932. ** Konstanten
  2933. **
  2934.  
  2935. *
  2936. * Opcode Dispatch Table
  2937. * "*" bezeichnet einen undokumentierten Opcode
  2938. *
  2939.  
  2940.         CNOP    0,4
  2941. OpcodeTable    dc.l    BRK        ;$00
  2942.         dc.l    ORAIndX
  2943.         dc.l    IllegalOp
  2944.         dc.l    SLOIndX        ;*
  2945.         dc.l    NOPZero        ;*
  2946.         dc.l    ORAZero
  2947.         dc.l    ASLZero
  2948.         dc.l    SLOZero        ;*
  2949.  
  2950.         dc.l    PHP        ;$08
  2951.         dc.l    ORAImm
  2952.         dc.l    ASLA
  2953.         dc.l    ANCImm        ;*
  2954.         dc.l    NOPAbs        ;*
  2955.         dc.l    ORAAbs
  2956.         dc.l    ASLAbs
  2957.         dc.l    SLOAbs        ;*
  2958.  
  2959.         dc.l    BPLRel        ;$10
  2960.         dc.l    ORAIndY
  2961.         dc.l    IllegalOp
  2962.         dc.l    SLOIndY        ;*
  2963.         dc.l    NOPZeroX    ;*
  2964.         dc.l    ORAZeroX
  2965.         dc.l    ASLZeroX
  2966.         dc.l    SLOZeroX    ;*
  2967.  
  2968.         dc.l    CLC        ;$18
  2969.         dc.l    ORAAbsY
  2970.         dc.l    NOPImpl        ;*
  2971.         dc.l    SLOAbsY        ;*
  2972.         dc.l    NOPAbsX        ;*
  2973.         dc.l    ORAAbsX
  2974.         dc.l    ASLAbsX
  2975.         dc.l    SLOAbsX
  2976.  
  2977.         dc.l    JSRAbs        ;$20
  2978.         dc.l    ANDIndX
  2979.         dc.l    IllegalOp
  2980.         dc.l    RLAIndX        ;*
  2981.         dc.l    BITZero
  2982.         dc.l    ANDZero
  2983.         dc.l    ROLZero
  2984.         dc.l    RLAZero        ;*
  2985.  
  2986.         dc.l    PLP        ;$28
  2987.         dc.l    ANDImm
  2988.         dc.l    ROLA
  2989.         dc.l    ANCImm        ;*
  2990.         dc.l    BITAbs
  2991.         dc.l    ANDAbs
  2992.         dc.l    ROLAbs
  2993.         dc.l    RLAAbs        ;*
  2994.  
  2995.         dc.l    BMIRel        ;$30
  2996.         dc.l    ANDIndY
  2997.         dc.l    IllegalOp
  2998.         dc.l    RLAIndY        ;*
  2999.         dc.l    NOPZeroX    ;*
  3000.         dc.l    ANDZeroX
  3001.         dc.l    ROLZeroX
  3002.         dc.l    RLAZeroX    ;*
  3003.  
  3004.         dc.l    SEC        ;$38
  3005.         dc.l    ANDAbsY
  3006.         dc.l    NOPImpl        ;*
  3007.         dc.l    RLAAbsY        ;*
  3008.         dc.l    NOPAbsX        ;*
  3009.         dc.l    ANDAbsX
  3010.         dc.l    ROLAbsX
  3011.         dc.l    RLAAbsX        ;*
  3012.  
  3013.         dc.l    RTIImpl        ;$40
  3014.         dc.l    EORIndX
  3015.         dc.l    IllegalOp
  3016.         dc.l    SREIndX        ;*
  3017.         dc.l    NOPZero        ;*
  3018.         dc.l    EORZero
  3019.         dc.l    LSRZero
  3020.         dc.l    SREZero        ;*
  3021.  
  3022.         dc.l    PHA        ;$48
  3023.         dc.l    EORImm
  3024.         dc.l    LSRA
  3025.         dc.l    ASRImm        ;*
  3026.         dc.l    JMPAbs
  3027.         dc.l    EORAbs
  3028.         dc.l    LSRAbs
  3029.         dc.l    SREAbs        ;*
  3030.  
  3031.         dc.l    BVCRel        ;$50
  3032.         dc.l    EORIndY
  3033.         dc.l    IllegalOp
  3034.         dc.l    SREIndY        ;*
  3035.         dc.l    NOPZeroX    ;*
  3036.         dc.l    EORZeroX
  3037.         dc.l    LSRZeroX
  3038.         dc.l    SREZeroX    ;*
  3039.  
  3040.         dc.l    CLI        ;$58
  3041.         dc.l    EORAbsY
  3042.         dc.l    NOPImpl        ;*
  3043.         dc.l    SREAbsY        ;*
  3044.         dc.l    NOPAbsX        ;*
  3045.         dc.l    EORAbsX
  3046.         dc.l    LSRAbsX
  3047.         dc.l    SREAbsX        ;*
  3048.  
  3049.         dc.l    RTSImpl        ;$60
  3050.         dc.l    ADCIndX
  3051.         dc.l    IllegalOp
  3052.         dc.l    RRAIndX        ;*
  3053.         dc.l    NOPZero        ;*
  3054.         dc.l    ADCZero
  3055.         dc.l    RORZero
  3056.         dc.l    RRAZero        ;*
  3057.  
  3058.         dc.l    PLA        ;$68
  3059.         dc.l    ADCImm
  3060.         dc.l    RORA
  3061.         dc.l    ARRImm        ;*
  3062.         dc.l    JMPInd
  3063.         dc.l    ADCAbs
  3064.         dc.l    RORAbs
  3065.         dc.l    RRAAbs        ;*
  3066.  
  3067.         dc.l    BVSRel        ;$70
  3068.         dc.l    ADCIndY
  3069.         dc.l    IllegalOp
  3070.         dc.l    RRAIndY        ;*
  3071.         dc.l    NOPZeroX    ;*
  3072.         dc.l    ADCZeroX
  3073.         dc.l    RORZeroX
  3074.         dc.l    RRAZeroX    ;*
  3075.  
  3076.         dc.l    SEI        ;$78
  3077.         dc.l    ADCAbsY
  3078.         dc.l    NOPImpl        ;*
  3079.         dc.l    RRAAbsY        ;*
  3080.         dc.l    NOPAbsX        ;*
  3081.         dc.l    ADCAbsX
  3082.         dc.l    RORAbsX
  3083.         dc.l    RRAAbsX        ;*
  3084.  
  3085.         dc.l    NOPZero        ;* $80
  3086.         dc.l    STAIndX
  3087.         dc.l    NOPZero        ;*
  3088.         dc.l    SAXIndX        ;*
  3089.         dc.l    STYZero
  3090.         dc.l    STAZero
  3091.         dc.l    STXZero
  3092.         dc.l    SAXZero        ;*
  3093.  
  3094.         dc.l    DEY        ;$88
  3095.         dc.l    NOPZero        ;*
  3096.         dc.l    TXA
  3097.         dc.l    ANEImm        ;*
  3098.         dc.l    STYAbs
  3099.         dc.l    STAAbs
  3100.         dc.l    STXAbs
  3101.         dc.l    SAXAbs        ;*
  3102.  
  3103.         dc.l    BCCRel        ;$90
  3104.         dc.l    STAIndY
  3105.         dc.l    IllegalOp
  3106.         dc.l    SHAIndY        ;*
  3107.         dc.l    STYZeroX
  3108.         dc.l    STAZeroX
  3109.         dc.l    STXZeroY
  3110.         dc.l    SAXZeroY    ;*
  3111.  
  3112.         dc.l    TYA        ;$98
  3113.         dc.l    STAAbsY
  3114.         dc.l    TXS
  3115.         dc.l    SHSAbsY        ;*
  3116.         dc.l    SHYAbsX        ;*
  3117.         dc.l    STAAbsX
  3118.         dc.l    SHXAbsY        ;*
  3119.         dc.l    SHAAbsY        ;*
  3120.  
  3121.         dc.l    LDYImm        ;$a0
  3122.         dc.l    LDAIndX
  3123.         dc.l    LDXImm
  3124.         dc.l    LAXIndX        ;*
  3125.         dc.l    LDYZero
  3126.         dc.l    LDAZero
  3127.         dc.l    LDXZero
  3128.         dc.l    LAXZero        ;*
  3129.  
  3130.         dc.l    TAY        ;$a8
  3131.         dc.l    LDAImm
  3132.         dc.l    TAX
  3133.         dc.l    LXAImm        ;*
  3134.         dc.l    LDYAbs
  3135.         dc.l    LDAAbs
  3136.         dc.l    LDXAbs
  3137.         dc.l    LAXAbs        ;*
  3138.  
  3139.         dc.l    BCSRel        ;$b0
  3140.         dc.l    LDAIndY
  3141.         dc.l    IllegalOp
  3142.         dc.l    LAXIndY        ;*
  3143.         dc.l    LDYZeroX
  3144.         dc.l    LDAZeroX
  3145.         dc.l    LDXZeroY
  3146.         dc.l    LAXZeroY    ;*
  3147.  
  3148.         dc.l    CLV        ;$b8
  3149.         dc.l    LDAAbsY
  3150.         dc.l    TSX
  3151.         dc.l    LASAbsY        ;*
  3152.         dc.l    LDYAbsX
  3153.         dc.l    LDAAbsX
  3154.         dc.l    LDXAbsY
  3155.         dc.l    LAXAbsY        ;*
  3156.  
  3157.         dc.l    CPYImm        ;$c0
  3158.         dc.l    CMPIndX
  3159.         dc.l    NOPZero        ;*
  3160.         dc.l    DCPIndX        ;*
  3161.         dc.l    CPYZero
  3162.         dc.l    CMPZero
  3163.         dc.l    DECZero
  3164.         dc.l    DCPZero        ;*
  3165.  
  3166.         dc.l    INY        ;$c8
  3167.         dc.l    CMPImm
  3168.         dc.l    DEX
  3169.         dc.l    SBXImm        ;*
  3170.         dc.l    CPYAbs
  3171.         dc.l    CMPAbs
  3172.         dc.l    DECAbs
  3173.         dc.l    DCPAbs        ;*
  3174.  
  3175.         dc.l    BNERel        ;$d0
  3176.         dc.l    CMPIndY
  3177.         dc.l    OpWrap
  3178.         dc.l    DCPIndY        ;*
  3179.         dc.l    NOPZeroX    ;*
  3180.         dc.l    CMPZeroX
  3181.         dc.l    DECZeroX
  3182.         dc.l    DCPZeroX    ;*
  3183.  
  3184.         dc.l    CLD        ;$d8
  3185.         dc.l    CMPAbsY
  3186.         dc.l    NOPImpl        ;*
  3187.         dc.l    DCPAbsY        ;*
  3188.         dc.l    NOPAbsX        ;*
  3189.         dc.l    CMPAbsX
  3190.         dc.l    DECAbsX
  3191.         dc.l    DCPAbsX        ;*
  3192.  
  3193.         dc.l    CPXImm        ;$e0
  3194.         dc.l    SBCIndX
  3195.         dc.l    NOPZero        ;*
  3196.         dc.l    ISBIndX        ;*
  3197.         dc.l    CPXZero
  3198.         dc.l    SBCZero
  3199.         dc.l    INCZero
  3200.         dc.l    ISBZero        ;*
  3201.  
  3202.         dc.l    INX        ;$e8
  3203.         dc.l    SBCImm
  3204.         dc.l    NOPImpl
  3205.         dc.l    SBCImm        ;*
  3206.         dc.l    CPXAbs
  3207.         dc.l    SBCAbs
  3208.         dc.l    INCAbs
  3209.         dc.l    ISBAbs        ;*
  3210.  
  3211.         dc.l    BEQRel        ;$f0
  3212.         dc.l    SBCIndY
  3213.         dc.l    OpIEC        ;Patch
  3214.         dc.l    ISBIndY        ;*
  3215.         dc.l    NOPZeroX    ;*
  3216.         dc.l    SBCZeroX
  3217.         dc.l    INCZeroX
  3218.         dc.l    ISBZeroX    ;*
  3219.  
  3220.         dc.l    SED        ;$f8
  3221.         dc.l    SBCAbsY
  3222.         dc.l    NOPImpl        ;*
  3223.         dc.l    ISBAbsY        ;*
  3224.         dc.l    NOPAbsX        ;*
  3225.         dc.l    SBCAbsX
  3226.         dc.l    INCAbsX
  3227.         dc.l    ISBAbsX        ;*
  3228.  
  3229.  
  3230. *
  3231. * Speicherkonfigurationstabelle
  3232. *
  3233.  
  3234. ; Diese Tabelle enthält für alle 8 Speicherkonfigurationen
  3235. ; die Zeiger auf die zugehörigen Read- und WriteTabs
  3236.         CNOP    0,4
  3237. ConfigTab    dc.l    ReadWriteTab0
  3238.         dc.l    ReadWriteTab1
  3239.         dc.l    ReadWriteTab2
  3240.         dc.l    ReadWriteTab3
  3241.         dc.l    ReadWriteTab4
  3242.         dc.l    ReadWriteTab5
  3243.         dc.l    ReadWriteTab6
  3244.         dc.l    ReadWriteTab7
  3245.  
  3246.  
  3247. *
  3248. * Sonstige Konstanten
  3249. *
  3250.  
  3251. ; Taglist für CreateNewProc
  3252. ProcTags    dc.l    NP_Entry,CPUTaskProc
  3253.         dc.l    NP_Name,CPUTaskName
  3254.         dc.l    NP_Priority,-1
  3255.         dc.l    0
  3256.  
  3257. ; Strings
  3258. CPUTaskName    dc.b    "6510",0
  3259.  
  3260. IDString    dc.b    "FRODO V2.0",13
  3261.         dc.b    "(C)1994-1995 CHRISTIAN BAUER",0
  3262.         ds.b    64    ;Muß mind. 92 Zeichen lang sein
  3263.  
  3264. ; Flag: Dies ist nicht Frodo SC
  3265.         CNOP    0,4
  3266. _IsFrodoSC
  3267. IsFrodoSC    dc.w    0
  3268.  
  3269.  
  3270. **
  3271. ** Initialisierte Daten
  3272. **
  3273.  
  3274.         SECTION    "DATA",DATA
  3275.  
  3276. ; Requester
  3277. IllegalOpReq    dc.l    20,0,0,0,0
  3278. JumpToIOReq    dc.l    20,0,0,0,0
  3279.  
  3280. ; Emulator-Kennung
  3281. DFFFByte    dc.b    $55    ;Wechselt bei jedem Lesen zwischen $55 und $aa
  3282.  
  3283.  
  3284. **
  3285. ** Nicht initialisierte Daten
  3286. **
  3287.  
  3288.         SECTION    "BSS",BSS
  3289.  
  3290. ; Sprungtabellen für Speicherzugriff: Zwei Einträge pro Seite (Lesen/Schreiben)
  3291. ; Eine Tabelle für jede der 8 Speicherkonfigurationen
  3292. ReadWriteTab0    ds.l    512
  3293. ReadWriteTab1    ds.l    512
  3294. ReadWriteTab2    ds.l    512
  3295. ReadWriteTab3    ds.l    512
  3296. ReadWriteTab4    ds.l    512
  3297. ReadWriteTab5    ds.l    512
  3298. ReadWriteTab6    ds.l    512
  3299. ReadWriteTab7    ds.l    512
  3300.  
  3301. ; Sprungtabellen für Sprungbefehle: Einen Eintrag pro Seite (8 Bytes, nur
  3302. ;   die ersten 4 Bytes benutzt)
  3303. JumpTab0    ds.l    512
  3304. JumpTab1    ds.l    512
  3305. JumpTab2    ds.l    512
  3306. JumpTab3    ds.l    512
  3307. JumpTab4    ds.l    512
  3308. JumpTab5    ds.l    512
  3309. JumpTab6    ds.l    512
  3310. JumpTab7    ds.l    512
  3311.  
  3312.  
  3313.         SECTION    "__MERGED",BSS
  3314.  
  3315. ; 6510-Task
  3316.         CNOP    0,4
  3317. CPUProc        ds.l    1    ;Prozess-Handle
  3318.         XDEF    _CPUTask
  3319. _CPUTask
  3320. CPUTask        ds.l    1    ;Task des Prozesses
  3321. ReadySet    ds.l    1    ;Signal des Hauptprogramms
  3322. _InvokeSAMSet
  3323. InvokeSAMSet    ds.l    1    ;Signal -> Hauptprogramm: SAM aufrufen
  3324. ContinueSet    ds.l    1    ;Signal des CPU-Tasks
  3325. ReadySig    ds.b    1
  3326. InvokeSAMSig    ds.b    1
  3327. ContinueSig    ds.b    1
  3328.  
  3329. ; Interrupt-Flags. Bei einem Interrupt wird eins dieser Flags gesetzt.
  3330. ; Das bewirkt, daß nach dem nächsten Periodic der 6510-Task in die
  3331. ; Routine "HandleInt" springt. Dort werden diese Flags ausgewertet und
  3332. ; entsprechend verzweigt.
  3333.         CNOP    0,4
  3334. Interrupt            ;Zusammenfassung als Langwort
  3335. IntIsRESET    ds.b    1    ;RESET aufgetreten, 6510 beenden oder Pause
  3336. IntIsNMI    ds.b    1    ;NMI aufgetreten
  3337. IntIsIRQ            ;Zusammenfassung als Wort
  3338. IntIsVICIRQ    ds.b    1    ;IRQ durch VIC aufgetreten
  3339. IntIsCIAIRQ    ds.b    1    ;IRQ durch CIA-A aufgetreten
  3340.  
  3341. RESETIsEXIT    ds.b    1    ;Zur Unterscheidung von RESET und EXIT
  3342. RESETIsPause    ds.b    1    ;Zur Unterscheidung von RESET und Pause
  3343.  
  3344. NMIState    ds.b    1    ;Aktueller Zustand der NMI-Leitung (für Flankentriggerung)
  3345.  
  3346. ; Zwischenspeicher für Adc/Sbc im Dezimalmodus
  3347. TMPS        ds.b    1
  3348. TMPA        ds.b    1
  3349. TMPAL        ds.b    1
  3350.  
  3351. ; Anzahl zur Verfügung stehender CPU-Zyklen bis zum nächsten Periodic
  3352.         CNOP    0,2
  3353. CyclesLeft    ds.w    1
  3354.  
  3355. ; Speicherzeiger (außer bei TheChar stimmt bei allen das untere Wort
  3356. ; mit der tatsächlichen C64-Adresse überein, also
  3357. ;  TheRAM   : xxxx0000
  3358. ;  TheBasic : xxxxa000
  3359. ;  TheKernal: xxxxe000
  3360. ;  TheColor : xxxxd800
  3361.         CNOP    0,4
  3362. TheRAM        ds.l    1    ;Zeiger auf C64-RAM (64K)
  3363. TheBasic    ds.l    1    ;Zeiger auf Basic-ROM
  3364. TheKernal    ds.l    1    ;Zeiger auf Kernal-ROM
  3365. TheChar        ds.l    1    ;Zeiger auf Char-ROM
  3366. TheColor    ds.l    1    ;Zeiger auf Farb-RAM
  3367.  
  3368. ; Zwischenspeicher für Register bei Periodic/ReadWord/ReadAdrInd
  3369. RegStore    ds.l    5
  3370.  
  3371. ; Argumente für Requester
  3372. RequestStream    ds.l    16
  3373.  
  3374. ; Registerinhalte für SAM, nur gültig innerhalb von Pause6510/Resume6510
  3375.         XDEF    _RA
  3376. _RA        ds.b    1
  3377.         XDEF    _RX
  3378. _RX        ds.b    1
  3379.         XDEF    _RY
  3380. _RY        ds.b    1
  3381.         XDEF    _RP
  3382. _RP        ds.b    1
  3383.         XDEF    _RPR
  3384. _RPR        ds.b    1
  3385.         XDEF    _RDDR
  3386. _RDDR        ds.b    1
  3387.         XDEF    _RPC
  3388. _RPC        ds.w    1
  3389.         XDEF    _RS
  3390. _RS        ds.w    1
  3391.  
  3392.         XDEF    _SAMMemConfig
  3393. _SAMMemConfig    ds.b    1    ;CHAREN, LORAM, HIRAM
  3394.  
  3395.         END
  3396.