#include #include #include #include #include #include #include #define TAILLE 65536L #define LIGNE_RET 1 #define LIGNE_JR 2 #define LIGNE_JP 4 #define LIGNE_DJNZ 8 #define LIGNE_CALL 16 typedef struct { UBYTE User; char Nom[ 11 ]; UBYTE Vide1[ 6 ]; UBYTE Type; UBYTE Vide2[ 2 ]; USHORT Debut; UBYTE Vide3; UBYTE Longueur; UBYTE RL; UBYTE Exec; UBYTE Re; UBYTE Vide4[ 36 ]; USHORT CopieLong; UBYTE Vide5; USHORT Somme; UBYTE Vide6[ 59 ]; } StHeaderCPC; static USHORT Options = 0; static char * tabStrInstr[ 256 ] = { "NOP", "LD BC,nnnn", "LD (BC),A", "INC BC", "INC B", "DEC B", "LD B,nn", "RLCA", "EX AF,AF'", "ADD HL,BC", "LD A,(BC)", "DEC BC", "INC C", "DEC C", "LD C,nn", "RRCA", "DJNZ eeee", "LD DE,nnnn", "LD (DE),A", "INC DE", "INC D", "DEC D", "LD D,nn", "RLA", "JR eeee", "ADD HL,DE", "LD A,(DE)", "DEC DE", "INC E", "DEC E", "LD E,nn", "RRA", "JR NZ,eeee", "LD HL,nnnn", "LD (nnnn),HL", "INC HL", "INC H", "DEC H", "LD H,nn", "DAA", "JR Z,eeee", "ADD HL,HL", "LD HL,(nnnn)", "DEC HL", "INC L", "DEC L", "LD L,nn", "CPL", "JR NC,eeee", "LD SP,nnnn", "LD (nnnn),A", "INC SP", "INC (HL)", "DEC (HL)", "LD (HL),nn", "SCF", "JR C,eeee", "ADD HL,SP", "LD A,(nnnn)", "DEC SP", "INC A", "DEC A", "LD A,nn", "CCF", "LD B,B", "LD B,C", "LD B,D", "LD B,E", "LD B,H", "LD B,L", "LD B,(HL)", "LD B,A", "LD C,B", "LD C,C", "LD C,D", "LD C,E", "LD C,H", "LD C,L", "LD C,(HL)", "LD C,A", "LD D,B", "LD D,C", "LD D,D", "LD D,E", "LD D,H", "LD D,L", "LD D,(HL)", "LD D,A", "LD E,B", "LD E,C", "LD E,D", "LD E,E", "LD E,H", "LD E,L", "LD E,(HL)", "LD E,A", "LD H,B", "LD H,C", "LD H,D", "LD H,E", "LD H,H", "LD H,L", "LD H,(HL)", "LD H,A", "LD L,B", "LD L,C", "LD L,D", "LD L,E", "LD L,H", "LD L,L", "LD L,(HL)", "LD L,A", "LD (HL),B", "LD (HL),C", "LD (HL),D", "LD (HL),E", "LD (HL),H", "LD (HL),L", "HALT", "LD (HL),A", "LD A,B", "LD A,C", "LD A,D", "LD A,E", "LD A,H", "LD A,L", "LD A,(HL)", "LD A,A", "ADD A,B", "ADD A,C", "ADD A,D", "ADD A,E", "ADD A,H", "ADD A,L", "ADD A,(HL)", "ADD A,A", "ADC A,B", "ADC A,C", "ADC A,D", "ADC A,E", "ADC A,H", "ADC A,L", "ADC A,(HL)", "ADC A,A", "SUB B", "SUB C", "SUB D", "SUB E", "SUB H", "SUB L", "SUB (HL)", "SUB A", "SBC A,B", "SBC A,C", "SBC A,D", "SBC A,E", "SBC A,H", "SBC A,L", "SBC A,(HL)", "SBC A,A", "AND B", "AND C", "AND D", "AND E", "AND H", "AND L", "AND (HL)", "AND A", "XOR B", "XOR C", "XOR D", "XOR E", "XOR H", "XOR L", "XOR (HL)", "XOR A", "OR B", "OR C", "OR D", "OR E", "OR H", "OR L", "OR (HL)", "OR A", "CP B", "CP C", "CP D", "CP E", "CP H", "CP L", "CP (HL)", "CP A", "RET NZ", "POP BC", "JP NZ,nnnn", "JP nnnn", "CALL NZ,nnnn", "PUSH BC", "ADD A,nn", "RST 00", "RET Z", "RET", "JP Z,nnnn", "CB", "CALL Z,nnnn", "CALL nnnn", "ADC A,nn", "RST 08", "RET NC", "POP DE", "JP NC,nnnn", "OUT (nn),A", "CALL NC,nnnn", "PUSH DE", "SUB nn", "RST 10", "RET C", "EXX", "JP C,nnnn", "IN A,(nn)", "CALL C,nnnn", "DD", "SBC A,nn", "RST 18", "RET PO", "POP HL", "JP PO,nnnn", "EX (SP),HL", "CALL PO,nnnn", "PUSH HL", "AND nn", "RST 20", "RET PE", "JP (HL)", "JP PE,nnnn", "EX DE,HL", "CALL PE,nnnn", "ED", "XOR nn", "RST 28", "RET P", "POP AF", "JP P,nnnn", "DI", "CALL P,nnnn", "PUSH AF", "OR nn", "RST 30", "RET M", "LD SP,HL", "JP M,nnnn", "EI", "CALL M,nnnn", "FD", "CP nn", "RST 38 " }; static char * tabStrCB[ 256 ] = { "RLC B", "RLC C", "RLC D", "RLC E", "RLC H", "RLC L", "RLC (HL)", "RLC A", "RRC B", "RRC C", "RRC D", "RRC E", "RRC H", "RRC L", "RRC (HL)", "RRC A", "RL B", "RL C", "RL D", "RL E", "RL H", "RL L", "RL (HL)", "RL A", "RR B", "RR C", "RR D", "RR E", "RR H", "RR L", "RR (HL)", "RR A", "SLA B", "SLA C", "SLA D", "SLA E", "SLA H", "SLA L", "SLA (HL)", "SLA A", "SRA B", "SRA C", "SRA D", "SRA E", "SRA H", "SRA L", "SRA (HL)", "SRA A", "SLL B", "SLL C", "SLL D", "SLL E", "SLL H", "SLL L", "SLL (HL)", "SLL A", "SRL B", "SRL C", "SRL D", "SRL E", "SRL H", "SRL L", "SRL (HL)", "SRL A", "BIT 00,B", "BIT 00,C", "BIT 00,D", "BIT 00,E", "BIT 00,H", "BIT 00,L", "BIT 00,(HL)", "BIT 00,A", "BIT 01,B", "BIT 01,C", "BIT 01,D", "BIT 01,E", "BIT 01,H", "BIT 01,L", "BIT 01,(HL)", "BIT 01,A", "BIT 02,B", "BIT 02,C", "BIT 02,D", "BIT 02,E", "BIT 02,H", "BIT 02,L", "BIT 02,(HL)", "BIT 02,A", "BIT 03,B", "BIT 03,C", "BIT 03,D", "BIT 03,E", "BIT 03,H", "BIT 03,L", "BIT 03,(HL)", "BIT 03,A", "BIT 04,B", "BIT 04,C", "BIT 04,D", "BIT 04,E", "BIT 04,H", "BIT 04,L", "BIT 04,(HL)", "BIT 04,A", "BIT 05,B", "BIT 05,C", "BIT 05,D", "BIT 05,E", "BIT 05,H", "BIT 05,L", "BIT 05,(HL)", "BIT 05,A", "BIT 06,B", "BIT 06,C", "BIT 06,D", "BIT 06,E", "BIT 06,H", "BIT 06,L", "BIT 06,(HL)", "BIT 06,A", "BIT 07,B", "BIT 07,C", "BIT 07,D", "BIT 07,E", "BIT 07,H", "BIT 07,L", "BIT 07,(HL)", "BIT 07,A", "RES 00,B", "RES 00,C", "RES 00,D", "RES 00,E", "RES 00,H", "RES 00,L", "RES 00,(HL)", "RES 00,A", "RES 01,B", "RES 01,C", "RES 01,D", "RES 01,E", "RES 01,H", "RES 01,L", "RES 01,(HL)", "RES 01,A", "RES 02,B", "RES 02,C", "RES 02,D", "RES 02,E", "RES 02,H", "RES 02,L", "RES 02,(HL)", "RES 02,A", "RES 03,B", "RES 03,C", "RES 03,D", "RES 03,E", "RES 03,H", "RES 03,L", "RES 03,(HL)", "RES 03,A", "RES 04,B", "RES 04,C", "RES 04,D", "RES 04,E", "RES 04,H", "RES 04,L", "RES 04,(HL)", "RES 04,A", "RES 05,B", "RES 05,C", "RES 05,D", "RES 05,E", "RES 05,H", "RES 05,L", "RES 05,(HL)", "RES 05,A", "RES 06,B", "RES 06,C", "RES 06,D", "RES 06,E", "RES 06,H", "RES 06,L", "RES 06,(HL)", "RES 06,A", "RES 07,B", "RES 07,C", "RES 07,D", "RES 07,E", "RES 07,H", "RES 07,L", "RES 07,(HL)", "RES 07,A", "SET 00,B", "SET 00,C", "SET 00,D", "SET 00,E", "SET 00,H", "SET 00,L", "SET 00,(HL)", "SET 00,A", "SET 01,B", "SET 01,C", "SET 01,D", "SET 01,E", "SET 01,H", "SET 01,L", "SET 01,(HL)", "SET 01,A", "SET 02,B", "SET 02,C", "SET 02,D", "SET 02,E", "SET 02,H", "SET 02,L", "SET 02,(HL)", "SET 02,A", "SET 03,B", "SET 03,C", "SET 03,D", "SET 03,E", "SET 03,H", "SET 03,L", "SET 03,(HL)", "SET 03,A", "SET 04,B", "SET 04,C", "SET 04,D", "SET 04,E", "SET 04,H", "SET 04,L", "SET 04,(HL)", "SET 04,A", "SET 05,B", "SET 05,C", "SET 05,D", "SET 05,E", "SET 05,H", "SET 05,L", "SET 05,(HL)", "SET 05,A", "SET 06,B", "SET 06,C", "SET 06,D", "SET 06,E", "SET 06,H", "SET 06,L", "SET 06,(HL)", "SET 06,A", "SET 07,B", "SET 07,C", "SET 07,D", "SET 07,E", "SET 07,H", "SET 07,L", "SET 07,(HL)", "SET 07,A", }; static char * tabStrED[ 256 ] = { "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "IN B,(C)", "OUT (C),B", "SBC HL,BC", "LD (nnnn),BC", "NEG", "RETN", "IM 0", "LD I,A", "IN C,(C)", "OUT (C),C", "ADC HL,BC", "LD BC,(nnnn)", "*", "RETI", "*", "LD R,A", "IN D,(C)", "OUT (C),D", "SBC HL,DE", "LD (nnnn),DE", "*", "*", "IM 1", "LD A,I", "IN E,(C)", "OUT (C),E", "ADC HL,DE", "LD DE,(nnnn)", "*", "*", "IM 2", "LD A,R", "IN H,(C)", "OUT (C),H", "SBC HL,HL", "LD (nnnn),HL", "*", "*", "*", "RRD", "IN L,(C)", "OUT (C),L", "ADC HL,HL", "LD HL,(nnnn)", "*", "*", "*", "RLD", "*", "*", "SBC HL,SP", "LD (nnnn),SP", "*", "*", "*", "*", "IN A,(C)", "OUT (C),A", "ADC HL,SP", "LD SP,(nnnn)", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "LDI", "CPI", "INI", "OUTI", "*", "*", "*", "*", "LDD", "CPD", "IND", "OUTD", "*", "*", "*", "*", "LDIR", "CPIR", "INIR", "OTIR", "*", "*", "*", "*", "LDDR", "CPDR", "INDR", "OTDR", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*" }; static char * tabStrIX[ 256 ] = { "*", "*", "*", "*", "*", "*", "*", "*", "*", "ADD IX,BC", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "ADD IX,DE", "*", "*", "*", "*", "*", "*", "*", "LD IX,nnnn", "LD (nnnn),IX", "INC IX", "INC IXh", "DEC IXh", "LD IXh,nn", "*", "*", "ADD IX,IX", "LD IX,(nnnn)", "DEC IX", "INC IXl", "DEC IXl", "LD IXl,nn", "*", "*", "*", "*", "*", "INC (IX+ee)", "DEC (IX+ee)", "LD (IX+ee),nn", "*", "*", "ADD IX,SP", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "LD B,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "LD C,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "LD D,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "LD E,(IX+ee)", "*", "*", "*", "*", "*", "*", "LD IXh,IXl", "LD H,(IX+ee)", "LD IXh,A", "*", "*", "*", "*", "LD IXl,IXh", "*", "LD L,(IX+ee)", "LD IXl,A", "LD (IX+ee),B", "LD (IX+ee),C", "LD (IX+ee),D", "LD (IX+ee),E", "LD (IX+ee),H", "LD (IX+ee),L", "*", "LD (IX+ee),A", "*", "*", "*", "*", "*", "*", "LD A,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "ADD A,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "ADC A,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SUB (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SBC A,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "AND (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "XOR (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "OR (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "CP (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "** CB IX **", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "POP IX", "*", "EX (SP),IX", "*", "PUSH IX", "*", "*", "*", "JP (IX)", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "*", "LD SP,IX", "*", "*", "*", "*", "*", "*" }; static char * tabStrCBIX[ 256 ] = { "*", "*", "*", "*", "*", "*", "RLC (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RRC (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RL (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RR (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SLA (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SRA (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SLA (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SRL (IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 0,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 1,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 2,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 3,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 4,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 5,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 6,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "BIT 7,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 0,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 1,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 2,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 3,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 4,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 5,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 6,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "RES 7,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 0,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 1,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 2,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 3,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 4,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 5,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 6,(IX+ee)", "*", "*", "*", "*", "*", "*", "*", "SET 7,(IX+ee)", "*" }; static void Hex( char * chaine, USHORT val, USHORT digit ) { static char * hex = "0123456789ABCDEF"; USHORT i; chaine += digit; for ( i = 0; i < digit; i++ ) { *--chaine = hex[ val & 0xF ]; val >>= 4; } } static void PrintMess( char * mess, USHORT l ) { if ( ! l ) l = strlen( mess ); Write( Output(), mess, ( LONG )l ); } static void SetChaine( USHORT adrMax, UBYTE * buffer, USHORT adrAbs ) { static char chaine[ 80 ] = "???? "; unsigned char a, b, c; char * p; USHORT l, adr = 0; while( adr < adrMax ) { Hex( chaine, adrAbs + adr, 4 ); a = buffer[ adr++ ]; if ( a == 0xCB ) { b = buffer[ adr++ ]; strcpy( chaine + 5, tabStrCB[ b ] ); } else if ( a == 0xED ) { b = buffer[ adr++ ]; strcpy( chaine + 5, tabStrED[ b ] ); } else if ( a == 0xDD || a == 0xFD ) { b = buffer[ adr++ ]; if ( b == 0xCB ) strcpy( chaine + 5, tabStrCBIX[ b ] ); else strcpy( chaine + 5, tabStrIX[ b ] ); if ( a == 0xFD ) { p = strstr( chaine, "IX" ); if ( p ) memcpy( p, "IY", 2 ); p = strstr( chaine, "IX" ); if ( p ) memcpy( p, "IY", 2 ); } } else strcpy( chaine + 5, tabStrInstr[ a ] ); p = strstr( chaine, "eeee" ); if ( p ) { char offset = buffer[ adr++ ]; Hex( p, adr + adrAbs + offset, 4 ); } p = strstr( chaine, "ee" ); if ( p ) { char offset = buffer[ adr++ ]; Hex( p, offset, 2 ); if ( offset < 0 ) * --p = '-'; } p = strstr( chaine, "nnnn" ); if ( p ) { b = buffer[ adr++ ]; c = buffer[ adr++ ]; Hex( p, b + ( c << 8 ), 4 ); } p = strstr( chaine, "nn" ); if ( p ) { b = buffer[ adr++ ]; Hex( p, b, 2 ); } l = strlen( chaine ); while( chaine[ --l ] == ' ' ) ; PrintMess( chaine, l + 1 ); PrintMess( "\n", 1 ); if ( ( Options & LIGNE_RET ) && ( ! strncmp( chaine + 5, "RET", 3 ) ) ) PrintMess( "\n", 1 ); if ( ( Options & LIGNE_JP ) && ( ! strncmp( chaine + 5, "JP", 2 ) ) ) PrintMess( "\n", 1 ); if ( ( Options & LIGNE_JR ) && ( ! strncmp( chaine + 5, "JR", 2 ) ) ) PrintMess( "\n", 1 ); if ( ( Options & LIGNE_CALL ) && ( ! strncmp( chaine + 5, "CALL", 4 ) ) ) PrintMess( "\n", 1 ); if ( ( Options & LIGNE_DJNZ ) && ( ! strncmp( chaine + 5, "DJNZ", 4 ) ) ) PrintMess( "\n", 1 ); } } static USHORT SommeControle( StHeaderCPC * h ) { UBYTE * p = ( UBYTE * )h; USHORT i, total = 0, calc; for ( i = 0; i < 67; i++ ) total += * p++; calc = * p++; calc += ( * p ) << 8; return( ( USHORT )( calc == total ) ); } void main( USHORT argc, char * argv[] ) { static UBYTE far buffer[ TAILLE ]; char HexChaine[ 6 ] = "0000\n"; BPTR Handle; USHORT adr = 0, l = 0; if ( argc >= 3 ) { while( argv[ 1 ][ 0 ] == '-' ) { switch( argv[ 1 ][ 1 ] ) { case 'R' : case 'r' : Options |= LIGNE_RET; break; case 'L' : case 'l' : Options |= LIGNE_JR; break; case 'J' : case 'j' : Options |= LIGNE_JP; break; case 'D' : case 'd' : Options |= LIGNE_DJNZ; break; case 'C' : case 'c' : Options |= LIGNE_CALL; break; } argv++; } if ( argv[ 2 ][ 0 ] == '$' ) { char * p = argv[ 2 ]; while( isxdigit( * ++p ) ) { adr <<= 4; adr += ( * p <= '9' ) ? * p - '0' : toupper( * p ) - 'A' + 10; } PrintMess( "Héxadécimal détecté...\n", 0 ); } else adr = atoi( argv[ 2 ] ); Handle = Open( argv[ 1 ], MODE_OLDFILE ); if ( Handle ) { StHeaderCPC h; Read( Handle, &h, 128 ); if ( SommeControle( &h )) { PrintMess( "Fichier CPC détecté.\n", 0 ); PrintMess( "\tType = ", 0 ); if ( h.Type == 2 ) PrintMess( "BINAIRE\n", 0 ); else PrintMess( "BASIC\n", 0 ); PrintMess( "\tDebut = ", 0 ); Hex( HexChaine, h.Debut, 4 ); PrintMess( HexChaine, 5 ); PrintMess( "\tLongueur = ", 0 ); Hex( HexChaine, * ( USHORT * )&h.Longueur, 4 ); PrintMess( HexChaine, 5 ); PrintMess( "\tExecution = ", 0 ); Hex( HexChaine, * ( USHORT * )&h.Exec, 4 ); PrintMess( HexChaine, 5 ); PrintMess( "\n", 1 ); } else Seek( Handle, 0, OFFSET_BEGINNING ); l = Read( Handle, buffer, TAILLE ); } Close( Handle ); SetChaine( l, buffer, adr ); } else { PrintMess( "Utilisation : DZ80 [-option1] [-option2...] FichierCPC Adresse\n", 0 ); PrintMess( "\tOptions -R : Saut de ligne après un RET\n", 0 ); PrintMess( "\t -L : Saut de ligne après un JR\n", 0 ); PrintMess( "\t -J : Saut de ligne après un JP\n", 0 ); PrintMess( "\t -D : Saut de ligne après un DJNZ\n", 0 ); PrintMess( "\t -C : Saut de ligne après un CALL\n", 0 ); } }