home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / nasm20b / nasm_src / disasm.c < prev    next >
C/C++ Source or Header  |  1993-01-19  |  26KB  |  956 lines
  1. /* ---------------------------------------------------------------------- */
  2. /*                   Copyright (C) 1992 by Natürlich!                     */
  3. /*                      This file is copyrighted!                         */
  4. /*                Refer to the documentation for details.                 */
  5. /* ---------------------------------------------------------------------- */
  6. /* rev. history   1.0 -- original buggy version               */
  7. /*                1.1 -- fixed bcc/bpl bug                    */
  8. /*                1.2 -- fixed dget_j, added ASCII support    */
  9. /*                1.3 -- fixed tables (at LEAST 6 Errors)     */
  10. /*                1.4 -- X drivers, .O65, FF FF done rite,    */
  11. /*                       Boot files                           */
  12. /*                1.5 -- print inverted chars optionally      */
  13. /*                1.6 -- even more boot file support          */
  14. /*                1.7 -- AppleII and C64 support              */
  15. /*                1.8 -- no real changes, actually            */
  16. /* ---------------------------------------------------------- */
  17. #include "defines.h"
  18. #include <stdio.h>
  19. #include <string.h>
  20. #include <stdlib.h>
  21. #include <ctype.h>
  22. #define __BIG_GENERATOR__
  23. #include OSBIND
  24. #include "code.h"
  25. #include "seg.h"
  26. #include "object.h"
  27.  
  28. #define ATARI  0
  29. #define PLAIN  1
  30. #define C64    2
  31. #define APPLE  3
  32. #define SPARTA 4
  33. #define MODULE 5
  34. #define BOOT   6
  35.  
  36.  
  37. #define CHMIN  ' '
  38. #define CHMAX  '~'
  39.  
  40. #ifdef isprint
  41. # undef isprint
  42. #endif
  43.  
  44. #define toprint( c)  ((c) & (0x7F | inverted))
  45. #define isprint( c)  ( toprint( c) >= CHMIN && toprint( c) <= CHMAX)
  46. #define chprint( c)  ( isprint( c) ? (char) toprint( c) : '.')
  47.  
  48. word           disasm(), seg_disasm();
  49. extern char    trc_loss[];
  50. int            maxerrors = 100;
  51.  
  52. struct
  53. {
  54.    byte  flag,
  55.          secs;
  56.    word  start,
  57.          init;
  58. } boot_header;
  59.  
  60. struct
  61. {
  62.    word  ffff,
  63.          start,
  64.          end;
  65. } ffff_header;
  66.  
  67. struct
  68. {
  69.    byte  byte1,
  70.          byte2;
  71.    word  start,
  72.          len;
  73. } feff_header;
  74.  
  75. struct
  76. {
  77.    byte  byte1,
  78.          len_lsb,
  79.          len_msb;
  80. } fdff_header;
  81.  
  82. struct
  83. {
  84.    byte  mode, lsb, msb;
  85.    char  id[ 8];
  86. } fcff_header;
  87.  
  88. struct
  89. {
  90.    char  id[8];
  91.    word  w1;
  92. } fbff_header;
  93.  
  94. struct
  95. {
  96.    word  start,
  97.          end;
  98. } faff_header;
  99.  
  100. struct
  101. {
  102.    word  start,
  103.          end;
  104. } apple_header;
  105.  
  106. struct
  107. {
  108.    word  start,
  109.          end;
  110. } c64_header;
  111.  
  112.  
  113. word   __x;
  114. lword  __lx;
  115.  
  116. void fixheader()
  117. {
  118.    ffff_header.start = dpeek( &ffff_header.start);
  119.    ffff_header.end   = dpeek( &ffff_header.end);
  120. }
  121.  
  122. #if OS == TOS
  123.    int     tossable;
  124. #endif
  125.  
  126.  
  127. char  cminusminus[] = "; ---------------------------------------\n";
  128. FILE  *fq;
  129. int   pcoff,
  130.       showascii = 1,
  131.       showheader,
  132.       pstart,
  133.       inverted,
  134.       filetype;
  135. lword space,
  136.       mspace;
  137. byte  *room;
  138. long  bread;
  139. int   fp;
  140. int   tok_remain;
  141.  
  142. main( argc, argv)
  143. int   argc;
  144. char  **argv;
  145. {
  146.    static char    infile[ 256],
  147.                   outfile[ 256];
  148.    int            i = 0;
  149.  
  150.    fq = stdout;      /* done here for some lame Amiga cc */
  151. #if ! VERSION
  152.    chk_tables();
  153. #endif
  154.    while( ++i < argc)
  155.    {
  156.       if( *argv[i] == '-')
  157.          switch( Xtolower( argv[i][1]))
  158.          {
  159. #if OS == TOS
  160.             case 't' :
  161.                tossable = ! tossable;
  162.                break;
  163. #endif
  164.             case 'f' :
  165.                switch( Xtolower( argv[ i][2]))
  166.                {
  167.                   case 'o' :
  168.                      filetype = MODULE;
  169.                      break;
  170.  
  171.                   case 's' :
  172.                      filetype = SPARTA;
  173.                      break;
  174.  
  175.                   case 'p' :
  176.                      filetype = PLAIN;
  177.                      if( ! sscanf( &argv[ i][ 3], "%X", &pstart) ||
  178.                          ! pstart)
  179.                         nferror("Missing start address");
  180.                      break;
  181.  
  182.                   case 'b' :
  183.                      filetype = BOOT;
  184.                      break;
  185.  
  186.                   case 'a' :
  187.                      filetype = APPLE;
  188.                      break;
  189.  
  190.                   case 'c' :
  191.                      filetype = C64;
  192.                      break;
  193.  
  194.                   case 0   :
  195.                   case 'x' :
  196.                      filetype = ATARI;
  197.                      
  198.                   default  :
  199.                      goto usage;                     
  200.                }
  201.                break;
  202.  
  203.  
  204.             case 'a' :
  205.                showascii = ! showascii;
  206.                break;
  207.  
  208. #ifdef __DATE__
  209.             case ':' :
  210.                fputs( __DATE__, stderr);
  211. # ifdef __TIME__
  212.                fprintf( stderr, " %s", __TIME__);
  213. # endif
  214.                putc( '\n', stderr);
  215.                break;
  216. #endif
  217.             case 'v' :
  218.                fprintf( stderr, "disasm65 v1.8 (c) 1992 by Natuerlich!\
  219.  -- disassembles 6502 binaries\n");
  220.                break;
  221.  
  222.             case 'i' :
  223.                inverted = ~inverted;
  224.                break;
  225.  
  226.             case 'h' :
  227.                showheader = ! showheader;
  228.                break;
  229.  
  230.             case 'p' :
  231.                pcoff = ! pcoff;
  232.                break;
  233.  
  234.          }
  235.       else
  236.          if( ! infile[0])
  237.             strcpy( infile, argv[i]);
  238.          else
  239.             if( ! outfile[0])
  240.                strcpy( outfile, argv[i]);
  241.             else
  242.                goto usage;
  243.    }
  244.    if( ! infile[0])
  245.       goto usage;
  246.  
  247. #if OS == MSDOS
  248.    _fmode = O_BINARY;
  249. #endif
  250.    if( (fp = (int) Fopen( infile, OPEN_R)) < 0)
  251.       nferror("File open failed");
  252.    if( outfile[0] && ! (fq = fopen( outfile, "w")))
  253.       nferror("File creation failed");
  254.  
  255.    switch( filetype)
  256.    {
  257.       case APPLE :
  258.          if( (bread = Fread( fp, 4L, &apple_header)) < 4L)
  259.             nferror( trc_loss);
  260.          seg_disasm( dpeek( &apple_header.start),
  261.                      dpeek( &apple_header.end), 0);
  262.          break;
  263.  
  264.  
  265.       case C64   :
  266.       {
  267.          word pos;
  268.  
  269.          if( (bread = Fread( fp, 2L, &c64_header)) < 2L)
  270.             nferror( trc_loss);
  271.          pos = Fseek( 0L, fp, SEEK_END) - 2;
  272.          Fseek( 2L, fp, SEEK_SET);
  273.          seg_disasm( dpeek( &c64_header), pos, 0);
  274.       }
  275.       break;
  276.  
  277.  
  278.       case PLAIN :
  279.       {
  280.          word pos;
  281.  
  282.          pos = (word) Fseek( 0L, fp, SEEK_END);
  283.          Fseek( 0L, fp, SEEK_SET);
  284.          seg_disasm( pstart, pos, 0);
  285.       }
  286.       break;
  287.  
  288.       case BOOT :
  289.       {
  290.          word  start;
  291.  
  292.          if( (bread = Fread( fp, 6L, &boot_header)) < 6L)
  293.             nferror( trc_loss);
  294.          start = dpeek( &boot_header.start);
  295.          if( showheader)
  296.          {
  297.             fputs( cminusminus, fq);
  298.             fprintf( fq, "; Boot header - Flag $%02X  %d sectors\n\
  299. ; Address : $%04X  Init: $%04X\n",
  300.                         boot_header.flag, (word) boot_header.secs,
  301.                         start, dpeek( &boot_header.init));
  302.             fputs( cminusminus, fq);
  303.          }
  304.          if( ! showascii && pcoff)
  305.             fprintf( fq, "; link with  -x%04X\n\n", dpeek( &boot_header.init));
  306.          seg_disasm( start + 6, boot_header.secs * 0x80 - 6, 0);
  307.       }
  308.       break;
  309.  
  310.  
  311.       case SPARTA :
  312.          if( do_sparta())
  313.             do_atari();
  314.          break;
  315.  
  316.  
  317.       case MODULE :
  318.          do_module();
  319.          break;
  320.  
  321.  
  322.       case ATARI  :
  323.          if( (bread = Fread( fp, 6L, &ffff_header)) < 6L)
  324.             nferror( trc_loss);
  325.          if( ffff_header.ffff  != 0xFFFF)
  326.             nferror("Not a $FF $FF header");
  327.          do_atari();
  328.    }
  329.  
  330. #if OS == TOS
  331.    keypress();
  332. #endif
  333.    return(0);
  334.  
  335. usage:
  336. #if OS == TOS
  337.    fputs( "usage: disasm65 [-{tpiahvf}] infile [outfile]\n", stderr);
  338. #else
  339.    fputs( "usage: disasm65 [-{fahvip}] infile [outfile]\n", stderr);
  340. #endif
  341.    fputs( "\
  342. \t-p\t: turn off the dump\n\
  343. \t-i\t: don't print inverted stuff\n\
  344. \t-a\t: turn off ASCII dump\n\
  345. \t-h\t: show info about the binary headers\n\
  346. \t-v\t: version\n\
  347. \t-f[type]: input file type (default: -fx)\n\
  348. \t   o\t: .O65 module\n\
  349. \t   a\t: Apple II ProDOS binary\n\
  350. \t   c\t: C64 binary\n\
  351. \t   pxxxx: plain 6502 binary (xxxx gives start address)\n\
  352. \t   s\t: SpartaDOS X-Cartridge drivers\n\
  353. \t   x\t: Atari 8bit FF FF binaries\n", stderr);
  354. #if OS == TOS
  355.    fputs( "\t-t\t: wait for keypress before exitin'\n", stderr);
  356.    keypress();
  357. #endif
  358.    return( 1);
  359. }
  360.  
  361.  
  362. do_atari()
  363. {
  364.    lword bread;
  365.  
  366.    for(;;)
  367.    {
  368.       fixheader();
  369.       if( showheader)
  370.       {
  371.          fputs( cminusminus, fq);
  372.          fprintf( fq, "; FFFF header  start : $%04X  end : $%04X\n",
  373.                      ffff_header.start, ffff_header.end);
  374.          fputs( cminusminus, fq);
  375.       }
  376.       fprintf( fq, "\n\t\t   * =  $%04X\n\n",
  377.                   ffff_header.start, ffff_header.ffff);
  378.       seg_disasm( ffff_header.start,
  379.                   (1 + ffff_header.end - ffff_header.start), 0);
  380.       if( (bread = Fread( fp, 4L, ((char huge *) &ffff_header) + 2)) <= 0)
  381.          break;
  382.       if( bread < 4)
  383.          nferror("Garbage at end of segment");
  384.       if( ffff_header.start == 0xFFFF)
  385.       {
  386.          ffff_header.ffff  = ffff_header.start;
  387.          ffff_header.start = ffff_header.end;
  388.          if( (bread = Fread( fp, 2L, (char huge *) &ffff_header + 4)) <= 0 ||
  389.              bread < 2)
  390.             nferror("It's a trashed binary");
  391.       }
  392.    }
  393. }
  394.  
  395.  
  396. do_sparta()
  397. {
  398.    word  head, len, pc, byteit,
  399.          oldpcoff = pcoff,
  400.          oldshowascii = showascii;
  401.  
  402.    for(;;)
  403.    {
  404.       if( (bread = Fread( fp, 2L, &head)) <= 0 || (bread == 1 && head < 256))
  405.          break;
  406.       if( bread != 2)
  407.          nferror("File trunctated or mangled");
  408.       len = dpeek( &head);
  409.  
  410.       switch( len)
  411.       {
  412.          case 0xFFFF :
  413.             ffff_header.ffff = 0xFFFF;
  414.             if( (bread = Fread( fp, 4L, (char huge *) &ffff_header + 2)) != 4L)
  415.                nferror( trc_loss);
  416.             return( 1);
  417.  
  418.          case 0xFFFE :
  419.             if( (bread = Fread( fp, 6L, &feff_header)) != 6L)
  420.                nferror( trc_loss);
  421.             len = dpeek( &feff_header.len);
  422.             pc  = dpeek( &feff_header.start);
  423.             if( showheader)
  424.             {
  425.                fputs( cminusminus, fq);
  426.                fprintf( fq, "; FEFF header  %02X %02X  start : $%04X  len : $%04X\n",
  427.                            feff_header.byte1, feff_header.byte2,
  428.                            pc, len);
  429.                fputs( cminusminus, fq);
  430.             }
  431.             fprintf( fq, "\n\t\t   * =  $%04X\n\n", pc);
  432.             if( feff_header.byte2 > 0x80)
  433.                continue;
  434.             byteit = 0;
  435.             break;
  436.  
  437.          case 0xFFFD :
  438.             if( (bread = Fread( fp, 3L, &fdff_header)) != 3L)
  439.                nferror( trc_loss);
  440.             len = dpeek( &fdff_header.len_lsb);
  441.             if( showheader)
  442.             {
  443.                fputs( cminusminus, fq);
  444.                fprintf( fq, "; FDFF header  $%02X  len : $%04X\n",
  445.                            fdff_header.byte1,
  446.                            len);
  447.                fputs( cminusminus, fq);
  448.             }
  449.             showascii = 0;
  450.             pcoff = byteit = 1;
  451.             break;
  452.  
  453.          case 0xFFFC :
  454.             if( (bread = Fread( fp, 11L, &fcff_header)) != 11L)
  455.                nferror( trc_loss);
  456.             if( showheader)
  457.             {
  458.                fputs( cminusminus, fq);
  459.                fputs( "; FCFF header (Export address @ loadtime)\n", fq);
  460.                fputs( cminusminus, fq);
  461.             }
  462.             fprintf( fq, "\t\t   .byte $%02X\n\t\t   .word $%02X%02X\n\t\t \
  463.   .byte \"%8.8s\"\n",
  464.                         fcff_header.mode,
  465.                         fcff_header.msb, fcff_header.lsb,
  466.                         fcff_header.id);
  467.             continue;
  468.  
  469.          case 0xFFFB :
  470.             if( (bread = Fread( fp, 10L, &fbff_header)) != 10L)
  471.                nferror( trc_loss);
  472.             if( showheader)
  473.             {
  474.                fputs( cminusminus, fq);
  475.                fputs( "; FBFF header (Import address @ loadtime)\n", fq);
  476.                fputs( cminusminus, fq);
  477.             }
  478.             fprintf( fq, "\t\t   .byte \"%8.8s\"\n\t\t   .word $%04X\n",
  479.                         fbff_header.id,
  480.                         len = dpeek( &fbff_header.w1));
  481.             showascii = 0;
  482.             pcoff = byteit = 1;
  483.             break;
  484.  
  485.          case 0xFFFA :
  486.             if( (bread = Fread( fp, 4L, (char huge *) &faff_header)) != 4L)
  487.                nferror( trc_loss);
  488.             pc  = dpeek( &faff_header.start);
  489.             len = dpeek( &faff_header.end);
  490.             if( showheader)
  491.             {
  492.                fputs( cminusminus, fq);
  493.                fprintf( fq, "; FAFF header  start : $%04X  end : $%04X\n",
  494.                            pc, len);
  495.                fputs( cminusminus, fq);
  496.             }
  497.             len = 1 + len - pc;
  498.             fprintf( fq, "\n\t\t   * =  $%04X\n\n", pc);
  499.             byteit = 0;
  500.             break;
  501.  
  502.          default     :
  503.          {
  504.             static char mess[] = "Unknown SpartaDOS header $FFFF";
  505.  
  506.             sprintf( mess + 26, "%04X", len);
  507.             nferror( mess);
  508.          }
  509.       }
  510.  
  511.       pc = seg_disasm( pc, len, byteit);
  512.       showascii = oldshowascii;
  513.       pcoff = oldpcoff;
  514.    }
  515.    return( 0);
  516. }
  517.  
  518.  
  519. static char *txlat[] =
  520. {
  521.    "Reloc. code   ",
  522.    "Static data   ",
  523.    "Reloc. .WORDs ",
  524.    "Reloc. .DBYTEs",
  525.    ".DS allocation"
  526. };
  527.  
  528. do_module()
  529. {
  530.    extern byte huge        *pb;
  531.    extern s_dropped huge   *ps;
  532.    extern lword            bytes, sbytes;
  533.    word                    i;
  534.    word                    pc = DEFORG;
  535.  
  536.    do_load( fp);
  537.    if( showheader)
  538.    {
  539.       s_dropped huge *p = ps;
  540.       word           plus = 0;
  541.  
  542.       fputs( cminusminus, fq);
  543.       fprintf( fq, "; SEGMENTS:\n");
  544.       for( i = (word) sbytes; i; i--, p++)
  545.       {
  546.          fprintf( fq, ";\tType: %s  $%04X-$%04X\n",
  547.                      txlat[ p->type], DEFORG + p->index + plus,
  548.                      DEFORG + p->index + plus + p->size - 1);
  549.          if( p->type == S_DS)
  550.             plus += p->size;
  551.       }
  552.       fputs( cminusminus, fq);
  553.    }
  554.    for( i = (word) sbytes; i; i--, pc += ps->size, ps++)
  555.       if( ps->type != S_DS)
  556.       {
  557.          disasm( pc, pb, (lword) ps->size, 0);
  558.          pb += ps->size;
  559.       }
  560. }
  561.  
  562. word  seg_disasm( pc, len, byteit)
  563. word  pc, len;
  564. int   byteit;
  565. {
  566.    static lword   space,
  567.                   mspace;
  568.    static byte    *room;
  569.  
  570.  
  571.       space = (lword) len;
  572.       if( space > mspace)
  573.       {
  574.          if( mspace)
  575.             free( room);
  576.          if( ! (room = (byte *) malloc( (mspace = space))))
  577.             nferror("out of memory");
  578.       }
  579.       if( Fread( fp, space, room) != space)
  580.          nferror("read failed (file truncated ?)");
  581.  
  582.       return( disasm( pc, room, space, byteit));
  583. }
  584.  
  585. char
  586.    adc[]="adc", xnd[]="and", asl[]="asl", bcc[]="bcc",
  587.    bcs[]="bcs", beq[]="beq", bit[]="bit", bmi[]="bmi",
  588.    bne[]="bne", bpl[]="bpl", bra[]="bra",xbrk[]="brk",
  589.    bvc[]="bvc", bvs[]="bvs", clc[]="clc", cld[]="cld",
  590.    cli[]="cli", clv[]="clv", cmp[]="cmp", cpx[]="cpx",
  591.    cpy[]="cpy", dea[]="dea", dec[]="dec", dex[]="dex",
  592.    dey[]="dey", eor[]="eor", ina[]="ina", inc[]="inc",
  593.    inx[]="inx", iny[]="iny", jmp[]="jmp", jsr[]="jsr",
  594.    lda[]="lda", ldx[]="ldx", ldy[]="ldy", lsr[]="lsr",
  595.    nop[]="nop", ora[]="ora", pha[]="pha", php[]="php",
  596.    phx[]="phx", phy[]="phy", pla[]="pla", plp[]="plp",
  597.    plx[]="plx", ply[]="ply", rol[]="rol", ror[]="ror",
  598.    rti[]="rti", rts[]="rts", sbc[]="sbc", sec[]="sec",
  599.    sed[]="sed", sei[]="sei", sta[]="sta", stx[]="stx",
  600.    sty[]="sty", stz[]="stz", tax[]="tax", tay[]="tay",
  601.    trb[]="trb", tsb[]="tsb", tsx[]="txa", txa[]="txa",
  602.    txs[]="txs", tya[]="tya", o__[]=".byte";
  603.  
  604. char  *ops[] =
  605. {
  606.   xbrk, ora, o__, o__, tsb, ora, asl, o__,
  607.    php, ora, asl, o__, tsb, ora, asl, o__,    /*0*/
  608.  
  609.    bpl, ora, ora, o__, trb, ora, asl, o__,
  610.    clc, ora, ina, o__, trb, ora, asl, o__,    /*1*/
  611.  
  612.    jsr, xnd, o__, o__, bit, xnd, rol, o__,
  613.    plp, xnd, rol, o__, bit, xnd, rol, o__,    /*2*/
  614.  
  615.    bmi, xnd, xnd, o__, bit, xnd, rol, o__,
  616.    sec, xnd, dea, o__, bit, xnd, rol, o__,    /*3*/
  617.  
  618.    rti, eor, o__, o__, o__, eor, lsr, o__,
  619.    pha, eor, lsr, o__, jmp, eor, lsr, o__,    /*4*/
  620.  
  621.    bvc, eor, eor, o__, o__, eor, lsr, o__,
  622.    cli, eor, phy, o__, o__, eor, lsr, o__,    /*5*/
  623.  
  624.    rts, adc, o__, o__, stz, adc, ror, o__,
  625.    pla, adc, ror, o__, jmp, adc, ror, o__,    /*6*/
  626.  
  627.    bvs, adc, adc, o__, stz, adc, ror, o__,
  628.    sei, adc, ply, o__, jmp, adc, ror, o__,    /*7*/
  629.  
  630.    bra, sta, o__, o__, sty, sta, stx, o__,
  631.    dey, o__, txa, o__, sty, sta, stx, o__,    /*8*/
  632.  
  633.    bcc, sta, sta, o__, sty, sta, stx, o__,
  634.    tya, sta, txs, o__, stz, sta, stz, o__,    /*9*/
  635.  
  636.    ldy, lda, ldx, o__, ldy, lda, ldx, o__,
  637.    tay, lda, tax, o__, ldy, lda, ldx, o__,    /*A*/
  638.  
  639.    bcs, lda, lda, o__, ldy, lda, ldx, o__,
  640.    clv, lda, tsx, o__, ldy, lda, ldx, o__,    /*B*/
  641.  
  642.    cpy, cmp, o__, o__, cpy, cmp, dec, o__,
  643.    iny, cmp, dex, o__, cpy, cmp, dec, o__,    /*C*/
  644.  
  645.    bne, cmp, cmp, o__, o__, cmp, dec, o__,
  646.    cld, cmp, phx, o__, o__, cmp, dec, o__,    /*D*/
  647.  
  648.    cpx, sbc, o__, o__, cpx, sbc, inc, o__,
  649.    inx, sbc, nop, o__, cpx, sbc, inc, o__,    /*E*/
  650.  
  651.    beq, sbc, sbc, o__, o__, sbc, inc, o__,
  652.    sed, sbc, plx, o__, o__, sbc, inc, o__     /*F*/
  653. };
  654.  
  655.  
  656. byte  mode[]=
  657. {
  658.    8, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 1,0xF,0, 0x5, 5, 5, 0,     /*0*/
  659.    9, 0xB, 0xD, 0, 2, 3, 3, 0,  8, 7, 8, 0, 0x5, 6, 6, 0,     /*1*/
  660.    5, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 1,0xF,0, 0x5, 5, 5, 0,     /*2*/
  661.    9, 0xB, 0xD, 0, 3, 3, 3, 0,  8, 7, 8, 0, 0x6, 6, 6, 0,     /*3*/
  662.    8, 0xA, 0x0, 0, 0, 2, 2, 0,  8, 1,0xF,0, 0x5, 5, 5, 0,     /*4*/
  663.    9, 0xB, 0xD, 0, 0, 3, 3, 0,  8, 7, 8, 0, 0x0, 6, 6, 0,     /*5*/
  664.    8, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 1,0xF,0, 0xC, 5, 5, 0,     /*6*/
  665.    9, 0xB, 0xD, 0, 3, 3, 3, 0,  8, 7, 8, 0, 0xE, 6, 6, 0,     /*7*/
  666.  
  667.    9, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 0, 8, 0, 0x5, 5, 5, 0,     /*8*/
  668.    9, 0xB, 0xD, 0, 3, 3, 4, 0,  8, 7, 8, 0, 0x6, 6, 6, 0,     /*9*/
  669.    1, 0xA, 0x1, 0, 2, 2, 2, 0,  8, 1, 8, 0, 0x5, 5, 5, 0,     /*A*/
  670.    9, 0xB, 0xD, 0, 3, 3, 4, 0,  8, 7, 8, 0, 0x6, 6, 7, 0,     /*B*/
  671.    1, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 1, 8, 0, 0x5, 5, 5, 0,     /*C*/
  672.    9, 0xB, 0xD, 0, 0, 3, 3, 0,  8, 7, 8, 0, 0x0, 6, 6, 0,     /*D*/
  673.    1, 0xA, 0x0, 0, 2, 2, 2, 0,  8, 1, 8, 0, 0x5, 5, 5, 0,     /*E*/
  674.    9, 0xB, 0xD, 0, 0, 3, 3, 0,  8, 7, 8, 0, 0x0, 6, 6, 0      /*F*/
  675. };
  676.  
  677. #if ! VERSION
  678. chk_tables()
  679. {
  680.    register byte huge   *p = mode;
  681.    register char huge   **q = ops;
  682.    register int         i = 256;
  683.  
  684.    while( i--)
  685.       if( (*q++ != o__) ^ (*p++ >= 1))
  686.          fprintf( stderr, "Table entry mismatch for op-code $%02X \
  687.  mnemo=\"%s\" mode=%d\n", 255 - i, q[-1], p[-1]);
  688. }
  689. #endif
  690.  
  691. #define  get_j()           \
  692. {                          \
  693.    pc++;                   \
  694.    if( len--)              \
  695.       j = *p++;            \
  696.    else                    \
  697.       goto fini;           \
  698. }
  699.  
  700. #define  dget_j()          \
  701.    if( (len - 2) >= 0)     \
  702.    {                       \
  703.       j    = dpeek( p);    \
  704.       and  = j;            \
  705.       shift= peek( p + 1); \
  706.       p   += 2;            \
  707.       len -= 2;            \
  708.       pc  += 2;            \
  709.    }                       \
  710.    else                    \
  711.       goto fini2
  712.  
  713.  
  714. #define printpc()    fprintf( fq, "%04X  ", pc)
  715.  
  716.  
  717. word  disasm( pc, p, len, byteit)
  718. register word  pc;
  719. byte huge      *p;
  720. word           byteit;
  721. long           len;
  722. {
  723.    register word     i, j;
  724.    register byte     shift, and;
  725.  
  726.    while( len--)
  727.    {
  728.       if( ! pcoff)
  729.          printpc();
  730.       else
  731.          putc( '\t', fq);
  732.       i = *p++;
  733.       pc++;
  734.       if( byteit)
  735.       {
  736.          if( ! pcoff)
  737.             fprintf( fq, "%02X", i);
  738.          fprintf( fq, "\t   .byte $%02X", i);
  739.          if( showascii)
  740.             fprintf( fq, "\t\t; \"%c\"", chprint( i));
  741.       }
  742.       else
  743.          switch( mode[i])
  744.          {
  745.             case 0x0 :
  746.                if( ! pcoff)
  747.                   fprintf( fq, "%02X", i);
  748.                fprintf( fq, "\t   %s", ops[ i]);
  749.                if( ops[i] == o__)
  750.                   fprintf( fq, " $%02X", i);
  751.                if( showascii)
  752.                   fprintf( fq, "\t\t; \"%c\"", chprint( i));
  753.                break;
  754.  
  755.             case 0x1 :
  756.                get_j();
  757.                if( ! pcoff)
  758.                   fprintf( fq, "%02X %02X", i, j);
  759.                fprintf( fq, "\t   %s #", ops[i]);
  760.                if( j < 0xA)
  761.                   fprintf( fq, "%d", j);
  762.                else
  763.                   fprintf( fq, "$%X", j);
  764.                if( showascii)
  765.                   fprintf( fq, "\t\t; \"%c%c\"", chprint( i), chprint( j));
  766.                break;
  767.  
  768.             case 0x2 :
  769.                get_j();
  770.                if( ! pcoff)
  771.                   fprintf( fq, "%02X %02X", i, j);
  772.                fprintf( fq, "\t   %s $%02X", ops[i], j);
  773.                if( showascii)
  774.                   fprintf( fq, "\t\t; \"%c%c\"", chprint( i), chprint( j));
  775.                break;
  776.  
  777.             case 0x3 :
  778.                get_j();
  779.                if( ! pcoff)
  780.                   fprintf( fq, "%02X %02X", i, j);
  781.                fprintf( fq, "\t   %s $%02X,X", ops[i], j);
  782.                if( showascii)
  783.                   fprintf( fq, "\t\t; \"%c%c\"", chprint( i), chprint( j));
  784.                break;
  785.  
  786.             case 0x4 :
  787.                get_j();
  788.                if( ! pcoff)
  789.                   fprintf( fq, "%02X %02X", i, j);
  790.                fprintf( fq, "\t   %s $%02X,Y", ops[i], j);
  791.                if( showascii)
  792.                   fprintf( fq, "\t\t; \"%c%c\"", chprint( i), chprint( j));
  793.                break;
  794.  
  795.             case 0x5 :
  796.                dget_j();
  797.                if( ! pcoff)
  798.                   fprintf( fq, "%02X %02X %02X", i,(word) and,(word) shift);
  799.                fprintf( fq, "\t   %s $%04X", ops[i], j);
  800.                if( showascii)
  801.                   fprintf( fq, "\t\t; \"%c%c%c\"",
  802.                            chprint( i), chprint( and), chprint( shift));
  803.                break;
  804.  
  805.             case 0x6 :
  806.                dget_j();
  807.                if( ! pcoff)
  808.                   fprintf( fq, "%02X %02X %02X", i,(word) and,(word) shift);
  809.                fprintf( fq, "\t   %s $%04X,X", ops[i], j);
  810.                if( showascii)
  811.                   fprintf( fq, "\t\t; \"%c%c%c\"",
  812.                            chprint( i), chprint( and), chprint( shift));
  813.                break;
  814.  
  815.             case 0x7 :
  816.                dget_j();
  817.                if( ! pcoff)
  818.                   fprintf( fq, "%02X %02X %02X", i,(word) and,(word) shift);
  819.                fprintf( fq, "\t   %s $%04X,Y", ops[i], j);
  820.                if( showascii)
  821.                   fprintf( fq, "\t\t; \"%c%c%c\"",
  822.                            chprint( i), chprint( and), chprint( shift));
  823.                break;
  824.  
  825.             case 0x8 :
  826.                if( ! pcoff)
  827.                   fprintf( fq, "%02X", i);
  828.                fprintf( fq, "\t   %s", ops[i]);
  829.                if( showascii)
  830.                   fprintf( fq, "\t\t\t; \"%c\"", chprint( i));
  831.                break;
  832.  
  833.             case 0x9 :
  834.                {
  835.                   register byte  j;
  836.                   register word  k;
  837.  
  838.                   get_j();
  839.                   k = j;
  840.                   if( ! pcoff)
  841.                      fprintf( fq, "%02X %02X", i, k);
  842.                   fprintf( fq, "\t   %s $%04X", ops[ i], pc +
  843.                                                          (signed char) j);
  844.                   if( showascii)
  845.                      fprintf( fq, "\t\t; \"%c%c\"",
  846.                               chprint( i), chprint( j));
  847.                }
  848.                break;
  849.  
  850.             case 0xA :
  851.                get_j();
  852.                if( ! pcoff)
  853.                   fprintf( fq, "%02X %02X", i, j);
  854.                fprintf( fq, "\t   %s ($%02X,X)", ops[i], j);
  855.                if( showascii)
  856.                      fprintf( fq, "\t\t; \"%c%c\"",
  857.                               chprint( i), chprint( j));
  858.                break;
  859.  
  860.             case 0xB :
  861.                get_j();
  862.                if( ! pcoff)
  863.                   fprintf( fq, "%02X %02X", i, j);
  864.                fprintf( fq, "\t   %s ($%02X),Y", ops[i], j);
  865.                if( showascii)
  866.                      fprintf( fq, "\t\t; \"%c%c\"",
  867.                               chprint( i), chprint( j));
  868.                break;
  869.  
  870.             case 0xC :
  871.                dget_j();
  872.                if( ! pcoff)
  873.                   fprintf( fq, "%02X %02X %02X", i,(word) and,(word) shift);
  874.                fprintf( fq, "\t   %s ($%04X)", ops[i], j);
  875.                if( showascii)
  876.                   fprintf( fq, "\t\t; \"%c%c%c\"",
  877.                            chprint( i), chprint( and), chprint( shift));
  878.                break;
  879.  
  880.             case 0xD :
  881.                get_j();
  882.                if( ! pcoff)
  883.                   fprintf( fq, "%02X %02X", i, j);
  884.                fprintf( fq, "\t   %s ($%02X)", ops[i], j);
  885.                if( showascii)
  886.                      fprintf( fq, "\t\t; \"%c%c\"",
  887.                               chprint( i), chprint( j));
  888.                break;
  889.  
  890.             case 0xE :
  891.                dget_j();
  892.                if( ! pcoff)
  893.                   fprintf( fq, "%02X %02X %02X", i,(word) and,(word) shift);
  894.                fprintf( fq, "\t   %s ($%04X,X)", ops[i], j);
  895.                if( showascii)
  896.                   fprintf( fq, "\t; \"%c%c%c\"",
  897.                            chprint( i), chprint( and), chprint( shift));
  898.                 break;
  899.  
  900.             case 0xF :
  901.                if( ! pcoff)
  902.                   fprintf( fq, "%02X", i);
  903.                fprintf( fq, "\t   %s a", ops[i]);
  904.                if( showascii)
  905.                   fprintf( fq, "\t\t; \"%c\"", chprint( i));
  906.                break;
  907.  
  908.          }
  909.       putc( '\n', fq);
  910.    }
  911.    return( pc);
  912.  
  913. fini:
  914.    if( ! pcoff)
  915.       fprintf( fq, "%02X", i);
  916.    fprintf( fq, "\t   .byte $%02X", i);
  917.    if( showascii)
  918.       fprintf( fq, "\t\t; \"%c\"", chprint( i));
  919.    putc( '\n', fq);
  920.    return( pc);
  921.  
  922. fini2:
  923.    if( ! len)
  924.       goto fini;
  925.    j = *p;
  926.    if( ! pcoff)
  927.       fprintf( fq, "%02X %02X", i, j);
  928.    fprintf( fq, "\t   .byte $%02X, $%02X", i, j);
  929.    if( showascii)
  930.          fprintf( fq, "\t; \"%c%c\"", chprint( i), chprint( j));
  931.    putc( '\n', fq);
  932.    return( pc);
  933. }
  934.  
  935. keypress()
  936. {
  937. #if OS == TOS
  938.    if( tossable)
  939.    {
  940.       while( Bconstat( 2))
  941.          Bconin( 2);
  942.       Bconin( 2);
  943.    }
  944. #endif
  945. }
  946.  
  947. h_print()
  948. {
  949.    fputs( "disasm65: ", stderr);
  950. }
  951.  
  952. finalshit()
  953. {
  954. }
  955.  
  956.