/***************************************************************************** * * * Module : DEBUG.C * * * * Fenêtre de débuggage... * * * *****************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include "Main.h" #include "Debug.h" #define TEXT_X 0 #define TEXT_Y 0 #define TEXT_INC_Y 9 extern UWORD TableRGB4[]; extern StInfosRegs InfosRegistres; extern USHORT EtatDebug; /* // Instructions "Standard" */ 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" }; /* // Instructions après l'OP-CODE 0xCB */ 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", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??", "??" }; /* // Instructions après l'OP-CODE 0xDD (ou 0xFD après modif...) */ 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", "??", "??", "??", "??", "??", "??" }; /* // Instructions après les'OP-CODE 0xDD, 0xCB (ou 0xFD, 0xCB après modif...) */ 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)", "??" }; /* // Positionne une valeur hexadécimale dans une chaine */ void Hex( char * chaine, ULONG value, USHORT nbdigits ) { static char tabDigits[] = "0123456789ABCDEF"; for ( ; nbdigits; ) { chaine[ --nbdigits ] = tabDigits[ value & 15 ]; value >>= 4; } } /* // Initialise un tableau de chaines contenant les valeurs des registres Z80 */ static char * RegString( USHORT ret ) { static char * s[] = { "AF BC DE HL AF' BC' DE' HL' ", "IX IY SP IR PC ", "flags : SZ.H.VNC", }; static char * flags = "SZ.H.VNC"; char * p = s[ ret ]; char * q = flags + strlen( flags ); USHORT i; UBYTE Flags = InfosRegistres.AF & 0xFF; switch( ret ) { case 0 : Hex( p + 3, ( ULONG )InfosRegistres.AF, 4 ); Hex( p + 12, ( ULONG )InfosRegistres.BC, 4 ); Hex( p + 21, ( ULONG )InfosRegistres.DE, 4 ); Hex( p + 30, ( ULONG )InfosRegistres.HL, 4 ); Hex( p + 40, ( ULONG )InfosRegistres._AF, 4 ); Hex( p + 49, ( ULONG )InfosRegistres._BC, 4 ); Hex( p + 58, ( ULONG )InfosRegistres._DE, 4 ); Hex( p + 67, ( ULONG )InfosRegistres._HL, 4 ); break; case 1 : Hex( p + 3, ( ULONG )InfosRegistres.IX, 4 ); Hex( p + 12, ( ULONG )InfosRegistres.IY, 4 ); Hex( p + 21, ( ULONG )InfosRegistres.SP, 4 ); Hex( p + 30, ( ULONG )InfosRegistres.IR, 4 ); Hex( p + 40, ( ULONG )InfosRegistres.PC, 4 ); break; case 2 : p += strlen( s[ ret ] ); for ( i = 0; i < 8; i++ ) { if ( ( Flags ) & ( 1 << i ) ) *--p = *--q; else { *--p = '.'; --q; } } break; } return( s[ ret ] ); } /* // Retourne la chaine de débugging */ static char * DebugString( void ) { static char chaine[ 80 ] = "00 00 00 00 .. "; static UBYTE Buffer[ 10 ]; USHORT adr = 0, AdrReel; UBYTE a, b, c; char * p; Buffer[ 0 ] = InfosRegistres.Oct0; Buffer[ 1 ] = InfosRegistres.Oct1; Buffer[ 2 ] = InfosRegistres.Oct2; Buffer[ 3 ] = InfosRegistres.Oct3; Hex( chaine, ( ULONG )Buffer[ 0 ], 2 ); Hex( chaine + 3, ( ULONG )Buffer[ 1 ], 2 ); Hex( chaine + 6, ( ULONG )Buffer[ 2 ], 2 ); Hex( chaine + 9, ( ULONG )Buffer[ 3 ], 2 ); a = Buffer[ adr++ ]; if ( a == 0xCB ) { b = Buffer[ adr++ ]; strcpy( chaine + 12, tabStrCB[ b ] ); } else if ( a == 0xED ) { b = Buffer[ adr++ ]; strcpy( chaine + 12, tabStrED[ b ] ); } else if ( a == 0xDD || a == 0xFD ) { b = Buffer[ adr++ ]; if ( b == 0xCB ) strcpy( chaine + 12, tabStrCBIX[ Buffer[ adr++ ] ] ); else strcpy( chaine + 12, 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 + 12, tabStrInstr[ a ] ); p = strstr( chaine, "eeee" ); if ( p ) { b = Buffer[ adr++ ] + 2; AdrReel = InfosRegistres.PC + b; if ( b > 0x80 ) AdrReel -= 256; Hex( p, ( ULONG )AdrReel, 4 ); } p = strstr( chaine, "ee" ); if ( p ) { b = Buffer[ adr++ ]; Hex( p, ( ULONG )b, 2 ); if ( b > 0x7F ) * ( p - 1 ) = '-'; } p = strstr( chaine, "nnnn" ); if ( p ) { b = Buffer[ adr++ ]; c = Buffer[ adr++ ]; Hex( p, ( ULONG )( b + ( c << 8 ) ), 4 ); } p = strstr( chaine, "nn" ); if ( p ) { b = Buffer[ adr ]; Hex( p, ( ULONG )b, 2 ); } return( chaine ); } /* // Affiche une chaine de caractères dans une fenêtre */ void AfficheChaine( struct Window * Fenetre, char * ch, LONG x, LONG y ) { static struct IntuiText TxtInfo = { 1, 0, JAM2, 4, 12, &topaz8, NULL, 0 }; TxtInfo.IText = ( UBYTE * )ch; PrintIText( Fenetre->RPort, &TxtInfo, x, y ); } /* // Boucle de gestion des messages... */ static void GestionMessages( struct Window * Fenetre ) { struct IntuiMessage * message; struct Gadget * gadget; USHORT OldSp = 0; int cnt = 0, fin = 0; while ( ! fin ) { cnt = 0; while( EtatDebug == 2 ) { Delay( 1 ); if ( cnt++ > 2 ) break; } if ( EtatDebug == 3 ) { cnt = 0; while( EtatDebug == 3 ) { Delay( 1 ); if ( cnt++ > 2 ) break; } while( OldSp != InfosRegistres.SP ) { EtatDebug = 3; Delay( 1 ); } } AfficheChaine( Fenetre, " ", TEXT_X, TEXT_Y ); AfficheChaine( Fenetre, DebugString(), TEXT_X, TEXT_Y ); AfficheChaine( Fenetre, RegString( 0 ), TEXT_X, TEXT_Y + TEXT_INC_Y ); AfficheChaine( Fenetre, RegString( 1 ), TEXT_X, TEXT_Y + TEXT_INC_Y * 2 ); AfficheChaine( Fenetre, RegString( 2 ), TEXT_X, TEXT_Y + TEXT_INC_Y * 3 ); /* // Attente messages */ WaitPort( Fenetre->UserPort ); while ( message = ( struct IntuiMessage * )GetMsg( Fenetre->UserPort ) ) { gadget = ( struct Gadget * )message->IAddress; ReplyMsg( ( struct Message * )message ); switch ( message->Class ) { case GADGETUP : switch( gadget->GadgetID ) { case BOUTON_PC : EtatDebug = 2; break; case BOUTON_OVER : OldSp = InfosRegistres.SP; EtatDebug = 3; break; } break; case CLOSEWINDOW : fin = 1; break; } } } } /* // Crée la fenêtre du mode "Debug" */ void DebugMode( struct Screen * Ecran, APTR VisualInfo ) { struct Window * Fenetre; struct Gadget * GList; struct Gadget * g; struct NewGadget ng1 = { 580, 16, 52, 14, (UBYTE *)"EX", &topaz8, BOUTON_PC, PLACETEXT_IN ,NULL, NULL }; struct NewGadget ng2 = { 580, 32, 52, 14, (UBYTE *)"OVER", &topaz8, BOUTON_OVER, PLACETEXT_IN ,NULL, NULL }; if ( g = CreateContext( &GList ) ) { ng1.ng_VisualInfo = ng2.ng_VisualInfo = VisualInfo; g = CreateGadget( BUTTON_KIND, g, &ng1, TAG_DONE ); g = CreateGadget( BUTTON_KIND, g, &ng2, TAG_DONE ); if ( Fenetre = OpenWindowTags( NULL , WA_Left, 0 , WA_Top, 200 , WA_Width, 640 , WA_Height, 56 , WA_IDCMP, BUTTONIDCMP | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW , WA_Flags, WFLG_ACTIVATE | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH , WA_Gadgets, GList , WA_Title, "Debug" , WA_CustomScreen, Ecran , TAG_DONE ) ) { LONG i; EtatDebug = 2; RefreshGList( GList, Fenetre, NULL, -1 ); SetRGB4( &Ecran->ViewPort, 0, 0x0A, 0x0A, 0x0A ); SetRGB4( &Ecran->ViewPort, 1, 0x00, 0x00, 0x00 ); SetRGB4( &Ecran->ViewPort, 2, 0x0F, 0x0F, 0x0F ); SetRGB4( &Ecran->ViewPort, 3, 0x06, 0x08, 0x0B ); GestionMessages( Fenetre ); for ( i = 0; i < 4; i++ ) SetRGB4( &Ecran->ViewPort , i , ( TableRGB4[ i ] >> 8 ) & 15L , ( TableRGB4[ i ] >> 4 ) & 15L , TableRGB4[ i ] & 15L ); CloseWindow( Fenetre ); FreeGadgets( GList ); EtatDebug = 0; } } }