home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / programs / emulaton / utilities / magicasm / assembler / c / code < prev    next >
Encoding:
Text File  |  1998-04-14  |  7.6 KB  |  407 lines
  1. #include <stdio.h>
  2. #include "defs.h"
  3. #include "externs.h"
  4.  
  5. /* class 1 machine operations processor - 1 byte, no operand field */
  6.  
  7. class1(int *ip)
  8. {
  9.     check_eol(ip);
  10.     if (pass == LAST_PASS) {
  11.         loadlc(loccnt, 0);
  12.         loadv(loccnt, opval, 0);
  13.         println();
  14.     }
  15.     loccnt++;
  16. }
  17.  
  18. /* class 2 machine operations processor - 2 byte, relative addressing */
  19.  
  20. class2(int *ip)
  21. {
  22.     if (pass == LAST_PASS) {
  23.         loadlc(loccnt, 0);
  24.         loadv(loccnt, opval, 0);
  25.         while (isspace(prlnbuf[++(*ip)]));
  26.         if (evaluate(ip, ';')) {
  27.             value -= ((loccnt + 2) + (page << 13));
  28.             if (value >= -128 && value < 128) {
  29.                 loadv(loccnt + 1, value, 1);
  30.                 println();
  31.             } else
  32.                 error("Invalid branch address!");
  33.         }
  34.     }
  35.     loccnt += 2;
  36. }
  37.  
  38. /* class 3 machine operations processor - 2 byte, inherent addressing */
  39.  
  40. class3(int *ip)
  41. {
  42.     check_eol(ip);
  43.     if (pass == LAST_PASS) {
  44.         loadlc(loccnt, 0);
  45.         loadv(loccnt, opval, 0);
  46.         loadv(loccnt+1, optype, 1);
  47.         println();
  48.     }
  49.     loccnt += 2;
  50. }
  51.  
  52. /* class 4 machine operations processor - various addressing modes */
  53.  
  54. class4(int *ip)
  55. {
  56.     char c;
  57.     int    code;
  58.     int    flag;
  59.     int    i;
  60.     int temp;
  61.  
  62.     while (isspace(c = prlnbuf[++(*ip)]));
  63.     switch(c) {
  64.     case '\0':
  65.     case ';':
  66.         error("Operand field missing!");
  67.         return;
  68.     case 'A':
  69.     case 'a':
  70.         if ((c = prlnbuf[*ip + 1]) == ' ' || c == 0 || c == '\t') {
  71.             flag = ACC;
  72.             break;
  73.         }
  74.     default:
  75.         switch(c = prlnbuf[*ip]) {
  76.         case '#':
  77.             flag = IMM;
  78.             ++(*ip);
  79.             break;
  80.         case '<':
  81.             flag = ZP | ZP_X | ZP_Y;
  82.             ++(*ip);
  83.             break;
  84.         case '[':
  85.             flag = ABS_IND | ABS_IND_X | ZP_IND | ZP_IND_X | ZP_IND_Y;
  86.             ++(*ip);
  87.             break;
  88.         default:
  89.             flag = ABS | ABS_X | ABS_Y;
  90.         }
  91.         if (!evaluate(ip, 0))
  92.             return;
  93.  
  94.         /* --  range checking. */
  95.  
  96.         if (flag & (ZP | ZP_X | ZP_Y | ZP_IND | ZP_IND_X | ZP_IND_Y) & opflg) {
  97.             if ((value & 0xFFFFFF00) && ((value & 0xFFFFFF00) != 0x2000)) {
  98.                 error("Zero page index out of range!");
  99.                 return;
  100.             }
  101.         } else if (flag & (IMM) & opflg) {
  102.             if ((value > 0xFF) && (value < 0xFFFFFF00)) {
  103.                 error("Immediate value out of range!");
  104.                 return;
  105.             }
  106.         } else if (flag & (ABS | ABS_X | ABS_Y | ABS_IND | ABS_IND_X) & opflg) {
  107.             if (value & 0xFFFF0000) {
  108.                 error("Address out of range!");
  109.                 return;
  110.             }
  111.         }
  112.         code = 0;
  113.         while (c = prlnbuf[(*ip)++]) {
  114.             if (c == ';')
  115.                 break;
  116.             if (!isspace(c))
  117.                 code *= 8;
  118.             switch(c) {
  119.             case ']':        /* ] = 4 */
  120.                 ++code;
  121.             case ',':        /* , = 3 */
  122.                 ++code;
  123.             case 'X':        /* X = 2 */
  124.             case 'x':
  125.                 ++code;
  126.             case 'Y':        /* Y = 1 */
  127.             case 'y':
  128.                 ++code;
  129.             case ' ':
  130.             case '\t':
  131.                 break;
  132.             default:
  133.                 flag = 0;
  134.             }
  135.         }
  136.         switch(code) {
  137.         case 0:            /* no termination characters */
  138.             flag &= (ABS | ZP | IMM);
  139.             break;
  140.         case 4:            /* termination = ] */
  141.             flag &= (ZP_IND | ABS_IND);
  142.             break;
  143.         case 25:        /* termination = ,Y */
  144.             flag &= (ABS_Y | ZP_Y);
  145.             break;
  146.         case 26:        /* termination = ,X */
  147.             flag &= (ABS_X | ZP_X);
  148.             break;
  149.         case 212:        /* termination = ,X] */
  150.             flag &= (ZP_IND_X | ABS_IND_X);
  151.             break;
  152.         case 281:        /* termination = ],Y */
  153.             flag &= ZP_IND_Y;
  154.             break;
  155.         default:
  156.             flag = 0;
  157.         }
  158.     }
  159.     opflg &= flag;
  160.  
  161.     i = 0;
  162.     temp = opflg;
  163.     while (temp >>= 1)
  164.         i++;
  165.     opval += opvaltab[optype][i];
  166.  
  167.     switch(opflg) {
  168.     case ACC:        /* single byte - class 4 */
  169.         if (pass == LAST_PASS) {
  170.             loadlc(loccnt, 0);
  171.             loadv(loccnt, opval, 0);
  172.             println();
  173.         }
  174.         loccnt++;
  175.         return;
  176.     case IMM:        /* double byte - class 4 */
  177.     case ZP:
  178.     case ZP_X:
  179.     case ZP_Y:
  180.     case ZP_IND:
  181.     case ZP_IND_X:
  182.     case ZP_IND_Y:
  183.         if (pass == LAST_PASS) {
  184.             loadlc(loccnt, 0);
  185.             loadv(loccnt, opval, 0);
  186.             loadv(loccnt+1, value & 0xFF, 1);
  187.             println();
  188.         }
  189.         loccnt += 2;
  190.         return;
  191.     case ABS:        /* triple byte - class 4 */
  192.     case ABS_X:
  193.     case ABS_Y:
  194.     case ABS_IND:
  195.     case ABS_IND_X:
  196.         if (pass == LAST_PASS) {
  197.             loadlc(loccnt, 0);
  198.             loadv(loccnt,   opval, 0);
  199.             loadv(loccnt+1, value, 1);
  200.             loadv(loccnt+2, value >> 8, 2);
  201.             println();
  202.         }
  203.         loccnt += 3;
  204.         return;
  205.     default:
  206.         error("Invalid addressing mode!");
  207.         return;
  208.     }
  209. }
  210.  
  211. /* class 5 machine operations processor - 3 bytes, zp/relative addressing */
  212.  
  213. class5(int *ip)
  214. {
  215.     char c;
  216.     int    zp;
  217.  
  218.     while (isspace(c = prlnbuf[(*ip)++]));
  219.     if (c != '<') {
  220.         error("Invalid addressing mode!");
  221.         return;
  222.     }
  223.     if (!evaluate(ip, ','))
  224.         return;
  225.     zp = value;
  226.     if (!evaluate(ip, ';'))
  227.         return;
  228.     if (pass == LAST_PASS) {
  229.         if ((zp & 0xFFFFFF00) && ((zp & 0xFFFFFF00) != 0x2000))
  230.             error("Zero page index out of range!");
  231.         else {
  232.             loadlc(loccnt, 0);
  233.             loadv(loccnt, opval, 0);
  234.             loadv(loccnt + 1, zp & 0xFF, 1);
  235.             value  -= ((loccnt + 3) + (page << 13));
  236.             if (value >= -128 && value < 128) {
  237.                 loadv(loccnt + 2, value, 2);
  238.                 println();
  239.             } else
  240.                 error("Invalid branch address!");
  241.         }
  242.     }
  243.     loccnt += 3;
  244. }
  245.  
  246. /* class 6 machine operations processor - 7 bytes, src/dest/length */
  247.  
  248. class6(int *ip)
  249. {
  250.     char c;
  251.     int     i, j, temp[3];
  252.  
  253.     for (i = 0; i < 3; i++) {
  254.         if (!evaluate(ip, 0))
  255.             return;
  256.         temp[i] = value;
  257.         if (i == 2)
  258.             check_eol(ip);
  259.         else {
  260.             if (prlnbuf[(*ip)++] != ',') {
  261.                 error("Syntax error!");
  262.                 return;
  263.             }
  264.         }
  265.     }
  266.     if (pass == LAST_PASS) {
  267.         for (i = 0; i < 3; i++) {
  268.             if (temp[i] & 0xFFFF0000) {
  269.                 error("Number out of range!");
  270.                 loccnt += 7;
  271.                 return;
  272.             }
  273.         }
  274.         loadlc(loccnt, 0);
  275.         loadv(loccnt, opval, 0);
  276.         loadv(loccnt + 1,  temp[0] & 0xFF, 1);
  277.         loadv(loccnt + 2, (temp[0] & 0xFF00) >> 8, 2);
  278.         println(); clearln();
  279.         loadlc(loccnt + 3, 0);
  280.         loadv(loccnt + 3,  temp[1] & 0xFF, 0);
  281.         loadv(loccnt + 4, (temp[1] & 0xFF00) >> 8, 1);
  282.         loadv(loccnt + 5,  temp[2] & 0xFF, 2);
  283.         println(); clearln();
  284.         loadlc(loccnt + 6, 0);
  285.         loadv(loccnt + 6, (temp[2] & 0xFF00) >> 8, 0);
  286.         println();
  287.     }
  288.     loccnt += 7;
  289. }
  290.  
  291. /* class 7 machine operations processor - TST instruction */
  292.  
  293. class7(int *ip)
  294. {
  295.     char c;
  296.     int     code, imm;
  297.  
  298.     while (isspace(c = prlnbuf[(*ip)++]));
  299.     if (c != '#') {
  300.         error("Invalid addressing mode!");
  301.         return;
  302.     }
  303.     if (!evaluate(ip, ','))
  304.         return;
  305.     imm = value;
  306.     if (prlnbuf[*ip] != '<')
  307.         opval = 0x93;
  308.     else {
  309.         (*ip)++;
  310.         opval = 0x83;
  311.     }
  312.     if (!evaluate(ip, 0))
  313.         return;
  314.     code = 0;
  315.     while (c = prlnbuf[(*ip)++]) {
  316.         if (c == ';')
  317.             break;
  318.         if (!isspace(c))
  319.             code *= 4;
  320.         switch(c) {
  321.         case ',':        /* , = 2 */
  322.             code++;
  323.         case 'X':        /* X = 1 */
  324.         case 'x':
  325.             code++;
  326.             break;
  327.         case ' ':
  328.         case '\t':
  329.             break;
  330.         }
  331.     }
  332.     switch (code) {
  333.     case 0:
  334.         break;
  335.     case 9:
  336.         opval += 0x20;
  337.         break;
  338.     default:
  339.         error("Syntax error!");
  340.         return;
  341.     }
  342.     switch (opval & 0x93) {
  343.     case 0x83:
  344.         if (pass == LAST_PASS) {
  345.             if ((value & 0xFFFFFF00) && ((value & 0xFFFFFF00) != 0x2000))
  346.                 error("Zero page index out of range!");
  347.             else if (imm & 0xFFFFFF00)
  348.                 error("Immediate value out of range!");
  349.             else {
  350.                 loadlc(loccnt, 0);
  351.                 loadv(loccnt, opval, 0);
  352.                 loadv(loccnt + 1,  imm, 1);
  353.                 loadv(loccnt + 2,  value & 0xFF, 2);
  354.                 println();
  355.             }
  356.         }
  357.         loccnt += 3;
  358.         break;
  359.     case 0x93:
  360.         if (pass == LAST_PASS) {
  361.             if (value & 0xFFFF0000)
  362.                 error("Address out of range!");
  363.             else if (imm & 0xFFFFFF00)
  364.                 error("Immediate value out of range!");
  365.             else {
  366.                 loadlc(loccnt, 0);
  367.                 loadv(loccnt, opval, 0);
  368.                 loadv(loccnt + 1, imm, 1);
  369.                 loadv(loccnt + 2, value & 0xFF, 2);
  370.                 println(); clearln();
  371.                 loadlc(loccnt + 3, 0);
  372.                 loadv(loccnt + 3, (value & 0xFF00) >> 8, 0);
  373.                 println();
  374.             }
  375.         }
  376.         loccnt += 4;
  377.         break;
  378.     }
  379. }
  380.  
  381. /* class 8 machine operations processor - TAM/TMA instruction */
  382.  
  383. class8(int *ip)
  384. {
  385.     char c;
  386.  
  387.     while (isspace(c = prlnbuf[(*ip)++]));
  388.     if (c != '#') {
  389.         error("Invalid addressing mode!");
  390.         return;
  391.     }
  392.     if (!evaluate(ip, ';'))
  393.         return;
  394.     if (pass == LAST_PASS) {
  395.         if (value & 0xFFFFFFF8)
  396.             error("Page index out of range!");
  397.         else {
  398.             loadlc(loccnt, 0);
  399.             loadv(loccnt, opval, 0);
  400.             loadv(loccnt + 1, (1 << value), 1);
  401.             println();
  402.         }
  403.     }
  404.     loccnt += 2;
  405. }
  406.  
  407.