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