home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CROSSASM / AS68K.ZIP / AS4.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-01-10  |  16.4 KB  |  724 lines
  1. #include "a:printf.h"
  2. #include "a:stdio.h"
  3. #include "as.h"
  4.  
  5.  
  6. andor(opskel,opsk2)
  7. unsigned    opskel,opsk2;
  8. {
  9. /*
  10.        process AND,OR
  11.        <EA>,DN DN,<EA>  DATA,<EA>
  12. */
  13.  
  14.         /* check for error - can't be An */
  15.  
  16.         if (op1ea == 2 || op2ea == 2)
  17.                 return 3;
  18.  
  19.         if (op1ea == 6) {
  20.  
  21.                 /* process DATA,<EA> */
  22.  
  23.                 opskel = opsk2;
  24.  
  25.                 if (op2ea == 6)
  26.                         return 3;
  27.  
  28.                 procop(&opnptr);
  29.                 objbuf[2] = opnwrd[2];
  30.  
  31.                 if (opnwc == 2) {
  32.                         objbuf[2] = opnwrd[3];
  33.                         objbuf[3] = opnwrd[2];
  34.                 }
  35.  
  36.                 objwc += opnwc;
  37.  
  38.                 /* now get ,<EA> */
  39.  
  40.                 if (op2ea == 0)  {
  41.             if (op1ea == 1)
  42.                             return 0;
  43.  
  44.                         /* evaluate ,<EA> for complex address */
  45.  
  46.                         procop(&opnpt2);
  47.                         objbuf[objwc + 1] = opnwrd[2];
  48.  
  49.                         if (opnwc == 2) {
  50.                                 objbuf[objwc + 1] = opnwrd[3];
  51.                                 objbuf[objwc + 2] = opnwrd[2];
  52.                         }
  53.  
  54.                         objwc += opnwc;
  55.                         objbuf[1] |= opskel;
  56.                         return 0;
  57.                 }
  58.  
  59.                 /* check for DATA,SR or DATA,CCR */
  60.  
  61.                 if (op2ea < 7) {
  62.                         objbuf[1] = opskel | ((op2ea - 1) * 8) | op2da;
  63.                         return 0;
  64.                 }
  65.  
  66.                 if (op2ea > 8)
  67.                         return 3;
  68.  
  69.                 if (imode == 1 && op2ea == 8) {
  70.                         objbuf[1] = opskel | 0x3c;
  71.                         return 0;
  72.                 }
  73.  
  74.                 if (imode == 1 || imode == 3)
  75.                         return 3;
  76.         }
  77.  
  78.         if (op2ea != 1) {
  79.  
  80.                 /* EVALUATE DN,<EA> */
  81.  
  82.                 opskel = opskel + (op1da * 0x200) | 0x100;
  83.  
  84.                 if (op2ea == 0) {
  85.                         procop(&opnpt2);
  86.                         objbuf[objwc + 1] = opnwrd[2];
  87.  
  88.                         if (opnwc == 2) {
  89.                                 objbuf[objwc + 1] = opnwrd[3];
  90.                                 objbuf[objwc + 2] = opnwrd[2];
  91.                         }
  92.  
  93.                         objwc += opnwc;
  94.                         objbuf[1] |= opskel;
  95.                         return 0;
  96.                 }
  97.  
  98.                 objbuf[1] = opskel | op2da | ((op2ea - 1) * 8);
  99.                 return 0;
  100.         }
  101.  
  102.         /* PROCESS <EA>,DN */
  103.  
  104.         opskel += (op2da * 0x200);
  105.  
  106.         if (op1ea != 0) {
  107.                 objbuf[1] = opskel | op1da | ((op1ea - 1) * 8);
  108.                 return 0;
  109.         }
  110.  
  111.         procop(&opnptr);
  112.         objbuf[1] = opskel | opnwrd[1];
  113.         objbuf[2] = opnwrd[2];
  114.  
  115.         if (opnwc == 2) {
  116.                 objbuf[2] = opnwrd[3];
  117.                 objbuf[3] = opnwrd[2];
  118.         }
  119.  
  120.         objwc += opnwc;
  121.         return 0;
  122. }
  123.  
  124.  
  125. eor(opskel,opsk2)
  126. unsigned    opskel,opsk2;
  127. {
  128. /*
  129.        process EOR
  130.        DN,<EA> DATA,<EA>
  131. */
  132.  
  133.         /* check for errors - can't be An */
  134.  
  135.         if (op1ea == 2 || op2ea == 2)
  136.                 return 3;
  137.  
  138.         if (op1ea == 6) {
  139.                 opskel = opsk2;
  140.  
  141.                 if (op2ea == 6)
  142.                         return 3;
  143.  
  144.                 procop(&opnptr);
  145.                 objbuf[2] = opnwrd[2];
  146.  
  147.                 if (opnwc == 2) {
  148.                         objbuf[2] = opnwrd[3];
  149.                         objbuf[3] = opnwrd[2];
  150.                 }
  151.  
  152.                 objwc += opnwc;
  153.  
  154.                 /* now that we have immediate data get ,<EA> */
  155.  
  156.                 if (op2ea == 0)  {
  157.             if (op1ea == 1)
  158.                 return 0;
  159.  
  160.                         /* evaluate ,<EA> for complex address */
  161.  
  162.                         procop(&opnpt2);
  163.                         objbuf[objwc + 1] = opnwrd[2];
  164.  
  165.                         if (opnwc == 2) {
  166.                                 objbuf[objwc + 1] = opnwrd[3];
  167.                                 objbuf[objwc + 2] = opnwrd[2];
  168.                         }
  169.  
  170.                         objwc += opnwc;
  171.                         objbuf[1] |= opskel;
  172.                         return 0;
  173.                 }
  174.  
  175.                 /* check for DATA,SR or DATA,CCR */
  176.  
  177.                 if (op2ea < 7) {
  178.                         objbuf[1] = opskel | ((op2ea - 1) * 8) | op2da;
  179.                         return 0;
  180.                 }
  181.  
  182.                 if (op2ea > 8)
  183.                         return 3;
  184.  
  185.                 if (imode == 1 && op2ea == 8) {
  186.                         objbuf[1] = opskel | 0x3c;
  187.                         return 0;
  188.                 }
  189.  
  190.                 if (imode == 1 || imode == 3)
  191.                         return 3;
  192.         }
  193.  
  194.         if (op1ea != 1)
  195.                 return 3;
  196.  
  197.         if (op2ea == 0) {
  198.  
  199.                 /* evaluate DN,<EA> */
  200.  
  201.                 opskel = opskel + (op1da * 0x200) | 0x100;
  202.  
  203.                 if (op2ea == 0) {
  204.                         procop(&opnpt2);
  205.                         objbuf[objwc + 1] = opnwrd[2];
  206.  
  207.                         if (opnwc == 2) {
  208.                                 objbuf[objwc + 1] = opnwrd[3];
  209.                                 objbuf[objwc + 2] = opnwrd[2];
  210.                         }
  211.  
  212.                         objwc += opnwc;
  213.                         objbuf[1] |= opskel;
  214.                         return 0;
  215.                 }
  216.  
  217.                 objbuf[1] = opskel | op2da | ((op2ea - 1) * 8);
  218.                 return 0;
  219.         }
  220.  
  221.         objbuf[1] = opskel + ((op1ea - 1) * 0x200) + op2da + ((op1ea - 1) * 8);
  222.         return 0;
  223. }
  224.  
  225.  
  226. rotate(opskel)
  227. unsigned    opskel;
  228. {
  229. /*
  230.        process ROTATES and SHIFTS
  231.        DX,DY   DATA,DY  <EA>
  232. */
  233.  
  234.         if (op1ea == 1 && op2ea == 1) {
  235.                 objbuf[1] = opskel | 0x20 | (op1da * 0x200) | op2da;
  236.                 return 0;
  237.         }
  238.  
  239.         if ((op1ea == 6 && op2ea == 1) || (op1ea == 0 && op2ea == 1)) {
  240.                 procop(&opnptr);
  241.  
  242.                 if (opnwrd[2] < 1 || opnwrd[2] > 8)
  243.                         return 3;
  244.  
  245.                 if (opnwrd[2] == 8)
  246.                         opnwrd[2] = 0;
  247.  
  248.                 objbuf[1] = opskel + (opnwrd[2] * 0x200) + op2da;
  249.                 return 0;
  250.         }
  251.  
  252.         /* process <EA> */
  253.  
  254.         if (op1ea != 0) {
  255.                 if (op1ea < 3 || op1ea > 5)
  256.                         return 3;
  257.  
  258.                 objbuf[1] = opskel + ((op1ea - 1) * 8) + op1da;
  259.                 return 1;
  260.         }
  261.  
  262.         procop(&opnptr);
  263.         objbuf[1] = opskel + opnwrd[1];
  264.         objbuf[2] = opnwrd[2];
  265.  
  266.         if (opnwc == 2) {
  267.                 objbuf[2] = opnwrd[3];
  268.                 objbuf[3] = opnwrd[2];
  269.         }
  270.  
  271.         objwc += opnwc;
  272.         return 1;
  273. }
  274.  
  275.  
  276. branch(opskel)
  277. unsigned    opskel;
  278. {
  279. /*
  280.        process BRANCH
  281.        <label>
  282. */
  283.         int     itemp;
  284.  
  285.         if (opnptr == 0 || op1ea != 0)
  286.                 return 3;
  287.  
  288.         dbflg = 1;
  289.         procop(&opnptr);
  290.  
  291.         /* check for forced short address mode */
  292.  
  293.         if (imode == 4) {
  294.                 objwc = 1;
  295.                 objbuf[1] = opskel | (opnwrd[2] & 0xff);
  296.                 dbflg = 0;
  297.                 return 1;
  298.         }
  299.  
  300.         /* CHECK FOR FWD SYMBOL OR REF BEFORE DEFINITION */
  301.  
  302.         if (opnflg == 1) {
  303.                 objbuf[1] = opskel;
  304.                 objbuf[2] = opnwrd[2];
  305.                 objwc = 2;
  306.                 dbflg = 0;
  307.                 return 1;
  308.         }
  309.  
  310.         /* CHECK FOR SHORT BRANCH */
  311.  
  312.         itemp = opnwrd[2];
  313.         if (itemp >= -126 && itemp <= 129 && itemp != -2) {
  314.                 objwc = 1;
  315.                 objbuf[1] = opskel | (opnwrd[2] & 0xff);
  316.                 dbflg = 0;
  317.                 return 1;
  318.         }
  319.  
  320.         if (imode == 4)
  321.                 error(404);
  322.  
  323.         /* ELSE GENERATE TWO WORD BRANCH */
  324.  
  325.         objbuf[1] = opskel;
  326.         objbuf[2] = opnwrd[2];
  327.         objwc = 2;
  328.         dbflg = 0;
  329.         return 1;
  330. }
  331.  
  332.  
  333. bitmod(opskel,opsk2)
  334. unsigned    opskel,opsk2;
  335. {
  336. /*
  337.        process BIT MODIFICATION
  338.        DN,<EA> DATA,<EA>
  339. */
  340.         unsigned    tflg;
  341.         long        ltemp;
  342.  
  343.         if ((op1ea != 1 && op1ea != 6) || op2ea == 2 || op2ea > 5)
  344.                 return 3;
  345.  
  346.         if (op1ea == 6) {       /* imm,<EA> */
  347.                 procop(&opnptr);
  348.  
  349.                 ltemp = asn(opnwrd[2],opnwrd[3]);
  350.                 if (op2ea == 1)  {
  351.                         if (ltemp < 0l || ltemp > 31l)
  352.                                 return 3;
  353.         }
  354.                 else  {
  355.                         if (ltemp < 0l || ltemp > 7l)
  356.                                 return 3;
  357.         }
  358.  
  359.                 objbuf[2] = opnwrd[2];
  360.                 ++objwc;
  361.  
  362.                 if (op2ea == 0) {       /* #imm,complex <EA> */
  363.                         tflg = rflg;
  364.                         rflg = 1;
  365.                         procop(&opnpt2);
  366.                         rflg = tflg;
  367.                         objbuf[3] = opnwrd[2];
  368.  
  369.                         if (opnwc == 2) {
  370.                                 objbuf[3] = opnwrd[3];
  371.                                 objbuf[4] = opnwrd[2];
  372.                         }
  373.  
  374.                         objwc += opnwc;
  375.                         objbuf[1] = opsk2 + (opnwrd[1] & 0x3f);
  376.                         return 1;
  377.                 }
  378.  
  379.                 /* simple <EA> */
  380.  
  381.                 objbuf[1] = opsk2 + op2da + ((op2ea - 1) * 8);
  382.                 return 1;
  383.         }
  384.  
  385.         if (op2ea == 0) {       /* Dn,complex <EA> */
  386.                 tflg = rflg;
  387.                 rflg = 1;
  388.                 procop(&opnpt2);
  389.                 rflg = tflg;
  390.                 objbuf[2] = opnwrd[2];
  391.  
  392.                 if (opnwc == 2) {
  393.                         objbuf[2] = opnwrd[3];
  394.                         objbuf[3] = opnwrd[2];
  395.                 }
  396.  
  397.                 objwc += opnwc;
  398.                 objbuf[1] = opskel | (opnwrd[1] & 0x3f) | (op1da * 0x200);
  399.                 return 1;
  400.         }
  401.  
  402.         /* SIMPLE EA'S */
  403.  
  404.         objbuf[1] = opskel | (op1da * 0x200) | op2da | ((op2ea - 1) * 8);
  405.         return 1;
  406. }
  407.  
  408.  
  409. mult(opskel)
  410. unsigned    opskel;
  411. {
  412. /*
  413.           process MULT DIV and CHK
  414.           <EA>,DN
  415. */
  416.  
  417.         if (op2ea != 1 || op1ea == 2)
  418.                 return 3;
  419.  
  420.         if (op1ea != 0 && op1ea != 6) {
  421.                 if (op1ea > 6)
  422.                         return 3;
  423.  
  424.                 opskel = opskel + ((op1ea - 1) * 8) + op1da;
  425.         }
  426.         else {
  427.                 procop(&opnptr);
  428.                 opskel += opnwrd[1];
  429.                 objbuf[2] = opnwrd[2];
  430.  
  431.                 if (opnwc == 2) {
  432.                         objbuf[2] = opnwrd[3];
  433.                         objbuf[3] = opnwrd[2];
  434.                 }
  435.  
  436.                 objwc += opnwc;
  437.         }
  438.  
  439.         objbuf[1] = opskel + (op2da * 0x200);
  440.         return 1;
  441. }
  442.  
  443.  
  444. sglea(opidx,opskel)
  445. unsigned    opidx,opskel;
  446. {
  447. /*
  448.     process opcode <EA>
  449.     CHK FOR CLR,NEG,NOT,TST,NEGX
  450. */
  451.         unsigned    tflg;
  452.  
  453.         if (opidx == 17 || opidx == 24 || opidx == 26 || opidx == 47 || opidx == 23) {
  454.                 if (opidx == 23 && imode != 0 || op1ea == 2 || op1ea >= 6)
  455.                         return 3;
  456.  
  457.                 if (opidx != 23) {
  458.                         if (imode == 3)
  459.                                 opskel += 0x80;
  460.  
  461.             if (imode == 2 || imode == 0)
  462.                                 opskel += 0x40;
  463.                 }
  464.  
  465.                 if (op1ea == 0) {
  466.                         tflg = rflg;
  467.                         rflg = 1;
  468.                         procop(&opnptr);
  469.                         objbuf[1] = opskel | opnwrd[1];
  470.                         objbuf[2] = opnwrd[2];
  471.  
  472.                         if (opnwc == 2) {
  473.                                 objbuf[2] = opnwrd[3];
  474.                                 objbuf[3] = opnwrd[2];
  475.                         }
  476.  
  477.                         objwc += opnwc;
  478.                         rflg = tflg;
  479.                         return 1;
  480.                 }
  481.  
  482.                 /* PROCESS REG opERAND */
  483.  
  484.                 objbuf[1] = opskel | op1da | ((op1ea - 1) * 8);
  485.                 return 1;
  486.         }
  487.  
  488.         /* PROCESS JSR or JMP */
  489.  
  490.         if (op1ea != 0 && op1ea != 3)
  491.                 return 3;
  492.  
  493.         if (op1ea == 3) {
  494.                 objbuf[1] = opskel | op1da | 0x10;
  495.                 return 1;
  496.         }
  497.  
  498.         /* GENERATE EXTENSION WORDS AS NECESSARY */
  499.  
  500.         procop(&opnptr);
  501.         objbuf[1] = opskel | opnwrd[1];
  502.         objbuf[2] = opnwrd[2];
  503.  
  504.         if (opnwc == 2) {
  505.                 objbuf[2] = opnwrd[3];
  506.                 objbuf[3] = opnwrd[2];
  507.         }
  508.  
  509.         objwc += opnwc;
  510.         return 1;
  511. }
  512.  
  513.  
  514. decrbr(opskel)
  515. unsigned    opskel;
  516. {
  517. /*
  518.           process DECR and BRANCH
  519.           DN,<label>
  520. */
  521.     int    i;
  522.  
  523.         if (op1ea != 1 || op2ea != 0)
  524.                 return 3;
  525.  
  526.         objbuf[1] = opskel + op1da;
  527.         i = rflg;
  528.         rflg = 0;
  529.         dbflg = 1;
  530.         scanpt = opnpt2;
  531.         procop(&opnpt2);
  532.         objbuf[2] = opnwrd[2];
  533.         rflg = i;
  534.         objwc = 2;
  535.         dbflg = 0;
  536.         return 1;
  537. }
  538.  
  539.  
  540. exg(opskel)
  541. unsigned    opskel;
  542. {
  543. /*
  544.           process EXG
  545. */
  546.         if (op1ea == 0 || op1ea > 2 || op2ea == 0 || op2ea > 2)
  547.                 return 3;
  548.  
  549.         opskel += op2da;
  550.         opskel += (op1da * 0x200);
  551.  
  552.         if (op1ea == 1 && op2ea == 1)
  553.                 objbuf[1] = opskel + 0x140;
  554.  
  555.         if (op1ea == 2 && op2ea == 2)
  556.                 objbuf[1] = opskel + 0x148;
  557.  
  558.         if (op1ea == op2ea)
  559.                 return 1;
  560.  
  561.         objbuf[1] = opskel + 0x188;
  562.         return 1;
  563. }
  564.  
  565.  
  566. ext(opidx,opskel)
  567. unsigned    opidx,opskel;
  568. {
  569. /*
  570.           process EXT and SWAP
  571.           DN
  572. */
  573.         if (opidx != 27)
  574.                 if (imode == 3)
  575.                         opskel |= 0x40;
  576.  
  577.         if (op1ea != 1)
  578.                 return 3;
  579.  
  580.         objbuf[1] = opskel + op1da;
  581.         return 1;
  582. }
  583.  
  584.  
  585. lea(opskel)
  586. unsigned    opskel;
  587. {
  588. /*
  589.           process LEA
  590.           <EA>,AN
  591. */
  592.         if (op1ea == 0) {
  593.                 procop(&opnptr);
  594.                 objbuf[1] = opskel | opnwrd[1] | (op2da << 9);
  595.                 objbuf[2] = opnwrd[2];
  596.  
  597.                 if (opnwc == 2) {
  598.                         objbuf[2] = opnwrd[3];
  599.                         objbuf[3] = opnwrd[2];
  600.                 }
  601.  
  602.                 objwc += opnwc;
  603.                 return 1;
  604.         }
  605.  
  606.         if (op1ea == 3) {
  607.                 objbuf[1] = opskel | (op2da << 9) | op1da;
  608.                 objbuf[1] |= ((op1ea - 1) * 8);
  609.                 return 1;
  610.         }
  611.  
  612.         return 3;
  613. }
  614.  
  615.  
  616. link(opskel)
  617. unsigned    opskel;
  618. {
  619. /*
  620.           process LINK
  621.           AN,<DISPLACEMENT>
  622. */
  623.         if (op1ea != 2 && op2ea != 6)
  624.                 return 3;
  625.  
  626.         procop(&opnpt2);
  627.  
  628.         if (opnwrd[3] == 0 || opnwrd[3] == -1) {
  629.                 objwc = 2;
  630.                 objbuf[1] = opskel + op1da;
  631.                 objbuf[2] = opnwrd[2];
  632.                 return 1;
  633.         }
  634.  
  635.         return 3;
  636. }
  637.  
  638.  
  639. trap(opskel)
  640. unsigned    opskel;
  641. {
  642. /*
  643.           process TRAP
  644.           <VECTOR>
  645. */
  646.         if (op1ea != 6)
  647.                 return 3;
  648.  
  649.         procop(&opnptr);
  650.  
  651.         if (opnwc != 1 || opnwrd[2] > 16)
  652.                 return 3;
  653.  
  654.         objbuf[1] = opskel + opnwrd[2];
  655.         return 1;
  656. }
  657.  
  658.  
  659. stop(opskel)
  660. unsigned    opskel;
  661. {
  662. /*
  663.           process STOP
  664.           #<SR>
  665. */
  666.         if (op1ea != 6)
  667.                 return 3;
  668.  
  669.         procop(&opnptr);
  670.  
  671.         if (opnwc != 1)
  672.                 return 3;
  673.  
  674.         objbuf[1] = opskel;
  675.         objbuf[2] = opnwrd[2];
  676.         objwc = 2;
  677.         return 1;
  678. }
  679.  
  680.  
  681. abcd(opskel)
  682. unsigned    opskel;
  683. {
  684. /*
  685.           process ABCD,SBCD,ADDX,SUBX
  686.           DY,DX -(AY),-(AX)
  687. */
  688.  
  689.         if (op1ea == 1 && op2ea == 1) {
  690.                 if (op1ea == 5)
  691.                         opskel += 8;
  692.  
  693.                 opskel += op2da;
  694.                 objbuf[1] = opskel + op1da * 0x200;
  695.                 return 1;
  696.         }
  697.  
  698.         if (op1ea != 5 || op2ea != 5)
  699.                 return 3;
  700.  
  701.         if (op1ea == 5)
  702.                 opskel += 8;
  703.  
  704.         opskel += op2da;
  705.         objbuf[1] = opskel + op1da * 0x200;
  706.  
  707.         return 1;
  708. }
  709.  
  710.  
  711. unlk(opskel)
  712. unsigned    opskel;
  713. {
  714. /*
  715.           process UNLK
  716.           AN
  717. */
  718.         if (op1ea != 2)
  719.                 return 3;
  720.  
  721.         objbuf[1] = opskel+op1da;
  722.         return 1;
  723. }
  724.