home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / szadb21b / source / src / dis3.c < prev    next >
C/C++ Source or Header  |  1990-11-13  |  16KB  |  817 lines
  1. /* Copyright (c) 1990 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    dis3.c
  12.  */
  13. /*
  14.  * Modifications:
  15.  *    - in case of ailure to disassemble print operand as a constant
  16.  *      in 'dc.w' instruction
  17.  *    - make printout to align in a nicer way
  18.  *
  19.  *    Michal Jaegermann, November 1990
  20.  */
  21.  
  22. #include "adb.h"
  23.  
  24. extern long     dot;
  25. extern int      dotoff;
  26. extern int      opcode_pos;    /* this value depends on resolution */
  27.  
  28. #define DOT    (dot+dotoff)
  29.  
  30. int             cursz;
  31.  
  32. nextw ()
  33. {
  34.     return getwd ();
  35. }
  36.  
  37. long
  38. nextl ()
  39. {
  40.     unsigned int    i[2];
  41.  
  42.     i[0] = getwd ();
  43.     i[1] = getwd ();
  44.     return ((long) i[0]) << 16 | i[1];
  45. }
  46.  
  47. int             op0 (), op1 (), op2 (), op3 (), op4 (), op5 (), op6 (), op7 ();
  48. int             op8 (), op9 (), opa (), opb (), opc (), opd (), ope (), opf ();
  49.  
  50. int             (*funhi[]) () = { op0, op1, op2, op3, op4, op5, op6, op7,
  51.                   op8, op9, opa, opb, opc, opd, ope, opf
  52.                 };
  53.  
  54. puti ()
  55. {
  56.     unsigned int    op;
  57.     int             ar_pos;
  58.  
  59.     align (opcode_pos);
  60.  
  61.     op = nextw ();
  62.  
  63.     if (!(*funhi[op >> 12]) (op, ar_pos = opcode_pos + ALIGN_OP)) {
  64.     prt ("dc.w");
  65.     align (ar_pos);
  66.     prtn ((unsigned long) op, 0);
  67.     }
  68. }
  69.  
  70.  
  71. #define M_IMM    1
  72. #define M_PX    2
  73. #define M_POFF    4
  74. #define M_ABSL    010
  75. #define M_ABSW    020
  76. #define M_AX    040
  77. #define M_AOFF    0100
  78. #define M_ADEC    0200
  79. #define M_AINC    0400
  80. #define M_ATA    01000
  81. #define M_AREG    02000
  82. #define M_DREG    04000
  83.  
  84. valid (mode, reg, mask)
  85. {
  86.     if (mode == 7)
  87.     switch (reg) {
  88.     case 0:
  89.         return mask & M_ABSW;
  90.     case 1:
  91.         return mask & M_ABSL;
  92.     case 2:
  93.         return mask & M_POFF;
  94.     case 3:
  95.         return mask & M_PX;
  96.     case 4:
  97.         return mask & M_IMM;
  98.     default:
  99.         return 0;
  100.     }
  101.     else
  102.     switch (mode) {
  103.     case 0:
  104.         return mask & M_DREG;
  105.     case 1:
  106.         return mask & M_AREG;
  107.     case 2:
  108.         return mask & M_ATA;
  109.     case 3:
  110.         return mask & M_AINC;
  111.     case 4:
  112.         return mask & M_ADEC;
  113.     case 5:
  114.         return mask & M_AOFF;
  115.     case 6:
  116.         return mask & M_AX;
  117.     }
  118. }
  119.  
  120. ix_str (n)
  121. {
  122.     int             op, r;
  123.     char            c;
  124.     char           *fmt;
  125.  
  126.     op = nextw ();
  127.     r = (op >> 12) & 7;
  128.     c = (op & 0x800) ? 'l' : 'w';
  129.     if (n >= 8) {
  130.     if (op < 0)
  131.         fmt = "%i(pc,%a.%c)";
  132.     else
  133.         fmt = "%i(pc,%d.%c)";
  134.     prtf (fmt, (char) op, r, c);
  135.     }
  136.     else {
  137.     if (op < 0)
  138.         fmt = "%i(%a,%a.%c)";
  139.     else
  140.         fmt = "%i(%a,%d.%c)";
  141.     prtf (fmt, (char) op, n, r, c);
  142.     }
  143. }
  144.  
  145. modepr (mode, reg)
  146. {
  147.     char           *p;
  148.  
  149.     switch (mode) {
  150.     case 0:
  151.     prtf ("%d", reg);
  152.     break;
  153.     case 1:
  154.     prtf ("%a", reg);
  155.     break;
  156.     case 2:
  157.     prtf ("(%a)", reg);
  158.     break;
  159.     case 3:
  160.     prtf ("(%a)+", reg);
  161.     break;
  162.     case 4:
  163.     prtf ("-(%a)", reg);
  164.     break;
  165.     case 5:
  166.     prtf ("%i(%a)", nextw (), reg);
  167.     break;
  168.     case 6:
  169.     ix_str (reg);
  170.     break;
  171.     case 7:
  172.     switch (reg) {
  173.     case 0:
  174.         prtf ("%i", nextw ());
  175.         break;
  176.     case 1:
  177.         longval ();
  178.         break;
  179.     case 2:
  180.         prtf ("%i(pc)", nextw ());
  181.         break;
  182.     case 3:
  183.         ix_str (8);
  184.         break;
  185.     case 4:
  186.         switch (cursz) {
  187.         case 0:
  188.         case 1:
  189.         prtf ("#%i", nextw ());
  190.         break;
  191.         case 2:
  192.         putchr ('#');
  193.         longval ();
  194.         break;
  195.         }
  196.         break;
  197.     }
  198.     }
  199. }
  200.  
  201. longval ()
  202. {
  203.     long            l;
  204.     struct sym     *sp;
  205.  
  206.     prtf ("%A", nextl ());
  207. }
  208.  
  209. char            szchr[] = {'b', 'w', 'l'};
  210.  
  211. struct optbl {
  212.     char            sel[6];
  213.     char           *name;
  214.     int             allow;
  215.     char            arg[4];
  216.     char            sz;
  217. };
  218.  
  219. struct optbl    t0[] = {
  220.             {"0s", "or", 05770, "ie"},
  221.             {"00", "or", 1, "ic"},
  222.             {"01", "or", 1, "is", 1},
  223.             {"*4", "btst", 05777, "De"},
  224.             {"*5", "bchg", 05770, "De"},
  225.             {"*6", "bclr", 05770, "De"},
  226.             {"*7", "bset", 05770, "De"},
  227.             {"*4", "movep.w", 02000, "oD"},
  228.             {"*5", "movep.l", 02000, "oD"},
  229.             {"*6", "movep.w", 02000, "Do"},
  230.             {"*7", "movep.l", 02000, "Do"},
  231.             {"1s", "and", 05770, "ie"},
  232.             {"10", "and", 1, "ic"},
  233.             {"11", "and", 1, "is", 1},
  234.             {"2s", "sub", 05770, "ie"},
  235.             {"3s", "add", 05770, "ie"},
  236.             {"40", "btst", 05776, "ie"},
  237.             {"41", "bchg", 05770, "ie"},
  238.             {"42", "bclr", 05770, "ie"},
  239.             {"43", "bset", 05770, "ie"},
  240.             {"5s", "eor", 05770, "ie"},
  241.             {"50", "eor", 1, "ic"},
  242.             {"51", "eor", 1, "is", 1},
  243.             {"6s", "cmp", 05770, "ie"},
  244.             {0, 0, 0, 0}
  245. };
  246.  
  247. op0 (op, pos)
  248.     unsigned int    op;
  249.     int             pos;
  250. {
  251.     return tblop (op, t0, pos);
  252. }
  253.  
  254. match (c, val)
  255. {
  256.     switch (c) {
  257.     case '*':
  258.     return 1;
  259.     case 's':
  260.     return val <= 2;
  261.     case 'S':
  262.     return val >= 4 && val <= 6;
  263.     case 'z':
  264.     return val >= 1 && val <= 2;
  265.     case 'Z':
  266.     return val == 3 || val == 7;
  267.     default:
  268.     return val == (c - '0');
  269.     }
  270. }
  271.  
  272. op1 (op, pos)
  273.     unsigned int    op;
  274.     int             pos;
  275. {
  276.     int             sm, sr, dm, dr;
  277.  
  278.     sm = (op >> 3) & 7;
  279.     sr = op & 7;
  280.     dm = (op >> 6) & 7;
  281.     dr = (op >> 9) & 7;
  282.     cursz = 0;
  283.     if (valid (sm, sr, 07777) && valid (dm, dr, 05770)) {
  284.     prt ("move.b");
  285.     align (pos);
  286.     modepr (sm, sr);
  287.     putchr (',');
  288.     modepr (dm, dr);
  289.     return 1;
  290.     }
  291.     return 0;
  292. }
  293.  
  294. op2 (op, pos)
  295.     unsigned int    op;
  296.     int             pos;
  297. {
  298.     int             sm, sr, dm, dr;
  299.  
  300.     sm = (op >> 3) & 7;
  301.     sr = op & 7;
  302.     dm = (op >> 6) & 7;
  303.     dr = (op >> 9) & 7;
  304.     cursz = 2;
  305.     if (valid (sm, sr, 07777) && valid (dm, dr, 07770)) {
  306.     prt ("move.l");
  307.     align (pos);
  308.     modepr (sm, sr);
  309.     putchr (',');
  310.     modepr (dm, dr);
  311.     return 1;
  312.     }
  313.     return 0;
  314. }
  315.  
  316. op3 (op, pos)
  317.     unsigned int    op;
  318.     int             pos;
  319. {
  320.     int             sm, sr, dm, dr;
  321.  
  322.     sm = (op >> 3) & 7;
  323.     sr = op & 7;
  324.     dm = (op >> 6) & 7;
  325.     dr = (op >> 9) & 7;
  326.     cursz = 1;
  327.     if (valid (sm, sr, 07777) && valid (dm, dr, 07770)) {
  328.     prt ("move.w");
  329.     align (pos);
  330.     modepr (sm, sr);
  331.     putchr (',');
  332.     modepr (dm, dr);
  333.     return 1;
  334.     }
  335.     return 0;
  336. }
  337.  
  338. struct optbl    t4[] = {
  339.             {"0s", "negx", 05770, "e"},
  340.             {"03", "move.w", 05770, "se"},
  341.             {"*6", "chk", 05777, "eD"},
  342.             {"*7", "lea", 01176, "eA"},
  343.             {"1s", "clr", 05770, "e"},
  344.             {"2s", "neg", 05770, "e"},
  345.             {"23", "move.b", 05777, "ec"},
  346.             {"3s", "not", 05770, "e"},
  347.             {"33", "move.w", 05777, "es", 1},
  348.             {"40", "nbcd", 05770, "e"},
  349.             {"41", "swap", 04000, "d"},
  350.             {"41", "pea", 01176, "e"},
  351.             {"42", "ext.w", 04000, "d"},
  352.             {"42", "movem.w", 01170, "le"},
  353.             {"42", "movem.w", 00200, "Le"},
  354.             {"43", "movem.l", 01170, "le"},
  355.             {"43", "movem.l", 00200, "Le"},
  356.             {"43", "ext.l", 04000, "d"},
  357.             {"5s", "tst", 05770, "e"},
  358.             {"53", "tas", 05770, "e"},
  359.             {"53", "illegal", 0001, ""},
  360.             {"71", "trap", 06000, "t"},
  361.             {"71", "link", 01000, "ai", 1},
  362.             {"71", "unlk", 00400, "a"},
  363.             {"71", "move", 00200, "au"},
  364.             {"71", "move", 00100, "ua"},
  365.             {"7160", "reset", 0, ""},
  366.             {"7161", "nop", 0, ""},
  367.             {"7162", "stop", 0, ""},
  368.             {"7163", "rte", 0, ""},
  369.             {"7165", "rts", 0, ""},
  370.             {"7166", "trapv", 0, ""},
  371.             {"7167", "rtr", 0, ""},
  372.             {"72", "jsr", 01176, "e"},
  373.             {"73", "jmp", 01176, "e"},
  374.             {0, 0, 0, 0}
  375. };
  376.  
  377. op4 (op, pos)
  378.     unsigned int    op;
  379.     int             pos;
  380. {
  381.     int             mode, reg, list;
  382.  
  383.     if ((op & 07600) == 06200) {
  384.     reg = op & 7;
  385.     mode = (op >> 3) & 7;
  386.     if (valid (mode, reg, 01576)) {
  387.         prtf ("movem.%c", op & 0100 ? 'l' : 'w');
  388.         align (pos);
  389.         list = nextw ();
  390.         modepr (mode, reg);
  391.         putchr (',');
  392.         rlist (list);
  393.         return 1;
  394.     }
  395.     else
  396.         return 0;
  397.     }
  398.     return tblop (op, t4, pos);
  399. }
  400.  
  401. tblop (op, tp, pos)
  402.     unsigned        op;
  403.     register struct optbl *tp;
  404.     int             pos;
  405. {
  406.     int             mode, reg;
  407.     int             hi, lo;
  408.  
  409.     reg = op & 7;
  410.     mode = (op >> 3) & 7;
  411.     lo = (op >> 6) & 7;
  412.     hi = (op >> 9) & 7;
  413.  
  414.     for (; tp->name; tp++)
  415.     if (match (tp->sel[0], hi) &&
  416.         match (tp->sel[1], lo) &&
  417.         (tp->allow == 0 || valid (mode, reg, tp->allow)) &&
  418.         (tp->sel[2] == 0 || match (tp->sel[2], mode)) &&
  419.         (tp->sel[3] == 0 || match (tp->sel[3], reg))) {
  420.  
  421.         prt (tp->name);
  422.  
  423.         switch (tp->sel[1]) {
  424.         case 's':
  425.         cursz = lo;
  426.         break;
  427.         case 'S':
  428.         cursz = lo - 4;
  429.         break;
  430.         case 'z':
  431.         cursz = (lo == 1) ? 1 : 2;
  432.         break;
  433.         case 'Z':
  434.         cursz = (lo == 3) ? 1 : 2;
  435.         break;
  436.         default:
  437.         cursz = tp->sz;
  438.         goto noszpr;
  439.         }
  440.  
  441.         prtf (".%c", szchr[cursz]);
  442.     noszpr:
  443.         align (pos);
  444.  
  445.         if (tp->arg[0]) {
  446.         puta (tp->arg[0], op);
  447.         if (tp->arg[1]) {
  448.             putchr (',');
  449.             puta (tp->arg[1], op);
  450.         }
  451.         }
  452.         return 1;
  453.     }
  454.     return 0;
  455. }
  456.  
  457. puta (c, op)
  458. {
  459.     int             reg, mode, hi;
  460.  
  461.     reg = op & 7;
  462.     mode = (op >> 3) & 7;
  463.     hi = (op >> 9) & 7;
  464.  
  465.     switch (c) {
  466.     case 'i':
  467.     modepr (7, 4);
  468.     break;
  469.     case 'e':
  470.     modepr (mode, reg);
  471.     break;
  472.     case 'c':
  473.     prt ("ccr");
  474.     break;
  475.     case 's':
  476.     prt ("sr");
  477.     break;
  478.     case 'D':
  479.     modepr (0, hi);
  480.     break;
  481.     case 'd':
  482.     modepr (0, reg);
  483.     break;
  484.     case 'A':
  485.     modepr (1, hi);
  486.     break;
  487.     case 'a':
  488.     modepr (1, reg);
  489.     break;
  490.     case 'o':
  491.     modepr (5, reg);
  492.     break;
  493.     case 'm':
  494.     modepr (4, reg);
  495.     break;
  496.     case 'M':
  497.     modepr (4, hi);
  498.     break;
  499.     case 'p':
  500.     modepr (3, reg);
  501.     break;
  502.     case 'P':
  503.     modepr (3, hi);
  504.     break;
  505.     case 'l':
  506.     rlist (nextw ());
  507.     break;
  508.     case 'L':
  509.     blist (nextw ());
  510.     break;
  511.     case 'u':
  512.     prt ("usp");
  513.     break;
  514.     case 't':
  515.     prtf ("#%i", op & 0xf);
  516.     break;
  517.     case 'k':
  518.     prtf ("#%i", hi ? hi : 8);
  519.     break;
  520.     }
  521. }
  522.  
  523. rlist (x)
  524. {
  525.     int             as, ds;
  526.  
  527.     ds = x & 0xff;
  528.     as = (x >> 8) & 0xff;
  529.     putchr ('[');
  530.     if (ds) {
  531.     listc ('d', ds);
  532.     if (as) {
  533.         putchr (',');
  534.         listc ('a', as);
  535.     }
  536.     }
  537.     else if (as)
  538.     listc ('a', as);
  539.     putchr (']');
  540. }
  541.  
  542. listc (c, x)
  543.     char            c;
  544. {
  545.     int             i;
  546.  
  547.     for (i = 0; i < 8;)
  548.     if (x & (1 << i))
  549.         i += chunk (c, x, i);
  550.     else
  551.         i++;
  552. }
  553.  
  554. chunk (c, x, i)
  555.     char            c;
  556. {
  557.     int             j;
  558.  
  559.     putchr (c);
  560.     j = cnt1s (x >> i);
  561.     if (j == 1) {
  562.     putchr ('0' + i);
  563.     return j;
  564.     }
  565.     else {
  566.     putchr ('0' + i);
  567.     putchr ('-');
  568.     putchr ('0' + i + (j - 1));
  569.     return j;
  570.     }
  571. }
  572.  
  573. cnt1s (x)
  574. {
  575.     int             i;
  576.  
  577.     for (i = 0; i < 9; i++)
  578.     if ((x & (1 << i)) == 0)
  579.         return i;
  580. }
  581.  
  582. blist (x)
  583. {
  584.     int             y;
  585.     int             i;
  586.     unsigned        uw = 0x8000;
  587.  
  588.     y = 0;
  589.     for (i = 0; i < 16; i++)
  590.     if (x & (1 << i))
  591.         y |= (uw >> i);
  592.     rlist (y);
  593. }
  594.  
  595. char           *bnm[] = {"t", "f", "hi", "ls",
  596.              "cc", "cs", "ne", "eq",
  597.              "vc", "vs", "pl", "mi",
  598.              "ge", "lt", "gt", "le"};
  599.  
  600. op5 (op, pos)
  601.     unsigned int    op;
  602.     int             pos;
  603. {
  604.     int             cond, mode, reg;
  605.     int             sz, k;
  606.     long            svdot = DOT;
  607.  
  608.     sz = (op >> 6) & 3;
  609.     reg = op & 7;
  610.     mode = (op >> 3) & 7;
  611.  
  612.     if (sz == 3) {
  613.     cond = (op >> 8) & 0xf;
  614.     if (mode == 1) {
  615.         prtf ("db%s", bnm[cond]);
  616.         align (pos);
  617.         prtf ("%d,%A", reg, svdot + nextw ());
  618.         return 1;
  619.     }
  620.     else if (valid (mode, reg, 05770)) {
  621.         prtf ("s%s", bnm[cond]);
  622.         align (pos);
  623.         modepr (mode, reg);
  624.         return 1;
  625.     }
  626.     }
  627.     else {
  628.     k = (op >> 9) & 7;
  629.     if (k == 0)
  630.         k = 8;
  631.     if (valid (mode, reg, sz ? 07770 : 05770)) {
  632.         prtf ((op & 0x100) ? "subq.%c" : "addq.%c", szchr[sz]);
  633.         align (pos);
  634.         prtf ("#%i,", k);
  635.         modepr (mode, reg);
  636.         return 1;
  637.     }
  638.     }
  639.     return 0;
  640. }
  641.  
  642. op6 (op, pos)
  643.     unsigned int    op;
  644.     int             pos;
  645. {
  646.     int             cond, k;
  647.     long            svdot = DOT;
  648.  
  649.     cond = (op >> 8) & 0xf;
  650.     k = (char) op;
  651.     if (k == 0)
  652.     svdot += nextw ();
  653.     else
  654.     svdot += k;
  655.     if (cond < 2)
  656.     prt (cond ? "bsr" : "bra");
  657.     else
  658.     prtf ("b%s", bnm[cond]);
  659.     align (pos);
  660.     prtf ("%A", svdot);
  661.     return 1;
  662. }
  663.  
  664. op7 (op, pos)
  665.     unsigned int    op;
  666.     int             pos;
  667. {
  668.     register int    val, reg, k;
  669.  
  670.     if (val = (0 == (op & 0x100))) {
  671.     k = (char) op;
  672.     reg = (op >> 9) & 7;
  673.     prt ("moveq");
  674.     align (pos);
  675.     prtf ("#%i,%d", k, reg);
  676.     }
  677.     return val;
  678. }
  679.  
  680. struct optbl    t8[] = {
  681.             {"*s", "or", 05777, "eD"},
  682.             {"*S", "or", 01770, "De"},
  683.             {"*3", "divu", 05777, "eD"},
  684.             {"*7", "divs", 05777, "eD"},
  685.             {"*4", "sbcd", 04000, "dD"},
  686.             {"*4", "sbcd", 02000, "mM"},
  687.             {0, 0, 0, 0}
  688. };
  689.  
  690. op8 (op, pos)
  691.     unsigned int    op;
  692.     int             pos;
  693. {
  694.     return tblop (op, t8, pos);
  695. }
  696.  
  697. struct optbl    t9[] = {
  698.             {"*0", "sub.b", 05777, "eD"},
  699.             {"*z", "sub", 07777, "eD"},
  700.             {"*S", "sub", 01770, "De"},
  701.             {"*Z", "sub", 07777, "eA"},
  702.             {"*S", "subx", 04000, "dD"},
  703.             {"*S", "subx", 02000, "mM"},
  704.             {0, 0, 0, 0}
  705. };
  706.  
  707. op9 (op, pos)
  708.     unsigned int    op;
  709.     int             pos;
  710. {
  711.     return tblop (op, t9, pos);
  712. }
  713.  
  714. opa (op, pos)
  715.     unsigned int    op;
  716.     int             pos;
  717. {
  718.     return 0;
  719. }
  720.  
  721. struct optbl    tb[] = {
  722.             {"*0", "cmp.b", 05777, "eD"},
  723.             {"*z", "cmp", 07777, "eD"},
  724.             {"*Z", "cmp", 07777, "eA"},
  725.             {"*S", "eor", 05770, "De"},
  726.             {"*S", "cmpm", 02000, "pP"},
  727.             {0, 0, 0, 0}
  728. };
  729.  
  730. opb (op, pos)
  731.     unsigned int    op;
  732.     int             pos;
  733. {
  734.     return tblop (op, tb, pos);
  735. }
  736.  
  737. struct optbl    tc[] = {
  738.             {"*s", "and", 05777, "eD"},
  739.             {"*S", "and", 01770, "De"},
  740.             {"*3", "mulu", 05777, "eD"},
  741.             {"*7", "muls", 05777, "eD"},
  742.             {"*4", "abcd", 04000, "dD"},
  743.             {"*4", "abcd", 02000, "mM"},
  744.             {"*5", "exg", 04000, "dD"},
  745.             {"*5", "exg", 02000, "aA"},
  746.             {"*6", "exg", 02000, "aD"},
  747.             {0, 0, 0, 0}
  748. };
  749.  
  750. opc (op, pos)
  751.     unsigned        op;
  752.     int             pos;
  753. {
  754.     return tblop (op, tc, pos);
  755. }
  756.  
  757. struct optbl    td[] = {
  758.             {"*0", "add.b", 05777, "eD"},
  759.             {"*z", "add", 07777, "eD"},
  760.             {"*S", "add", 01770, "De"},
  761.             {"*Z", "add", 07777, "eA"},
  762.             {"*S", "addx", 04000, "dD"},
  763.             {"*S", "addx", 02000, "mM"},
  764.             {0, 0, 0, 0}
  765. };
  766.  
  767. opd (op, pos)
  768.     unsigned int    op;
  769.     int             pos;
  770. {
  771.     return tblop (op, td, pos);
  772. }
  773.  
  774. char           *shiftnm[] = {"as", "ls", "rox", "ro"};
  775.  
  776. ope (op, pos)
  777.     unsigned int    op;
  778.     int             pos;
  779. {
  780.     int             sz, c_r;
  781.     int             mode, reg;
  782.  
  783.     sz = (op >> 6) & 3;
  784.     if (sz == 3) {
  785.     mode = (op >> 3) & 7;
  786.     reg = op & 7;
  787.     if (valid (mode, reg, 01770)) {
  788.         prtf ("%s%c.w,", shiftnm[(op >> 9) & 3],
  789.           (op & 0x100) ? 'l' : 'r');
  790.         align (pos);
  791.         prtf ("#1,");
  792.         modepr (mode, reg);
  793.         return 1;
  794.     }
  795.     }
  796.     else {
  797.     prtf ("%s%c.%c", shiftnm[(op >> 3) & 3],
  798.           (op & 0x100) ? 'l' : 'r', szchr[sz]);
  799.     align (pos);
  800.     c_r = (op >> 9) & 7;
  801.     if (op & 040)
  802.         prtf ("%d", c_r);
  803.     else
  804.         prtf ("#%i", c_r ? c_r : 8);
  805.     prtf (",%d", op & 7);
  806.     return 1;
  807.     }
  808.     return 0;
  809. }
  810.  
  811. opf (op, pos)
  812.     unsigned int    op;
  813.     int             pos;
  814. {
  815.     return 0;
  816. }
  817.