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