Return to disass.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src

Annotation of hatari/src/disass.c, revision 1.1

1.1     ! root        1: /*
        !             2:   Hatari
        !             3: 
        !             4:   Disassemble 'OpCode' into text string for use with debugger
        !             5: 
        !             6:   This works in a similar way to the decoding of instructions, which while produces
        !             7:   more complicated code is very handy for debugging in the early stages of development.
        !             8:   (Anyhow, none of this is included in the final executable!)
        !             9:   Note the 'rprintf' functions; these do a sprintf but the variables are in reverse order
        !            10:   as I use function calls as parameters which 'C' puts them on stack in the opposite order.
        !            11:   These functions are also used when writing out a history of the last 'x' instructions
        !            12:   ran, which is used for debugging.
        !            13: */
        !            14: 
        !            15: #include "main.h"
        !            16: //#include "debugger.h"
        !            17: #include "decode.h"
        !            18: #include "disass.h"
        !            19: #include "m68000.h"
        !            20: #include "misc.h"
        !            21: #include "stMemory.h"
        !            22: 
        !            23: #ifdef USE_DEBUGGER
        !            24: 
        !            25: char szSizeString[4];             /* Size B,W or L */
        !            26: char szParamString[256];          /* Data */
        !            27: char szConditionString[256];      /* Condition code */
        !            28: char szImmString[256];            /* Immediate */
        !            29: char szEffAddrString[256];        /* Effective address */
        !            30: char szUpperEffAddrString[256];   /* Effective address, upper bits in OpCode (for MOVE instruction) */
        !            31: char szRegString[256];            /* MoveM register list */
        !            32: char szOpString[256];             /* Final disassembly */
        !            33: char szOpData[256];               /* Final disassembly */
        !            34: 
        !            35: unsigned short int OpCode;        /* Opcode of instruction */
        !            36: unsigned long DisPC;              /* Disassembly Program Counter */
        !            37: 
        !            38: char *pszCC_Strings[] = {
        !            39:   "T",   // 0000 (Not used in Bcc)
        !            40:   "F",   // 0001 (Not used in Bcc)
        !            41:   "HI",  // 0010
        !            42:   "LS",  // 0011
        !            43:   "CC",  // 0100
        !            44:   "CS",  // 0101
        !            45:   "NE",  // 0110
        !            46:   "EQ",  // 0111
        !            47:   "VC",  // 1000
        !            48:   "VS",  // 1001
        !            49:   "PL",  // 1010
        !            50:   "MI",  // 1011
        !            51:   "GE",  // 1100
        !            52:   "LT",  // 1101
        !            53:   "GT",  // 1110
        !            54:   "LE"   // 1111
        !            55: };
        !            56: 
        !            57: //-----------------------------------------------------------------------
        !            58: /*
        !            59:   As 'C' functions parameters are in 'reverse' order, have set of functions
        !            60:   which pass parameters in correct order and swap in function.
        !            61:   Uses 'C++' overloads to get correct types!
        !            62: */
        !            63: void rprintf0(char *pSrcString)
        !            64: {
        !            65:   sprintf(szOpString,pSrcString);
        !            66: }
        !            67: //-----------------------------------------------------------------------
        !            68: // %s
        !            69: void rprintf1(char *pSrcString, char *pString1)
        !            70: {
        !            71:   sprintf(szOpString,pSrcString,pString1);
        !            72: }
        !            73: // %d
        !            74: void rprintf1(char *pSrcString, int Var1)
        !            75: {
        !            76:   sprintf(szOpString,pSrcString,Var1);
        !            77: }
        !            78: //-----------------------------------------------------------------------
        !            79: // %s %s
        !            80: void rprintf2(char *pSrcString, char *pString1, char *pString2)
        !            81: {
        !            82:   sprintf(szOpString,pSrcString,pString2,pString1);
        !            83: }
        !            84: // %d %s
        !            85: void rprintf2(char *pSrcString, char *pString1, int Var2)
        !            86: {
        !            87:   sprintf(szOpString,pSrcString,Var2,pString1);
        !            88: }
        !            89: // %s %d
        !            90: void rprintf2(char *pSrcString, int Var1, char *pString2)
        !            91: {
        !            92:   sprintf(szOpString,pSrcString,pString2,Var1);
        !            93: }
        !            94: // %d %d
        !            95: void rprintf2(char *pSrcString, int Var1, int Var2)
        !            96: {
        !            97:   sprintf(szOpString,pSrcString,Var2,Var1);
        !            98: }
        !            99: //-----------------------------------------------------------------------
        !           100: // %s %s %s
        !           101: void rprintf3(char *pSrcString, char *pString1, char *pString2, char *pString3)
        !           102: {
        !           103:   sprintf(szOpString,pSrcString,pString3,pString2,pString1);
        !           104: }
        !           105: // %s %s %d
        !           106: void rprintf3(char *pSrcString, int Var1, char *pString2, char *pString3)
        !           107: {
        !           108:   sprintf(szOpString,pSrcString,pString3,pString2,Var1);
        !           109: }
        !           110: // %s %d %s
        !           111: void rprintf3(char *pSrcString, char *pString1, int Var2, char *pString3)
        !           112: {
        !           113:   sprintf(szOpString,pSrcString,pString3,Var2,pString1);
        !           114: }
        !           115: // %s %d %d
        !           116: void rprintf3(char *pSrcString, int Var1, int Var2, char *pString3)
        !           117: {
        !           118:   sprintf(szOpString,pSrcString,pString3,Var2,Var1);
        !           119: }
        !           120: //-----------------------------------------------------------------------
        !           121: // %s %d %s %d
        !           122: void rprintf4(char *pSrcString, int Var1, char *pString2, int Var3, char *pString4)
        !           123: {
        !           124:   sprintf(szOpString,pSrcString,pString4,Var3,pString2,Var1);
        !           125: }
        !           126: // %s %s %d %d
        !           127: void rprintf4(char *pSrcString, int Var1, int Var2, char *pString3, char *pString4)
        !           128: {
        !           129:   sprintf(szOpString,pSrcString,pString4,pString3,Var2,Var1);
        !           130: }
        !           131: 
        !           132: 
        !           133: //-----------------------------------------------------------------------
        !           134: /*
        !           135:   Read byte,byte(odd address),word and long from memory
        !           136: */
        !           137: unsigned char Disass_ReadByte(void)
        !           138: {
        !           139:   char szString[256];
        !           140:   unsigned char Var;
        !           141: 
        !           142:   Var = *(unsigned char *)((unsigned long)STRam+(DisPC&0xffffff));
        !           143:   DisPC += SIZE_BYTE;
        !           144: 
        !           145:   // Add to szOpString
        !           146:   sprintf(szString,"%2.2X",Var);
        !           147:   strcat(szOpData,szString);
        !           148: 
        !           149:   return(Var);
        !           150: }
        !           151: unsigned char Disass_ReadByte_OddAddr(void)
        !           152: {
        !           153:   char szString[256];
        !           154:   unsigned char Var;
        !           155: 
        !           156:   Var = *(unsigned char *)((unsigned long)STRam+(DisPC&0xffffff)+1);
        !           157:   DisPC += SIZE_WORD;
        !           158: 
        !           159:   // Add to szOpString
        !           160:   sprintf(szString,"%4.4X",Var);
        !           161:   strcat(szOpData,szString);
        !           162: 
        !           163:   return(Var);
        !           164: }
        !           165: unsigned short int Disass_ReadWord(void)
        !           166: {
        !           167:   char szString[256];
        !           168:   unsigned short int Var;
        !           169: 
        !           170:   Var = *(unsigned short int *)((unsigned long)STRam+(DisPC&0xffffff));
        !           171:   DisPC += SIZE_WORD;
        !           172: 
        !           173:   // Add to szOpString
        !           174:   sprintf(szString,"%4.4X",STMemory_Swap68000Int(Var));
        !           175:   strcat(szOpData,szString);
        !           176: 
        !           177:   return(STMemory_Swap68000Int(Var));
        !           178: }
        !           179: unsigned long Diass_ReadLong(void)
        !           180: {
        !           181:   char szString[256];
        !           182:   unsigned long Var;
        !           183: 
        !           184:   Var = *(unsigned long *)((unsigned long)STRam+(DisPC&0xffffff));
        !           185:   DisPC += SIZE_LONG;
        !           186: 
        !           187:   // Add to szOpString
        !           188:   sprintf(szString,"%8.8X",STMemory_Swap68000Long(Var));
        !           189:   strcat(szOpData,szString);
        !           190: 
        !           191:   return(STMemory_Swap68000Long(Var));
        !           192: }
        !           193: 
        !           194: //-----------------------------------------------------------------------
        !           195: /*
        !           196:   Convert unsigned values to strings
        !           197: */
        !           198: char *Disass_ByteToString(unsigned char DataB)
        !           199: {
        !           200:   if (DataB<=9)
        !           201:     sprintf(szParamString,"%d",DataB);
        !           202:   else
        !           203:     sprintf(szParamString,"$%X",DataB);
        !           204:   
        !           205:   return(szParamString);
        !           206: }
        !           207: char *Disass_WordToString(unsigned short int DataW)
        !           208: {
        !           209:   if (DataW<=9)
        !           210:     sprintf(szParamString,"%d",DataW);
        !           211:   else
        !           212:     sprintf(szParamString,"$%X",DataW);
        !           213:   
        !           214:   return(szParamString);
        !           215: }
        !           216: char *Disass_LongToString(unsigned long DataL)
        !           217: {
        !           218:   if (DataL<=9)
        !           219:     sprintf(szParamString,"%d",DataL);
        !           220:   else
        !           221:     sprintf(szParamString,"$%X",DataL);
        !           222:   
        !           223:   return(szParamString);
        !           224: }
        !           225: 
        !           226: //-----------------------------------------------------------------------
        !           227: /*
        !           228:   Convert signed values to strings, pass NULL as String to write to 'szParamString' (default)
        !           229: */
        !           230: char *Disass_SignedByteToString(char DataB,char *pString=NULL)
        !           231: {
        !           232:   if (pString==NULL)
        !           233:     pString = szParamString;
        !           234: 
        !           235:   if (abs(DataB)<=9) {
        !           236:     if (DataB>=0)
        !           237:       sprintf(pString,"%d",DataB);
        !           238:     else
        !           239:       sprintf(pString,"-%d",-DataB);
        !           240:   }
        !           241:   else {
        !           242:     if (DataB>=0)
        !           243:       sprintf(pString,"$%X",DataB);
        !           244:     else
        !           245:       sprintf(pString,"$%X",(unsigned char)DataB);
        !           246:   }
        !           247: 
        !           248:   return(pString);
        !           249: }
        !           250: char *Disass_SignedWordToString(short int DataW,char *pString=NULL)
        !           251: {
        !           252:   if (pString==NULL)
        !           253:     pString = szParamString;
        !           254: 
        !           255:   if (abs(DataW)<=9) {
        !           256:     if (DataW>=0)
        !           257:       sprintf(pString,"%d",DataW);
        !           258:     else
        !           259:       sprintf(pString,"-%d",-DataW);
        !           260:   }
        !           261:   else {
        !           262:     if (DataW>=0)
        !           263:       sprintf(pString,"$%X",DataW);
        !           264:     else
        !           265:       sprintf(pString,"$%X",(unsigned short int)DataW);
        !           266:   }
        !           267: 
        !           268:   return(pString);
        !           269: }
        !           270: char *Disass_SignedLongToString(long DataL,char *pString=NULL)
        !           271: {
        !           272:   if (pString==NULL)
        !           273:     pString = szParamString;
        !           274: 
        !           275:   if (abs(DataL)<=9) {
        !           276:     if (DataL>=0)
        !           277:       sprintf(pString,"%d",DataL);
        !           278:     else
        !           279:       sprintf(pString,"-%d",-DataL);
        !           280:   }
        !           281:   else {
        !           282:     if (DataL>=0)
        !           283:       sprintf(pString,"$%X",DataL);
        !           284:     else
        !           285:       sprintf(pString,"$%X",(unsigned long)DataL);
        !           286:   }
        !           287: 
        !           288:   return(pString);
        !           289: }
        !           290: 
        !           291: //-----------------------------------------------------------------------
        !           292: /*
        !           293:   Create 'Effective Address' string from OpCode and size, 'asserts' on error
        !           294: */
        !           295: char *Disass_CalcEffAddr(int Size,unsigned short int Mode,unsigned short int Reg, char *pString)
        !           296: {
        !           297:   unsigned long OffsetL;
        !           298:   unsigned short int OffsetW,EReg,OffsetSize;
        !           299:   unsigned char OffsetB;
        !           300: 
        !           301:   // Clear string, allows easy error check when complete
        !           302:   strcpy(pString,"");
        !           303: 
        !           304:   switch(Mode) {
        !           305:     case BIN3(0,0,0):  // Dn
        !           306:       sprintf(pString,"D%d",Reg);
        !           307:       break;
        !           308:     case BIN3(0,0,1):  // An
        !           309:       sprintf(pString,"A%d",Reg);
        !           310:       break;
        !           311: 
        !           312:     case BIN3(0,1,0):  // (An)
        !           313:       sprintf(pString,"(A%d)",Reg);
        !           314:       break;
        !           315:     case BIN3(0,1,1):  // (An)+
        !           316:       sprintf(pString,"(A%d)+",Reg);
        !           317:       break;
        !           318:     case BIN3(1,0,0):  // -(An)
        !           319:       sprintf(pString,"-(A%d)",Reg);
        !           320:       break;
        !           321: 
        !           322:     case BIN3(1,0,1):  // (d16,An)
        !           323:       OffsetW = Disass_ReadWord();
        !           324:       sprintf(pString,"%s(A%d)",Disass_SignedWordToString(OffsetW),Reg);
        !           325:       break;
        !           326: 
        !           327:     case BIN3(1,1,0):  // (d8,An,Xn)
        !           328:       OffsetW = Disass_ReadWord();
        !           329:       EReg = OffsetW>>12;        // d0-d7,a0-a7
        !           330:       OffsetSize = (OffsetW>>11)&0x1;  // 0-Sign extended word, 1-long
        !           331:       if (EReg<REG_A0) {
        !           332:         if (OffsetSize==0)
        !           333:           sprintf(pString,"%s(A%d,D%d.W)",Disass_SignedByteToString((char)OffsetW),Reg,EReg);
        !           334:         else
        !           335:           sprintf(pString,"%s(A%d,D%d.L)",Disass_SignedByteToString((char)OffsetW),Reg,EReg);
        !           336:       }
        !           337:       else {
        !           338:         if (OffsetSize==0)
        !           339:           sprintf(pString,"%s(A%d,A%d.W)",Disass_SignedByteToString((char)OffsetW),Reg,EReg-REG_A0);
        !           340:         else
        !           341:           sprintf(pString,"%s(A%d,A%d.L)",Disass_SignedByteToString((char)OffsetW),Reg,EReg-REG_A0);
        !           342:       }
        !           343:       break;
        !           344: 
        !           345:     case BIN3(1,1,1):  // 0x111
        !           346:       switch(Reg) {
        !           347:         case BIN3(0,0,0):  // xxx.W
        !           348:           OffsetW = Disass_ReadWord();
        !           349:           sprintf(pString,"%s",Disass_WordToString(OffsetW));
        !           350:           break;
        !           351:         case BIN3(0,0,1):  // xxx.L
        !           352:           OffsetL = Diass_ReadLong();
        !           353:           sprintf(pString,"%s",Disass_LongToString(OffsetL));
        !           354:           break;
        !           355:         case BIN3(0,1,0):  // (d16,PC)
        !           356:           OffsetW = Disass_ReadWord();
        !           357:           sprintf(pString,"%s(PC)",Disass_LongToString((long)DisPC+(short int)OffsetW-SIZE_WORD));
        !           358:           break;
        !           359:         case BIN3(0,1,1):  // (d8,PC,Xn)
        !           360:           OffsetW = Disass_ReadWord();
        !           361:           EReg = OffsetW>>12;        // d0-d7,a0-a7
        !           362:           OffsetSize = (OffsetW>>11)&0x1;  // 0-Sign extended word, 1-long
        !           363:           if (EReg<REG_A0) {
        !           364:             if (OffsetSize==0)
        !           365:               sprintf(pString,"%s(PC,D%d.W)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg);
        !           366:             else
        !           367:               sprintf(pString,"%s(PC,D%d.L)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg);
        !           368:           }
        !           369:           else {
        !           370:             if (OffsetSize==0)
        !           371:               sprintf(pString,"%s(PC,A%d.W)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg-REG_A0);
        !           372:             else
        !           373:               sprintf(pString,"%s(PC,A%d.L)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg-REG_A0);
        !           374:           }
        !           375:           break;
        !           376:         case BIN3(1,0,0):  // 0x100  // # data
        !           377:           switch(Size) {
        !           378:             case SIZE_BYTE:
        !           379:               OffsetB = Disass_ReadByte_OddAddr();
        !           380:               sprintf(pString,"#%s",Disass_SignedByteToString(OffsetB));
        !           381:               break;
        !           382:             case SIZE_WORD:
        !           383:               OffsetW = Disass_ReadWord();
        !           384:               sprintf(pString,"#%s",Disass_SignedWordToString(OffsetW));
        !           385:               break;
        !           386:             case SIZE_LONG:
        !           387:               OffsetL = Diass_ReadLong();
        !           388:               sprintf(pString,"#%s",Disass_SignedLongToString(OffsetL));
        !           389:               break;
        !           390:           }
        !           391:           break;
        !           392:       }
        !           393:       break;
        !           394:   }
        !           395: 
        !           396:   // Check for errors!
        !           397:   if (strlen(pString)==0) {
        !           398:     assert(0);
        !           399:   }
        !           400: 
        !           401:   return(pString);
        !           402: }
        !           403: 
        !           404: //-----------------------------------------------------------------------
        !           405: /*
        !           406:   Use these two functions to find Effective Address, use 'upper' version for MOVE instruction
        !           407: */
        !           408: char *Disass_FindEffAddr(int Size)
        !           409: {
        !           410:   unsigned short int Mode,Reg;
        !           411: 
        !           412:   // Find effective address Mode and Register
        !           413:   Mode = (OpCode>>3)&0x7;
        !           414:   Reg = OpCode&0x7;
        !           415: 
        !           416:   return(Disass_CalcEffAddr(Size,Mode,Reg,szEffAddrString));
        !           417: }
        !           418: char *Disass_FindUpperEffAddr(int Size)
        !           419: {
        !           420:   unsigned short int Mode,Reg;
        !           421: 
        !           422:   // Find effective address Mode and Register in upper bits in OpCode
        !           423:   Mode = (OpCode>>6)&0x7;
        !           424:   Reg = (OpCode>>9)&0x7;
        !           425: 
        !           426:   return(Disass_CalcEffAddr(Size,Mode,Reg,szUpperEffAddrString));
        !           427: }
        !           428: 
        !           429: //-----------------------------------------------------------------------
        !           430: /*
        !           431:   Find size .B,.W,.L
        !           432:   Do as string and as SIZE_xxxx
        !           433: */
        !           434: char *Disass_FindSize_00_01_10(void)
        !           435: {
        !           436:   unsigned short int Size;
        !           437: 
        !           438:   Size = (OpCode>>6)&0x3;
        !           439:   switch(Size) {
        !           440:     case BIN2(0,0):    strcpy(szSizeString,"B"); break;
        !           441:     case BIN2(0,1):    strcpy(szSizeString,"W"); break;
        !           442:     case BIN2(1,0):    strcpy(szSizeString,"L"); break;
        !           443:   }
        !           444: 
        !           445:   return(szSizeString);
        !           446: }
        !           447: int Disass_EffAddrSize_00_01_10(void)
        !           448: {
        !           449:   unsigned short int Size;
        !           450: 
        !           451:   Size = (OpCode>>6)&0x3;
        !           452:   switch(Size) {
        !           453:     case BIN2(0,0):    return(SIZE_BYTE);
        !           454:     case BIN2(0,1):    return(SIZE_WORD);
        !           455:     case BIN2(1,0):    return(SIZE_LONG);
        !           456:   }
        !           457: 
        !           458:   // Error
        !           459:   assert(0);
        !           460:   return(0);
        !           461: }
        !           462: 
        !           463: //-----------------------------------------------------------------------
        !           464: char *Disass_FindSize_000_001_010(void)
        !           465: {
        !           466:   unsigned short int Size;
        !           467: 
        !           468:   Size = (OpCode>>6)&0x7;
        !           469:   switch(Size) {
        !           470:     case BIN3(0,0,0):    strcpy(szSizeString,"B"); break;
        !           471:     case BIN3(0,0,1):    strcpy(szSizeString,"W"); break;
        !           472:     case BIN3(0,1,0):    strcpy(szSizeString,"L"); break;
        !           473:   }
        !           474: 
        !           475:   return(szSizeString);
        !           476: }
        !           477: int Disass_EffAddrSize_000_001_010(void)
        !           478: {
        !           479:   unsigned short int Size;
        !           480: 
        !           481:   Size = (OpCode>>6)&0x7;
        !           482:   switch(Size) {
        !           483:     case BIN3(0,0,0):    return(SIZE_BYTE);
        !           484:     case BIN3(0,0,1):    return(SIZE_WORD);
        !           485:     case BIN3(0,1,0):    return(SIZE_LONG);
        !           486:   }
        !           487: 
        !           488:   // Error
        !           489:   assert(0);
        !           490:   return(0);
        !           491: }
        !           492: 
        !           493: //-----------------------------------------------------------------------
        !           494: char *Disass_FindSize_011_111(void)
        !           495: {
        !           496:   unsigned short int Size;
        !           497: 
        !           498:   Size = (OpCode>>6)&0x7;
        !           499:   switch(Size) {
        !           500:     case BIN3(0,1,1):    strcpy(szSizeString,"W"); break;
        !           501:     case BIN3(1,1,1):    strcpy(szSizeString,"L"); break;
        !           502:   }
        !           503: 
        !           504:   return(szSizeString);
        !           505: }
        !           506: int Disass_EffAddrSize_011_111(void)
        !           507: {
        !           508:   unsigned short int Size;
        !           509: 
        !           510:   Size = (OpCode>>6)&0x7;
        !           511:   switch(Size) {
        !           512:     case BIN3(0,1,1):    return(SIZE_WORD);
        !           513:     case BIN3(1,1,1):    return(SIZE_LONG);
        !           514:   }
        !           515: 
        !           516:   // Error
        !           517:   assert(0);
        !           518:   return(0);
        !           519: }
        !           520: 
        !           521: //-----------------------------------------------------------------------
        !           522: char *Disass_FindSize_100_101_110(void)
        !           523: {
        !           524:   unsigned short int Size;
        !           525: 
        !           526:   Size = (OpCode>>6)&0x7;
        !           527:   switch(Size) {
        !           528:     case BIN3(1,0,0):    strcpy(szSizeString,"B"); break;
        !           529:     case BIN3(1,0,1):    strcpy(szSizeString,"W"); break;
        !           530:     case BIN3(1,1,0):    strcpy(szSizeString,"L"); break;
        !           531:   }
        !           532: 
        !           533:   return(szSizeString);
        !           534: }
        !           535: int Disass_EffAddrSize_100_101_110(void)
        !           536: {
        !           537:   unsigned short int Size;
        !           538: 
        !           539:   Size = (OpCode>>6)&0x7;
        !           540:   switch(Size) {
        !           541:     case BIN3(1,0,0):    return(SIZE_BYTE);
        !           542:     case BIN3(1,0,1):    return(SIZE_WORD);
        !           543:     case BIN3(1,1,0):    return(SIZE_LONG);
        !           544:   }
        !           545: 
        !           546:   // Error
        !           547:   assert(0);
        !           548:   return(0);
        !           549: }
        !           550: 
        !           551: //-----------------------------------------------------------------------
        !           552: char *Disass_FindSize_010_011(void)
        !           553: {
        !           554:   unsigned short int Size;
        !           555: 
        !           556:   Size = (OpCode>>6)&0x7;
        !           557:   switch(Size) {
        !           558:     case BIN3(0,1,0):    strcpy(szSizeString,"W"); break;
        !           559:     case BIN3(0,1,1):    strcpy(szSizeString,"L"); break;
        !           560:   }
        !           561: 
        !           562:   return(szSizeString);
        !           563: }
        !           564: int Disass_EffAddrSize_010_011(void)
        !           565: {
        !           566:   unsigned short int Size;
        !           567: 
        !           568:   Size = (OpCode>>6)&0x7;
        !           569:   switch(Size) {
        !           570:     case BIN3(0,1,0):    return(SIZE_WORD);
        !           571:     case BIN3(0,1,1):    return(SIZE_LONG);
        !           572:   }
        !           573: 
        !           574:   // Error
        !           575:   assert(0);
        !           576:   return(0);
        !           577: }
        !           578: 
        !           579: //-----------------------------------------------------------------------
        !           580: char *Disass_FindSize_110_111(void)
        !           581: {
        !           582:   unsigned short int Size;
        !           583: 
        !           584:   Size = (OpCode>>6)&0x7;
        !           585:   switch(Size) {
        !           586:     case BIN3(1,1,0):  strcpy(szSizeString,"W"); break;
        !           587:     case BIN3(1,1,1):  strcpy(szSizeString,"L"); break;
        !           588:   }
        !           589: 
        !           590:   return(szSizeString);
        !           591: }
        !           592: 
        !           593: //-----------------------------------------------------------------------
        !           594: char *Disass_FindSize_100_101(void)
        !           595: {
        !           596:   unsigned short int Size;
        !           597: 
        !           598:   Size = (OpCode>>6)&0x7;
        !           599:   switch(Size) {
        !           600:     case BIN3(1,0,0):  strcpy(szSizeString,"W"); break;
        !           601:     case BIN3(1,0,1):  strcpy(szSizeString,"L"); break;
        !           602:   }
        !           603: 
        !           604:   return(szSizeString);
        !           605: }
        !           606: 
        !           607: //-----------------------------------------------------------------------
        !           608: /*
        !           609:   NOTE This is ONLY to be used with MOVE instruction, as Size bits are 12,13
        !           610: */
        !           611: char *Disass_FindSize_01_11_10(void)
        !           612: {
        !           613:   unsigned short int Size;
        !           614: 
        !           615:   Size = (OpCode>>12)&0x3;
        !           616:   switch(Size) {
        !           617:     case BIN2(0,1):    strcpy(szSizeString,"B"); break;
        !           618:     case BIN2(1,1):    strcpy(szSizeString,"W"); break;
        !           619:     case BIN2(1,0):    strcpy(szSizeString,"L"); break;
        !           620:   }
        !           621: 
        !           622:   return(szSizeString);
        !           623: }
        !           624: int Disass_EffAddrSize_01_11_10(void)
        !           625: {
        !           626:   unsigned short int Size;
        !           627: 
        !           628:   Size = (OpCode>>12)&0x3;
        !           629:   switch(Size) {
        !           630:     case BIN2(0,1):    return(SIZE_BYTE);
        !           631:     case BIN2(1,1):    return(SIZE_WORD);
        !           632:     case BIN2(1,0):    return(SIZE_LONG);
        !           633:   }
        !           634: 
        !           635:   // Error
        !           636:   assert(0);
        !           637:   return(0);
        !           638: }
        !           639: 
        !           640: //-----------------------------------------------------------------------
        !           641: /*
        !           642:   NOTE This is ONLY to be used with MOVE instruction, as Size bits are 12,13
        !           643: */
        !           644: char *Disass_FindSize_11_10(void)
        !           645: {
        !           646:   unsigned short int Size;
        !           647: 
        !           648:   Size = (OpCode>>12)&0x3;
        !           649:   switch(Size) {
        !           650:     case BIN2(1,1):    strcpy(szSizeString,"W"); break;
        !           651:     case BIN2(1,0):    strcpy(szSizeString,"L"); break;
        !           652:   }
        !           653: 
        !           654:   return(szSizeString);
        !           655: }
        !           656: int Disass_EffAddrSize_11_10(void)
        !           657: {
        !           658:   unsigned short int Size;
        !           659: 
        !           660:   Size = (OpCode>>12)&0x3;
        !           661:   switch(Size) {
        !           662:     case BIN2(1,1):    return(SIZE_WORD);
        !           663:     case BIN2(1,0):    return(SIZE_LONG);
        !           664:   }
        !           665: 
        !           666:   // Error
        !           667:   assert(0);
        !           668:   return(0);
        !           669: }
        !           670: 
        !           671: //-----------------------------------------------------------------------
        !           672: /*
        !           673:   Find size of MOVEM instruction operands
        !           674: */
        !           675: char *Disass_FindSize_MoveM(void)
        !           676: {
        !           677:   if ((OpCode&BIN7(1,0,0,0,0,0,0))==0)
        !           678:     sprintf(szSizeString,"W");
        !           679:   else
        !           680:     sprintf(szSizeString,"L");
        !           681: 
        !           682:   return(szSizeString);
        !           683: }
        !           684: int Disass_EffAddrSize_MoveM(void)
        !           685: {
        !           686:   if ((OpCode&BIN7(1,0,0,0,0,0,0))==0)
        !           687:     return(SIZE_WORD);
        !           688:   else
        !           689:     return(SIZE_LONG);
        !           690: }
        !           691: 
        !           692: //-----------------------------------------------------------------------
        !           693: /*
        !           694:   Find if access BYTE or LONG according to 'Dn' or other effective address (see BTST etc...)
        !           695: */
        !           696: char *Disass_FindSize_WordOrLong(void)
        !           697: {
        !           698:   if (((OpCode>>3)&0x7)==BIN3(0,0,0))  // Dn
        !           699:     sprintf(szSizeString,"L");
        !           700:   else
        !           701:     sprintf(szSizeString,"B");
        !           702: 
        !           703:   return(szSizeString);
        !           704: }
        !           705: int Disass_EffAddrSize_WordOrLong(void)
        !           706: {
        !           707:   if (((OpCode>>3)&0x7)==BIN3(0,0,0))  // Dn
        !           708:     return(SIZE_LONG);
        !           709:   else
        !           710:     return(SIZE_BYTE);
        !           711: }
        !           712: 
        !           713: //-----------------------------------------------------------------------
        !           714: /*
        !           715:   Read Immediate data after OpCode
        !           716: */
        !           717: char *Disass_ReadImmediate(int Size)
        !           718: {
        !           719:   // Clear string, allows easy error check when complete
        !           720:   strcpy(szImmString,"");
        !           721: 
        !           722:   switch(Size) {
        !           723:     case SIZE_BYTE:
        !           724:       Disass_SignedByteToString(Disass_ReadByte_OddAddr(),szImmString);
        !           725:       break;
        !           726:     case SIZE_WORD:
        !           727:       Disass_SignedWordToString(Disass_ReadWord(),szImmString);
        !           728:       break;
        !           729:     case SIZE_LONG:
        !           730:       Disass_SignedLongToString(Diass_ReadLong(),szImmString);
        !           731:       break;
        !           732:   }
        !           733: 
        !           734:   // Check for errors!
        !           735:   if (strlen(szImmString)==0) {
        !           736:     assert(0);
        !           737:   }
        !           738: 
        !           739:   return(szImmString);
        !           740: }
        !           741: 
        !           742: //-----------------------------------------------------------------------
        !           743: /*
        !           744:   Find conditon codes using in Bcc,Scc,DBcc etc...
        !           745: */
        !           746: char *Disass_FindCondition(void)
        !           747: {
        !           748:   strcpy(szConditionString,pszCC_Strings[(OpCode>>8)&0xf]);
        !           749:   
        !           750:   return(szConditionString);
        !           751: }
        !           752: 
        !           753: //-----------------------------------------------------------------------
        !           754: /*
        !           755:   Find register index using bits 9,10,11
        !           756: */
        !           757: int Disass_FindRegister(void)
        !           758: {
        !           759:   return((OpCode>>9)&0x7);
        !           760: }
        !           761: 
        !           762: // And using bits 0,1,2
        !           763: int Disass_FindRegisterLower(void)
        !           764: {
        !           765:   return(OpCode&0x7);
        !           766: }
        !           767: 
        !           768: //-----------------------------------------------------------------------
        !           769: /*
        !           770:   Find shift count 1,2,3,4...8 from data 0,1,2,3...7
        !           771: */
        !           772: #define Disass_FindQuickData  Disass_FindShiftCount  // 'Quick' data ie ADDQ uses same process
        !           773: int Disass_FindShiftCount(void)
        !           774: {
        !           775:   unsigned short int Count;
        !           776: 
        !           777:   Count = (OpCode>>9)&0x7;
        !           778:   if (Count==0)
        !           779:     Count = 8;
        !           780: 
        !           781:   return(Count);
        !           782: }
        !           783: 
        !           784: //-----------------------------------------------------------------------
        !           785: /*
        !           786:   Return TRUE is displacement is a signed 8-bit number
        !           787:   Used in BRA,BSR,Bcc etc...
        !           788: */
        !           789: BOOL Disass_ShortDisplacement(void)
        !           790: {
        !           791:   if ((OpCode&0xff)==0)
        !           792:     return(FALSE);    // 16-bit offset
        !           793:   else
        !           794:     return(TRUE);    // 8-bit offset
        !           795: }
        !           796: 
        !           797: //-----------------------------------------------------------------------
        !           798: /*
        !           799:   Convert register mask for MOVEM into string, eg D0123/A167 (D0-D3/A1/A6-A7)
        !           800: */
        !           801: char *Disass_FindMoveMRegisters(unsigned short int MaskW)
        !           802: {
        !           803:   char szString[256];
        !           804:   int i;
        !           805: 
        !           806:   // Set 'Dx-Dy/Ax-Ay' string
        !           807:   strcpy(szRegString,"");
        !           808:   // Is pre-decrement? -(An)
        !           809:   if (((OpCode>>3)&0x7)==BIN3(1,0,0)) {  // D0..D7/A0..A7
        !           810:     if (MaskW&0xff00) {  // Any 'D' registers?
        !           811:       strcat(szRegString,"D");
        !           812:       for(i=0; i<8; i++) {
        !           813:         if (MaskW&(0x8000>>i)) {
        !           814:           sprintf(szString,"%d",i);
        !           815:           strcat(szRegString,szString);
        !           816:         }
        !           817:       }
        !           818:     }
        !           819:     if (MaskW&0x00ff) {  // Any 'A' registers?
        !           820:       // Separate by '/'
        !           821:       if (strlen(szRegString)>0)
        !           822:         strcat(szRegString,"/");
        !           823: 
        !           824:       strcat(szRegString,"A");
        !           825:       for(i=0; i<8; i++) {
        !           826:         if (MaskW&(0x0080>>i)) {
        !           827:           sprintf(szString,"%d",i);
        !           828:           strcat(szRegString,szString);
        !           829:         }
        !           830:       }
        !           831:     }
        !           832:   }
        !           833:   else {              // A7..A0/D7..D0
        !           834:     if (MaskW&0x00ff) {  // Any 'D' registers?
        !           835:       strcat(szRegString,"D");
        !           836:       for(i=0; i<8; i++) {
        !           837:         if (MaskW&(0x0001<<i)) {
        !           838:           sprintf(szString,"%d",i);
        !           839:           strcat(szRegString,szString);
        !           840:         }
        !           841:       }
        !           842:     }
        !           843:     if (MaskW&0xff00) {  // Any 'A' registers?
        !           844:       // Separate by '/'
        !           845:       if (strlen(szRegString)>0)
        !           846:         strcat(szRegString,"/");
        !           847: 
        !           848:       strcat(szRegString,"A");
        !           849:       for(i=0; i<8; i++) {
        !           850:         if (MaskW&(0x0100<<i)) {
        !           851:           sprintf(szString,"%d",i);
        !           852:           strcat(szRegString,szString);
        !           853:         }
        !           854:       }
        !           855:     }
        !           856:   }
        !           857: 
        !           858:   return(szRegString);
        !           859: }
        !           860: 
        !           861: 
        !           862: 
        !           863: //-----------------------------------------------------------------------
        !           864: /*
        !           865:   List of disassembly instruction functions
        !           866: */
        !           867: 
        !           868: //-----------------------------------------------------------------------
        !           869: // ABCD Dy,Dx
        !           870: void Disass_ABCD_Dy_Dx(void)
        !           871: {
        !           872:   rprintf2( "ABCD.B\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower() );
        !           873: }
        !           874: 
        !           875: // ABCD -(Ay),-(Ax)
        !           876: void Disass_ABCD_Ay_Ax(void)
        !           877: {
        !           878:   rprintf2( "ABCD.B\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower() );
        !           879: }
        !           880: 
        !           881: //-----------------------------------------------------------------------
        !           882: // ADD <ea>,Dn
        !           883: void Disass_ADD_ea_Dn(void)
        !           884: {
        !           885:   rprintf3( "ADD.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
        !           886: }
        !           887: 
        !           888: // ADD Dn,<ea>
        !           889: void Disass_ADD_Dn_ea(void)
        !           890: {
        !           891:   rprintf3( "ADD.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
        !           892: }
        !           893: 
        !           894: //-----------------------------------------------------------------------
        !           895: // ADDA <ea>,An
        !           896: void Disass_ADDA(void)
        !           897: {
        !           898:   rprintf3( "ADDA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
        !           899: }
        !           900: 
        !           901: //-----------------------------------------------------------------------
        !           902: // ADDI #<data>,<ea>
        !           903: void Disass_ADDI(void)
        !           904: {
        !           905:   rprintf3( "ADDI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !           906: }
        !           907: 
        !           908: //-----------------------------------------------------------------------
        !           909: // ADDQ #<data>,<ea>
        !           910: void Disass_ADDQ(void)
        !           911: {
        !           912:   rprintf3( "ADDQ.%s\t#%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindQuickData(),Disass_FindSize_00_01_10() );
        !           913: }
        !           914: 
        !           915: //-----------------------------------------------------------------------
        !           916: // ADDX Dy,Dx
        !           917: void Disass_ADDX_Dy_Dx(void)
        !           918: {
        !           919:   rprintf3( "ADDX.%s\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
        !           920: }
        !           921: 
        !           922: // ADDX -(Ay),-(Ax)
        !           923: void Disass_ADDX_Ay_Ax(void)
        !           924: {
        !           925:   rprintf3( "ADDX.%s\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
        !           926: }
        !           927: 
        !           928: //-----------------------------------------------------------------------
        !           929: // AND <ea>,Dn
        !           930: void Disass_AND_ea_Dn(void)
        !           931: {
        !           932:   rprintf3( "AND.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
        !           933: }
        !           934: 
        !           935: // AND Dn,<ea>
        !           936: void Disass_AND_Dn_ea(void)
        !           937: {
        !           938:   rprintf3( "AND.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
        !           939: }
        !           940: 
        !           941: //-----------------------------------------------------------------------
        !           942: // ANDI #<data>,<ea>
        !           943: void Disass_ANDI(void)
        !           944: {
        !           945:   rprintf3( "ANDI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !           946: }
        !           947: 
        !           948: //-----------------------------------------------------------------------
        !           949: // AND to CCR #<data>,CCR
        !           950: void Disass_ANDI_to_CCR(void)
        !           951: {
        !           952:   rprintf1( "ANDI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
        !           953: }
        !           954: 
        !           955: //-----------------------------------------------------------------------
        !           956: // AND to SR #<data>,SR
        !           957: void Disass_ANDI_to_SR(void)
        !           958: {
        !           959:   rprintf1( "ANDI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
        !           960: }
        !           961: 
        !           962: //-----------------------------------------------------------------------
        !           963: // ASL Dx,Dy
        !           964: void Disass_ASL_Dx_Dy(void)
        !           965: {
        !           966:   rprintf3( "ASL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !           967: }
        !           968: 
        !           969: // ASL #<data>,Dy
        !           970: void Disass_ASL_data_Dy(void)
        !           971: {
        !           972:   rprintf3( "ASL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !           973: }
        !           974: 
        !           975: // ASL <ea>
        !           976: void Disass_ASL(void)
        !           977: {
        !           978:   rprintf1( "ASL.W\t%s",Disass_FindEffAddr(NULL) );
        !           979: }
        !           980: 
        !           981: //-----------------------------------------------------------------------
        !           982: // ASR Dx,Dy
        !           983: void Disass_ASR_Dx_Dy(void)
        !           984: {
        !           985:   rprintf3( "ASR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !           986: }
        !           987: 
        !           988: // ASR #<data>,Dy
        !           989: void Disass_ASR_data_Dy(void)
        !           990: {
        !           991:   rprintf3( "ASR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !           992: }
        !           993: 
        !           994: // ASR <ea>
        !           995: void Disass_ASR(void)
        !           996: {
        !           997:   rprintf1( "ASR.W\t%s",Disass_FindEffAddr(NULL) );
        !           998: }
        !           999: 
        !          1000: //-----------------------------------------------------------------------
        !          1001: // Bcc <label>
        !          1002: void Disass_Bcc(void)
        !          1003: {
        !          1004:   short int OffsetW;
        !          1005: 
        !          1006:   if (Disass_ShortDisplacement())
        !          1007:     rprintf2( "B%s.S\t$%X",DisPC+(char)OpCode,Disass_FindCondition() );
        !          1008:   else {
        !          1009:     OffsetW = Disass_ReadWord();
        !          1010:     rprintf2( "B%s.W\t$%X",(DisPC-SIZE_WORD)+OffsetW,Disass_FindCondition() );
        !          1011:   }
        !          1012: }
        !          1013: 
        !          1014: //-----------------------------------------------------------------------
        !          1015: // BCHG Dn,<ea>
        !          1016: void Disass_BCHG(void)
        !          1017: {
        !          1018:   rprintf3( "BCHG.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
        !          1019: }
        !          1020: 
        !          1021: // BCHG #<data>,<ea>
        !          1022: void Disass_BCHG_imm(void)
        !          1023: {
        !          1024:   rprintf3( "BCHG.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
        !          1025: }
        !          1026: 
        !          1027: //-----------------------------------------------------------------------
        !          1028: // BCLR Dn,<ea>
        !          1029: void Disass_BCLR(void)
        !          1030: {
        !          1031:   rprintf3( "BCLR.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
        !          1032: }
        !          1033: 
        !          1034: // BCLR #<data>,<ea>
        !          1035: void Disass_BCLR_imm(void)
        !          1036: {
        !          1037:   rprintf3( "BCLR.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
        !          1038: }
        !          1039: 
        !          1040: //-----------------------------------------------------------------------
        !          1041: // BRA <label>
        !          1042: void Disass_BRA(void)
        !          1043: {
        !          1044:   short int OffsetW;
        !          1045: 
        !          1046:   if (Disass_ShortDisplacement())
        !          1047:     rprintf1( "BRA.S\t$%X",DisPC+(char)OpCode );
        !          1048:   else {
        !          1049:     OffsetW = Disass_ReadWord();
        !          1050:     rprintf1( "BRA.W\t$%X",(DisPC-SIZE_WORD)+OffsetW );
        !          1051:   }
        !          1052: }
        !          1053: 
        !          1054: //-----------------------------------------------------------------------
        !          1055: // BSET Dn,<ea>
        !          1056: void Disass_BSET(void)
        !          1057: {
        !          1058:   rprintf3( "BSET.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
        !          1059: }
        !          1060: 
        !          1061: // BSET #<data>,<ea>
        !          1062: void Disass_BSET_imm(void)
        !          1063: {
        !          1064:   rprintf3( "BSET.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
        !          1065: }
        !          1066: 
        !          1067: //-----------------------------------------------------------------------
        !          1068: // BSR <label>
        !          1069: void Disass_BSR(void)
        !          1070: {
        !          1071:   short int OffsetW;
        !          1072: 
        !          1073:   if (Disass_ShortDisplacement())
        !          1074:     rprintf1( "BSR.S\t$%X",DisPC+(char)OpCode );
        !          1075:   else {
        !          1076:     OffsetW = Disass_ReadWord();
        !          1077:     rprintf1( "BSR.W\t$%X",(DisPC-SIZE_WORD)+OffsetW );
        !          1078:   }
        !          1079: }
        !          1080: 
        !          1081: //-----------------------------------------------------------------------
        !          1082: // BTST Dn,<ea>
        !          1083: void Disass_BTST(void)
        !          1084: {
        !          1085:   rprintf3( "BTST.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
        !          1086: }
        !          1087: 
        !          1088: // BTST #<data>,<ea>
        !          1089: void Disass_BTST_imm(void)
        !          1090: {
        !          1091:   rprintf3( "BTST.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
        !          1092: }
        !          1093: 
        !          1094: //-----------------------------------------------------------------------
        !          1095: // CHK <ea>,Dn
        !          1096: void Disass_CHK(void)
        !          1097: {
        !          1098:   rprintf2( "CHK.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
        !          1099: }
        !          1100: 
        !          1101: //-----------------------------------------------------------------------
        !          1102: // CLR <ea>
        !          1103: void Disass_CLR(void)
        !          1104: {
        !          1105:   rprintf2( "CLR.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1106: }
        !          1107: 
        !          1108: //-----------------------------------------------------------------------
        !          1109: // CMP <ea>,Dn
        !          1110: void Disass_CMP(void)
        !          1111: {
        !          1112:   rprintf3( "CMP.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
        !          1113: }
        !          1114: 
        !          1115: //-----------------------------------------------------------------------
        !          1116: // CMPA <ea>,An
        !          1117: void Disass_CMPA(void)
        !          1118: {
        !          1119:   rprintf3( "CMPA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
        !          1120: }
        !          1121: 
        !          1122: //-----------------------------------------------------------------------
        !          1123: // CMPI #<data>,<ea>
        !          1124: void Disass_CMPI(void)
        !          1125: {
        !          1126:   rprintf3( "CMPI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1127: }
        !          1128: 
        !          1129: //-----------------------------------------------------------------------
        !          1130: // CMPM (Ay)+,(Ax)+
        !          1131: void Disass_CMPM(void)
        !          1132: {
        !          1133:   rprintf3( "CMPM.%s\t(A%d)+,(A%d)+",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
        !          1134: }
        !          1135: 
        !          1136: //-----------------------------------------------------------------------
        !          1137: // DBcc Dn,<label>
        !          1138: void Disass_DBcc(void)
        !          1139: {
        !          1140:   short int OffsetW;
        !          1141: 
        !          1142:   OffsetW = Disass_ReadWord();
        !          1143:   rprintf3( "DB%s.W\tD%d,$%X",(DisPC-SIZE_WORD)+OffsetW,Disass_FindRegisterLower(),Disass_FindCondition() );
        !          1144: }
        !          1145: 
        !          1146: //-----------------------------------------------------------------------
        !          1147: // DIVS <ea>,Dn
        !          1148: void Disass_DIVS(void)
        !          1149: {
        !          1150:   rprintf2( "DIVS.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
        !          1151: }
        !          1152: 
        !          1153: //-----------------------------------------------------------------------
        !          1154: // DIVU <ea>,Dn
        !          1155: void Disass_DIVU(void)
        !          1156: {
        !          1157:   rprintf2( "DIVU.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
        !          1158: }
        !          1159: 
        !          1160: //-----------------------------------------------------------------------
        !          1161: // EOR Dn,<ea>
        !          1162: void Disass_EOR(void)
        !          1163: {
        !          1164:   rprintf3( "EOR.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindSize_100_101_110() );
        !          1165: }
        !          1166: 
        !          1167: //-----------------------------------------------------------------------
        !          1168: // EORI #<data>,Dn
        !          1169: void Disass_EORI(void)
        !          1170: {
        !          1171:   rprintf3( "EORI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1172: }
        !          1173: 
        !          1174: //-----------------------------------------------------------------------
        !          1175: // EOR to CCR #<data>,CCR
        !          1176: void Disass_EORI_to_CCR(void)
        !          1177: {
        !          1178:   rprintf1( "EORI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
        !          1179: }
        !          1180: 
        !          1181: //-----------------------------------------------------------------------
        !          1182: // EOR to SR #<data>,SR
        !          1183: void Disass_EORI_to_SR(void)
        !          1184: {
        !          1185:   rprintf1( "EORI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
        !          1186: }
        !          1187: 
        !          1188: //-----------------------------------------------------------------------
        !          1189: // EXG Dx,Dy
        !          1190: void Disass_EXG_Dx_Dy(void)
        !          1191: {
        !          1192:   rprintf2( "EXG.L\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister() );
        !          1193: }
        !          1194: 
        !          1195: // EXG Ax,Ay
        !          1196: void Disass_EXG_Ax_Ay(void)
        !          1197: {
        !          1198:   rprintf2( "EXG.L\tA%d,A%d",Disass_FindRegisterLower(),Disass_FindRegister() );
        !          1199: }
        !          1200: 
        !          1201: // EXG Dx,Ay
        !          1202: void Disass_EXG_Dx_Ay(void)
        !          1203: {
        !          1204:   rprintf2( "EXG.L\tD%d,A%d",Disass_FindRegisterLower(),Disass_FindRegister() );
        !          1205: }
        !          1206: 
        !          1207: //-----------------------------------------------------------------------
        !          1208: // EXT Dn
        !          1209: void Disass_EXT(void)
        !          1210: {
        !          1211:   rprintf2( "EXT.%s\tD%d",Disass_FindRegisterLower(),Disass_FindSize_010_011() );
        !          1212: }
        !          1213: 
        !          1214: //-----------------------------------------------------------------------
        !          1215: // ILLEGAL
        !          1216: void Disass_ILLEGAL(void)
        !          1217: {
        !          1218:   rprintf0( "ILLEGAL" );
        !          1219: }
        !          1220: 
        !          1221: //-----------------------------------------------------------------------
        !          1222: // JMP <ea>
        !          1223: void Disass_JMP(void)
        !          1224: {
        !          1225:   rprintf1( "JMP\t%s",Disass_FindEffAddr(NULL) );
        !          1226: }
        !          1227: 
        !          1228: //-----------------------------------------------------------------------
        !          1229: // JSR <ea>
        !          1230: void Disass_JSR(void)
        !          1231: {
        !          1232:   rprintf1( "JSR\t%s",Disass_FindEffAddr(NULL) );
        !          1233: }
        !          1234: 
        !          1235: //-----------------------------------------------------------------------
        !          1236: // LEA <ea>,An
        !          1237: void Disass_LEA(void)
        !          1238: {
        !          1239:   rprintf2( "LEA\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_LONG) );
        !          1240: }
        !          1241: 
        !          1242: //-----------------------------------------------------------------------
        !          1243: // LINK An,#<displacement>
        !          1244: void Disass_LINK(void)
        !          1245: {
        !          1246:   unsigned short int OffsetW;
        !          1247: 
        !          1248:   OffsetW = Disass_ReadWord();
        !          1249:   rprintf2( "LINK\tA%d,#%s",Disass_WordToString(OffsetW),Disass_FindRegisterLower() );
        !          1250: }
        !          1251: 
        !          1252: //-----------------------------------------------------------------------
        !          1253: // LSL Dx,Dy
        !          1254: void Disass_LSL_Dx_Dy(void)
        !          1255: {
        !          1256:   rprintf3( "LSL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1257: }
        !          1258: 
        !          1259: // LSL #<data>,Dy
        !          1260: void Disass_LSL_data_Dy(void)
        !          1261: {
        !          1262:   rprintf3( "LSL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1263: }
        !          1264: 
        !          1265: // LSL <ea>
        !          1266: void Disass_LSL(void)
        !          1267: {
        !          1268:   rprintf1( "LSL.W\t%s",Disass_FindEffAddr(NULL) );
        !          1269: }
        !          1270: 
        !          1271: //-----------------------------------------------------------------------
        !          1272: // LSR Dx,Dy
        !          1273: void Disass_LSR_Dx_Dy(void)
        !          1274: {
        !          1275:   rprintf3( "LSR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1276: }
        !          1277: 
        !          1278: // LSR #<data>,Dy
        !          1279: void Disass_LSR_data_Dy(void)
        !          1280: {
        !          1281:   rprintf3( "LSR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1282: }
        !          1283: 
        !          1284: // LSR <ea>
        !          1285: void Disass_LSR(void)
        !          1286: {
        !          1287:   rprintf1( "LSR.W\t%s",Disass_FindEffAddr(NULL) );
        !          1288: }
        !          1289: 
        !          1290: //-----------------------------------------------------------------------
        !          1291: // MOVE <ea>,<ea>
        !          1292: void Disass_MOVE(void)
        !          1293: {
        !          1294:   rprintf3( "MOVE.%s\t%s,%s",Disass_FindUpperEffAddr(Disass_EffAddrSize_01_11_10()),Disass_FindEffAddr(Disass_EffAddrSize_01_11_10()),Disass_FindSize_01_11_10() );
        !          1295: }
        !          1296: 
        !          1297: //-----------------------------------------------------------------------
        !          1298: // MOVEA <ea>,An
        !          1299: void Disass_MOVEA(void)
        !          1300: {
        !          1301:   rprintf3( "MOVEA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_11_10()),Disass_FindSize_11_10() );
        !          1302: }
        !          1303: 
        !          1304: //-----------------------------------------------------------------------
        !          1305: // MOVE CCR,<ea>
        !          1306: void Disass_MOVE_from_CCR(void)
        !          1307: {
        !          1308:   rprintf1( "MOVE.W\tCCR,%s",Disass_FindEffAddr(SIZE_WORD) );
        !          1309: }
        !          1310: 
        !          1311: //-----------------------------------------------------------------------
        !          1312: // MOVE <ea>,CCR
        !          1313: void Disass_MOVE_to_CCR(void)
        !          1314: {
        !          1315:   rprintf1( "MOVE.W\t%s,CCR",Disass_FindEffAddr(SIZE_WORD) );
        !          1316: }
        !          1317: 
        !          1318: //-----------------------------------------------------------------------
        !          1319: // MOVE SR,<ea>
        !          1320: void Disass_MOVE_from_SR(void)
        !          1321: {
        !          1322:   rprintf1( "MOVE.W\tSR,%s",Disass_FindEffAddr(SIZE_WORD) );
        !          1323: }
        !          1324: 
        !          1325: //-----------------------------------------------------------------------
        !          1326: // MOVE <ea>,SR
        !          1327: void Disass_MOVE_to_SR(void)
        !          1328: {
        !          1329:   rprintf1( "MOVE.W\t%s,SR",Disass_FindEffAddr(SIZE_WORD) );
        !          1330: }
        !          1331: 
        !          1332: //-----------------------------------------------------------------------
        !          1333: // MOVE USP,An
        !          1334: void Disass_MOVE_USP_An(void)
        !          1335: {
        !          1336:   rprintf1( "MOVE.L\tUSP,A%d",Disass_FindRegisterLower() );
        !          1337: }
        !          1338: 
        !          1339: // MOVE An,USP
        !          1340: void Disass_MOVE_An_USP(void)
        !          1341: {
        !          1342:   rprintf1( "MOVE.L\tA%d,USP",Disass_FindRegisterLower() );
        !          1343: }
        !          1344: 
        !          1345: //-----------------------------------------------------------------------
        !          1346: // MOVEM regs,<ea>
        !          1347: void Disass_MOVEM_regs_ea(void)
        !          1348: {
        !          1349:   unsigned short int MaskW;
        !          1350: 
        !          1351:   MaskW = Disass_ReadWord();
        !          1352:   rprintf3( "MOVEM.%s\t%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_MoveM()),Disass_FindMoveMRegisters(MaskW),Disass_FindSize_MoveM() );
        !          1353: }
        !          1354: 
        !          1355: // MOVEM <ea>,regs
        !          1356: void Disass_MOVEM_ea_regs(void)
        !          1357: {
        !          1358:   unsigned short int MaskW;
        !          1359: 
        !          1360:   MaskW = Disass_ReadWord();
        !          1361:   rprintf3( "MOVEM.%s\t%s,%s",Disass_FindMoveMRegisters(MaskW),Disass_FindEffAddr(Disass_EffAddrSize_MoveM()),Disass_FindSize_MoveM() );
        !          1362: }
        !          1363: 
        !          1364: //-----------------------------------------------------------------------
        !          1365: // MOVEP Dx,(d,Ay)
        !          1366: void Disass_MOVEP_Dn_An(void)
        !          1367: {
        !          1368:   rprintf4( "MOVEP.%s\tD%d,%s(A%d)",Disass_FindRegisterLower(),Disass_ReadImmediate(SIZE_WORD),Disass_FindRegister(),Disass_FindSize_110_111() );
        !          1369: }
        !          1370: 
        !          1371: // MOVEP (d,Ay),Dx
        !          1372: void Disass_MOVEP_An_Dn(void)
        !          1373: {
        !          1374:   rprintf4( "MOVEP.%s\t%s(A%d),D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_ReadImmediate(SIZE_WORD),Disass_FindSize_100_101() );
        !          1375: }
        !          1376: 
        !          1377: //-----------------------------------------------------------------------
        !          1378: // MOVEQ #<data>,Dn
        !          1379: void Disass_MOVEQ(void)
        !          1380: {
        !          1381:   rprintf2( "MOVEQ.L\t#%d,D%d",Disass_FindRegister(),(char)OpCode );
        !          1382: }
        !          1383: 
        !          1384: //-----------------------------------------------------------------------
        !          1385: // MULS <ea>,Dn
        !          1386: void Disass_MULS(void)
        !          1387: {
        !          1388:   rprintf2( "MULS.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
        !          1389: }
        !          1390: 
        !          1391: //-----------------------------------------------------------------------
        !          1392: // MULU <ea>,Dn
        !          1393: void Disass_MULU(void)
        !          1394: {
        !          1395:   rprintf2( "MULU.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
        !          1396: }
        !          1397: 
        !          1398: //-----------------------------------------------------------------------
        !          1399: // NBCD <ea>
        !          1400: void Disass_NBCD(void)
        !          1401: {
        !          1402:   rprintf1( "NBCD.B\t%s",Disass_FindEffAddr(SIZE_BYTE) );
        !          1403: }
        !          1404: 
        !          1405: //-----------------------------------------------------------------------
        !          1406: // NEG <ea>
        !          1407: void Disass_NEG(void)
        !          1408: {
        !          1409:   rprintf2( "NEG.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1410: }
        !          1411: 
        !          1412: //-----------------------------------------------------------------------
        !          1413: // NEGX <ea>
        !          1414: void Disass_NEGX(void)
        !          1415: {
        !          1416:   rprintf2( "NEGX.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1417: }
        !          1418: 
        !          1419: //-----------------------------------------------------------------------
        !          1420: // NOP
        !          1421: void Disass_NOP(void)
        !          1422: {
        !          1423:   rprintf0( "NOP" );
        !          1424: }
        !          1425: 
        !          1426: //-----------------------------------------------------------------------
        !          1427: // NOT <ea>
        !          1428: void Disass_NOT(void)
        !          1429: {
        !          1430:   rprintf2( "NOT.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1431: }
        !          1432: 
        !          1433: //-----------------------------------------------------------------------
        !          1434: // OR <ea>,Dn
        !          1435: void Disass_OR_ea_Dn(void)
        !          1436: {
        !          1437:   rprintf3( "OR.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
        !          1438: }
        !          1439: 
        !          1440: // OR Dn,<ea>
        !          1441: void Disass_OR_Dn_ea(void)
        !          1442: {
        !          1443:   rprintf3( "OR.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
        !          1444: }
        !          1445: 
        !          1446: //-----------------------------------------------------------------------
        !          1447: // ORI #<data>,<ea>
        !          1448: void Disass_ORI(void)
        !          1449: {
        !          1450:   rprintf3( "ORI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1451: }
        !          1452: 
        !          1453: //-----------------------------------------------------------------------
        !          1454: // OR to CCR #<data>,CCR
        !          1455: void Disass_ORI_to_CCR(void)
        !          1456: {
        !          1457:   rprintf1( "ORI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
        !          1458: }
        !          1459: 
        !          1460: //-----------------------------------------------------------------------
        !          1461: // OR to SR #<data>,SR
        !          1462: void Disass_ORI_to_SR(void)
        !          1463: {
        !          1464:   rprintf1( "ORI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
        !          1465: }
        !          1466: 
        !          1467: //-----------------------------------------------------------------------
        !          1468: // PEA <ea>
        !          1469: void Disass_PEA(void)
        !          1470: {
        !          1471:   rprintf1( "PEA.L\t%s",Disass_FindEffAddr(SIZE_LONG) );
        !          1472: }
        !          1473: 
        !          1474: //-----------------------------------------------------------------------
        !          1475: // RESET
        !          1476: void Disass_RESET(void)
        !          1477: {
        !          1478:   rprintf0( "RESET" );
        !          1479: }
        !          1480: 
        !          1481: //-----------------------------------------------------------------------
        !          1482: // ROL Dx,Dy
        !          1483: void Disass_ROL_Dx_Dy(void)
        !          1484: {
        !          1485:   rprintf3( "ROL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1486: }
        !          1487: 
        !          1488: // ROL #<data>,Dy
        !          1489: void Disass_ROL_data_Dy(void)
        !          1490: {
        !          1491:   rprintf3( "ROL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1492: }
        !          1493: 
        !          1494: // ROL <ea>
        !          1495: void Disass_ROL(void)
        !          1496: {
        !          1497:   rprintf1( "ROL.W\t%s",Disass_FindEffAddr(NULL) );
        !          1498: }
        !          1499: 
        !          1500: //-----------------------------------------------------------------------
        !          1501: // ROR Dx,Dy
        !          1502: void Disass_ROR_Dx_Dy(void)
        !          1503: {
        !          1504:   rprintf3( "ROR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1505: }
        !          1506: 
        !          1507: // ROR #<data>,Dy
        !          1508: void Disass_ROR_data_Dy(void)
        !          1509: {
        !          1510:   rprintf3( "ROR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1511: }
        !          1512: 
        !          1513: // ROR <ea>
        !          1514: void Disass_ROR(void)
        !          1515: {
        !          1516:   rprintf1( "ROR.W\t%s",Disass_FindEffAddr(NULL) );
        !          1517: }
        !          1518: 
        !          1519: //-----------------------------------------------------------------------
        !          1520: // ROXL Dx,Dy
        !          1521: void Disass_ROXL_Dx_Dy(void)
        !          1522: {
        !          1523:   rprintf3( "ROXL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1524: }
        !          1525: 
        !          1526: // ROXL #<data>,Dy
        !          1527: void Disass_ROXL_data_Dy(void)
        !          1528: {
        !          1529:   rprintf3( "ROXL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1530: }
        !          1531: 
        !          1532: // ROXL <ea>
        !          1533: void Disass_ROXL(void)
        !          1534: {
        !          1535:   rprintf1( "ROXL.W\t%s",Disass_FindEffAddr(NULL) );
        !          1536: }
        !          1537: 
        !          1538: //-----------------------------------------------------------------------
        !          1539: // ROXR Dx,Dy
        !          1540: void Disass_ROXR_Dx_Dy(void)
        !          1541: {
        !          1542:   rprintf3( "ROXR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
        !          1543: }
        !          1544: 
        !          1545: // ROXR #<data>,Dy
        !          1546: void Disass_ROXR_data_Dy(void)
        !          1547: {
        !          1548:   rprintf3( "ROXR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
        !          1549: }
        !          1550: 
        !          1551: // ROXR <ea>
        !          1552: void Disass_ROXR(void)
        !          1553: {
        !          1554:   rprintf1( "ROXR.W\t%s",Disass_FindEffAddr(NULL) );
        !          1555: }
        !          1556: 
        !          1557: //-----------------------------------------------------------------------
        !          1558: // RTE
        !          1559: void Disass_RTE(void)
        !          1560: {
        !          1561:   rprintf0( "RTE" );
        !          1562: }
        !          1563: 
        !          1564: //-----------------------------------------------------------------------
        !          1565: // RTR
        !          1566: void Disass_RTR(void)
        !          1567: {
        !          1568:   rprintf0( "RTR" );
        !          1569: }
        !          1570: 
        !          1571: //-----------------------------------------------------------------------
        !          1572: // RTS
        !          1573: void Disass_RTS(void)
        !          1574: {
        !          1575:   rprintf0( "RTS" );
        !          1576: }
        !          1577: 
        !          1578: //-----------------------------------------------------------------------
        !          1579: // SBCD Dy,Dx
        !          1580: void Disass_SBCD_Dy_Dx(void)
        !          1581: {
        !          1582:   rprintf2( "SBCD.B\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower() );
        !          1583: }
        !          1584: 
        !          1585: // SBCD -(Ay),-(Ax)
        !          1586: void Disass_SBCD_Ay_Ax(void)
        !          1587: {
        !          1588:   rprintf2( "SBCD.B\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower() );
        !          1589: }
        !          1590: 
        !          1591: //-----------------------------------------------------------------------
        !          1592: // Scc <ea>
        !          1593: void Disass_Scc(void)
        !          1594: {
        !          1595:   rprintf2( "S%s.B\t%s",Disass_FindEffAddr(SIZE_BYTE),Disass_FindCondition() );
        !          1596: }
        !          1597: 
        !          1598: //-----------------------------------------------------------------------
        !          1599: // STOP #<data>
        !          1600: void Disass_STOP(void)
        !          1601: {
        !          1602:   rprintf1( "STOP\t#%s",Disass_ReadImmediate(SIZE_WORD) );
        !          1603: }
        !          1604: 
        !          1605: //-----------------------------------------------------------------------
        !          1606: // SUB <ea>,Dn
        !          1607: void Disass_SUB_ea_Dn(void)
        !          1608: {
        !          1609:   rprintf3( "SUB.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
        !          1610: }
        !          1611: 
        !          1612: // SUB Dn,<ea>
        !          1613: void Disass_SUB_Dn_ea(void)
        !          1614: {
        !          1615:   rprintf3( "SUB.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
        !          1616: }
        !          1617: 
        !          1618: //-----------------------------------------------------------------------
        !          1619: // SUBA <ea>,An
        !          1620: void Disass_SUBA(void)
        !          1621: {
        !          1622:   rprintf3( "SUBA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
        !          1623: }
        !          1624: 
        !          1625: //-----------------------------------------------------------------------
        !          1626: // SUBI #<data>,<ea>
        !          1627: void Disass_SUBI(void)
        !          1628: {
        !          1629:   rprintf3( "SUBI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
        !          1630: }
        !          1631: 
        !          1632: //-----------------------------------------------------------------------
        !          1633: // SUBQ #<data>,<ea>
        !          1634: void Disass_SUBQ(void)
        !          1635: {
        !          1636:   rprintf3( "SUBQ.%s\t#%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindQuickData(),Disass_FindSize_00_01_10() );
        !          1637: }
        !          1638: 
        !          1639: //-----------------------------------------------------------------------
        !          1640: // SUBX Dy,Dx
        !          1641: void Disass_SUBX_Dy_Dx(void)
        !          1642: {
        !          1643:   rprintf3( "SUBX.%s\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
        !          1644: }
        !          1645: 
        !          1646: // SUBX -(Ay),-(Ax)
        !          1647: void Disass_SUBX_Ay_Ax(void)
        !          1648: {
        !          1649:   rprintf3( "SUBX.%s\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
        !          1650: }
        !          1651: 
        !          1652: //-----------------------------------------------------------------------
        !          1653: // SWAP Dn
        !          1654: void Disass_SWAP(void)
        !          1655: {
        !          1656:   rprintf1( "SWAP.W\tD%d",Disass_FindRegisterLower() );
        !          1657: }
        !          1658: 
        !          1659: //-----------------------------------------------------------------------
        !          1660: // TAS <ea>
        !          1661: void Disass_TAS(void)
        !          1662: {
        !          1663:   rprintf1( "TAS.B\t%s",Disass_FindEffAddr(SIZE_BYTE) );
        !          1664: }
        !          1665: 
        !          1666: //-----------------------------------------------------------------------
        !          1667: // TRAP #<vector>
        !          1668: void Disass_TRAP(void)
        !          1669: {
        !          1670:   rprintf1( "TRAP\t#%d",OpCode&0xf );
        !          1671: }
        !          1672: 
        !          1673: //-----------------------------------------------------------------------
        !          1674: // TRAPV
        !          1675: void Disass_TRAPV(void)
        !          1676: {
        !          1677:   rprintf0( "TRAPV" );
        !          1678: }
        !          1679: 
        !          1680: //-----------------------------------------------------------------------
        !          1681: // TST <ea>
        !          1682: void Disass_TST(void)
        !          1683: {
        !          1684:   rprintf2( "TST.%s\t%s",Disass_FindEffAddr(SIZE_BYTE),Disass_FindSize_00_01_10() );
        !          1685: }
        !          1686: 
        !          1687: //-----------------------------------------------------------------------
        !          1688: // UNLK An
        !          1689: void Disass_UNLK(void)
        !          1690: {
        !          1691:   rprintf1( "UNLK\tA%d",Disass_FindRegisterLower() );
        !          1692: }
        !          1693: 
        !          1694: 
        !          1695: 
        !          1696: //-----------------------------------------------------------------------
        !          1697: /*
        !          1698:   Disassemble from 'DisPC' program counter to 'szOpData', update DisPC
        !          1699:   Return TRUE if instruction was valid
        !          1700: */
        !          1701: BOOL Disass_DiassembleLine(void)
        !          1702: {
        !          1703:   void *pFunc;
        !          1704:   int OpCodeIndex;
        !          1705: 
        !          1706:   // Clear OpCode data
        !          1707:   strcpy(szOpData,"");
        !          1708: 
        !          1709:   // Read 'Opcode'
        !          1710:   OpCode = Disass_ReadWord();
        !          1711: 
        !          1712:   // Look up disassembly function
        !          1713:   OpCodeIndex = STMemory_Swap68000Int(OpCode)*SIZEOF_DECODE;
        !          1714:   pFunc = (void *)DecodeTable[OpCodeIndex+(DECODE_DISASS/sizeof(long))];  
        !          1715:   if (pFunc) {
        !          1716:     CALL_VAR(pFunc);                // Disassemble
        !          1717:     return(TRUE);
        !          1718:   }
        !          1719:   else {
        !          1720:     strcpy(szOpString,"----");            // Not an instruction
        !          1721:     return(FALSE);
        !          1722:   }
        !          1723: }
        !          1724: 
        !          1725: #endif  //USE_DEBUGGER

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.