home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CROSSASM / AS68K.ZIP / AS2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-01-10  |  12.0 KB  |  524 lines
  1. #include "a:printf.h"
  2. #include "a:stdio.h"
  3. #include "as.h"
  4.  
  5. prcess()
  6. {
  7.  
  8. /*
  9.  
  10.  OUTPUT:
  11.        objwc   NUMBER OF WORDS REQUIRED FOR INSTRUCTION
  12.  
  13.        objbuf  TABLE OF WORDS GENERATED
  14.  
  15.        prflg   0       ERRORS DETECTED (PRINT LINE AS READ)
  16.                1       NO ERRORS DETECTED (PRINT NORMALLY)
  17.                2       DC.W / DC.L DIRECTIVES
  18.                3       DONT PRINT LINE
  19.                4       DC.B DIRECTIVE
  20.                5       NAM / END / MON DIRECTIVES
  21.                6       EQU / SET DIRECTIVES
  22.                7       ORG / RORG DIRECTIVES
  23.                8       DS DIRECTIVE
  24.                9       PAGE DIRECTIVE
  25.  
  26.        newpc   NEW VALUE FOR PC
  27.  
  28.        op1ea   0       NOT REG OR IMMEDIATE DATA
  29.                1       D REG
  30.                2       A REG
  31.                3       (AN)
  32.                4       (AN)+
  33.                5       -(AN)
  34.                6       DATA
  35.                7       SR
  36.                8       CCR
  37.                9       USP
  38.                10      ERROR DETECTED
  39.  
  40.        imode   0       NO SIZE SPECIFIED (DEFAULT IS WORD)
  41.                1       .B
  42.                2       .W
  43.                3       .L
  44.                4       .S (SHORT BRANCH)
  45.  
  46.        ERRORS DEFINED...
  47.        400     UNDEFINED OPCODE
  48.        401     OPERAND MISSING FOR OPCODE
  49.        402     LABEL ILLEGAL
  50.        403     ERROR IN DC or ORG OPN VALUE
  51.        406     GENERAL ERROR IN DECODING
  52.        407     UNDEFINED SYMBOL
  53.        408     ERROR IN SIZE OF Y(AX,RX) INDEX
  54.        409     MULT DEFN SYMBOL
  55. */
  56.     int      i;
  57.         unsigned  optyp,opidx,opskel,opsk2;
  58.  
  59.         /* SET UP FLAGS THAT CHANGE EACH TIME THRU */
  60.  
  61.         newpc = 0l;
  62.     op1ea = op2ea = op1da = op2da = opnwc = 0;
  63.  
  64.         if (opclen == 0)  {
  65.                 symval = pc;
  66.                 newpc = 0l;
  67.  
  68.                 if (label[0] == 0)
  69.                         return;
  70.  
  71.                 symtbl(2,symval,label);
  72.  
  73.                 if (symflg[stind] & 8)
  74.                         error(409);
  75.  
  76.                 return;
  77.         }
  78.  
  79.         /* decode opcode */
  80.  
  81.         if ((optyp = decopc(&opidx,&opskel,&opsk2)) == 0) {
  82.                 error(400);
  83.                 return;
  84.         }
  85.  
  86.         /* skip if no operands */
  87.  
  88.         if (opnptr) {
  89.                 op1ea = eatyp(opnptr,&op1da);
  90.  
  91.                 if (opnpt2)
  92.                         op2ea = eatyp(opnpt2,&op2da);
  93.         }
  94.  
  95.         /* check for operands */
  96.  
  97.         if (op1ea == 10 || op2ea == 10)
  98.                 where = 3;
  99.         else {
  100.                 if (optyp == 1 || optyp == 2 || opnptr != 0)
  101.         
  102.                         /* DEFAULT SIZE IS ONE WORD FOR INSTRUCTIONS */
  103.  
  104.                         objwc = 1;
  105.                 else {
  106.                         error(401);
  107.                         return;
  108.                 }
  109.  
  110. /*
  111.     goto opCODE EVALUATION ROUTINES VIA optyp
  112. */
  113.  
  114.                 switch (optyp) {
  115.                 case 1:         where = pseudo(opidx);
  116.                                 break;
  117.                 case 2:         where = nop(opskel);
  118.                                 break;
  119.                 case 3:         where = move();
  120.                                 break;
  121.                 case 4:         where = add(opskel,opsk2);
  122.                                 break;
  123.                 case 5:         where = cmp(opskel,opsk2);
  124.                                 break;
  125.                 case 6:         where = andor(opskel,opsk2);
  126.                                 break;
  127.                 case 7:         where = eor(opskel,opsk2);
  128.                                 break;
  129.                 case 8:         where = rotate(opskel);
  130.                                 break;
  131.                 case 9:         where = branch(opskel);
  132.                                 break;
  133.                 case 10:        where = bitmod(opskel,opsk2);
  134.                                 break;
  135.                 case 11:        where = mult(opskel);
  136.                                 break;
  137.                 case 12:        where = sglea(opidx,opskel);
  138.                                 break;
  139.                 case 13:        where = decrbr(opskel);
  140.                                 break;
  141.                 case 14:        where = exg(opskel);
  142.                                 break;
  143.                 case 15:        where = ext(opidx,opskel);
  144.                                 break;
  145.                 case 16:        where = lea(opskel);
  146.                                 break;
  147.                 case 17:        where = link(opskel);
  148.                                 break;
  149.                 case 18:        where = trap(opskel);
  150.                                 break;
  151.                 case 19:        where = abcd(opskel);
  152.                                 break;
  153.                 case 20:        where = unlk(opskel);
  154.                                 break;
  155.                 case 21:        where = ldmstm(opskel);
  156.                                 break;
  157.                 case 22:        where = stop(opskel);
  158.                                 break;
  159.                 default:        where = 3;
  160.                                 break;
  161.                 }
  162.         }
  163.  
  164.         switch (where) {
  165.         case 4:
  166.             return;
  167.         case 3:                    /* error detected */
  168.             prflg = 0;
  169.             for (i = 1; i <= objwc; ++i)  /* zero object buffer */
  170.                 objbuf[i] = 0;
  171.             error(406);
  172.         case 0:
  173.  
  174.                 /*     HANDLE 'NORMAL' SIZE FIELD SPECIFICATIONS
  175.                        USING INFORMATION FROM VARIABLE 'imode'
  176.                 
  177.                        SIZE FIELD NORMALLY IS IN BITS 6 AND 7 OF
  178.                        INSTRUCTION WITH THE FOLLOWING DEFINITION
  179.                 
  180.                           00=.B  01=.W  10=.L
  181.                 
  182.                        INSTRUCTIONS WITH imode=0 DEFAULT TO
  183.                        A SIZE OF 'WORD'
  184.                 */
  185.  
  186.             if (!where) {
  187.                 switch (imode) {
  188.                     case 1:
  189.                         break;
  190.                     case 0:
  191.                     case 2:
  192.                         objbuf[1] |= 0x40;
  193.                         break;
  194.                     case 3:
  195.                         objbuf[1] |= 0x80;
  196.                         break;
  197.                 }
  198.             }
  199.         case 1:         /* PROCESS label FIELD */
  200.                 /* CURRENT PC VAL IS STORED AS SYMBOL VAL */
  201.             symval = pc;
  202.             newpc = (long)objwc * 2;
  203.         case 2:
  204.             if (label[0] == 0)
  205.                 return;
  206.  
  207.             symtbl(2,symval,label);
  208.  
  209.             if (symflg[stind] & 8)
  210.                 error(409);
  211.  
  212.             return;
  213.     }
  214. }
  215.  
  216.  
  217. pseudo(opidx)
  218. unsigned    opidx;
  219. {
  220.  
  221. /*
  222.     PROCESS PSEUDO opS
  223.  
  224.     PSEUDO opS NORMALLY DONT GENERATE CODE
  225.     THE EXCEPTION BEING 'DC'
  226. */
  227.  
  228.         objwc = 0;
  229.         switch (opidx) {
  230.         case 1:         return psdc();
  231.         case 2:         return psds();
  232.         case 3:         return psorg();
  233.         case 4:         return psend();
  234.         case 5:         return psequ();
  235.         case 6:         return psnam();
  236.         case 7:         return psequ();
  237.         case 8:         return psrorg();
  238.         case 9:         return pspage();
  239.         case 10:        return pslist();
  240.         case 11:        return psnlst();
  241.         default:        return 0;
  242.         }
  243. }
  244.  
  245. psdc()
  246. {
  247.     /* DC */
  248.  
  249.         int     right;
  250.  
  251.         right = 0;
  252.         prflg = 2;
  253.         iflg  = rflg;
  254.         rflg  = 1;
  255.  
  256.         while (1) {
  257.                 procop(&opnptr);
  258.                 if (opnwc == 0) {
  259.                         error(403);
  260.                         break;
  261.                 }
  262.  
  263.                 if (imode == 3) {
  264.                         objbuf[++objwc] = opnwrd[3];
  265.                         objbuf[++objwc] = opnwrd[2];
  266.                 }
  267.                 else if (imode == 1) {
  268.                         if (right) {
  269.                                 objbuf[objwc] <<= 8;
  270.                                 objbuf[objwc] |= opnwrd[2];
  271.                                 right = 0;
  272.                         }
  273.                         else {
  274.                                 objbuf[++objwc] = opnwrd[2];
  275.                                 right = 1;
  276.                         }
  277.                 }
  278.                 else
  279.                         objbuf[++objwc] = opnwrd[2];
  280.  
  281.                 if (objwc >= OBJMAX && !right) {
  282.                         error(405);
  283.                         break;
  284.                 }
  285.  
  286.                 if (srclne[opnptr] != ',')
  287.                         break;
  288.                 ++opnptr;
  289.         }
  290.  
  291.         if (right)
  292.                 objbuf[objwc] <<= 8;
  293.  
  294.         rflg = iflg;
  295.         return 1;
  296. }
  297.  
  298.  
  299. psds()
  300. {
  301.     /* DS */
  302.  
  303.         long    ltemp;
  304.  
  305.         prflg = 7;
  306.         if (opnptr == 0)
  307.                 return 3;
  308.  
  309.         procop(&opnptr);
  310.         if (opnwc == 7)  {
  311.                 error(403);
  312.                 return 4;
  313.         }
  314.  
  315.         ltemp = asn(opnwrd[2],opnwrd[3]);
  316.         if (imode == 1)
  317.                 newpc = ltemp;
  318.         else
  319.     if (imode != 3)
  320.                 newpc = 2l * ltemp;
  321.         else
  322.                 newpc = 4l * ltemp;
  323.  
  324.         objbuf[2] = (unsigned)(pc & (long)0xffff);
  325.         objbuf[3] = (unsigned)((pc >> 16) & (long)0xffff);
  326.         symval = pc;
  327.         return 2;
  328. }
  329.  
  330.  
  331. psorg()
  332. {
  333.     /* ORG */
  334.  
  335.         long    ltemp;
  336.  
  337.         if (label[0] != 0) {
  338.                 error(402);
  339.                 return 4;
  340.         }
  341.  
  342.         rflg  = 1;
  343.         prflg = 7;
  344.  
  345.         if (opnptr == 0) {
  346.                 newpc = pc = 0l;
  347.                 return 4;
  348.         }
  349.  
  350.         procop(&opnptr);
  351.  
  352.         if (opnwc == 7) {
  353.                 error(403);
  354.                 return 4;
  355.         }
  356.  
  357.         pc = 0l;
  358.         ltemp = asn(opnwrd[2],opnwrd[3]);
  359.         newpc = ltemp;
  360.  
  361.         if (endval == 0l)
  362.                 endval = ltemp;
  363.         return 4;
  364. }
  365.  
  366.  
  367. psend()
  368. {
  369.  
  370.     /* END <STARTING ADR> */
  371.  
  372.         iserr = TRUE;
  373.         if (label[0] == 0) {
  374.                 prflg = 5;
  375.                 rflg  = 1;
  376.                 if (opnptr) {
  377.                         procop(&opnptr);
  378.                         if (opnwc == 7)
  379.                                 return 4;
  380.  
  381.                         endval = asn(opnwrd[2],opnwrd[3]);
  382.                 }
  383.                 return 4;
  384.         }
  385.         else {
  386.                 error(402);
  387.                 return 4;
  388.         }
  389. }
  390.  
  391.  
  392. psequ()
  393. {
  394.     /* EQU */
  395.  
  396.         long    ltemp;
  397.  
  398.         if (label[0] == 0) {
  399.                 error(402);
  400.                 return 4;
  401.         }
  402.  
  403.         prflg = 6;
  404.         if (opnptr == 0)
  405.                 return 3;
  406.  
  407.         procop(&opnptr);
  408.  
  409.         if (opnwc == 7)
  410.                 return 4;
  411.  
  412.         ltemp = asn(opnwrd[2],opnwrd[3]);
  413.         symtbl(2,ltemp,label);
  414.         if (symflg[stind] & 8)
  415.                 error(409);
  416.  
  417.         symadr[stind] = asn(opnwrd[2],opnwrd[3]);
  418.         objbuf[3] = opnwrd[3];
  419.         objbuf[2] = opnwrd[2];
  420.         symflg[stind] |= 16;
  421.         return 4;
  422. }
  423.  
  424.  
  425. psrorg()
  426. {
  427.     /* RORG */
  428.  
  429.         if (label[0] != 0) {
  430.                 error(402);
  431.                 return 4;
  432.         }
  433.  
  434.         prflg = 7;
  435.         if (opnptr == 0) {
  436.                 newpc = pc = 0l;
  437.                 return 4;
  438.         }
  439.  
  440.         rflg = 1;
  441.         procop(&opnptr);
  442.         if (opnwc == 7) {
  443.                 error(403);
  444.                 return 4;
  445.         }
  446.  
  447.         rflg = 0;
  448.     pc   = 0l;
  449.         newpc = asn(opnwrd[2],opnwrd[3]);
  450.  
  451.         if (endval == 0l)
  452.                 endval = newpc;
  453.  
  454.         return 4;
  455. }
  456.  
  457.  
  458. pspage()
  459. {
  460.     /* PAGE */
  461.  
  462.         if (label[0] != 0) {
  463.                 error(402);
  464.                 return 4;
  465.         }
  466.  
  467.         no_list = TRUE;
  468.         prflg = 9;
  469.         return 4;
  470. }
  471.  
  472.  
  473. pslist()
  474. {
  475.     /* LIST */
  476.  
  477.         if (label[0] != 0) {
  478.                 error(402);
  479.                 return 4;
  480.         }
  481.  
  482.         no_list = FALSE;
  483.         prflg = 5;
  484.         return 4;
  485. }
  486.  
  487.  
  488. psnlst()
  489. {
  490.     /* NLIST */
  491.  
  492.         if (label[0] != 0) {
  493.                 error(402);
  494.                 return 4;
  495.         }
  496.  
  497.         no_list = TRUE;
  498.         prflg = 5;
  499.         return 4;
  500. }
  501.  
  502.  
  503. psnam()
  504. {
  505.     /* NAM */
  506.  
  507.     int    i, n;
  508.  
  509.         prflg = 5;
  510.         if (label[0] != 0) {
  511.                 error(402);
  512.                 return 4;
  513.         }
  514.  
  515.         for (n = 0, i = opnptr; i < opnptr+8; ++n,++i) {
  516.                 name[n] = srclne[i];
  517.                 if (!srclne[i])
  518.                         break;
  519.         }
  520.  
  521.         name[n] = EOS;
  522.         return 4;
  523. }
  524.