Shamusworld >> Repos - virtualjaguar/blob - src/m68kdasmAG.cpp

   1 /*
   2  *   A MC68000/MC68010 disassembler
   3  *
   4  *   Note: this is probably not the most efficient disassembler in the world :-)
   5  *
   6  *   This code written by Aaron Giles (agiles@sirius.com) for the MAME project
   7  *
   8  */
   9
  10 #include <string.h>
  11 #include <stdio.h>
  12
  13 static char *ccodes[16] = { "T ", "F ", "HI", "LS", "CC", "CS", "NE", "EQ", "VC", "VS", "PL", "MI", "GE", "LT", "GT", "LE" };
  14
  15 #define PARAM_WORD(v) ((v) = *(unsigned short *)&p[0], p += 2)
  16 #define PARAM_LONG(v) ((v) = (*(unsigned short *)&p[0] << 16) + *(unsigned short *)&p[2], p += 4)
  17
  18 #ifdef LOGGING
  19
  20 static char *MakeEA (int lo, char *pBase, int size, int *count)
  21 {
  22         static char buffer[2][80];
  23         static int which;
  24
  25         unsigned char *p = (unsigned char *)pBase;
  26         char *buf = buffer[which];
  27         int reg = lo & 7;
  28         unsigned long pm;
  29         int temp;
  30
  31         which ^= 1;
  32         switch ((lo >> 3) & 7)
  33         {
  34                 case 0:
  35                         sprintf (buf, "D%d", reg);
  36                         break;
  37                 case 1:
  38                         sprintf (buf, "A%d", reg);
  39                         break;
  40                 case 2:
  41                         sprintf (buf, "(A%d)", reg);
  42                         break;
  43                 case 3:
  44                         sprintf (buf, "(A%d)+", reg);
  45                         break;
  46                 case 4:
  47                         sprintf (buf, "-(A%d)", reg);
  48                         break;
  49                 case 5:
  50                         PARAM_WORD (pm);
  51                         if (pm & 0x8000)
  52                                 sprintf (buf, "(-$%X,A%d)", -(signed short)pm & 0xffff, reg);
  53                         else
  54                                 sprintf (buf, "($%lX,A%d)", pm, reg);
  55                         break;
  56                 case 6:
  57                         PARAM_WORD (pm);
  58                         temp = pm & 0xff;
  59                         if (temp & 0x80)
  60                                 sprintf (buf, "(-$%X,A%d,D%ld.%c)", -(signed char)temp & 0xff, reg, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
  61                         else
  62                                 sprintf (buf, "($%X,A%d,D%ld.%c)", temp, reg, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
  63                         break;
  64                 case 7:
  65                         switch (reg)
  66                         {
  67                                 case 0:
  68                                         PARAM_WORD (pm);
  69                                         sprintf (buf, "$%lX", pm);
  70                                         break;
  71                                 case 1:
  72                                         PARAM_LONG (pm);
  73                                         sprintf (buf, "$%lX", pm);
  74                                         break;
  75                                 case 2:
  76                                         PARAM_WORD (pm);
  77                                         if (pm & 0x8000)
  78                                                 sprintf (buf, "(-$%X,PC)", -(signed short)pm & 0xffff);
  79                                         else
  80                                                 sprintf (buf, "($%lX,PC)", pm);
  81                                         break;
  82                                 case 3:
  83                                         PARAM_WORD (pm);
  84                                         temp = pm & 0xff;
  85                                         if (temp & 0x80)
  86                                                 sprintf (buf, "(-$%X,PC,D%ld.%c)", -(signed char)temp & 0xff, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
  87                                         else
  88                                                 sprintf (buf, "($%X,PC,D%ld.%c)", temp, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
  89                                         break;
  90                                 case 4:
  91                                         if (size == 1)
  92                                         {
  93                                                 PARAM_WORD (pm);
  94                                                 temp = pm & 0xff;
  95                                                 sprintf (buf, "#$%X", temp);
  96                                         }
  97                                         else if (size == 2)
  98                                         {
  99                                                 PARAM_WORD (pm);
 100                                                 sprintf (buf, "#$%lX", pm);
 101                                         }
 102                                         else
 103                                         {
 104                                                 PARAM_LONG (pm);
 105                                                 sprintf (buf, "#$%lX", pm);
 106                                         }
 107                                         break;
 108                         }
 109                         break;
 110         }
 111
 112         *count = p - ((unsigned char*)pBase);
 113         return buf;
 114 }
 115
 116 static char *MakeRegList (char *p, unsigned short pm)
 117 {
 118         int start = -1, sep = 0;
 119         int i;
 120
 121         for (i = 0; i < 8; i++, pm >>= 1)
 122         {
 123                 if ((pm & 1) && start == -1)
 124                         start = i;
 125                 else if (!(pm & 1) && start != -1)
 126                 {
 127                         if (sep++) p += sprintf (p, "/");
 128                         if (start == i - 1) p += sprintf (p, "D%d", start);
 129                         else p += sprintf (p, "D%d-D%d", start, i - 1);
 130                         start = -1;
 131                 }
 132         }
 133         if (start != -1)
 134         {
 135                 if (sep++) p += sprintf (p, "/");
 136                 if (start == 7) p += sprintf (p, "D7");
 137                 else p += sprintf (p, "D%d-D7", start);
 138                 start = -1;
 139         }
 140
 141         for (i = 0; i < 8; i++, pm >>= 1)
 142         {
 143                 if ((pm & 1) && start == -1)
 144                         start = i;
 145                 else if (!(pm & 1) && start != -1)
 146                 {
 147                         if (sep++) p += sprintf (p, "/");
 148                         if (start == i - 1) p += sprintf (p, "A%d", start);
 149                         else p += sprintf (p, "A%d-A%d", start, i - 1);
 150                         start = -1;
 151                 }
 152         }
 153         if (start != -1)
 154         {
 155                 if (sep++) p += sprintf (p, "/");
 156                 if (start == 7) p += sprintf (p, "A7");
 157                 else p += sprintf (p, "A%d-A7", start);
 158         }
 159
 160         return p;
 161 }
 162
 163 static char *MakeRevRegList (char *p, unsigned short pm)
 164 {
 165         int start = -1, sep = 0;
 166         int i;
 167
 168         for (i = 0; i < 8; i++, pm <<= 1)
 169         {
 170                 if ((pm & 0x8000) && start == -1)
 171                         start = i;
 172                 else if (!(pm & 0x8000) && start != -1)
 173                 {
 174                         if (sep++) p += sprintf (p, "/");
 175                         if (start == i - 1) p += sprintf (p, "D%d", start);
 176                         else p += sprintf (p, "D%d-D%d", start, i - 1);
 177                         start = -1;
 178                 }
 179         }
 180         if (start != -1)
 181         {
 182                 if (sep++) p += sprintf (p, "/");
 183                 if (start == 7) p += sprintf (p, "D7");
 184                 else p += sprintf (p, "D%d-D7", start);
 185                 start = -1;
 186         }
 187
 188         for (i = 0; i < 8; i++, pm <<= 1)
 189         {
 190                 if ((pm & 0x8000) && start == -1)
 191                         start = i;
 192                 else if (!(pm & 0x8000) && start != -1)
 193                 {
 194                         if (sep++) p += sprintf (p, "/");
 195                         if (start == i - 1) p += sprintf (p, "A%d", start);
 196                         else p += sprintf (p, "A%d-A%d", start, i - 1);
 197                         start = -1;
 198                 }
 199         }
 200         if (start != -1)
 201         {
 202                 if (sep++) p += sprintf (p, "/");
 203                 if (start == 7) p += sprintf (p, "A7");
 204                 else p += sprintf (p, "A%d-A7", start);
 205         }
 206
 207         return p;
 208 }
 209
 210
 211 int Dasm68000 (char *pBase, char *buffer, int pc)
 212 {
 213         char *ea, *ea2, *p = pBase;
 214         unsigned short op, lo, rhi, rlo;
 215         unsigned long pm;
 216         int count;
 217
 218         PARAM_WORD(op);
 219
 220         lo = op & 0x3f;
 221         rhi = (op >> 9) & 7;
 222         rlo = op & 7;
 223         switch (op & 0xffc0)
 224         {
 225                 case 0x0000:
 226                         PARAM_WORD(pm);
 227                         if (lo == 0x3c)
 228                                 sprintf (buffer, "ORI      #$%lX,CCR", pm & 0xff);
 229                         else
 230                         {
 231                                 ea = MakeEA (lo, p, 1, &count); p += count;
 232                                 sprintf (buffer, "ORI.B    #$%lX,%s", pm & 0xff, ea);
 233                         }
 234                         break;
 235                 case 0x0040:
 236                         PARAM_WORD(pm);
 237                         if (lo == 0x3c)
 238                                 sprintf (buffer, "ORI      #$%lX,SR", pm & 0xffff);
 239                         else
 240                         {
 241                                 ea = MakeEA (lo, p, 2, &count); p += count;
 242                                 sprintf (buffer, "ORI.W    #$%lX,%s", pm & 0xffff, ea);
 243                         }
 244                         break;
 245                 case 0x0080:
 246                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 247                         sprintf (buffer, "ORI.L    #$%lX,%s", pm, ea);
 248                         break;
 249                 case 0x0100: case 0x0300: case 0x0500: case 0x0700: case 0x0900: case 0x0b00: case 0x0d00: case 0x0f00:
 250                         if ((lo & 0x38) == 0x08)
 251                         {
 252                                 PARAM_WORD(pm);
 253                                 sprintf (buffer, "MOVEP.W  ($%lX,A%d),D%d", pm, rlo, rhi);
 254                         }
 255                         else
 256                         {
 257                                 ea = MakeEA (lo, p, 2, &count); p += count;
 258                                 sprintf (buffer, "BTST     D%d,%s", rhi, ea);
 259                         }
 260                         break;
 261                 case 0x0140: case 0x0340: case 0x0540: case 0x0740: case 0x0940: case 0x0b40: case 0x0d40: case 0x0f40:
 262                         if ((lo & 0x38) == 0x08)
 263                         {
 264                                 PARAM_WORD(pm);
 265                                 sprintf (buffer, "MOVEP.L  ($%lX,A%d),D%d", pm, rlo, rhi);
 266                         }
 267                         else
 268                         {
 269                                 ea = MakeEA (lo, p, 2, &count); p += count;
 270                                 sprintf (buffer, "BCHG     D%d,%s", rhi, ea);
 271                         }
 272                         break;
 273                 case 0x0180: case 0x0380: case 0x0580: case 0x0780: case 0x0980: case 0x0b80: case 0x0d80: case 0x0f80:
 274                         if ((lo & 0x38) == 0x08)
 275                         {
 276                                 PARAM_WORD(pm);
 277                                 sprintf (buffer, "MOVEP.W  D%d,($%lX,A%d)", rhi, pm, rlo);
 278                         }
 279                         else
 280                         {
 281                                 ea = MakeEA (lo, p, 2, &count); p += count;
 282                                 sprintf (buffer, "BCLR     D%d,%s", rhi, ea);
 283                         }
 284                         break;
 285                 case 0x01c0: case 0x03c0: case 0x05c0: case 0x07c0: case 0x09c0: case 0x0bc0: case 0x0dc0: case 0x0fc0:
 286                         if ((lo & 0x38) == 0x08)
 287                         {
 288                                 PARAM_WORD(pm);
 289                                 sprintf (buffer, "MOVEP.L  D%d,($%lX,A%d)", rhi, pm, rlo);
 290                         }
 291                         else
 292                         {
 293                                 ea = MakeEA (lo, p, 2, &count); p += count;
 294                                 sprintf (buffer, "BSET     D%d,%s", rhi, ea);
 295                         }
 296                         break;
 297                 case 0x0200:
 298                         PARAM_WORD(pm);
 299                         if (lo == 0x3c)
 300                                 sprintf (buffer, "ANDI     #$%lX,CCR", pm & 0xff);
 301                         else
 302                         {
 303                                 ea = MakeEA (lo, p, 1, &count); p += count;
 304                                 sprintf (buffer, "ANDI.B   #$%lX,%s", pm & 0xff, ea);
 305                         }
 306                         break;
 307                 case 0x0240:
 308                         PARAM_WORD(pm);
 309                         if (lo == 0x3c)
 310                                 sprintf (buffer, "ANDI     #$%lX,SR", pm & 0xffff);
 311                         else
 312                         {
 313                                 ea = MakeEA (lo, p, 2, &count); p += count;
 314                                 sprintf (buffer, "ANDI.W   #$%lX,%s", pm & 0xffff, ea);
 315                         }
 316                         break;
 317                 case 0x0280:
 318                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 319                         sprintf (buffer, "ANDI.L   #$%lX,%s", pm, ea);
 320                         break;
 321                 case 0x0400:
 322                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
 323                         sprintf (buffer, "SUBI.B   #$%lX,%s", pm & 0xff, ea);
 324                         break;
 325                 case 0x0440:
 326                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 327                         sprintf (buffer, "SUBI.W   #$%lX,%s", pm & 0xffff, ea);
 328                         break;
 329                 case 0x0480:
 330                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 331                         sprintf (buffer, "SUBI.L   #$%lX,%s", pm, ea);
 332                         break;
 333                 case 0x0600:
 334                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
 335                         sprintf (buffer, "ADDI.B   #$%lX,%s", pm & 0xff, ea);
 336                         break;
 337                 case 0x0640:
 338                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 339                         sprintf (buffer, "ADDI.W   #$%lX,%s", pm & 0xffff, ea);
 340                         break;
 341                 case 0x0680:
 342                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 343                         sprintf (buffer, "ADDI.L   #$%lX,%s", pm, ea);
 344                         break;
 345                 case 0x0800:
 346                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 347                         sprintf (buffer, "BTST     #$%lX,%s", pm & 0xff, ea);
 348                         break;
 349                 case 0x0840:
 350                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 351                         sprintf (buffer, "BCHG     #$%lX,%s", pm & 0xff, ea);
 352                         break;
 353                 case 0x0880:
 354                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 355                         sprintf (buffer, "BCLR     #$%lX,%s", pm & 0xff, ea);
 356                         break;
 357                 case 0x08c0:
 358                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 359                         sprintf (buffer, "BSET     #$%lX,%s", pm & 0xff, ea);
 360                         break;
 361                 case 0x0a00:
 362                         PARAM_WORD(pm);
 363                         if (lo == 0x3c)
 364                                 sprintf (buffer, "EORI     #$%lX,CCR", pm & 0xff);
 365                         else
 366                         {
 367                                 ea = MakeEA (lo, p, 1, &count); p += count;
 368                                 sprintf (buffer, "EORI.B   #$%lX,%s", pm & 0xff, ea);
 369                         }
 370                         break;
 371                 case 0x0a40:
 372                         PARAM_WORD(pm);
 373                         if (lo == 0x3c)
 374                                 sprintf (buffer, "EORI     #$%lX,SR", pm & 0xffff);
 375                         else
 376                         {
 377                                 ea = MakeEA (lo, p, 2, &count); p += count;
 378                                 sprintf (buffer, "EORI.W   #$%lX,%s", pm & 0xffff, ea);
 379                         }
 380                         break;
 381                 case 0x0a80:
 382                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 383                         sprintf (buffer, "EORI.L   #$%lX,%s", pm, ea);
 384                         break;
 385                 case 0x0c00:
 386                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
 387                         sprintf (buffer, "CMPI.B   #$%lX,%s", pm & 0xff, ea);
 388                         break;
 389                 case 0x0c40:
 390                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 391                         sprintf (buffer, "CMPI.W   #$%lX,%s", pm & 0xffff, ea);
 392                         break;
 393                 case 0x0c80:
 394                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 395                         sprintf (buffer, "CMPI.L   #$%lX,%s", pm, ea);
 396                         break;
 397                 case 0x0e00:
 398                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
 399                         if (pm & 0x0800)
 400                         {
 401                                 if (pm & 0x8000)
 402                                         sprintf (buffer, "MOVES.B  A%ld,%s", (pm >> 12) & 7, ea);
 403                                 else
 404                                         sprintf (buffer, "MOVES.B  D%ld,%s", (pm >> 12) & 7, ea);
 405                         }
 406                         else
 407                         {
 408                                 if (pm & 0x8000)
 409                                         sprintf (buffer, "MOVES.B  %s,A%ld", ea, (pm >> 12) & 7);
 410                                 else
 411                                         sprintf (buffer, "MOVES.B  %s,D%ld", ea, (pm >> 12) & 7);
 412                         }
 413                         break;
 414                 case 0x0e40:
 415                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
 416                         if (pm & 0x0800)
 417                         {
 418                                 if (pm & 0x8000)
 419                                         sprintf (buffer, "MOVES.W  A%ld,%s", (pm >> 12) & 7, ea);
 420                                 else
 421                                         sprintf (buffer, "MOVES.W  D%ld,%s", (pm >> 12) & 7, ea);
 422                         }
 423                         else
 424                         {
 425                                 if (pm & 0x8000)
 426                                         sprintf (buffer, "MOVES.W  %s,A%ld", ea, (pm >> 12) & 7);
 427                                 else
 428                                         sprintf (buffer, "MOVES.W  %s,D%ld", ea, (pm >> 12) & 7);
 429                         }
 430                         break;
 431                 case 0x0e80:
 432                         PARAM_WORD(pm); ea = MakeEA (lo, p, 4, &count); p += count;
 433                         if (pm & 0x0800)
 434                         {
 435                                 if (pm & 0x8000)
 436                                         sprintf (buffer, "MOVES.L  A%ld,%s", (pm >> 12) & 7, ea);
 437                                 else
 438                                         sprintf (buffer, "MOVES.L  D%ld,%s", (pm >> 12) & 7, ea);
 439                         }
 440                         else
 441                         {
 442                                 if (pm & 0x8000)
 443                                         sprintf (buffer, "MOVES.L  %s,A%ld", ea, (pm >> 12) & 7);
 444                                 else
 445                                         sprintf (buffer, "MOVES.L  %s,D%ld", ea, (pm >> 12) & 7);
 446                         }
 447                         break;
 448                 case 0x1000: case 0x1080: case 0x10c0: case 0x1100: case 0x1140: case 0x1180: case 0x11c0:
 449                 case 0x1200: case 0x1280: case 0x12c0: case 0x1300: case 0x1340: case 0x1380: case 0x13c0:
 450                 case 0x1400: case 0x1480: case 0x14c0: case 0x1500: case 0x1540: case 0x1580:
 451                 case 0x1600: case 0x1680: case 0x16c0: case 0x1700: case 0x1740: case 0x1780:
 452                 case 0x1800: case 0x1880: case 0x18c0: case 0x1900: case 0x1940: case 0x1980:
 453                 case 0x1a00: case 0x1a80: case 0x1ac0: case 0x1b00: case 0x1b40: case 0x1b80:
 454                 case 0x1c00: case 0x1c80: case 0x1cc0: case 0x1d00: case 0x1d40: case 0x1d80:
 455                 case 0x1e00: case 0x1e80: case 0x1ec0: case 0x1f00: case 0x1f40: case 0x1f80:
 456                         ea = MakeEA (lo, p, 1, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 1, &count); p += count;
 457                         sprintf (buffer, "MOVE.B   %s,%s", ea, ea2);
 458                         break;
 459                 case 0x2000: case 0x2080: case 0x20c0: case 0x2100: case 0x2140: case 0x2180: case 0x21c0:
 460                 case 0x2200: case 0x2280: case 0x22c0: case 0x2300: case 0x2340: case 0x2380: case 0x23c0:
 461                 case 0x2400: case 0x2480: case 0x24c0: case 0x2500: case 0x2540: case 0x2580:
 462                 case 0x2600: case 0x2680: case 0x26c0: case 0x2700: case 0x2740: case 0x2780:
 463                 case 0x2800: case 0x2880: case 0x28c0: case 0x2900: case 0x2940: case 0x2980:
 464                 case 0x2a00: case 0x2a80: case 0x2ac0: case 0x2b00: case 0x2b40: case 0x2b80:
 465                 case 0x2c00: case 0x2c80: case 0x2cc0: case 0x2d00: case 0x2d40: case 0x2d80:
 466                 case 0x2e00: case 0x2e80: case 0x2ec0: case 0x2f00: case 0x2f40: case 0x2f80:
 467                         ea = MakeEA (lo, p, 4, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 4, &count); p += count;
 468                         sprintf (buffer, "MOVE.L   %s,%s", ea, ea2);
 469                         break;
 470                 case 0x2040: case 0x2240: case 0x2440: case 0x2640: case 0x2840: case 0x2a40: case 0x2c40: case 0x2e40:
 471                         ea = MakeEA (lo, p, 4, &count); p += count;
 472                         sprintf (buffer, "MOVEA.L  %s,A%d", ea, rhi);
 473                         break;
 474                 case 0x3000: case 0x3080: case 0x30c0: case 0x3100: case 0x3140: case 0x3180: case 0x31c0:
 475                 case 0x3200: case 0x3280: case 0x32c0: case 0x3300: case 0x3340: case 0x3380: case 0x33c0:
 476                 case 0x3400: case 0x3480: case 0x34c0: case 0x3500: case 0x3540: case 0x3580:
 477                 case 0x3600: case 0x3680: case 0x36c0: case 0x3700: case 0x3740: case 0x3780:
 478                 case 0x3800: case 0x3880: case 0x38c0: case 0x3900: case 0x3940: case 0x3980:
 479                 case 0x3a00: case 0x3a80: case 0x3ac0: case 0x3b00: case 0x3b40: case 0x3b80:
 480                 case 0x3c00: case 0x3c80: case 0x3cc0: case 0x3d00: case 0x3d40: case 0x3d80:
 481                 case 0x3e00: case 0x3e80: case 0x3ec0: case 0x3f00: case 0x3f40: case 0x3f80:
 482                         ea = MakeEA (lo, p, 2, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 2, &count); p += count;
 483                         sprintf (buffer, "MOVE.W   %s,%s", ea, ea2);
 484                         break;
 485                 case 0x3040: case 0x3240: case 0x3440: case 0x3640: case 0x3840: case 0x3a40: case 0x3c40: case 0x3e40:
 486                         ea = MakeEA (lo, p, 2, &count); p += count;
 487                         sprintf (buffer, "MOVEA.W  %s,A%d", ea, rhi);
 488                         break;
 489                 case 0x4000:
 490                         ea = MakeEA (lo, p, 1, &count); p += count;
 491                         sprintf (buffer, "NEGX.B   %s", ea);
 492                         break;
 493                 case 0x4040:
 494                         ea = MakeEA (lo, p, 2, &count); p += count;
 495                         sprintf (buffer, "NEGX.W   %s", ea);
 496                         break;
 497                 case 0x4080:
 498                         ea = MakeEA (lo, p, 4, &count); p += count;
 499                         sprintf (buffer, "NEGX.L   %s", ea);
 500                         break;
 501                 case 0x40c0:
 502                         ea = MakeEA (lo, p, 2, &count); p += count;
 503                         sprintf (buffer, "MOVE     SR,%s", ea);
 504                         break;
 505                 case 0x4180: case 0x4380: case 0x4580: case 0x4780: case 0x4980: case 0x4b80: case 0x4d80: case 0x4f80:
 506                         ea = MakeEA (lo, p, 2, &count); p += count;
 507                         sprintf (buffer, "CHK.W    %s,D%d", ea, rhi);
 508                         break;
 509                 case 0x41c0: case 0x43c0: case 0x45c0: case 0x47c0: case 0x49c0: case 0x4bc0: case 0x4dc0: case 0x4fc0:
 510                         ea = MakeEA (lo, p, 4, &count); p += count;
 511                         sprintf (buffer, "LEA      %s,A%d", ea, rhi);
 512                         break;
 513                 case 0x4200:
 514                         ea = MakeEA (lo, p, 1, &count); p += count;
 515                         sprintf (buffer, "CLR.B    %s", ea);
 516                         break;
 517                 case 0x4240:
 518                         ea = MakeEA (lo, p, 2, &count); p += count;
 519                         sprintf (buffer, "CLR.W    %s", ea);
 520                         break;
 521                 case 0x4280:
 522                         ea = MakeEA (lo, p, 4, &count); p += count;
 523                         sprintf (buffer, "CLR.L    %s", ea);
 524                         break;
 525                 case 0x42c0:
 526                         ea = MakeEA (lo, p, 2, &count); p += count;
 527                         sprintf (buffer, "MOVE     CCR,%s", ea);
 528                         break;
 529                 case 0x4400:
 530                         ea = MakeEA (lo, p, 1, &count); p += count;
 531                         sprintf (buffer, "NEG.B    %s", ea);
 532                         break;
 533                 case 0x4440:
 534                         ea = MakeEA (lo, p, 2, &count); p += count;
 535                         sprintf (buffer, "NEG.W    %s", ea);
 536                         break;
 537                 case 0x4480:
 538                         ea = MakeEA (lo, p, 4, &count); p += count;
 539                         sprintf (buffer, "NEG.L    %s", ea);
 540                         break;
 541                 case 0x44c0:
 542                         ea = MakeEA (lo, p, 2, &count); p += count;
 543                         sprintf (buffer, "MOVE     %s,CCR", ea);
 544                         break;
 545                 case 0x4600:
 546                         ea = MakeEA (lo, p, 1, &count); p += count;
 547                         sprintf (buffer, "NOT.B    %s", ea);
 548                         break;
 549                 case 0x4640:
 550                         ea = MakeEA (lo, p, 2, &count); p += count;
 551                         sprintf (buffer, "NOT.W    %s", ea);
 552                         break;
 553                 case 0x4680:
 554                         ea = MakeEA (lo, p, 4, &count); p += count;
 555                         sprintf (buffer, "NOT.L    %s", ea);
 556                         break;
 557                 case 0x46c0:
 558                         ea = MakeEA (lo, p, 2, &count); p += count;
 559                         sprintf (buffer, "MOVE     %s,SR", ea);
 560                         break;
 561                 case 0x4800:
 562                         ea = MakeEA (lo, p, 1, &count); p += count;
 563                         sprintf (buffer, "NBCD.B   %s", ea);
 564                         break;
 565                 case 0x4840:
 566                         if ((lo & 0x38) == 0x00)
 567                                 sprintf (buffer, "SWAP     D%d", rlo);
 568                         else
 569                         {
 570                                 ea = MakeEA (lo, p, 4, &count); p += count;
 571                                 sprintf (buffer, "PEA      %s", ea);
 572                         }
 573                         break;
 574                 case 0x4880:
 575                         if ((lo & 0x38) == 0x00)
 576                                 sprintf (buffer, "EXT.W    D%d", rlo);
 577                         else
 578                         {
 579                                 char *b = buffer;
 580                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 2, &count); p += count;
 581                                 b += sprintf (b, "MOVEM.W  ");
 582                                 if ((lo & 0x38) != 0x20) b = MakeRegList (b, pm);
 583                                 else b = MakeRevRegList (b, pm);
 584                                 sprintf (b, ",%s", ea);
 585                         }
 586                         break;
 587                 case 0x48c0:
 588                         if ((lo & 0x38) == 0x00)
 589                                 sprintf (buffer, "EXT.L    D%d", rlo);
 590                         else
 591                         {
 592                                 char *b = buffer;
 593                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 4, &count); p += count;
 594                                 b += sprintf (b, "MOVEM.L  ");
 595                                 if ((lo & 0x38) != 0x20) b = MakeRegList (b, pm);
 596                                 else b = MakeRevRegList (b, pm);
 597                                 sprintf (b, ",%s", ea);
 598                         }
 599                         break;
 600                 case 0x4a00:
 601                         ea = MakeEA (lo, p, 1, &count); p += count;
 602                         sprintf (buffer, "TST.B    %s", ea);
 603                         break;
 604                 case 0x4a40:
 605                         ea = MakeEA (lo, p, 2, &count); p += count;
 606                         sprintf (buffer, "TST.W    %s", ea);
 607                         break;
 608                 case 0x4a80:
 609                         ea = MakeEA (lo, p, 4, &count); p += count;
 610                         sprintf (buffer, "TST.L    %s", ea);
 611                         break;
 612                 case 0x4ac0:
 613                         ea = MakeEA (lo, p, 1, &count); p += count;
 614                         sprintf (buffer, "TAS.B    %s", ea);
 615                         break;
 616                 case 0x4c80:
 617                         {
 618                                 char *b = buffer;
 619                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 2, &count); p += count;
 620                                 b += sprintf (b, "MOVEM.W  %s,", ea);
 621                                 b = MakeRegList (b, pm);
 622                         }
 623                         break;
 624                 case 0x4cc0:
 625                         {
 626                                 char *b = buffer;
 627                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 4, &count); p += count;
 628                                 b += sprintf (b, "MOVEM.L  %s,", ea);
 629                                 b = MakeRegList (b, pm);
 630                         }
 631                         break;
 632                 case 0x4e40:
 633                         if ((lo & 30) == 0x00)
 634                                 sprintf (buffer, "TRAP     #$%X", lo & 15);
 635                         else if ((lo & 0x38) == 0x10)
 636                         {
 637                                 PARAM_WORD (pm);
 638                                 sprintf (buffer, "LINK     A%d,#$%lX", rlo, pm);
 639                         }
 640                         else if ((lo & 0x38) == 0x18)
 641                         {
 642                                 sprintf (buffer, "UNLK     A%d", rlo);
 643                         }
 644                         else if ((lo & 0x38) == 0x20)
 645                                 sprintf (buffer, "MOVE     A%d,USP", rlo);
 646                         else if ((lo & 0x38) == 0x28)
 647                                 sprintf (buffer, "MOVE     USP,A%d", rlo);
 648                         else if (lo == 0x30)
 649                                 sprintf (buffer, "RESET");
 650                         else if (lo == 0x31)
 651                                 sprintf (buffer, "NOP");
 652                         else if (lo == 0x32)
 653                                 sprintf (buffer, "STOP");
 654                         else if (lo == 0x33)
 655                                 sprintf (buffer, "RTE");
 656                         else if (lo == 0x35)
 657                                 sprintf (buffer, "RTS");
 658                         else if (lo == 0x36)
 659                                 sprintf (buffer, "TRAPV");
 660                         else if (lo == 0x37)
 661                                 sprintf (buffer, "RTR");
 662                         else if (lo == 0x3a)
 663                         {
 664                                 PARAM_WORD (pm);
 665                                 switch (pm & 0xfff)
 666                                 {
 667                                         case 0x000:     ea = "SFC";     break;
 668                                         case 0x001:     ea = "DFC"; break;
 669                                         case 0x800: ea = "USP"; break;
 670                                         case 0x801: ea = "VBR"; break;
 671                                         default: ea = "???"; break;
 672                                 }
 673                                 if (pm & 0x8000)
 674                                         sprintf (buffer, "MOVEC    %s,A%ld", ea, (pm >> 12) & 7);
 675                                 else
 676                                         sprintf (buffer, "MOVEC    %s,D%ld", ea, (pm >> 12) & 7);
 677                         }
 678                         else if (lo == 0x3b)
 679                         {
 680                                 PARAM_WORD (pm);
 681                                 switch (pm & 0xfff)
 682                                 {
 683                                         case 0x000:     ea = "SFC";     break;
 684                                         case 0x001:     ea = "DFC"; break;
 685                                         case 0x800: ea = "USP"; break;
 686                                         case 0x801: ea = "VBR"; break;
 687                                         default: ea = "???"; break;
 688                                 }
 689                                 if (pm & 0x8000)
 690                                         sprintf (buffer, "MOVEC    A%ld,%s", (pm >> 12) & 7, ea);
 691                                 else
 692                                         sprintf (buffer, "MOVEC    D%ld,%s", (pm >> 12) & 7, ea);
 693                         }
 694                         else
 695                                 sprintf (buffer, "DC.W     $%X", op);
 696                         break;
 697                 case 0x4e80:
 698                         ea = MakeEA (lo, p, 4, &count); p += count;
 699                         sprintf (buffer, "JSR      %s", ea);
 700                         break;
 701                 case 0x4ec0:
 702                         ea = MakeEA (lo, p, 4, &count); p += count;
 703                         sprintf (buffer, "JMP      %s", ea);
 704                         break;
 705                 case 0x5000: case 0x5200: case 0x5400: case 0x5600: case 0x5800: case 0x5a00: case 0x5c00: case 0x5e00:
 706                         ea = MakeEA (lo, p, 1, &count); p += count;
 707                         sprintf (buffer, "ADDQ.B   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 708                         break;
 709                 case 0x5040: case 0x5240: case 0x5440: case 0x5640: case 0x5840: case 0x5a40: case 0x5c40: case 0x5e40:
 710                         ea = MakeEA (lo, p, 2, &count); p += count;
 711                         sprintf (buffer, "ADDQ.W   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 712                         break;
 713                 case 0x5080: case 0x5280: case 0x5480: case 0x5680: case 0x5880: case 0x5a80: case 0x5c80: case 0x5e80:
 714                         ea = MakeEA (lo, p, 4, &count); p += count;
 715                         sprintf (buffer, "ADDQ.L   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 716                         break;
 717                 case 0x50c0: case 0x52c0: case 0x54c0: case 0x56c0: case 0x58c0: case 0x5ac0: case 0x5cc0: case 0x5ec0:
 718                 case 0x51c0: case 0x53c0: case 0x55c0: case 0x57c0: case 0x59c0: case 0x5bc0: case 0x5dc0: case 0x5fc0:
 719                         if ((lo & 0x38) == 0x08)
 720                         {
 721                                 PARAM_WORD (pm);
 722                                 if (pm & 0x8000)
 723                                         sprintf (buffer, "DB%s     D%d,*-$%X [%X]", ccodes[(op >> 8) & 15], rlo, (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
 724                                 else
 725                                         sprintf (buffer, "DB%s     D%d,*+$%lX [%lX]", ccodes[(op >> 8) & 15], rlo, pm - 2, pc + pm + 2);
 726                         }
 727                         else
 728                         {
 729                                 ea = MakeEA (lo, p, 1, &count); p += count;
 730                                 sprintf (buffer, "S%s.B    %s", ccodes[(op >> 8) & 15], ea);
 731                         }
 732                         break;
 733                 case 0x5100: case 0x5300: case 0x5500: case 0x5700: case 0x5900: case 0x5b00: case 0x5d00: case 0x5f00:
 734                         ea = MakeEA (lo, p, 1, &count); p += count;
 735                         sprintf (buffer, "SUBQ.B   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 736                         break;
 737                 case 0x5140: case 0x5340: case 0x5540: case 0x5740: case 0x5940: case 0x5b40: case 0x5d40: case 0x5f40:
 738                         ea = MakeEA (lo, p, 2, &count); p += count;
 739                         sprintf (buffer, "SUBQ.W   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 740                         break;
 741                 case 0x5180: case 0x5380: case 0x5580: case 0x5780: case 0x5980: case 0x5b80: case 0x5d80: case 0x5f80:
 742                         ea = MakeEA (lo, p, 4, &count); p += count;
 743                         sprintf (buffer, "SUBQ.L   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
 744                         break;
 745                 case 0x6000: case 0x6040: case 0x6080: case 0x60c0:
 746                         pm = op & 0xff;
 747                         if (pm == 0)
 748                         {
 749                                 PARAM_WORD(pm);
 750                                 if (pm & 0x8000)
 751                                         sprintf (buffer, "BRA      *-$%X [%X]", (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
 752                                 else
 753                                         sprintf (buffer, "BRA      *+$%lX [%lX]", pm + 2, pc + pm + 2);
 754                         }
 755                         else
 756                         {
 757                                 if (pm & 0x80)
 758                                         sprintf (buffer, "BRA.S    *-$%X [%X]", (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
 759                                 else
 760                                         sprintf (buffer, "BRA.S    *+$%lX [%lX]", pm + 2, pc + pm + 2);
 761                         }
 762                         break;
 763                 case 0x6100: case 0x6140: case 0x6180: case 0x61c0:
 764                         pm = op & 0xff;
 765                         if (pm == 0)
 766                         {
 767                                 PARAM_WORD(pm);
 768                                 if (pm & 0x8000)
 769                                         sprintf (buffer, "BSR      *-$%X [%X]", (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
 770                                 else
 771                                         sprintf (buffer, "BSR      *+$%lX [%lX]", pm + 2, pc + pm + 2);
 772                         }
 773                         else
 774                         {
 775                                 if (pm & 0x80)
 776                                         sprintf (buffer, "BSR.S    *-$%X [%X]", (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
 777                                 else
 778                                         sprintf (buffer, "BSR.S    *+$%lX [%lX]", pm + 2, pc + pm + 2);
 779                         }
 780                         break;
 781                 case 0x6200: case 0x6240: case 0x6280: case 0x62c0: case 0x6300: case 0x6340: case 0x6380: case 0x63c0:
 782                 case 0x6400: case 0x6440: case 0x6480: case 0x64c0: case 0x6500: case 0x6540: case 0x6580: case 0x65c0:
 783                 case 0x6600: case 0x6640: case 0x6680: case 0x66c0: case 0x6700: case 0x6740: case 0x6780: case 0x67c0:
 784                 case 0x6800: case 0x6840: case 0x6880: case 0x68c0: case 0x6900: case 0x6940: case 0x6980: case 0x69c0:
 785                 case 0x6a00: case 0x6a40: case 0x6a80: case 0x6ac0: case 0x6b00: case 0x6b40: case 0x6b80: case 0x6bc0:
 786                 case 0x6c00: case 0x6c40: case 0x6c80: case 0x6cc0: case 0x6d00: case 0x6d40: case 0x6d80: case 0x6dc0:
 787                 case 0x6e00: case 0x6e40: case 0x6e80: case 0x6ec0: case 0x6f00: case 0x6f40: case 0x6f80: case 0x6fc0:
 788                         pm = op & 0xff;
 789                         if (pm == 0)
 790                         {
 791                                 PARAM_WORD(pm);
 792                                 if (pm & 0x8000)
 793                                         sprintf (buffer, "B%s      *-$%X [%X]", ccodes[(op >> 8) & 15], (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
 794                                 else
 795                                         sprintf (buffer, "B%s      *+$%lX [%lX]", ccodes[(op >> 8) & 15], pm + 2, pc + pm + 2);
 796                         }
 797                         else
 798                         {
 799                                 if (pm & 0x80)
 800                                         sprintf (buffer, "B%s.S    *-$%X [%X]", ccodes[(op >> 8) & 15], (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
 801                                 else
 802                                         sprintf (buffer, "B%s.S    *+$%lX [%lX]", ccodes[(op >> 8) & 15], pm + 2, pc + pm + 2);
 803                         }
 804                         break;
 805                 case 0x7000: case 0x7040: case 0x7080: case 0x70c0:
 806                 case 0x7200: case 0x7240: case 0x7280: case 0x72c0:
 807                 case 0x7400: case 0x7440: case 0x7480: case 0x74c0:
 808                 case 0x7600: case 0x7640: case 0x7680: case 0x76c0:
 809                 case 0x7800: case 0x7840: case 0x7880: case 0x78c0:
 810                 case 0x7a00: case 0x7a40: case 0x7a80: case 0x7ac0:
 811                 case 0x7c00: case 0x7c40: case 0x7c80: case 0x7cc0:
 812                 case 0x7e00: case 0x7e40: case 0x7e80: case 0x7ec0:
 813                         pm = op & 0xff;
 814                         if (pm & 0x80)
 815                                 sprintf (buffer, "MOVEQ    #$-%X,D%d", -(signed char)pm, rhi);
 816                         else
 817                                 sprintf (buffer, "MOVEQ    #$%lX,D%d", pm, rhi);
 818                         break;
 819                 case 0x8000: case 0x8200: case 0x8400: case 0x8600: case 0x8800: case 0x8a00: case 0x8c00: case 0x8e00:
 820                         ea = MakeEA (lo, p, 1, &count); p += count;
 821                         sprintf (buffer, "OR.B     %s,D%d", ea, rhi);
 822                         break;
 823                 case 0x8040: case 0x8240: case 0x8440: case 0x8640: case 0x8840: case 0x8a40: case 0x8c40: case 0x8e40:
 824                         ea = MakeEA (lo, p, 2, &count); p += count;
 825                         sprintf (buffer, "OR.W     %s,D%d", ea, rhi);
 826                         break;
 827                 case 0x8080: case 0x8280: case 0x8480: case 0x8680: case 0x8880: case 0x8a80: case 0x8c80: case 0x8e80:
 828                         ea = MakeEA (lo, p, 4, &count); p += count;
 829                         sprintf (buffer, "OR.L     %s,D%d", ea, rhi);
 830                         break;
 831                 case 0x80c0: case 0x82c0: case 0x84c0: case 0x86c0: case 0x88c0: case 0x8ac0: case 0x8cc0: case 0x8ec0:
 832                         ea = MakeEA (lo, p, 2, &count); p += count;
 833                         sprintf (buffer, "DIVU.W   %s,D%d", ea, rhi);
 834                         break;
 835                 case 0x8100: case 0x8300: case 0x8500: case 0x8700: case 0x8900: case 0x8b00: case 0x8d00: case 0x8f00:
 836                         ea = MakeEA (lo, p, 1, &count); p += count;
 837                         sprintf (buffer, "OR.B     D%d,%s", rhi, ea);
 838                         break;
 839                 case 0x8140: case 0x8340: case 0x8540: case 0x8740: case 0x8940: case 0x8b40: case 0x8d40: case 0x8f40:
 840                         ea = MakeEA (lo, p, 2, &count); p += count;
 841                         sprintf (buffer, "OR.W     D%d,%s", rhi, ea);
 842                         break;
 843                 case 0x8180: case 0x8380: case 0x8580: case 0x8780: case 0x8980: case 0x8b80: case 0x8d80: case 0x8f80:
 844                         ea = MakeEA (lo, p, 4, &count); p += count;
 845                         sprintf (buffer, "OR.L     D%d,%s", rhi, ea);
 846                         break;
 847                 case 0x81c0: case 0x83c0: case 0x85c0: case 0x87c0: case 0x89c0: case 0x8bc0: case 0x8dc0: case 0x8fc0:
 848                         ea = MakeEA (lo, p, 2, &count); p += count;
 849                         sprintf (buffer, "DIVS.W   %s,D%d", ea, rhi);
 850                         break;
 851                 case 0x9000: case 0x9200: case 0x9400: case 0x9600: case 0x9800: case 0x9a00: case 0x9c00: case 0x9e00:
 852                         ea = MakeEA (lo, p, 1, &count); p += count;
 853                         sprintf (buffer, "SUB.B    %s,D%d", ea, rhi);
 854                         break;
 855                 case 0x9040: case 0x9240: case 0x9440: case 0x9640: case 0x9840: case 0x9a40: case 0x9c40: case 0x9e40:
 856                         ea = MakeEA (lo, p, 2, &count); p += count;
 857                         sprintf (buffer, "SUB.W    %s,D%d", ea, rhi);
 858                         break;
 859                 case 0x9080: case 0x9280: case 0x9480: case 0x9680: case 0x9880: case 0x9a80: case 0x9c80: case 0x9e80:
 860                         ea = MakeEA (lo, p, 4, &count); p += count;
 861                         sprintf (buffer, "SUB.L    %s,D%d", ea, rhi);
 862                         break;
 863                 case 0x90c0: case 0x92c0: case 0x94c0: case 0x96c0: case 0x98c0: case 0x9ac0: case 0x9cc0: case 0x9ec0:
 864                         ea = MakeEA (lo, p, 2, &count); p += count;
 865                         sprintf (buffer, "SUBA.W   %s,A%d", ea, rhi);
 866                         break;
 867                 case 0x9100: case 0x9300: case 0x9500: case 0x9700: case 0x9900: case 0x9b00: case 0x9d00: case 0x9f00:
 868                         if ((lo & 0x30) == 0)
 869                         {
 870                                 if (lo & 0x08)
 871                                         sprintf (buffer, "SUBX.B   -(A%d),-(A%d)", rlo, rhi);
 872                                 else
 873                                         sprintf (buffer, "SUBX.B   D%d,D%d", rlo, rhi);
 874                         }
 875                         else
 876                         {
 877                                 ea = MakeEA (lo, p, 1,&count); p += count;
 878                                 sprintf (buffer, "SUB.B    D%d,%s", rhi, ea);
 879                         }
 880                         break;
 881                 case 0x9140: case 0x9340: case 0x9540: case 0x9740: case 0x9940: case 0x9b40: case 0x9d40: case 0x9f40:
 882                         if ((lo & 0x30) == 0)
 883                         {
 884                                 if (lo & 0x08)
 885                                         sprintf (buffer, "SUBX.W   -(A%d),-(A%d)", rlo, rhi);
 886                                 else
 887                                         sprintf (buffer, "SUBX.W   D%d,D%d", rlo, rhi);
 888                         }
 889                         else
 890                         {
 891                                 ea = MakeEA (lo, p, 2, &count); p += count;
 892                                 sprintf (buffer, "SUB.W    D%d,%s", rhi, ea);
 893                         }
 894                         break;
 895                 case 0x9180: case 0x9380: case 0x9580: case 0x9780: case 0x9980: case 0x9b80: case 0x9d80: case 0x9f80:
 896                         if ((lo & 0x30) == 0)
 897                         {
 898                                 if (lo & 0x08)
 899                                         sprintf (buffer, "SUBX.L   -(A%d),-(A%d)", rlo, rhi);
 900                                 else
 901                                         sprintf (buffer, "SUBX.L   D%d,D%d", rlo, rhi);
 902                         }
 903                         else
 904                         {
 905                                 ea = MakeEA (lo, p, 4, &count); p += count;
 906                                 sprintf (buffer, "SUB.L    D%d,%s", rhi, ea);
 907                         }
 908                         break;
 909                 case 0x91c0: case 0x93c0: case 0x95c0: case 0x97c0: case 0x99c0: case 0x9bc0: case 0x9dc0: case 0x9fc0:
 910                         ea = MakeEA (lo, p, 4, &count); p += count;
 911                         sprintf (buffer, "SUBA.L   %s,A%d", ea, rhi);
 912                         break;
 913                 case 0xb000: case 0xb200: case 0xb400: case 0xb600: case 0xb800: case 0xba00: case 0xbc00: case 0xbe00:
 914                         ea = MakeEA (lo, p, 1, &count); p += count;
 915                         sprintf (buffer, "CMP.B    %s,D%d", ea, rhi);
 916                         break;
 917                 case 0xb040: case 0xb240: case 0xb440: case 0xb640: case 0xb840: case 0xba40: case 0xbc40: case 0xbe40:
 918                         ea = MakeEA (lo, p, 2, &count); p += count;
 919                         sprintf (buffer, "CMP.W    %s,D%d", ea, rhi);
 920                         break;
 921                 case 0xb080: case 0xb280: case 0xb480: case 0xb680: case 0xb880: case 0xba80: case 0xbc80: case 0xbe80:
 922                         ea = MakeEA (lo, p, 4, &count); p += count;
 923                         sprintf (buffer, "CMP.L    %s,D%d", ea, rhi);
 924                         break;
 925                 case 0xb0c0: case 0xb2c0: case 0xb4c0: case 0xb6c0: case 0xb8c0: case 0xbac0: case 0xbcc0: case 0xbec0:
 926                         ea = MakeEA (lo, p, 2, &count); p += count;
 927                         sprintf (buffer, "CMPA.W   %s,A%d", ea, rhi);
 928                         break;
 929                 case 0xb100: case 0xb300: case 0xb500: case 0xb700: case 0xb900: case 0xbb00: case 0xbd00: case 0xbf00:
 930                         if ((lo & 0x38) == 0x08)
 931                                 sprintf (buffer, "CMPM.B   (A%d)+,(A%d)+", rlo, rhi);
 932                         else
 933                         {
 934                                 ea = MakeEA (lo, p, 1, &count); p += count;
 935                                 sprintf (buffer, "EOR.B    D%d,%s", rhi, ea);
 936                         }
 937                         break;
 938                 case 0xb140: case 0xb340: case 0xb540: case 0xb740: case 0xb940: case 0xbb40: case 0xbd40: case 0xbf40:
 939                         if ((lo & 0x38) == 0x08)
 940                                 sprintf (buffer, "CMPM.W   (A%d)+,(A%d)+", rlo, rhi);
 941                         else
 942                         {
 943                                 ea = MakeEA (lo, p, 2, &count); p += count;
 944                                 sprintf (buffer, "EOR.W    D%d,%s", rhi, ea);
 945                         }
 946                         break;
 947                 case 0xb180: case 0xb380: case 0xb580: case 0xb780: case 0xb980: case 0xbb80: case 0xbd80: case 0xbf80:
 948                         if ((lo & 0x38) == 0x08)
 949                                 sprintf (buffer, "CMPM.L   (A%d)+,(A%d)+", rlo, rhi);
 950                         else
 951                         {
 952                                 ea = MakeEA (lo, p, 4, &count); p += count;
 953                                 sprintf (buffer, "EOR.L    D%d,%s", rhi, ea);
 954                         }
 955                         break;
 956                 case 0xb1c0: case 0xb3c0: case 0xb5c0: case 0xb7c0: case 0xb9c0: case 0xbbc0: case 0xbdc0: case 0xbfc0:
 957                         ea = MakeEA (lo, p, 4, &count); p += count;
 958                         sprintf (buffer, "CMPA.L   %s,A%d", ea, rhi);
 959                         break;
 960                 case 0xc000: case 0xc200: case 0xc400: case 0xc600: case 0xc800: case 0xca00: case 0xcc00: case 0xce00:
 961                         ea = MakeEA (lo, p, 1, &count); p += count;
 962                         sprintf (buffer, "AND.B    %s,D%d", ea, rhi);
 963                         break;
 964                 case 0xc040: case 0xc240: case 0xc440: case 0xc640: case 0xc840: case 0xca40: case 0xcc40: case 0xce40:
 965                         ea = MakeEA (lo, p, 2, &count); p += count;
 966                         sprintf (buffer, "AND.W    %s,D%d", ea, rhi);
 967                         break;
 968                 case 0xc080: case 0xc280: case 0xc480: case 0xc680: case 0xc880: case 0xca80: case 0xcc80: case 0xce80:
 969                         ea = MakeEA (lo, p, 4, &count); p += count;
 970                         sprintf (buffer, "AND.L    %s,D%d", ea, rhi);
 971                         break;
 972                 case 0xc0c0: case 0xc2c0: case 0xc4c0: case 0xc6c0: case 0xc8c0: case 0xcac0: case 0xccc0: case 0xcec0:
 973                         ea = MakeEA (lo, p, 2, &count); p += count;
 974                         sprintf (buffer, "MULU.W   %s,D%d", ea, rhi);
 975                         break;
 976                 case 0xc100: case 0xc300: case 0xc500: case 0xc700: case 0xc900: case 0xcb00: case 0xcd00: case 0xcf00:
 977                         if ((lo & 0x30) == 0)
 978                         {
 979                                 if (lo & 0x08)
 980                                         sprintf (buffer, "ABCD.B   -(A%d),-(A%d)", rlo, rhi);
 981                                 else
 982                                         sprintf (buffer, "ABCD.B   D%d,D%d", rlo, rhi);
 983                         }
 984                         else
 985                         {
 986                                 ea = MakeEA (lo, p, 1, &count); p += count;
 987                                 sprintf (buffer, "AND.B    D%d,%s", rhi, ea);
 988                         }
 989                         break;
 990                 case 0xc140: case 0xc340: case 0xc540: case 0xc740: case 0xc940: case 0xcb40: case 0xcd40: case 0xcf40:
 991                         if ((lo & 0x30) == 0)
 992                         {
 993                                 if (lo & 0x08)
 994                                         sprintf (buffer, "EXG      A%d,A%d", rhi, rlo);
 995                                 else
 996                                         sprintf (buffer, "EXG      D%d,D%d", rhi, rlo);
 997                         }
 998                         else
 999                         {
1000                                 ea = MakeEA (lo, p, 2,&count); p += count;
1001                                 sprintf (buffer, "AND.W    D%d,%s", rhi, ea);
1002                         }
1003                         break;
1004                 case 0xc180: case 0xc380: case 0xc580: case 0xc780: case 0xc980: case 0xcb80: case 0xcd80: case 0xcf80:
1005                         if ((lo & 0x38) == 0x08)
1006                                 sprintf (buffer, "EXG      D%d,A%d", rhi, rlo);
1007                         else
1008                         {
1009                                 ea = MakeEA (lo, p, 4, &count); p += count;
1010                                 sprintf (buffer, "AND.L    D%d,%s", rhi, ea);
1011                         }
1012                         break;
1013                 case 0xc1c0: case 0xc3c0: case 0xc5c0: case 0xc7c0: case 0xc9c0: case 0xcbc0: case 0xcdc0: case 0xcfc0:
1014                         ea = MakeEA (lo, p, 2, &count); p += count;
1015                         sprintf (buffer, "MULS.W   %s,D%d", ea, rhi);
1016                         break;
1017                 case 0xd000: case 0xd200: case 0xd400: case 0xd600: case 0xd800: case 0xda00: case 0xdc00: case 0xde00:
1018                         ea = MakeEA (lo, p, 1, &count); p += count;
1019                         sprintf (buffer, "ADD.B    %s,D%d", ea, rhi);
1020                         break;
1021                 case 0xd040: case 0xd240: case 0xd440: case 0xd640: case 0xd840: case 0xda40: case 0xdc40: case 0xde40:
1022                         ea = MakeEA (lo, p, 2, &count); p += count;
1023                         sprintf (buffer, "ADD.W    %s,D%d", ea, rhi);
1024                         break;
1025                 case 0xd080: case 0xd280: case 0xd480: case 0xd680: case 0xd880: case 0xda80: case 0xdc80: case 0xde80:
1026                         ea = MakeEA (lo, p, 4, &count); p += count;
1027                         sprintf (buffer, "ADD.L    %s,D%d", ea, rhi);
1028                         break;
1029                 case 0xd0c0: case 0xd2c0: case 0xd4c0: case 0xd6c0: case 0xd8c0: case 0xdac0: case 0xdcc0: case 0xdec0:
1030                         ea = MakeEA (lo, p, 2, &count); p += count;
1031                         sprintf (buffer, "ADDA.W   %s,A%d", ea, rhi);
1032                         break;
1033                 case 0xd100: case 0xd300: case 0xd500: case 0xd700: case 0xd900: case 0xdb00: case 0xdd00: case 0xdf00:
1034                         if ((lo & 0x30) == 0)
1035                         {
1036                                 if (lo & 0x08)
1037                                         sprintf (buffer, "ADDX.B   -(A%d),-(A%d)", rlo, rhi);
1038                                 else
1039                                         sprintf (buffer, "ADDX.B   D%d,D%d", rlo, rhi);
1040                         }
1041                         else
1042                         {
1043                                 ea = MakeEA (lo, p, 1, &count); p += count;
1044                                 sprintf (buffer, "ADD.B    D%d,%s", rhi, ea);
1045                         }
1046                         break;
1047                 case 0xd140: case 0xd340: case 0xd540: case 0xd740: case 0xd940: case 0xdb40: case 0xdd40: case 0xdf40:
1048                         if ((lo & 0x30) == 0)
1049                         {
1050                                 if (lo & 0x08)
1051                                         sprintf (buffer, "ADDX.W   -(A%d),-(A%d)", rlo, rhi);
1052                                 else
1053                                         sprintf (buffer, "ADDX.W   D%d,D%d", rlo, rhi);
1054                         }
1055                         else
1056                         {
1057                                 ea = MakeEA (lo, p, 2, &count); p += count;
1058                                 sprintf (buffer, "ADD.W    D%d,%s", rhi, ea);
1059                         }
1060                         break;
1061                 case 0xd180: case 0xd380: case 0xd580: case 0xd780: case 0xd980: case 0xdb80: case 0xdd80: case 0xdf80:
1062                         if ((lo & 0x30) == 0)
1063                         {
1064                                 if (lo & 0x08)
1065                                         sprintf (buffer, "ADDX.L   -(A%d),-(A%d)", rlo, rhi);
1066                                 else
1067                                         sprintf (buffer, "ADDX.L   D%d,D%d", rlo, rhi);
1068                         }
1069                         else
1070                         {
1071                                 ea = MakeEA (lo, p, 4,&count); p += count;
1072                                 sprintf (buffer, "ADD.L    D%d,%s", rhi, ea);
1073                         }
1074                         break;
1075                 case 0xd1c0: case 0xd3c0: case 0xd5c0: case 0xd7c0: case 0xd9c0: case 0xdbc0: case 0xddc0: case 0xdfc0:
1076                         ea = MakeEA (lo, p, 4, &count); p += count;
1077                         sprintf (buffer, "ADDA.L   %s,A%d", ea, rhi);
1078                         break;
1079                 case 0xe000: case 0xe200: case 0xe400: case 0xe600: case 0xe800: case 0xea00: case 0xec00: case 0xee00:
1080                         switch ((lo >> 3) & 7)
1081                         {
1082                                 case 0: sprintf (buffer, "ASR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1083                                 case 1: sprintf (buffer, "LSR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1084                                 case 2: sprintf (buffer, "ROXR.B   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1085                                 case 3: sprintf (buffer, "ROR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1086                                 case 4: sprintf (buffer, "ASR.B    D%d,D%d", rhi, rlo);         break;
1087                                 case 5: sprintf (buffer, "LSR.B    D%d,D%d", rhi, rlo);         break;
1088                                 case 6: sprintf (buffer, "ROXR.B   D%d,D%d", rhi, rlo);         break;
1089                                 case 7: sprintf (buffer, "ROR.B    D%d,D%d", rhi, rlo);         break;
1090                         }
1091                         break;
1092                 case 0xe040: case 0xe240: case 0xe440: case 0xe640: case 0xe840: case 0xea40: case 0xec40: case 0xee40:
1093                         switch ((lo >> 3) & 7)
1094                         {
1095                                 case 0: sprintf (buffer, "ASR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1096                                 case 1: sprintf (buffer, "LSR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1097                                 case 2: sprintf (buffer, "ROXR.W   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1098                                 case 3: sprintf (buffer, "ROR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1099                                 case 4: sprintf (buffer, "ASR.W    D%d,D%d", rhi, rlo);         break;
1100                                 case 5: sprintf (buffer, "LSR.W    D%d,D%d", rhi, rlo);         break;
1101                                 case 6: sprintf (buffer, "ROXR.W   D%d,D%d", rhi, rlo);         break;
1102                                 case 7: sprintf (buffer, "ROR.W    D%d,D%d", rhi, rlo);         break;
1103                         }
1104                         break;
1105                 case 0xe080: case 0xe280: case 0xe480: case 0xe680: case 0xe880: case 0xea80: case 0xec80: case 0xee80:
1106                         switch ((lo >> 3) & 7)
1107                         {
1108                                 case 0: sprintf (buffer, "ASR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1109                                 case 1: sprintf (buffer, "LSR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1110                                 case 2: sprintf (buffer, "ROXR.L   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1111                                 case 3: sprintf (buffer, "ROR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1112                                 case 4: sprintf (buffer, "ASR.L    D%d,D%d", rhi, rlo);         break;
1113                                 case 5: sprintf (buffer, "LSR.L    D%d,D%d", rhi, rlo);         break;
1114                                 case 6: sprintf (buffer, "ROXR.L   D%d,D%d", rhi, rlo);         break;
1115                                 case 7: sprintf (buffer, "ROR.L    D%d,D%d", rhi, rlo);         break;
1116                         }
1117                         break;
1118                 case 0xe0c0: case 0xe2c0: case 0xe4c0: case 0xe6c0:
1119                 case 0xe1c0: case 0xe3c0: case 0xe5c0: case 0xe7c0:
1120                         ea = MakeEA (lo, p, 4, &count); p += count;
1121                         switch ((op >> 8) & 7)
1122                         {
1123                                 case 0: sprintf (buffer, "ASR.L    #1,%s", ea);         break;
1124                                 case 1: sprintf (buffer, "ASL.L    #1,%s", ea);         break;
1125                                 case 2: sprintf (buffer, "LSR.L    #1,%s", ea);         break;
1126                                 case 3: sprintf (buffer, "LSL.L    #1,%s", ea);         break;
1127                                 case 4: sprintf (buffer, "ROXR.L   #1,%s", ea);         break;
1128                                 case 5: sprintf (buffer, "ROXL.L   #1,%s", ea);         break;
1129                                 case 6: sprintf (buffer, "ROR.L    #1,%s", ea);         break;
1130                                 case 7: sprintf (buffer, "ROL.L    #1,%s", ea);         break;
1131                         }
1132                         break;
1133                 case 0xe100: case 0xe300: case 0xe500: case 0xe700: case 0xe900: case 0xeb00: case 0xed00: case 0xef00:
1134                         switch ((lo >> 3) & 7)
1135                         {
1136                                 case 0: sprintf (buffer, "ASL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1137                                 case 1: sprintf (buffer, "LSL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1138                                 case 2: sprintf (buffer, "ROXL.B   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1139                                 case 3: sprintf (buffer, "ROL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1140                                 case 4: sprintf (buffer, "ASL.B    D%d,D%d", rhi, rlo);         break;
1141                                 case 5: sprintf (buffer, "LSL.B    D%d,D%d", rhi, rlo);         break;
1142                                 case 6: sprintf (buffer, "ROXL.B   D%d,D%d", rhi, rlo);         break;
1143                                 case 7: sprintf (buffer, "ROL.B    D%d,D%d", rhi, rlo);         break;
1144                         }
1145                         break;
1146                 case 0xe140: case 0xe340: case 0xe540: case 0xe740: case 0xe940: case 0xeb40: case 0xed40: case 0xef40:
1147                         switch ((lo >> 3) & 7)
1148                         {
1149                                 case 0: sprintf (buffer, "ASL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1150                                 case 1: sprintf (buffer, "LSL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1151                                 case 2: sprintf (buffer, "ROXL.W   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1152                                 case 3: sprintf (buffer, "ROL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1153                                 case 4: sprintf (buffer, "ASL.W    D%d,D%d", rhi, rlo);         break;
1154                                 case 5: sprintf (buffer, "LSL.W    D%d,D%d", rhi, rlo);         break;
1155                                 case 6: sprintf (buffer, "ROXL.W   D%d,D%d", rhi, rlo);         break;
1156                                 case 7: sprintf (buffer, "ROL.W    D%d,D%d", rhi, rlo);         break;
1157                         }
1158                         break;
1159                 case 0xe180: case 0xe380: case 0xe580: case 0xe780: case 0xe980: case 0xeb80: case 0xed80: case 0xef80:
1160                         switch ((lo >> 3) & 7)
1161                         {
1162                                 case 0: sprintf (buffer, "ASL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1163                                 case 1: sprintf (buffer, "LSL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1164                                 case 2: sprintf (buffer, "ROXL.L   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1165                                 case 3: sprintf (buffer, "ROL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
1166                                 case 4: sprintf (buffer, "ASL.L    D%d,D%d", rhi, rlo);         break;
1167                                 case 5: sprintf (buffer, "LSL.L    D%d,D%d", rhi, rlo);         break;
1168                                 case 6: sprintf (buffer, "ROXL.L   D%d,D%d", rhi, rlo);         break;
1169                                 case 7: sprintf (buffer, "ROL.L    D%d,D%d", rhi, rlo);         break;
1170                         }
1171                         break;
1172                 default:
1173                         sprintf (buffer, "DC.W     $%X", op);
1174                         break;
1175         }
1176
1177         return p - pBase;
1178 }
1179
1180 #else
1181
1182 static char *MakeEA (int lo, char *pBase, int size, int *count)
1183 {
1184         static char buffer[2][80];
1185         static int which;
1186
1187         unsigned char *p = (unsigned char *)pBase;
1188         char *buf = buffer[which];
1189         int reg = lo & 7;
1190         unsigned long pm;
1191         int temp;
1192
1193         which ^= 1;
1194         switch ((lo >> 3) & 7)
1195         {
1196                 case 0:
1197                         sprintf (buf, "D%d", reg);
1198                         break;
1199                 case 1:
1200                         sprintf (buf, "A%d", reg);
1201                         break;
1202                 case 2:
1203                         sprintf (buf, "(A%d)", reg);
1204                         break;
1205                 case 3:
1206                         sprintf (buf, "(A%d)+", reg);
1207                         break;
1208                 case 4:
1209                         sprintf (buf, "-(A%d)", reg);
1210                         break;
1211                 case 5:
1212                         PARAM_WORD (pm);
1213                         if (pm & 0x8000)
1214                                 sprintf (buf, "(-$%X,A%d)", -(signed short)pm & 0xffff, reg);
1215                         else
1216                                 sprintf (buf, "($%lX,A%d)", pm, reg);
1217                         break;
1218                 case 6:
1219                         PARAM_WORD (pm);
1220                         temp = pm & 0xff;
1221                         if (temp & 0x80)
1222                                 sprintf (buf, "(-$%X,A%d,D%ld.%c)", -(signed char)temp & 0xff, reg, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
1223                         else
1224                                 sprintf (buf, "($%X,A%d,D%ld.%c)", temp, reg, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
1225                         break;
1226                 case 7:
1227                         switch (reg)
1228                         {
1229                                 case 0:
1230                                         PARAM_WORD (pm);
1231                                         sprintf (buf, "$%lX", pm);
1232                                         break;
1233                                 case 1:
1234                                         PARAM_LONG (pm);
1235                                         sprintf (buf, "$%lX", pm);
1236                                         break;
1237                                 case 2:
1238                                         PARAM_WORD (pm);
1239                                         if (pm & 0x8000)
1240                                                 sprintf (buf, "(-$%X,PC)", -(signed short)pm & 0xffff);
1241                                         else
1242                                                 sprintf (buf, "($%lX,PC)", pm);
1243                                         break;
1244                                 case 3:
1245                                         PARAM_WORD (pm);
1246                                         temp = pm & 0xff;
1247                                         if (temp & 0x80)
1248                                                 sprintf (buf, "(-$%X,PC,D%ld.%c)", -(signed char)temp & 0xff, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
1249                                         else
1250                                                 sprintf (buf, "($%X,PC,D%ld.%c)", temp, (pm >> 12) & 7, (pm & 800) ? 'L' : 'W');
1251                                         break;
1252                                 case 4:
1253                                         if (size == 1)
1254                                         {
1255                                                 PARAM_WORD (pm);
1256                                                 temp = pm & 0xff;
1257                                                 sprintf (buf, "#$%X", temp);
1258                                         }
1259                                         else if (size == 2)
1260                                         {
1261                                                 PARAM_WORD (pm);
1262                                                 sprintf (buf, "#$%lX", pm);
1263                                         }
1264                                         else
1265                                         {
1266                                                 PARAM_LONG (pm);
1267                                                 sprintf (buf, "#$%lX", pm);
1268                                         }
1269                                         break;
1270                         }
1271                         break;
1272         }
1273
1274         *count = p - ((unsigned char*)pBase);
1275         return buf;
1276 }
1277
1278 static char *MakeRegList (char *p, unsigned short pm)
1279 {
1280         int start = -1, sep = 0;
1281         int i;
1282
1283         for (i = 0; i < 8; i++, pm >>= 1)
1284         {
1285                 if ((pm & 1) && start == -1)
1286                         start = i;
1287                 else if (!(pm & 1) && start != -1)
1288                 {
1289                         if (sep++) p += sprintf (p, "/");
1290                         if (start == i - 1) p += sprintf (p, "D%d", start);
1291                         else p += sprintf (p, "D%d-D%d", start, i - 1);
1292                         start = -1;
1293                 }
1294         }
1295         if (start != -1)
1296         {
1297                 if (sep++) p += sprintf (p, "/");
1298                 if (start == 7) p += sprintf (p, "D7");
1299                 else p += sprintf (p, "D%d-D7", start);
1300                 start = -1;
1301         }
1302
1303         for (i = 0; i < 8; i++, pm >>= 1)
1304         {
1305                 if ((pm & 1) && start == -1)
1306                         start = i;
1307                 else if (!(pm & 1) && start != -1)
1308                 {
1309                         if (sep++) p += sprintf (p, "/");
1310                         if (start == i - 1) p += sprintf (p, "A%d", start);
1311                         else p += sprintf (p, "A%d-A%d", start, i - 1);
1312                         start = -1;
1313                 }
1314         }
1315         if (start != -1)
1316         {
1317                 if (sep++) p += sprintf (p, "/");
1318                 if (start == 7) p += sprintf (p, "A7");
1319                 else p += sprintf (p, "A%d-A7", start);
1320         }
1321
1322         return p;
1323 }
1324
1325 static char *MakeRevRegList (char *p, unsigned short pm)
1326 {
1327         int start = -1, sep = 0;
1328         int i;
1329
1330         for (i = 0; i < 8; i++, pm <<= 1)
1331         {
1332                 if ((pm & 0x8000) && start == -1)
1333                         start = i;
1334                 else if (!(pm & 0x8000) && start != -1)
1335                 {
1336                         if (sep++) p += sprintf (p, "/");
1337                         if (start == i - 1) p += sprintf (p, "D%d", start);
1338                         else p += sprintf (p, "D%d-D%d", start, i - 1);
1339                         start = -1;
1340                 }
1341         }
1342         if (start != -1)
1343         {
1344                 if (sep++) p += sprintf (p, "/");
1345                 if (start == 7) p += sprintf (p, "D7");
1346                 else p += sprintf (p, "D%d-D7", start);
1347                 start = -1;
1348         }
1349
1350         for (i = 0; i < 8; i++, pm <<= 1)
1351         {
1352                 if ((pm & 0x8000) && start == -1)
1353                         start = i;
1354                 else if (!(pm & 0x8000) && start != -1)
1355                 {
1356                         if (sep++) p += sprintf (p, "/");
1357                         if (start == i - 1) p += sprintf (p, "A%d", start);
1358                         else p += sprintf (p, "A%d-A%d", start, i - 1);
1359                         start = -1;
1360                 }
1361         }
1362         if (start != -1)
1363         {
1364                 if (sep++) p += sprintf (p, "/");
1365                 if (start == 7) p += sprintf (p, "A7");
1366                 else p += sprintf (p, "A%d-A7", start);
1367         }
1368
1369         return p;
1370 }
1371
1372
1373 int Dasm68000 (char *pBase, char *buffer, int pc)
1374 {
1375         char *ea, *ea2, *p = pBase;
1376         unsigned short op, lo, rhi, rlo;
1377         unsigned long pm;
1378         int count;
1379
1380         PARAM_WORD(op);
1381
1382         lo = op & 0x3f;
1383         rhi = (op >> 9) & 7;
1384         rlo = op & 7;
1385         switch (op & 0xffc0)
1386         {
1387                 case 0x0000:
1388                         PARAM_WORD(pm);
1389                         if (lo == 0x3c)
1390                                 sprintf (buffer, "ORI      #$%lX,CCR", pm & 0xff);
1391                         else
1392                         {
1393                                 ea = MakeEA (lo, p, 1, &count); p += count;
1394                                 sprintf (buffer, "ORI.B    #$%lX,%s", pm & 0xff, ea);
1395                         }
1396                         break;
1397                 case 0x0040:
1398                         PARAM_WORD(pm);
1399                         if (lo == 0x3c)
1400                                 sprintf (buffer, "ORI      #$%lX,SR", pm & 0xffff);
1401                         else
1402                         {
1403                                 ea = MakeEA (lo, p, 2, &count); p += count;
1404                                 sprintf (buffer, "ORI.W    #$%lX,%s", pm & 0xffff, ea);
1405                         }
1406                         break;
1407                 case 0x0080:
1408                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1409                         sprintf (buffer, "ORI.L    #$%lX,%s", pm, ea);
1410                         break;
1411                 case 0x0100: case 0x0300: case 0x0500: case 0x0700: case 0x0900: case 0x0b00: case 0x0d00: case 0x0f00:
1412                         if ((lo & 0x38) == 0x08)
1413                         {
1414                                 PARAM_WORD(pm);
1415                                 sprintf (buffer, "MOVEP.W  ($%lX,A%d),D%d", pm, rlo, rhi);
1416                         }
1417                         else
1418                         {
1419                                 ea = MakeEA (lo, p, 2, &count); p += count;
1420                                 sprintf (buffer, "BTST     D%d,%s", rhi, ea);
1421                         }
1422                         break;
1423                 case 0x0140: case 0x0340: case 0x0540: case 0x0740: case 0x0940: case 0x0b40: case 0x0d40: case 0x0f40:
1424                         if ((lo & 0x38) == 0x08)
1425                         {
1426                                 PARAM_WORD(pm);
1427                                 sprintf (buffer, "MOVEP.L  ($%lX,A%d),D%d", pm, rlo, rhi);
1428                         }
1429                         else
1430                         {
1431                                 ea = MakeEA (lo, p, 2, &count); p += count;
1432                                 sprintf (buffer, "BCHG     D%d,%s", rhi, ea);
1433                         }
1434                         break;
1435                 case 0x0180: case 0x0380: case 0x0580: case 0x0780: case 0x0980: case 0x0b80: case 0x0d80: case 0x0f80:
1436                         if ((lo & 0x38) == 0x08)
1437                         {
1438                                 PARAM_WORD(pm);
1439                                 sprintf (buffer, "MOVEP.W  D%d,($%lX,A%d)", rhi, pm, rlo);
1440                         }
1441                         else
1442                         {
1443                                 ea = MakeEA (lo, p, 2, &count); p += count;
1444                                 sprintf (buffer, "BCLR     D%d,%s", rhi, ea);
1445                         }
1446                         break;
1447                 case 0x01c0: case 0x03c0: case 0x05c0: case 0x07c0: case 0x09c0: case 0x0bc0: case 0x0dc0: case 0x0fc0:
1448                         if ((lo & 0x38) == 0x08)
1449                         {
1450                                 PARAM_WORD(pm);
1451                                 sprintf (buffer, "MOVEP.L  D%d,($%lX,A%d)", rhi, pm, rlo);
1452                         }
1453                         else
1454                         {
1455                                 ea = MakeEA (lo, p, 2, &count); p += count;
1456                                 sprintf (buffer, "BSET     D%d,%s", rhi, ea);
1457                         }
1458                         break;
1459                 case 0x0200:
1460                         PARAM_WORD(pm);
1461                         if (lo == 0x3c)
1462                                 sprintf (buffer, "ANDI     #$%lX,CCR", pm & 0xff);
1463                         else
1464                         {
1465                                 ea = MakeEA (lo, p, 1, &count); p += count;
1466                                 sprintf (buffer, "ANDI.B   #$%lX,%s", pm & 0xff, ea);
1467                         }
1468                         break;
1469                 case 0x0240:
1470                         PARAM_WORD(pm);
1471                         if (lo == 0x3c)
1472                                 sprintf (buffer, "ANDI     #$%lX,SR", pm & 0xffff);
1473                         else
1474                         {
1475                                 ea = MakeEA (lo, p, 2, &count); p += count;
1476                                 sprintf (buffer, "ANDI.W   #$%lX,%s", pm & 0xffff, ea);
1477                         }
1478                         break;
1479                 case 0x0280:
1480                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1481                         sprintf (buffer, "ANDI.L   #$%lX,%s", pm, ea);
1482                         break;
1483                 case 0x0400:
1484                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
1485                         sprintf (buffer, "SUBI.B   #$%lX,%s", pm & 0xff, ea);
1486                         break;
1487                 case 0x0440:
1488                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1489                         sprintf (buffer, "SUBI.W   #$%lX,%s", pm & 0xffff, ea);
1490                         break;
1491                 case 0x0480:
1492                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1493                         sprintf (buffer, "SUBI.L   #$%lX,%s", pm, ea);
1494                         break;
1495                 case 0x0600:
1496                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
1497                         sprintf (buffer, "ADDI.B   #$%lX,%s", pm & 0xff, ea);
1498                         break;
1499                 case 0x0640:
1500                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1501                         sprintf (buffer, "ADDI.W   #$%lX,%s", pm & 0xffff, ea);
1502                         break;
1503                 case 0x0680:
1504                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1505                         sprintf (buffer, "ADDI.L   #$%lX,%s", pm, ea);
1506                         break;
1507                 case 0x0800:
1508                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1509                         sprintf (buffer, "BTST     #$%lX,%s", pm & 0xff, ea);
1510                         break;
1511                 case 0x0840:
1512                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1513                         sprintf (buffer, "BCHG     #$%lX,%s", pm & 0xff, ea);
1514                         break;
1515                 case 0x0880:
1516                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1517                         sprintf (buffer, "BCLR     #$%lX,%s", pm & 0xff, ea);
1518                         break;
1519                 case 0x08c0:
1520                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1521                         sprintf (buffer, "BSET     #$%lX,%s", pm & 0xff, ea);
1522                         break;
1523                 case 0x0a00:
1524                         PARAM_WORD(pm);
1525                         if (lo == 0x3c)
1526                                 sprintf (buffer, "EORI     #$%lX,CCR", pm & 0xff);
1527                         else
1528                         {
1529                                 ea = MakeEA (lo, p, 1, &count); p += count;
1530                                 sprintf (buffer, "EORI.B   #$%lX,%s", pm & 0xff, ea);
1531                         }
1532                         break;
1533                 case 0x0a40:
1534                         PARAM_WORD(pm);
1535                         if (lo == 0x3c)
1536                                 sprintf (buffer, "EORI     #$%lX,SR", pm & 0xffff);
1537                         else
1538                         {
1539                                 ea = MakeEA (lo, p, 2, &count); p += count;
1540                                 sprintf (buffer, "EORI.W   #$%lX,%s", pm & 0xffff, ea);
1541                         }
1542                         break;
1543                 case 0x0a80:
1544                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1545                         sprintf (buffer, "EORI.L   #$%lX,%s", pm, ea);
1546                         break;
1547                 case 0x0c00:
1548                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
1549                         sprintf (buffer, "CMPI.B   #$%lX,%s", pm & 0xff, ea);
1550                         break;
1551                 case 0x0c40:
1552                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1553                         sprintf (buffer, "CMPI.W   #$%lX,%s", pm & 0xffff, ea);
1554                         break;
1555                 case 0x0c80:
1556                         PARAM_LONG(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1557                         sprintf (buffer, "CMPI.L   #$%lX,%s", pm, ea);
1558                         break;
1559                 case 0x0e00:
1560                         PARAM_WORD(pm); ea = MakeEA (lo, p, 1, &count); p += count;
1561                         if (pm & 0x0800)
1562                         {
1563                                 if (pm & 0x8000)
1564                                         sprintf (buffer, "MOVES.B  A%ld,%s", (pm >> 12) & 7, ea);
1565                                 else
1566                                         sprintf (buffer, "MOVES.B  D%ld,%s", (pm >> 12) & 7, ea);
1567                         }
1568                         else
1569                         {
1570                                 if (pm & 0x8000)
1571                                         sprintf (buffer, "MOVES.B  %s,A%ld", ea, (pm >> 12) & 7);
1572                                 else
1573                                         sprintf (buffer, "MOVES.B  %s,D%ld", ea, (pm >> 12) & 7);
1574                         }
1575                         break;
1576                 case 0x0e40:
1577                         PARAM_WORD(pm); ea = MakeEA (lo, p, 2, &count); p += count;
1578                         if (pm & 0x0800)
1579                         {
1580                                 if (pm & 0x8000)
1581                                         sprintf (buffer, "MOVES.W  A%ld,%s", (pm >> 12) & 7, ea);
1582                                 else
1583                                         sprintf (buffer, "MOVES.W  D%ld,%s", (pm >> 12) & 7, ea);
1584                         }
1585                         else
1586                         {
1587                                 if (pm & 0x8000)
1588                                         sprintf (buffer, "MOVES.W  %s,A%ld", ea, (pm >> 12) & 7);
1589                                 else
1590                                         sprintf (buffer, "MOVES.W  %s,D%ld", ea, (pm >> 12) & 7);
1591                         }
1592                         break;
1593                 case 0x0e80:
1594                         PARAM_WORD(pm); ea = MakeEA (lo, p, 4, &count); p += count;
1595                         if (pm & 0x0800)
1596                         {
1597                                 if (pm & 0x8000)
1598                                         sprintf (buffer, "MOVES.L  A%ld,%s", (pm >> 12) & 7, ea);
1599                                 else
1600                                         sprintf (buffer, "MOVES.L  D%ld,%s", (pm >> 12) & 7, ea);
1601                         }
1602                         else
1603                         {
1604                                 if (pm & 0x8000)
1605                                         sprintf (buffer, "MOVES.L  %s,A%ld", ea, (pm >> 12) & 7);
1606                                 else
1607                                         sprintf (buffer, "MOVES.L  %s,D%ld", ea, (pm >> 12) & 7);
1608                         }
1609                         break;
1610                 case 0x1000: case 0x1080: case 0x10c0: case 0x1100: case 0x1140: case 0x1180: case 0x11c0:
1611                 case 0x1200: case 0x1280: case 0x12c0: case 0x1300: case 0x1340: case 0x1380: case 0x13c0:
1612                 case 0x1400: case 0x1480: case 0x14c0: case 0x1500: case 0x1540: case 0x1580:
1613                 case 0x1600: case 0x1680: case 0x16c0: case 0x1700: case 0x1740: case 0x1780:
1614                 case 0x1800: case 0x1880: case 0x18c0: case 0x1900: case 0x1940: case 0x1980:
1615                 case 0x1a00: case 0x1a80: case 0x1ac0: case 0x1b00: case 0x1b40: case 0x1b80:
1616                 case 0x1c00: case 0x1c80: case 0x1cc0: case 0x1d00: case 0x1d40: case 0x1d80:
1617                 case 0x1e00: case 0x1e80: case 0x1ec0: case 0x1f00: case 0x1f40: case 0x1f80:
1618                         ea = MakeEA (lo, p, 1, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 1, &count); p += count;
1619                         sprintf (buffer, "MOVE.B   %s,%s", ea, ea2);
1620                         break;
1621                 case 0x2000: case 0x2080: case 0x20c0: case 0x2100: case 0x2140: case 0x2180: case 0x21c0:
1622                 case 0x2200: case 0x2280: case 0x22c0: case 0x2300: case 0x2340: case 0x2380: case 0x23c0:
1623                 case 0x2400: case 0x2480: case 0x24c0: case 0x2500: case 0x2540: case 0x2580:
1624                 case 0x2600: case 0x2680: case 0x26c0: case 0x2700: case 0x2740: case 0x2780:
1625                 case 0x2800: case 0x2880: case 0x28c0: case 0x2900: case 0x2940: case 0x2980:
1626                 case 0x2a00: case 0x2a80: case 0x2ac0: case 0x2b00: case 0x2b40: case 0x2b80:
1627                 case 0x2c00: case 0x2c80: case 0x2cc0: case 0x2d00: case 0x2d40: case 0x2d80:
1628                 case 0x2e00: case 0x2e80: case 0x2ec0: case 0x2f00: case 0x2f40: case 0x2f80:
1629                         ea = MakeEA (lo, p, 4, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 4, &count); p += count;
1630                         sprintf (buffer, "MOVE.L   %s,%s", ea, ea2);
1631                         break;
1632                 case 0x2040: case 0x2240: case 0x2440: case 0x2640: case 0x2840: case 0x2a40: case 0x2c40: case 0x2e40:
1633                         ea = MakeEA (lo, p, 4, &count); p += count;
1634                         sprintf (buffer, "MOVEA.L  %s,A%d", ea, rhi);
1635                         break;
1636                 case 0x3000: case 0x3080: case 0x30c0: case 0x3100: case 0x3140: case 0x3180: case 0x31c0:
1637                 case 0x3200: case 0x3280: case 0x32c0: case 0x3300: case 0x3340: case 0x3380: case 0x33c0:
1638                 case 0x3400: case 0x3480: case 0x34c0: case 0x3500: case 0x3540: case 0x3580:
1639                 case 0x3600: case 0x3680: case 0x36c0: case 0x3700: case 0x3740: case 0x3780:
1640                 case 0x3800: case 0x3880: case 0x38c0: case 0x3900: case 0x3940: case 0x3980:
1641                 case 0x3a00: case 0x3a80: case 0x3ac0: case 0x3b00: case 0x3b40: case 0x3b80:
1642                 case 0x3c00: case 0x3c80: case 0x3cc0: case 0x3d00: case 0x3d40: case 0x3d80:
1643                 case 0x3e00: case 0x3e80: case 0x3ec0: case 0x3f00: case 0x3f40: case 0x3f80:
1644                         ea = MakeEA (lo, p, 2, &count); p += count; ea2 = MakeEA (((op >> 9) & 0x07) + ((op >> 3) & 0x38), p, 2, &count); p += count;
1645                         sprintf (buffer, "MOVE.W   %s,%s", ea, ea2);
1646                         break;
1647                 case 0x3040: case 0x3240: case 0x3440: case 0x3640: case 0x3840: case 0x3a40: case 0x3c40: case 0x3e40:
1648                         ea = MakeEA (lo, p, 2, &count); p += count;
1649                         sprintf (buffer, "MOVEA.W  %s,A%d", ea, rhi);
1650                         break;
1651                 case 0x4000:
1652                         ea = MakeEA (lo, p, 1, &count); p += count;
1653                         sprintf (buffer, "NEGX.B   %s", ea);
1654                         break;
1655                 case 0x4040:
1656                         ea = MakeEA (lo, p, 2, &count); p += count;
1657                         sprintf (buffer, "NEGX.W   %s", ea);
1658                         break;
1659                 case 0x4080:
1660                         ea = MakeEA (lo, p, 4, &count); p += count;
1661                         sprintf (buffer, "NEGX.L   %s", ea);
1662                         break;
1663                 case 0x40c0:
1664                         ea = MakeEA (lo, p, 2, &count); p += count;
1665                         sprintf (buffer, "MOVE     SR,%s", ea);
1666                         break;
1667                 case 0x4180: case 0x4380: case 0x4580: case 0x4780: case 0x4980: case 0x4b80: case 0x4d80: case 0x4f80:
1668                         ea = MakeEA (lo, p, 2, &count); p += count;
1669                         sprintf (buffer, "CHK.W    %s,D%d", ea, rhi);
1670                         break;
1671                 case 0x41c0: case 0x43c0: case 0x45c0: case 0x47c0: case 0x49c0: case 0x4bc0: case 0x4dc0: case 0x4fc0:
1672                         ea = MakeEA (lo, p, 4, &count); p += count;
1673                         sprintf (buffer, "LEA      %s,A%d", ea, rhi);
1674                         break;
1675                 case 0x4200:
1676                         ea = MakeEA (lo, p, 1, &count); p += count;
1677                         sprintf (buffer, "CLR.B    %s", ea);
1678                         break;
1679                 case 0x4240:
1680                         ea = MakeEA (lo, p, 2, &count); p += count;
1681                         sprintf (buffer, "CLR.W    %s", ea);
1682                         break;
1683                 case 0x4280:
1684                         ea = MakeEA (lo, p, 4, &count); p += count;
1685                         sprintf (buffer, "CLR.L    %s", ea);
1686                         break;
1687                 case 0x42c0:
1688                         ea = MakeEA (lo, p, 2, &count); p += count;
1689                         sprintf (buffer, "MOVE     CCR,%s", ea);
1690                         break;
1691                 case 0x4400:
1692                         ea = MakeEA (lo, p, 1, &count); p += count;
1693                         sprintf (buffer, "NEG.B    %s", ea);
1694                         break;
1695                 case 0x4440:
1696                         ea = MakeEA (lo, p, 2, &count); p += count;
1697                         sprintf (buffer, "NEG.W    %s", ea);
1698                         break;
1699                 case 0x4480:
1700                         ea = MakeEA (lo, p, 4, &count); p += count;
1701                         sprintf (buffer, "NEG.L    %s", ea);
1702                         break;
1703                 case 0x44c0:
1704                         ea = MakeEA (lo, p, 2, &count); p += count;
1705                         sprintf (buffer, "MOVE     %s,CCR", ea);
1706                         break;
1707                 case 0x4600:
1708                         ea = MakeEA (lo, p, 1, &count); p += count;
1709                         sprintf (buffer, "NOT.B    %s", ea);
1710                         break;
1711                 case 0x4640:
1712                         ea = MakeEA (lo, p, 2, &count); p += count;
1713                         sprintf (buffer, "NOT.W    %s", ea);
1714                         break;
1715                 case 0x4680:
1716                         ea = MakeEA (lo, p, 4, &count); p += count;
1717                         sprintf (buffer, "NOT.L    %s", ea);
1718                         break;
1719                 case 0x46c0:
1720                         ea = MakeEA (lo, p, 2, &count); p += count;
1721                         sprintf (buffer, "MOVE     %s,SR", ea);
1722                         break;
1723                 case 0x4800:
1724                         ea = MakeEA (lo, p, 1, &count); p += count;
1725                         sprintf (buffer, "NBCD.B   %s", ea);
1726                         break;
1727                 case 0x4840:
1728                         if ((lo & 0x38) == 0x00)
1729                                 sprintf (buffer, "SWAP     D%d", rlo);
1730                         else
1731                         {
1732                                 ea = MakeEA (lo, p, 4, &count); p += count;
1733                                 sprintf (buffer, "PEA      %s", ea);
1734                         }
1735                         break;
1736                 case 0x4880:
1737                         if ((lo & 0x38) == 0x00)
1738                                 sprintf (buffer, "EXT.W    D%d", rlo);
1739                         else
1740                         {
1741                                 char *b = buffer;
1742                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 2, &count); p += count;
1743                                 b += sprintf (b, "MOVEM.W  ");
1744                                 if ((lo & 0x38) != 0x20) b = MakeRegList (b, pm);
1745                                 else b = MakeRevRegList (b, pm);
1746                                 sprintf (b, ",%s", ea);
1747                         }
1748                         break;
1749                 case 0x48c0:
1750                         if ((lo & 0x38) == 0x00)
1751                                 sprintf (buffer, "EXT.L    D%d", rlo);
1752                         else
1753                         {
1754                                 char *b = buffer;
1755                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 4, &count); p += count;
1756                                 b += sprintf (b, "MOVEM.L  ");
1757                                 if ((lo & 0x38) != 0x20) b = MakeRegList (b, pm);
1758                                 else b = MakeRevRegList (b, pm);
1759                                 sprintf (b, ",%s", ea);
1760                         }
1761                         break;
1762                 case 0x4a00:
1763                         ea = MakeEA (lo, p, 1, &count); p += count;
1764                         sprintf (buffer, "TST.B    %s", ea);
1765                         break;
1766                 case 0x4a40:
1767                         ea = MakeEA (lo, p, 2, &count); p += count;
1768                         sprintf (buffer, "TST.W    %s", ea);
1769                         break;
1770                 case 0x4a80:
1771                         ea = MakeEA (lo, p, 4, &count); p += count;
1772                         sprintf (buffer, "TST.L    %s", ea);
1773                         break;
1774                 case 0x4ac0:
1775                         ea = MakeEA (lo, p, 1, &count); p += count;
1776                         sprintf (buffer, "TAS.B    %s", ea);
1777                         break;
1778                 case 0x4c80:
1779                         {
1780                                 char *b = buffer;
1781                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 2, &count); p += count;
1782                                 b += sprintf (b, "MOVEM.W  %s,", ea);
1783                                 b = MakeRegList (b, pm);
1784                         }
1785                         break;
1786                 case 0x4cc0:
1787                         {
1788                                 char *b = buffer;
1789                                 PARAM_WORD (pm);        ea = MakeEA (lo, p, 4, &count); p += count;
1790                                 b += sprintf (b, "MOVEM.L  %s,", ea);
1791                                 b = MakeRegList (b, pm);
1792                         }
1793                         break;
1794                 case 0x4e40:
1795                         if ((lo & 30) == 0x00)
1796                                 sprintf (buffer, "TRAP     #$%X", lo & 15);
1797                         else if ((lo & 0x38) == 0x10)
1798                         {
1799                                 PARAM_WORD (pm);
1800                                 sprintf (buffer, "LINK     A%d,#$%lX", rlo, pm);
1801                         }
1802                         else if ((lo & 0x38) == 0x18)
1803                         {
1804                                 sprintf (buffer, "UNLK     A%d", rlo);
1805                         }
1806                         else if ((lo & 0x38) == 0x20)
1807                                 sprintf (buffer, "MOVE     A%d,USP", rlo);
1808                         else if ((lo & 0x38) == 0x28)
1809                                 sprintf (buffer, "MOVE     USP,A%d", rlo);
1810                         else if (lo == 0x30)
1811                                 sprintf (buffer, "RESET");
1812                         else if (lo == 0x31)
1813                                 sprintf (buffer, "NOP");
1814                         else if (lo == 0x32)
1815                                 sprintf (buffer, "STOP");
1816                         else if (lo == 0x33)
1817                                 sprintf (buffer, "RTE");
1818                         else if (lo == 0x35)
1819                                 sprintf (buffer, "RTS");
1820                         else if (lo == 0x36)
1821                                 sprintf (buffer, "TRAPV");
1822                         else if (lo == 0x37)
1823                                 sprintf (buffer, "RTR");
1824                         else if (lo == 0x3a)
1825                         {
1826                                 PARAM_WORD (pm);
1827                                 switch (pm & 0xfff)
1828                                 {
1829                                         case 0x000:     ea = "SFC";     break;
1830                                         case 0x001:     ea = "DFC"; break;
1831                                         case 0x800: ea = "USP"; break;
1832                                         case 0x801: ea = "VBR"; break;
1833                                         default: ea = "???"; break;
1834                                 }
1835                                 if (pm & 0x8000)
1836                                         sprintf (buffer, "MOVEC    %s,A%ld", ea, (pm >> 12) & 7);
1837                                 else
1838                                         sprintf (buffer, "MOVEC    %s,D%ld", ea, (pm >> 12) & 7);
1839                         }
1840                         else if (lo == 0x3b)
1841                         {
1842                                 PARAM_WORD (pm);
1843                                 switch (pm & 0xfff)
1844                                 {
1845                                         case 0x000:     ea = "SFC";     break;
1846                                         case 0x001:     ea = "DFC"; break;
1847                                         case 0x800: ea = "USP"; break;
1848                                         case 0x801: ea = "VBR"; break;
1849                                         default: ea = "???"; break;
1850                                 }
1851                                 if (pm & 0x8000)
1852                                         sprintf (buffer, "MOVEC    A%ld,%s", (pm >> 12) & 7, ea);
1853                                 else
1854                                         sprintf (buffer, "MOVEC    D%ld,%s", (pm >> 12) & 7, ea);
1855                         }
1856                         else
1857                                 sprintf (buffer, "DC.W     $%X", op);
1858                         break;
1859                 case 0x4e80:
1860                         ea = MakeEA (lo, p, 4, &count); p += count;
1861                         sprintf (buffer, "JSR      %s", ea);
1862                         break;
1863                 case 0x4ec0:
1864                         ea = MakeEA (lo, p, 4, &count); p += count;
1865                         sprintf (buffer, "JMP      %s", ea);
1866                         break;
1867                 case 0x5000: case 0x5200: case 0x5400: case 0x5600: case 0x5800: case 0x5a00: case 0x5c00: case 0x5e00:
1868                         ea = MakeEA (lo, p, 1, &count); p += count;
1869                         sprintf (buffer, "ADDQ.B   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1870                         break;
1871                 case 0x5040: case 0x5240: case 0x5440: case 0x5640: case 0x5840: case 0x5a40: case 0x5c40: case 0x5e40:
1872                         ea = MakeEA (lo, p, 2, &count); p += count;
1873                         sprintf (buffer, "ADDQ.W   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1874                         break;
1875                 case 0x5080: case 0x5280: case 0x5480: case 0x5680: case 0x5880: case 0x5a80: case 0x5c80: case 0x5e80:
1876                         ea = MakeEA (lo, p, 4, &count); p += count;
1877                         sprintf (buffer, "ADDQ.L   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1878                         break;
1879                 case 0x50c0: case 0x52c0: case 0x54c0: case 0x56c0: case 0x58c0: case 0x5ac0: case 0x5cc0: case 0x5ec0:
1880                 case 0x51c0: case 0x53c0: case 0x55c0: case 0x57c0: case 0x59c0: case 0x5bc0: case 0x5dc0: case 0x5fc0:
1881                         if ((lo & 0x38) == 0x08)
1882                         {
1883                                 PARAM_WORD (pm);
1884                                 if (pm & 0x8000)
1885                                         sprintf (buffer, "DB%s     D%d,*-$%X [%X]", ccodes[(op >> 8) & 15], rlo, (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
1886                                 else
1887                                         sprintf (buffer, "DB%s     D%d,*+$%lX [%lX]", ccodes[(op >> 8) & 15], rlo, pm - 2, pc + pm + 2);
1888                         }
1889                         else
1890                         {
1891                                 ea = MakeEA (lo, p, 1, &count); p += count;
1892                                 sprintf (buffer, "S%s.B    %s", ccodes[(op >> 8) & 15], ea);
1893                         }
1894                         break;
1895                 case 0x5100: case 0x5300: case 0x5500: case 0x5700: case 0x5900: case 0x5b00: case 0x5d00: case 0x5f00:
1896                         ea = MakeEA (lo, p, 1, &count); p += count;
1897                         sprintf (buffer, "SUBQ.B   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1898                         break;
1899                 case 0x5140: case 0x5340: case 0x5540: case 0x5740: case 0x5940: case 0x5b40: case 0x5d40: case 0x5f40:
1900                         ea = MakeEA (lo, p, 2, &count); p += count;
1901                         sprintf (buffer, "SUBQ.W   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1902                         break;
1903                 case 0x5180: case 0x5380: case 0x5580: case 0x5780: case 0x5980: case 0x5b80: case 0x5d80: case 0x5f80:
1904                         ea = MakeEA (lo, p, 4, &count); p += count;
1905                         sprintf (buffer, "SUBQ.L   #%d,%s", (rhi == 0) ? 8 : rhi, ea);
1906                         break;
1907                 case 0x6000: case 0x6040: case 0x6080: case 0x60c0:
1908                         pm = op & 0xff;
1909                         if (pm == 0)
1910                         {
1911                                 PARAM_WORD(pm);
1912                                 if (pm & 0x8000)
1913                                         sprintf (buffer, "BRA      *-$%X [%X]", (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
1914                                 else
1915                                         sprintf (buffer, "BRA      *+$%lX [%lX]", pm + 2, pc + pm + 2);
1916                         }
1917                         else
1918                         {
1919                                 if (pm & 0x80)
1920                                         sprintf (buffer, "BRA.S    *-$%X [%X]", (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
1921                                 else
1922                                         sprintf (buffer, "BRA.S    *+$%lX [%lX]", pm + 2, pc + pm + 2);
1923                         }
1924                         break;
1925                 case 0x6100: case 0x6140: case 0x6180: case 0x61c0:
1926                         pm = op & 0xff;
1927                         if (pm == 0)
1928                         {
1929                                 PARAM_WORD(pm);
1930                                 if (pm & 0x8000)
1931                                         sprintf (buffer, "BSR      *-$%X [%X]", (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
1932                                 else
1933                                         sprintf (buffer, "BSR      *+$%lX [%lX]", pm + 2, pc + pm + 2);
1934                         }
1935                         else
1936                         {
1937                                 if (pm & 0x80)
1938                                         sprintf (buffer, "BSR.S    *-$%X [%X]", (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
1939                                 else
1940                                         sprintf (buffer, "BSR.S    *+$%lX [%lX]", pm + 2, pc + pm + 2);
1941                         }
1942                         break;
1943                 case 0x6200: case 0x6240: case 0x6280: case 0x62c0: case 0x6300: case 0x6340: case 0x6380: case 0x63c0:
1944                 case 0x6400: case 0x6440: case 0x6480: case 0x64c0: case 0x6500: case 0x6540: case 0x6580: case 0x65c0:
1945                 case 0x6600: case 0x6640: case 0x6680: case 0x66c0: case 0x6700: case 0x6740: case 0x6780: case 0x67c0:
1946                 case 0x6800: case 0x6840: case 0x6880: case 0x68c0: case 0x6900: case 0x6940: case 0x6980: case 0x69c0:
1947                 case 0x6a00: case 0x6a40: case 0x6a80: case 0x6ac0: case 0x6b00: case 0x6b40: case 0x6b80: case 0x6bc0:
1948                 case 0x6c00: case 0x6c40: case 0x6c80: case 0x6cc0: case 0x6d00: case 0x6d40: case 0x6d80: case 0x6dc0:
1949                 case 0x6e00: case 0x6e40: case 0x6e80: case 0x6ec0: case 0x6f00: case 0x6f40: case 0x6f80: case 0x6fc0:
1950                         pm = op & 0xff;
1951                         if (pm == 0)
1952                         {
1953                                 PARAM_WORD(pm);
1954                                 if (pm & 0x8000)
1955                                         sprintf (buffer, "B%s      *-$%X [%X]", ccodes[(op >> 8) & 15], (int)(-(signed short)pm) - 2, pc + (signed short)pm + 2);
1956                                 else
1957                                         sprintf (buffer, "B%s      *+$%lX [%lX]", ccodes[(op >> 8) & 15], pm + 2, pc + pm + 2);
1958                         }
1959                         else
1960                         {
1961                                 if (pm & 0x80)
1962                                         sprintf (buffer, "B%s.S    *-$%X [%X]", ccodes[(op >> 8) & 15], (int)(-(signed char)pm) - 2, pc + (signed char)pm + 2);
1963                                 else
1964                                         sprintf (buffer, "B%s.S    *+$%lX [%lX]", ccodes[(op >> 8) & 15], pm + 2, pc + pm + 2);
1965                         }
1966                         break;
1967                 case 0x7000: case 0x7040: case 0x7080: case 0x70c0:
1968                 case 0x7200: case 0x7240: case 0x7280: case 0x72c0:
1969                 case 0x7400: case 0x7440: case 0x7480: case 0x74c0:
1970                 case 0x7600: case 0x7640: case 0x7680: case 0x76c0:
1971                 case 0x7800: case 0x7840: case 0x7880: case 0x78c0:
1972                 case 0x7a00: case 0x7a40: case 0x7a80: case 0x7ac0:
1973                 case 0x7c00: case 0x7c40: case 0x7c80: case 0x7cc0:
1974                 case 0x7e00: case 0x7e40: case 0x7e80: case 0x7ec0:
1975                         pm = op & 0xff;
1976                         if (pm & 0x80)
1977                                 sprintf (buffer, "MOVEQ    #$-%X,D%d", -(signed char)pm, rhi);
1978                         else
1979                                 sprintf (buffer, "MOVEQ    #$%lX,D%d", pm, rhi);
1980                         break;
1981                 case 0x8000: case 0x8200: case 0x8400: case 0x8600: case 0x8800: case 0x8a00: case 0x8c00: case 0x8e00:
1982                         ea = MakeEA (lo, p, 1, &count); p += count;
1983                         sprintf (buffer, "OR.B     %s,D%d", ea, rhi);
1984                         break;
1985                 case 0x8040: case 0x8240: case 0x8440: case 0x8640: case 0x8840: case 0x8a40: case 0x8c40: case 0x8e40:
1986                         ea = MakeEA (lo, p, 2, &count); p += count;
1987                         sprintf (buffer, "OR.W     %s,D%d", ea, rhi);
1988                         break;
1989                 case 0x8080: case 0x8280: case 0x8480: case 0x8680: case 0x8880: case 0x8a80: case 0x8c80: case 0x8e80:
1990                         ea = MakeEA (lo, p, 4, &count); p += count;
1991                         sprintf (buffer, "OR.L     %s,D%d", ea, rhi);
1992                         break;
1993                 case 0x80c0: case 0x82c0: case 0x84c0: case 0x86c0: case 0x88c0: case 0x8ac0: case 0x8cc0: case 0x8ec0:
1994                         ea = MakeEA (lo, p, 2, &count); p += count;
1995                         sprintf (buffer, "DIVU.W   %s,D%d", ea, rhi);
1996                         break;
1997                 case 0x8100: case 0x8300: case 0x8500: case 0x8700: case 0x8900: case 0x8b00: case 0x8d00: case 0x8f00:
1998                         ea = MakeEA (lo, p, 1, &count); p += count;
1999                         sprintf (buffer, "OR.B     D%d,%s", rhi, ea);
2000                         break;
2001                 case 0x8140: case 0x8340: case 0x8540: case 0x8740: case 0x8940: case 0x8b40: case 0x8d40: case 0x8f40:
2002                         ea = MakeEA (lo, p, 2, &count); p += count;
2003                         sprintf (buffer, "OR.W     D%d,%s", rhi, ea);
2004                         break;
2005                 case 0x8180: case 0x8380: case 0x8580: case 0x8780: case 0x8980: case 0x8b80: case 0x8d80: case 0x8f80:
2006                         ea = MakeEA (lo, p, 4, &count); p += count;
2007                         sprintf (buffer, "OR.L     D%d,%s", rhi, ea);
2008                         break;
2009                 case 0x81c0: case 0x83c0: case 0x85c0: case 0x87c0: case 0x89c0: case 0x8bc0: case 0x8dc0: case 0x8fc0:
2010                         ea = MakeEA (lo, p, 2, &count); p += count;
2011                         sprintf (buffer, "DIVS.W   %s,D%d", ea, rhi);
2012                         break;
2013                 case 0x9000: case 0x9200: case 0x9400: case 0x9600: case 0x9800: case 0x9a00: case 0x9c00: case 0x9e00:
2014                         ea = MakeEA (lo, p, 1, &count); p += count;
2015                         sprintf (buffer, "SUB.B    %s,D%d", ea, rhi);
2016                         break;
2017                 case 0x9040: case 0x9240: case 0x9440: case 0x9640: case 0x9840: case 0x9a40: case 0x9c40: case 0x9e40:
2018                         ea = MakeEA (lo, p, 2, &count); p += count;
2019                         sprintf (buffer, "SUB.W    %s,D%d", ea, rhi);
2020                         break;
2021                 case 0x9080: case 0x9280: case 0x9480: case 0x9680: case 0x9880: case 0x9a80: case 0x9c80: case 0x9e80:
2022                         ea = MakeEA (lo, p, 4, &count); p += count;
2023                         sprintf (buffer, "SUB.L    %s,D%d", ea, rhi);
2024                         break;
2025                 case 0x90c0: case 0x92c0: case 0x94c0: case 0x96c0: case 0x98c0: case 0x9ac0: case 0x9cc0: case 0x9ec0:
2026                         ea = MakeEA (lo, p, 2, &count); p += count;
2027                         sprintf (buffer, "SUBA.W   %s,A%d", ea, rhi);
2028                         break;
2029                 case 0x9100: case 0x9300: case 0x9500: case 0x9700: case 0x9900: case 0x9b00: case 0x9d00: case 0x9f00:
2030                         if ((lo & 0x30) == 0)
2031                         {
2032                                 if (lo & 0x08)
2033                                         sprintf (buffer, "SUBX.B   -(A%d),-(A%d)", rlo, rhi);
2034                                 else
2035                                         sprintf (buffer, "SUBX.B   D%d,D%d", rlo, rhi);
2036                         }
2037                         else
2038                         {
2039                                 ea = MakeEA (lo, p, 1,&count); p += count;
2040                                 sprintf (buffer, "SUB.B    D%d,%s", rhi, ea);
2041                         }
2042                         break;
2043                 case 0x9140: case 0x9340: case 0x9540: case 0x9740: case 0x9940: case 0x9b40: case 0x9d40: case 0x9f40:
2044                         if ((lo & 0x30) == 0)
2045                         {
2046                                 if (lo & 0x08)
2047                                         sprintf (buffer, "SUBX.W   -(A%d),-(A%d)", rlo, rhi);
2048                                 else
2049                                         sprintf (buffer, "SUBX.W   D%d,D%d", rlo, rhi);
2050                         }
2051                         else
2052                         {
2053                                 ea = MakeEA (lo, p, 2, &count); p += count;
2054                                 sprintf (buffer, "SUB.W    D%d,%s", rhi, ea);
2055                         }
2056                         break;
2057                 case 0x9180: case 0x9380: case 0x9580: case 0x9780: case 0x9980: case 0x9b80: case 0x9d80: case 0x9f80:
2058                         if ((lo & 0x30) == 0)
2059                         {
2060                                 if (lo & 0x08)
2061                                         sprintf (buffer, "SUBX.L   -(A%d),-(A%d)", rlo, rhi);
2062                                 else
2063                                         sprintf (buffer, "SUBX.L   D%d,D%d", rlo, rhi);
2064                         }
2065                         else
2066                         {
2067                                 ea = MakeEA (lo, p, 4, &count); p += count;
2068                                 sprintf (buffer, "SUB.L    D%d,%s", rhi, ea);
2069                         }
2070                         break;
2071                 case 0x91c0: case 0x93c0: case 0x95c0: case 0x97c0: case 0x99c0: case 0x9bc0: case 0x9dc0: case 0x9fc0:
2072                         ea = MakeEA (lo, p, 4, &count); p += count;
2073                         sprintf (buffer, "SUBA.L   %s,A%d", ea, rhi);
2074                         break;
2075                 case 0xb000: case 0xb200: case 0xb400: case 0xb600: case 0xb800: case 0xba00: case 0xbc00: case 0xbe00:
2076                         ea = MakeEA (lo, p, 1, &count); p += count;
2077                         sprintf (buffer, "CMP.B    %s,D%d", ea, rhi);
2078                         break;
2079                 case 0xb040: case 0xb240: case 0xb440: case 0xb640: case 0xb840: case 0xba40: case 0xbc40: case 0xbe40:
2080                         ea = MakeEA (lo, p, 2, &count); p += count;
2081                         sprintf (buffer, "CMP.W    %s,D%d", ea, rhi);
2082                         break;
2083                 case 0xb080: case 0xb280: case 0xb480: case 0xb680: case 0xb880: case 0xba80: case 0xbc80: case 0xbe80:
2084                         ea = MakeEA (lo, p, 4, &count); p += count;
2085                         sprintf (buffer, "CMP.L    %s,D%d", ea, rhi);
2086                         break;
2087                 case 0xb0c0: case 0xb2c0: case 0xb4c0: case 0xb6c0: case 0xb8c0: case 0xbac0: case 0xbcc0: case 0xbec0:
2088                         ea = MakeEA (lo, p, 2, &count); p += count;
2089                         sprintf (buffer, "CMPA.W   %s,A%d", ea, rhi);
2090                         break;
2091                 case 0xb100: case 0xb300: case 0xb500: case 0xb700: case 0xb900: case 0xbb00: case 0xbd00: case 0xbf00:
2092                         if ((lo & 0x38) == 0x08)
2093                                 sprintf (buffer, "CMPM.B   (A%d)+,(A%d)+", rlo, rhi);
2094                         else
2095                         {
2096                                 ea = MakeEA (lo, p, 1, &count); p += count;
2097                                 sprintf (buffer, "EOR.B    D%d,%s", rhi, ea);
2098                         }
2099                         break;
2100                 case 0xb140: case 0xb340: case 0xb540: case 0xb740: case 0xb940: case 0xbb40: case 0xbd40: case 0xbf40:
2101                         if ((lo & 0x38) == 0x08)
2102                                 sprintf (buffer, "CMPM.W   (A%d)+,(A%d)+", rlo, rhi);
2103                         else
2104                         {
2105                                 ea = MakeEA (lo, p, 2, &count); p += count;
2106                                 sprintf (buffer, "EOR.W    D%d,%s", rhi, ea);
2107                         }
2108                         break;
2109                 case 0xb180: case 0xb380: case 0xb580: case 0xb780: case 0xb980: case 0xbb80: case 0xbd80: case 0xbf80:
2110                         if ((lo & 0x38) == 0x08)
2111                                 sprintf (buffer, "CMPM.L   (A%d)+,(A%d)+", rlo, rhi);
2112                         else
2113                         {
2114                                 ea = MakeEA (lo, p, 4, &count); p += count;
2115                                 sprintf (buffer, "EOR.L    D%d,%s", rhi, ea);
2116                         }
2117                         break;
2118                 case 0xb1c0: case 0xb3c0: case 0xb5c0: case 0xb7c0: case 0xb9c0: case 0xbbc0: case 0xbdc0: case 0xbfc0:
2119                         ea = MakeEA (lo, p, 4, &count); p += count;
2120                         sprintf (buffer, "CMPA.L   %s,A%d", ea, rhi);
2121                         break;
2122                 case 0xc000: case 0xc200: case 0xc400: case 0xc600: case 0xc800: case 0xca00: case 0xcc00: case 0xce00:
2123                         ea = MakeEA (lo, p, 1, &count); p += count;
2124                         sprintf (buffer, "AND.B    %s,D%d", ea, rhi);
2125                         break;
2126                 case 0xc040: case 0xc240: case 0xc440: case 0xc640: case 0xc840: case 0xca40: case 0xcc40: case 0xce40:
2127                         ea = MakeEA (lo, p, 2, &count); p += count;
2128                         sprintf (buffer, "AND.W    %s,D%d", ea, rhi);
2129                         break;
2130                 case 0xc080: case 0xc280: case 0xc480: case 0xc680: case 0xc880: case 0xca80: case 0xcc80: case 0xce80:
2131                         ea = MakeEA (lo, p, 4, &count); p += count;
2132                         sprintf (buffer, "AND.L    %s,D%d", ea, rhi);
2133                         break;
2134                 case 0xc0c0: case 0xc2c0: case 0xc4c0: case 0xc6c0: case 0xc8c0: case 0xcac0: case 0xccc0: case 0xcec0:
2135                         ea = MakeEA (lo, p, 2, &count); p += count;
2136                         sprintf (buffer, "MULU.W   %s,D%d", ea, rhi);
2137                         break;
2138                 case 0xc100: case 0xc300: case 0xc500: case 0xc700: case 0xc900: case 0xcb00: case 0xcd00: case 0xcf00:
2139                         if ((lo & 0x30) == 0)
2140                         {
2141                                 if (lo & 0x08)
2142                                         sprintf (buffer, "ABCD.B   -(A%d),-(A%d)", rlo, rhi);
2143                                 else
2144                                         sprintf (buffer, "ABCD.B   D%d,D%d", rlo, rhi);
2145                         }
2146                         else
2147                         {
2148                                 ea = MakeEA (lo, p, 1, &count); p += count;
2149                                 sprintf (buffer, "AND.B    D%d,%s", rhi, ea);
2150                         }
2151                         break;
2152                 case 0xc140: case 0xc340: case 0xc540: case 0xc740: case 0xc940: case 0xcb40: case 0xcd40: case 0xcf40:
2153                         if ((lo & 0x30) == 0)
2154                         {
2155                                 if (lo & 0x08)
2156                                         sprintf (buffer, "EXG      A%d,A%d", rhi, rlo);
2157                                 else
2158                                         sprintf (buffer, "EXG      D%d,D%d", rhi, rlo);
2159                         }
2160                         else
2161                         {
2162                                 ea = MakeEA (lo, p, 2,&count); p += count;
2163                                 sprintf (buffer, "AND.W    D%d,%s", rhi, ea);
2164                         }
2165                         break;
2166                 case 0xc180: case 0xc380: case 0xc580: case 0xc780: case 0xc980: case 0xcb80: case 0xcd80: case 0xcf80:
2167                         if ((lo & 0x38) == 0x08)
2168                                 sprintf (buffer, "EXG      D%d,A%d", rhi, rlo);
2169                         else
2170                         {
2171                                 ea = MakeEA (lo, p, 4, &count); p += count;
2172                                 sprintf (buffer, "AND.L    D%d,%s", rhi, ea);
2173                         }
2174                         break;
2175                 case 0xc1c0: case 0xc3c0: case 0xc5c0: case 0xc7c0: case 0xc9c0: case 0xcbc0: case 0xcdc0: case 0xcfc0:
2176                         ea = MakeEA (lo, p, 2, &count); p += count;
2177                         sprintf (buffer, "MULS.W   %s,D%d", ea, rhi);
2178                         break;
2179                 case 0xd000: case 0xd200: case 0xd400: case 0xd600: case 0xd800: case 0xda00: case 0xdc00: case 0xde00:
2180                         ea = MakeEA (lo, p, 1, &count); p += count;
2181                         sprintf (buffer, "ADD.B    %s,D%d", ea, rhi);
2182                         break;
2183                 case 0xd040: case 0xd240: case 0xd440: case 0xd640: case 0xd840: case 0xda40: case 0xdc40: case 0xde40:
2184                         ea = MakeEA (lo, p, 2, &count); p += count;
2185                         sprintf (buffer, "ADD.W    %s,D%d", ea, rhi);
2186                         break;
2187                 case 0xd080: case 0xd280: case 0xd480: case 0xd680: case 0xd880: case 0xda80: case 0xdc80: case 0xde80:
2188                         ea = MakeEA (lo, p, 4, &count); p += count;
2189                         sprintf (buffer, "ADD.L    %s,D%d", ea, rhi);
2190                         break;
2191                 case 0xd0c0: case 0xd2c0: case 0xd4c0: case 0xd6c0: case 0xd8c0: case 0xdac0: case 0xdcc0: case 0xdec0:
2192                         ea = MakeEA (lo, p, 2, &count); p += count;
2193                         sprintf (buffer, "ADDA.W   %s,A%d", ea, rhi);
2194                         break;
2195                 case 0xd100: case 0xd300: case 0xd500: case 0xd700: case 0xd900: case 0xdb00: case 0xdd00: case 0xdf00:
2196                         if ((lo & 0x30) == 0)
2197                         {
2198                                 if (lo & 0x08)
2199                                         sprintf (buffer, "ADDX.B   -(A%d),-(A%d)", rlo, rhi);
2200                                 else
2201                                         sprintf (buffer, "ADDX.B   D%d,D%d", rlo, rhi);
2202                         }
2203                         else
2204                         {
2205                                 ea = MakeEA (lo, p, 1, &count); p += count;
2206                                 sprintf (buffer, "ADD.B    D%d,%s", rhi, ea);
2207                         }
2208                         break;
2209                 case 0xd140: case 0xd340: case 0xd540: case 0xd740: case 0xd940: case 0xdb40: case 0xdd40: case 0xdf40:
2210                         if ((lo & 0x30) == 0)
2211                         {
2212                                 if (lo & 0x08)
2213                                         sprintf (buffer, "ADDX.W   -(A%d),-(A%d)", rlo, rhi);
2214                                 else
2215                                         sprintf (buffer, "ADDX.W   D%d,D%d", rlo, rhi);
2216                         }
2217                         else
2218                         {
2219                                 ea = MakeEA (lo, p, 2, &count); p += count;
2220                                 sprintf (buffer, "ADD.W    D%d,%s", rhi, ea);
2221                         }
2222                         break;
2223                 case 0xd180: case 0xd380: case 0xd580: case 0xd780: case 0xd980: case 0xdb80: case 0xdd80: case 0xdf80:
2224                         if ((lo & 0x30) == 0)
2225                         {
2226                                 if (lo & 0x08)
2227                                         sprintf (buffer, "ADDX.L   -(A%d),-(A%d)", rlo, rhi);
2228                                 else
2229                                         sprintf (buffer, "ADDX.L   D%d,D%d", rlo, rhi);
2230                         }
2231                         else
2232                         {
2233                                 ea = MakeEA (lo, p, 4,&count); p += count;
2234                                 sprintf (buffer, "ADD.L    D%d,%s", rhi, ea);
2235                         }
2236                         break;
2237                 case 0xd1c0: case 0xd3c0: case 0xd5c0: case 0xd7c0: case 0xd9c0: case 0xdbc0: case 0xddc0: case 0xdfc0:
2238                         ea = MakeEA (lo, p, 4, &count); p += count;
2239                         sprintf (buffer, "ADDA.L   %s,A%d", ea, rhi);
2240                         break;
2241                 case 0xe000: case 0xe200: case 0xe400: case 0xe600: case 0xe800: case 0xea00: case 0xec00: case 0xee00:
2242                         switch ((lo >> 3) & 7)
2243                         {
2244                                 case 0: sprintf (buffer, "ASR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2245                                 case 1: sprintf (buffer, "LSR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2246                                 case 2: sprintf (buffer, "ROXR.B   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2247                                 case 3: sprintf (buffer, "ROR.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2248                                 case 4: sprintf (buffer, "ASR.B    D%d,D%d", rhi, rlo);         break;
2249                                 case 5: sprintf (buffer, "LSR.B    D%d,D%d", rhi, rlo);         break;
2250                                 case 6: sprintf (buffer, "ROXR.B   D%d,D%d", rhi, rlo);         break;
2251                                 case 7: sprintf (buffer, "ROR.B    D%d,D%d", rhi, rlo);         break;
2252                         }
2253                         break;
2254                 case 0xe040: case 0xe240: case 0xe440: case 0xe640: case 0xe840: case 0xea40: case 0xec40: case 0xee40:
2255                         switch ((lo >> 3) & 7)
2256                         {
2257                                 case 0: sprintf (buffer, "ASR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2258                                 case 1: sprintf (buffer, "LSR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2259                                 case 2: sprintf (buffer, "ROXR.W   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2260                                 case 3: sprintf (buffer, "ROR.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2261                                 case 4: sprintf (buffer, "ASR.W    D%d,D%d", rhi, rlo);         break;
2262                                 case 5: sprintf (buffer, "LSR.W    D%d,D%d", rhi, rlo);         break;
2263                                 case 6: sprintf (buffer, "ROXR.W   D%d,D%d", rhi, rlo);         break;
2264                                 case 7: sprintf (buffer, "ROR.W    D%d,D%d", rhi, rlo);         break;
2265                         }
2266                         break;
2267                 case 0xe080: case 0xe280: case 0xe480: case 0xe680: case 0xe880: case 0xea80: case 0xec80: case 0xee80:
2268                         switch ((lo >> 3) & 7)
2269                         {
2270                                 case 0: sprintf (buffer, "ASR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2271                                 case 1: sprintf (buffer, "LSR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2272                                 case 2: sprintf (buffer, "ROXR.L   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2273                                 case 3: sprintf (buffer, "ROR.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2274                                 case 4: sprintf (buffer, "ASR.L    D%d,D%d", rhi, rlo);         break;
2275                                 case 5: sprintf (buffer, "LSR.L    D%d,D%d", rhi, rlo);         break;
2276                                 case 6: sprintf (buffer, "ROXR.L   D%d,D%d", rhi, rlo);         break;
2277                                 case 7: sprintf (buffer, "ROR.L    D%d,D%d", rhi, rlo);         break;
2278                         }
2279                         break;
2280                 case 0xe0c0: case 0xe2c0: case 0xe4c0: case 0xe6c0:
2281                 case 0xe1c0: case 0xe3c0: case 0xe5c0: case 0xe7c0:
2282                         ea = MakeEA (lo, p, 4, &count); p += count;
2283                         switch ((op >> 8) & 7)
2284                         {
2285                                 case 0: sprintf (buffer, "ASR.L    #1,%s", ea);         break;
2286                                 case 1: sprintf (buffer, "ASL.L    #1,%s", ea);         break;
2287                                 case 2: sprintf (buffer, "LSR.L    #1,%s", ea);         break;
2288                                 case 3: sprintf (buffer, "LSL.L    #1,%s", ea);         break;
2289                                 case 4: sprintf (buffer, "ROXR.L   #1,%s", ea);         break;
2290                                 case 5: sprintf (buffer, "ROXL.L   #1,%s", ea);         break;
2291                                 case 6: sprintf (buffer, "ROR.L    #1,%s", ea);         break;
2292                                 case 7: sprintf (buffer, "ROL.L    #1,%s", ea);         break;
2293                         }
2294                         break;
2295                 case 0xe100: case 0xe300: case 0xe500: case 0xe700: case 0xe900: case 0xeb00: case 0xed00: case 0xef00:
2296                         switch ((lo >> 3) & 7)
2297                         {
2298                                 case 0: sprintf (buffer, "ASL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2299                                 case 1: sprintf (buffer, "LSL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2300                                 case 2: sprintf (buffer, "ROXL.B   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2301                                 case 3: sprintf (buffer, "ROL.B    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2302                                 case 4: sprintf (buffer, "ASL.B    D%d,D%d", rhi, rlo);         break;
2303                                 case 5: sprintf (buffer, "LSL.B    D%d,D%d", rhi, rlo);         break;
2304                                 case 6: sprintf (buffer, "ROXL.B   D%d,D%d", rhi, rlo);         break;
2305                                 case 7: sprintf (buffer, "ROL.B    D%d,D%d", rhi, rlo);         break;
2306                         }
2307                         break;
2308                 case 0xe140: case 0xe340: case 0xe540: case 0xe740: case 0xe940: case 0xeb40: case 0xed40: case 0xef40:
2309                         switch ((lo >> 3) & 7)
2310                         {
2311                                 case 0: sprintf (buffer, "ASL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2312                                 case 1: sprintf (buffer, "LSL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2313                                 case 2: sprintf (buffer, "ROXL.W   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2314                                 case 3: sprintf (buffer, "ROL.W    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2315                                 case 4: sprintf (buffer, "ASL.W    D%d,D%d", rhi, rlo);         break;
2316                                 case 5: sprintf (buffer, "LSL.W    D%d,D%d", rhi, rlo);         break;
2317                                 case 6: sprintf (buffer, "ROXL.W   D%d,D%d", rhi, rlo);         break;
2318                                 case 7: sprintf (buffer, "ROL.W    D%d,D%d", rhi, rlo);         break;
2319                         }
2320                         break;
2321                 case 0xe180: case 0xe380: case 0xe580: case 0xe780: case 0xe980: case 0xeb80: case 0xed80: case 0xef80:
2322                         switch ((lo >> 3) & 7)
2323                         {
2324                                 case 0: sprintf (buffer, "ASL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2325                                 case 1: sprintf (buffer, "LSL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2326                                 case 2: sprintf (buffer, "ROXL.L   #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2327                                 case 3: sprintf (buffer, "ROL.L    #%d,D%d", (rhi == 0) ? 8 : rhi, rlo);                break;
2328                                 case 4: sprintf (buffer, "ASL.L    D%d,D%d", rhi, rlo);         break;
2329                                 case 5: sprintf (buffer, "LSL.L    D%d,D%d", rhi, rlo);         break;
2330                                 case 6: sprintf (buffer, "ROXL.L   D%d,D%d", rhi, rlo);         break;
2331                                 case 7: sprintf (buffer, "ROL.L    D%d,D%d", rhi, rlo);         break;
2332                         }
2333                         break;
2334                 default:
2335                         sprintf (buffer, "DC.W     $%X", op);
2336                         break;
2337         }
2338
2339         return p - pBase;
2340 }
2341
2342
2343
2344 #endif