Das deutsche Python-Forum

Code: Alles auswählen

0285                         * INITIALISE ACIA                      
0286 dbb0 86 95                        LDA  #RTS_LOW       DIV16 CLOCK -> 7372800 / 4 / 16 = 115200 
0287 dbb2 b7 a0 00                     STA  UCTRL           
0288 dbb5 8e dc 03                     LDX  #LA147-1       POINT X TO COLOR BASIC COPYRIGHT MESSAGE 
0289 dbb8 bd eb e5                     JSR  LB99C          PRINT ‘COLOR BASIC’ 
0290 dbbb 8e db c6                     LDX  #BAWMST        WARM START ADDRESS 
0291 dbbe 9f 6f                        STX  RSTVEC         SAVE IT 
0292 dbc0 86 55                        LDA  #$55           WARM START FLAG 
0293 dbc2 97 6e                        STA  RSTFLG         SAVE IT 
0294 dbc4 20 04                        BRA  LA0F3          GO TO BASIC’S MAIN LOOP 

Code: Alles auswählen

                        *
                        * DISPATCH TABLE FOR COMMANDS TOKEN #
                        CMD_TAB
...
0085                    TOK_IF    EQU  *-CMD_TAB/2+$7F
de36 e1 8d                        FDB  DATA                        86
0086                    TOK_DATA  EQU  *-CMD_TAB/2+$7F
de38 eb 6a                        FDB  PRINT                       87
0087                    TOK_PRINT EQU  *-CMD_TAB/2+$7F
de3a e1 ef                        FDB  ON                          88

Code: Alles auswählen

                        * HERE IS WHERE WE BRANCH TO DO A 'COMMAND'
e08f 6e 94                        JMP  [,X]                       GO DO A COMMAND

Code: Alles auswählen

e08f| 6e   JMP    ea:de38                     cc=57 a=00 b=0e dp=00 x=de38 y=dd35 u=00f7 s=7f32 | .F.I.ZVC
de38| eb   ADDB   B=0e ea:7f3c m:0            cc=50 a=00 b=0e dp=00 x=de38 y=dd35 u=00f7 s=7f32 | .F.I....
de3a| e1   CMPB   B=0e ea:e29c m:c6           cc=53 a=00 b=0e dp=00 x=de38 y=dd35 u=00f7 s=7f32 | .F.I..VC
de3e| e0   SUBB   B=0e ea:deff m:25           cc=53 a=00 b=e9 dp=00 x=de38 y=dd35 u=00f7 s=7f32 | .F.I..VC
...

Code: Alles auswählen

-indirect = postbyte & 0x10 == 1 # bit 4 is 1 -> Indirect
+indirect = postbyte & 0x10 != 0 # bit 4 is 1 -> Indirect

Code: Alles auswählen

{'ABX': {'ABX': {'desc': 'X = B+X (Unsigned)',
              'operand': '',
              'ops': {0x3a: 'INHERENT'},
              'read_from_memory': '-',
              'write_to_memory': '-'}},
'ADC': {'ADCA': {'desc': 'A = A+M+C',
               'operand': 'A',
               'ops': {0x89: 'IMMEDIATE',
                      0x99: 'DIRECT',
                      0xa9: 'INDEXED',
                      0xb9: 'EXTENDED'},
               'read_from_memory': 'BYTE',
               'write_to_memory': '-'},
       'ADCB': {'desc': 'B = B+M+C',
               'operand': 'B',
               'ops': {0xc9: 'IMMEDIATE',
                      0xd9: 'DIRECT',
                      0xe9: 'INDEXED',
                      0xf9: 'EXTENDED'},
               'read_from_memory': 'BYTE',
               'write_to_memory': '-'}},
'ADD': {'ADDA': {'desc': 'A = A+M',
               'operand': 'A',
               'ops': {0x8b: 'IMMEDIATE',
                      0x9b: 'DIRECT',
                      0xab: 'INDEXED',
                      0xbb: 'EXTENDED'},
               'read_from_memory': 'BYTE',
               'write_to_memory': '-'},
       'ADDB': {'desc': 'B = B+M',
               'operand': 'B',
               'ops': {0xcb: 'IMMEDIATE',
                      0xdb: 'DIRECT',
                      0xeb: 'INDEXED',
                      0xfb: 'EXTENDED'},
               'read_from_memory': 'BYTE',
               'write_to_memory': '-'},
       'ADDD': {'desc': 'D = D+M:M+1',
               'operand': 'D',
               'ops': {0xc3: 'IMMEDIATE_WORD',
                      0xd3: 'DIRECT',
                      0xe3: 'INDEXED',
                      0xf3: 'EXTENDED'},
               'read_from_memory': 'WORD',
               'write_to_memory': '-'}},
...

Code: Alles auswählen

    read_from_memory = "-"
    if "=" in desc:
        right = desc.split("=")[1]
        if "M:M" in right:
            read_from_memory = "WORD"
        elif "M" in right:
            read_from_memory = "BYTE"

    write_to_memory = "-"
    if desc.startswith("M:M"):
        write_to_memory = "WORD"
    elif desc.startswith("M ="):
        write_to_memory = "BYTE"

Code: Alles auswählen

OP_DATA = {ABX: {'HNZVC': '-----',
     'condition code': 'Not affected.',
     'description': 'Add the 8-bit unsigned value in accumulator B into index register X.',
     'instr_desc': 'Add B accumulator to X (unsigned)',
     'mnemonic': {ABX: {'desc': 'X = B+X (Unsigned)',
                      'operand': None,
                      'ops': {0x3a: {'addr_mode': INHERENT,
                                   'bytes': 1,
                                   'cycles': 3}},
                      'read_from_memory': None,
                      'write_to_memory': None}},
     'operation': "IX' = IX + ACCB",
     'source form': ABX},
ADC: {'HNZVC': 'aaaaa',
     'condition code': 'H - Set if a half-carry is generated; cleared otherwise.\nN - Set if the result is negative; cleared otherwise.\nZ - Set if the result is zero; cleared otherwise.\nV - Set if an overflow is generated; cleared otherwise.\nC - Set if a carry is generated; cleared otherwise.',
     'description': 'Adds the contents of the C (carry) bit and the memory byte into an 8-bit accumulator.',
     'instr_desc': 'Add memory to accumulator with carry',
     'mnemonic': {'ADCA': {'desc': 'A = A+M+C',
                         'operand': REG_A,
                         'ops': {0x89: {'addr_mode': IMMEDIATE,
                                      'bytes': 2,
                                      'cycles': 2},
                                0x99: {'addr_mode': DIRECT,
                                      'bytes': 2,
                                      'cycles': 4},
                                0xa9: {'addr_mode': INDEXED,
                                      'bytes': 2,
                                      'cycles': 4},
                                0xb9: {'addr_mode': EXTENDED,
                                      'bytes': 3,
                                      'cycles': 5}},
                         'read_from_memory': BYTE,
                         'write_to_memory': None},
                 'ADCB': {'desc': 'B = B+M+C',
                         'operand': REG_B,
                         'ops': {0xc9: {'addr_mode': IMMEDIATE,
                                      'bytes': 2,
                                      'cycles': 2},
                                0xd9: {'addr_mode': DIRECT,
                                      'bytes': 2,
                                      'cycles': 4},
                                0xe9: {'addr_mode': INDEXED,
                                      'bytes': 2,
                                      'cycles': 4},
                                0xf9: {'addr_mode': EXTENDED,
                                      'bytes': 3,
                                      'cycles': 5}},
                         'read_from_memory': BYTE,
                         'write_to_memory': None}},
     'operation': "R' = R + M + C",
     'source form': 'ADCA P; ADCB P'},
ADD: {'HNZVC': 'aaaaa',
...

Code: Alles auswählen

                        * CHECK TO SEE IF THERE IS ROOM TO STORE 2*ACCB
                        * BYTES IN FREE RAM - OM ERROR IF NOT
def0 4f                 LAC33     CLRA                            * ACCD CONTAINS NUMBER OF EXTRA
def1 58                           ASLB                            * BYTES TO PUT ON STACK
def2 d3 1f                        ADDD 001f(ARYEND)               END OF PROGRAM AND VARIABLES
def4 c3 00 3a           LAC37     ADDD #003a(STKBUF)              ADD STACK BUFFER - ROOM FOR STACK?
def7 25 08                        BCS  LAC44                      BRANCH IF GREATER THAN $FFFF
def9 10 df 17                     STS  0017(BOTSTK)               CURRENT NEW BOTTOM OF STACK STACK POINTER
defc 10 93 17                     CMPD 0017(BOTSTK)               ARE WE GOING TO BE BELOW STACK?
deff 25 ee                        BCS  deef(LAC32)                YES - NO ERROR
df01 c6 0c              LAC44     LDB  #6*2                       OUT OF MEMORY ERROR

Code: Alles auswählen

def2| (30188) read byte $c3 from $def4
read pc byte: $c3 from $def4
	get m with get_m_immediate_word
def4| (30189) read byte $3a from $def6
def4| (30190) read byte $0 from $def5
	read pc word: $003a from $def5
	get_m_immediate_word(): $3a from $def5
def4| instruction_ADD16(m=$3a opcode=$c3 register=D=021c)
$def7 c3 3a ADD16 D: 540 + 58 = 598 (signed: 598)
def4| c3   ADDD   D=021c m:3a                 cc=50 a=02 b=56 dp=00 x=00f4 y=dd35 u=00ff s=0147 | .F.I....
-------------------------------------------------------------------------------
def4| (30195) read byte $25 from $def7
read pc byte: $25 from $def7
	get ea with get_ea_relative
def7| (30196) read byte $8 from $def8
read pc byte: $08 from $def8
	get_ea_relative(): ea = $def9 + 8 = $df01 	| $df01: $df01 - OUT OF MEMORY ERROR
def7| instruction_BLO(ea=$df01 opcode=$25)
$def9 BLO/BCS/LBLO/LBCS: don't branch to $df01, because C==0 	| $df01: $df01 - OUT OF MEMORY ERROR
def7| 25   BLO    ea:df01                     cc=50 a=02 b=56 dp=00 x=00f4 y=dd35 u=00ff s=0147 | .F.I....
	 new PC: def7 -> $def9	| $def9: $def9 - CURRENT NEW BOTTOM OF STACK STACK POINTER

Code: Alles auswählen

b3d3| 30   LEAX   X=0601 ea:0602              cc=50 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.I....
b3d3| 3001        LEAX    1,X                 cc=50 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.I....
b3d5| 63   COM    ea:0603 m:10                cc=59 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.IN..C
b3d5| 6301        COM     1,X                 cc=59 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.IN..C
b3d8| f1   CMPB   B=60 m:dd                   cc=53 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.I..VC
b3d7| 20f1        BRA     $b3ca               cc=59 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.IN..C
trace: b3d7| 20f1        BRA     $b3ca               cc=59 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.IN..C
own..: b3d8| f1   CMPB   B=60 m:dd                   cc=53 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.I..VC
b3d8|Error in CPU cycles: 33439
address ('b3d8' != 'b3d7') not the same as trace reference!

trace: b3d7| 20f1        BRA     $b3ca               cc=59 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.IN..C
own..: b3d8| f1   CMPB   B=60 m:dd                   cc=53 a=00 b=60 dp=00 x=0602 y=b39b u=0000 s=03d7 | .F.I..VC
b3d8|Error in CPU cycles: 33439
mnemonic ('CMPB' != 'BRA') not the same as trace reference!

Code: Alles auswählen

db16 34 02 PSHS A
db18 81 0d CMPA #000d(CR) IS IT CARRIAGE RETURN?
db1a 27 0b BEQ NEWLINE YES

Code: Alles auswählen

        self.cpu_test_run2(start=0x4000, count=3, mem=[
            # origin start address in ROM: $db16
            0x34, 0x02, # PSHS A
            0x81, 0x0d, # CMPA #000d(CR)       ; IS IT CARRIAGE RETURN?
            0x27, 0x0b, # BEQ  NEWLINE         ; YES
        ])

Code: Alles auswählen

pc=e400 i=1a    x=0000 y=0000 u=0000 s=0000 a=00 b=00 cc=00
pc=e402 i=4f    x=0000 y=0000 u=0000 s=0000 a=00 b=00 cc=ff
pc=e403 i=1f    x=0000 y=0000 u=0000 s=0000 a=00 b=00 cc=f4
pc=e405 i=10 ce x=0000 y=0000 u=0000 s=0000 a=00 b=00 cc=f4
pc=e409 i=8e    x=0000 y=0000 u=0000 s=0400 a=00 b=00 cc=f0
pc=e40c i=ce    x=e520 y=0000 u=0000 s=0400 a=00 b=00 cc=f8
pc=e40f i=c6    x=e520 y=0000 u=0280 s=0400 a=00 b=00 cc=f0
...

Code: Alles auswählen

        if value >= 0x90: # FIXME: Why?
            value -= 0x60
            char = chr(value)
            log.error("convert value -= 0x30 to %s ($%x)" , repr(char), value)

        if value <= 9: # FIXME: Why?
            value += 0x41
            char = chr(value)
            log.error("convert value += 0x41 to %s ($%x)" , repr(char), value)

Code: Alles auswählen

6809 EXTENDED BASIC
(C) 1982 BY MICROSOFT

OK
10 FOR I=1 TO 3
20 PRINT STR$(I)+" DRAGONPY"
30 NEXT I
RUN
 .0/////909 DRAGONPY
 .0/////909 DRAGONPY
OK

A="B"
?TM ERROR
OK

LIST
0./////909 FOR I=1 TO 3
0./////909 PRINT STR$(I)+" DRAGONPY"
0.///90909 NEXT I
OK