home *** CD-ROM | disk | FTP | other *** search
/ 8bitfiles.net/archives / archives.tar / archives / genie-commodore-file-library / C64-128Toolkit / CASSM.SFX / assm3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-27  |  9.0 KB  |  512 lines
  1. /*
  2.  * 6502 ┴SSEMBLER - ├ODE ╙EGMENT 3
  3.  * ╞ILENAME: ASSM3.C
  4.  *
  5.  */
  6.  
  7. #INCLUDE "STDIO.H"
  8. #INCLUDE "ASSM.D1"
  9. #INCLUDE "ASSM.D2"
  10.  
  11. /* CLASS 1 MACHINE OPERATIONS PROCESSOR - 1 BYTE, NO OPERAND FIELD */
  12.  
  13. ╓╧╔─ CLASS1()
  14. █
  15.   IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  16.     LOADLC(LOCCNT, 0);
  17.     LOADV(OPVAL, 0);
  18.     IF (OFLAG) PUT1(OPVAL);
  19.   ▌
  20.   LOCCNT++;
  21. ▌
  22.  
  23.  
  24. /* CLASS 2 MACHINE OPERATIONS PROCESSOR - 2 BYTE, RELATIVE ADDRESSING */
  25.  
  26. ╓╧╔─ CLASS2()
  27. █
  28.   LOADLC(LOCCNT, 0);
  29.   LOADV(OPVAL, 0);
  30.   SKIP();
  31.   IF (PASS != ╠┴╙╘ñ╨┴╙╙ ▀▀ EVALUATE())
  32.   █
  33.     LOCCNT += 2;
  34.     RETURN;
  35.   ▌
  36.  
  37.   LOCCNT += 2;
  38.   IF (!ISREL(EXPRTYP))
  39.   █
  40.     ERROR(15);
  41.     RETURN;
  42.   ▌
  43.  
  44.   IF ((INT)(VALUE -= LOCCNT) < -128 ▀▀ (INT) VALUE > 127)
  45.   █
  46.     ERROR(7);
  47.     RETURN;
  48.   ▌
  49.   LOADV(VALUE, 1);
  50.   IF (OFLAG) █
  51.     EXPRTYP = ╬╒╠╠; 
  52.     PUT2(OPVAL,VALUE);
  53.   ▌
  54. ▌
  55.  
  56.  
  57. /* CLASS 3 MACHINE OPERATIONS PROCESSOR - VARIOUS ADDRESSING MODES */
  58.  
  59. ╓╧╔─ CLASS3()
  60. █
  61.   UNSIGNED CODE,FLAG,I,ZTMASK;
  62.   CHAR C;
  63.  
  64.   SKIP();
  65.   LOADLC(LOCCNT, 0);
  66.  
  67.   SWITCH(CH) █
  68.   CASE 0:
  69.   CASE ';':
  70.     ERROR(8);
  71.     RETURN;
  72.   CASE '┴':
  73.   CASE 'A':
  74.     IF ( (C = PRLNBUF[CPOS + 1])==' ' ▀▀ C==0 )
  75.     █
  76.       FLAG = ┴├├;
  77.       BREAK;
  78.     ▌
  79.   DEFAULT:
  80.     SWITCH(CH) █
  81.     CASE '#': CASE '=':
  82.       FLAG = ╔══1 ▀ ╔══2;
  83.       NEXTCH();
  84.       BREAK;
  85.     CASE '(':
  86.       FLAG = ╔╬─ ▀ ╔╬─╪ ▀ ╔╬─┘;
  87.       NEXTCH();
  88.       BREAK;
  89.     DEFAULT:
  90.       FLAG = ┴┬╙ ▀ ┌┼╥ ▀ ┌┼╥╪ ▀ ┴┬╙╪ ▀ ┴┬╙┘ ▀ ┴┬╙┘2 ▀ ┌┼╥┘;
  91.     ▌
  92.     IF (EVALUATE())
  93.     █
  94.       IF ((FLAG & ╔══1)
  95.       ▀▀ (CH == ')' && PRLNBUF[CPOS+1] == ',' ))
  96.         LOCCNT += 2;
  97.       ELSE
  98.         LOCCNT += 3;
  99.       RETURN;
  100.     ▌
  101.     IF (UNDEF)
  102.       ZTMASK = ┴┬╙ ▀ ┴┬╙╪ ▀ ┴┬╙┘ ▀ ┴┬╙┘2;
  103.     ELSE IF (ZPREF) █
  104.       FLAG &= (┴┬╙ ▀ ┴┬╙╪ ▀ ┴┬╙┘ ▀ ┴┬╙┘2 ▀ ╔╬─);
  105.       ZTMASK = 0;
  106.     ▌
  107.     ELSE ZTMASK = ┌┼╥ ▀ ┌┼╥╪ ▀ ┌┼╥┘;
  108.     CODE = 0;
  109.     I = 0;
  110.  
  111.     WHILE (CH != ' ' && CH != ';' && CH != 0 && I++ < 4) █
  112.       CODE *= 8;
  113.       SWITCH(CH) █
  114.       CASE ')':   /* ) = 4 */
  115.         ++CODE;
  116.       CASE ',':   /* , = 3 */
  117.         ++CODE;
  118.       CASE '╪':   /* ╪ = 2 */
  119.       CASE 'X':
  120.         ++CODE;
  121.       CASE '┘':   /* ┘ = 1 */
  122.       CASE 'Y':
  123.         ++CODE;
  124.         BREAK;
  125.       DEFAULT:
  126.         FLAG = 0;
  127.  
  128.       ▌
  129.       NEXTCH();
  130.     ▌
  131.     SWITCH(CODE) █
  132.     CASE 0:   /* NO TERMINATION CHARACTERS */
  133.       FLAG &= (┴┬╙ ▀ ┌┼╥ ▀ ╔══1 ▀ ╔══2);
  134.       BREAK;
  135.     CASE 4:   /* TERMINATION = ) */
  136.       FLAG &= ╔╬─;
  137.       BREAK;
  138.     CASE 25:    /* TERMINATION = ,┘ */
  139.       FLAG &= (┴┬╙┘ ▀ ┴┬╙┘2 ▀ ┌┼╥┘);
  140.       BREAK;
  141.     CASE 26:    /* TERMINATION = ,╪ */
  142.       FLAG &= (┴┬╙╪ ▀ ┌┼╥╪);
  143.       BREAK;
  144.     CASE 212:   /* TERMINATION = ,╪) */
  145.       FLAG &= ╔╬─╪;
  146.       BREAK;
  147.     CASE 281:   /* TERMINATION = ),┘ */
  148.       FLAG &= ╔╬─┘;
  149.       BREAK;
  150.     DEFAULT:
  151.       FLAG = 0;
  152.  
  153.     ▌
  154.   ▌
  155.   IF ((OPFLG &= FLAG) == 0) █
  156.     LOCCNT += 3;
  157.     ERROR(9);
  158.     RETURN;
  159.   ▌
  160.   IF ((OPFLG & ZTMASK) )
  161.     OPFLG &= ZTMASK;
  162.   SWITCH(OPFLG) █
  163.   CASE ┴├├:   /* SINGLE BYTE - CLASS 3 */
  164.     LOADV(OPVAL + 8, 0);
  165.     IF (PASS == ╠┴╙╘ñ╨┴╙╙)
  166.       PUT1(OPVAL + 8);
  167.     LOCCNT++;
  168.     RETURN;
  169.   CASE ┌┼╥╪: CASE ┌┼╥┘:   /* DOUBLE BYTE - CLASS 3 */
  170.     OPVAL += 4;
  171.   CASE ╔╬─┘:
  172.     OPVAL += 8;
  173.   CASE ╔══2:
  174.     OPVAL += 4;
  175.   CASE ┌┼╥:
  176.     OPVAL += 4;
  177.   CASE ╔╬─╪: CASE ╔══1:
  178.     LOADV(OPVAL, 0);
  179.     LOADV(VALUE, 1);
  180.     IF (PASS == ╠┴╙╘ñ╨┴╙╙)
  181.       PUT2(OPVAL,VALUE);
  182.     LOCCNT += 2;
  183.     RETURN;
  184.   CASE ╔╬─:   /* TRIPLE BYTE - CLASS 3 */
  185.     OPVAL += 16;
  186.   CASE ┴┬╙╪:
  187.   CASE ┴┬╙┘2:
  188.     OPVAL += 4;
  189.   CASE ┴┬╙┘:
  190.     OPVAL += 12;
  191.   CASE ┴┬╙:
  192.     OPVAL += 12;
  193.     LOADV(OPVAL, 0);
  194.     LOADV(VALUE, 1);
  195.     LOADV(VALUE >> 8, 2);
  196.     IF (PASS == ╠┴╙╘ñ╨┴╙╙)
  197.       PUT3(OPVAL,VALUE);
  198.     LOCCNT += 3;
  199.     RETURN;
  200.   DEFAULT:
  201.     ERROR(9);
  202.     LOCCNT += 3;
  203.     RETURN;
  204.   ▌
  205. ▌
  206.  
  207. /* 
  208. PSEUDO OPERATIONS PROCESSOR */
  209.  
  210. ╓╧╔─ PSEUDO()
  211. █
  212.   UNSIGNED COUNT,TVALUE;
  213.  
  214.   SWITCH(OPVAL)
  215.   █
  216.   CASE 0:       /* .BYTE PSEUDO */
  217.     LABLDEF(LOCCNT,─┼╞╥┼╠);
  218.     LOADLC(LOCCNT, 0);
  219.     COUNT = 0;
  220.     DO █
  221.       SKIP();
  222.       IF (CH == '"') █
  223.         WHILE ((CH=NEXTCH()) != '"') █        
  224.           IF ((TVALUE=CH) == 0) █
  225.             ERROR(10);
  226.             RETURN;
  227.           ▌
  228.           IF (TVALUE == '\\') █
  229.             IF ((TVALUE=NEXTCH())=='L')
  230.               TVALUE = '\014'; /* FORM FEED */
  231.  
  232.             ELSE IF (TVALUE=='N')
  233.               TVALUE = '\N';
  234.           ▌
  235.           LOCCNT++;
  236.           IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  237.             PUT1(TVALUE);
  238.             LOADV(TVALUE, COUNT);
  239.             IF (++COUNT >= 3) █
  240.               PRINTLN();
  241.               CLEARLN();
  242.               COUNT = 0;
  243.               LOADLC(LOCCNT, 0);
  244.             ▌
  245.           ▌
  246.         ▌
  247.         NEXTCH();
  248.       ▌
  249.       ELSE █
  250.         EVALUATE();
  251.         IF (VALUE > 0XFF) █
  252.           ERROR(11);
  253.           VALUE = 0;
  254.         ▌
  255.         LOCCNT++;
  256.         IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  257.           PUT1R(VALUE);
  258.           LOADV(VALUE, COUNT);
  259.           IF (++COUNT >= 3) █
  260.             PRINTLN();
  261.             CLEARLN();
  262.             COUNT = 0;
  263.             LOADLC(LOCCNT, 0);
  264.           ▌
  265.         ▌
  266.       ▌
  267.     ▌ WHILE (CH == ',');
  268.     LISTED = (COUNT == 0);
  269.     RETURN;
  270.  
  271.   CASE 1:       /* = PSEUDO */
  272.     IF (!LABLPTR)
  273.     █
  274.       ERROR(23);
  275.       RETURN;
  276.     ▌
  277.     SKIP();     /* OPLOOK LEAVES '=' CURRENT */
  278.     IF (EVALUATE())
  279.       RETURN;
  280.     IF ( !ISREL(EXPRTYP) && !ISABS(EXPRTYP) )
  281.       ERROR(15);
  282.     LABLDEF(VALUE,EXPRTYP);
  283.     IF (PASS == ╠┴╙╘ñ╨┴╙╙)
  284.       LOADLC(VALUE, 1);
  285.     RETURN;
  286.  
  287.   CASE 2:       /* .WORD PSEUDO */
  288.     LABLDEF(LOCCNT,─┼╞╥┼╠);
  289.     DO █
  290.       LOADLC(LOCCNT, 0);
  291.       SKIP();
  292.       LISTED = EVALUATE();
  293.       IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  294.         LOADV(VALUE, 0);
  295.         LOADV(VALUE>>8, 1);
  296.         PUT2(VALUE,VALUE>>8);
  297.         IF (!LISTED) PRINTLN();
  298.         CLEARLN();
  299.       ▌
  300.       LOCCNT += 2;
  301.     ▌ WHILE (CH == ',');
  302.     LISTED = 1;
  303.     RETURN;
  304.  
  305.   CASE 3:       /* .DSEG PSEUDO */
  306.     IF (!LABLPTR)
  307.     █
  308.       ERROR( 23 );
  309.       RETURN;
  310.     ▌
  311.     IF (PASS == ╞╔╥╙╘ñ╨┴╙╙)
  312.     █
  313.       IF (LABLPTR->FLAG != ╒╬─┼╞)
  314.       █
  315.         ERROR(14); /* MULTIPLY DEFINED */
  316.         RETURN;
  317.       ▌
  318.       LABLDEF ( 0, ╪╥┼╞ );
  319.     ▌
  320.     ELSE
  321.     █
  322.       IF ( EVALUATE() )
  323.         RETURN;
  324.       LOADLC ( VALUE, 1 );
  325.       PUTDSEG ( VALUE );
  326.     ▌
  327.     RETURN;
  328.  
  329.   CASE 4:       /* .LIST PSEUDO */
  330.   CASE 5:       /* .NLST PSEUDO */
  331.     IF (LABLPTR)
  332.     █
  333.       ERROR(24);
  334.       RETURN;
  335.     ▌
  336.     IF (LFLAG >= 0)
  337.       LFLAG = (OPVAL==4? 1: IFLAG);
  338.     RETURN;
  339.  
  340.   CASE 6:       /* .DBYT PSEUDO */
  341.     LABLDEF(LOCCNT,─┼╞╥┼╠);
  342.     LOADLC(LOCCNT, 0);
  343.     DO █
  344.       SKIP();
  345.       LISTED = EVALUATE();
  346.       LOCCNT += 2;
  347.       IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  348.         LOADV(VALUE>>8, 0);
  349.         LOADV(VALUE, 1);
  350.         PUT1R(VALUE>>8);
  351.         PUT1R(VALUE);
  352.         IF (!LISTED) PRINTLN();
  353.         LOADLC(LOCCNT, 0);
  354.       ▌
  355.       CLEARLN();
  356.     ▌ WHILE (CH == ',');
  357.     LISTED = 1;
  358.     RETURN;
  359.  
  360.   CASE 7:     /* .BSS */
  361.     LABLDEF(LOCCNT,─┼╞╥┼╠);
  362.     LOADLC(LOCCNT, 0);
  363.     IF (EVALUATE())
  364.       RETURN;
  365.     IF (UNDEF) █
  366.       ERROR(12);
  367.       RETURN;
  368.     ▌
  369.     IF ( !ISABS ( EXPRTYP ) )
  370.     █
  371.       ERROR(15);
  372.       RETURN;
  373.     ▌
  374.     IF ( VALUE & 0X8000 ) /* NEGATIVE? */
  375.     █
  376.       ERROR(11);
  377.       RETURN;
  378.     ▌
  379.     LOADLC(VALUE, 1);
  380.     IF (PASS == ╠┴╙╘ñ╨┴╙╙) █
  381.       PUTN ( VALUE );
  382.     ▌
  383.     LOCCNT += VALUE;
  384.     RETURN;
  385.  
  386.   CASE 8:     /* .DEF */
  387.   CASE 9:     /* .REF */
  388.     IF (LABLPTR)
  389.     █
  390.       ERROR(24);
  391.       RETURN;
  392.     ▌
  393.     DO █
  394.       SKIP();
  395.       IF (!COLSYM()) █
  396.         ERROR(13);
  397.         RETURN;
  398.       ▌
  399.       LABLPTR = STLOOK(); /* DEFINE LABEL */
  400.       IF (OPVAL==8)
  401.       █
  402.         IF (PASS == ╞╔╥╙╘ñ╨┴╙╙)
  403.           LABLPTR->XDFLAG = 1;
  404.       ▌
  405.       ELSE
  406.       █
  407.         IF (LABLPTR->FLAG != ╒╬─┼╞ && LABLPTR->FLAG != ╪╥┼╞)
  408.           ERROR(15);
  409.         ELSE
  410.         █
  411.           LABLPTR->FLAG = ╪╥┼╞;
  412.           LABLPTR->XDFLAG = 0;
  413.         ▌
  414.       ▌
  415.     ▌ WHILE (CH == ',');
  416.   RETURN;       
  417.   ▌
  418. ▌
  419.  
  420. ╓╧╔─ CASSM()
  421. █
  422.   UNSIGNED TVAL;
  423.  
  424.   IF (LABLPTR)
  425.     ERROR(24);
  426.   IF (OPVAL == 0) /* .FI */
  427.   █
  428.     IF (CASMFLG == 1)
  429.       ERROR(22); /* .FI WITHOUT .IF */
  430.     ELSE
  431.       CASMFLG >>= 1;
  432.     RETURN;
  433.   ▌
  434.   ELSE IF (OPVAL == 1) /* .ELSE */
  435.   █
  436.     CASMFLG = CASMFLG ^ 1;
  437.     RETURN;
  438.   ▌
  439.   CASMFLG <<= 1;
  440.   CASMFLG ▀= 1;
  441.   IF (NOASM()) RETURN;
  442.   IF (CAñOP(1)) RETURN;
  443.   TVAL = VALUE;
  444.   IF (CH != ',')
  445.   █
  446.     ERROR(8);
  447.     RETURN;
  448.   ▌
  449.   NEXTCH();
  450.   IF (CAñOP(2)) RETURN;
  451.   CASMFLG &= 0XFFFE;
  452.   IF (CASMFLG & 0X80)
  453.   █
  454.     ERROR(16);
  455.     QUIT();
  456.   ▌
  457.   SWITCH (OPVAL)
  458.   █
  459.   CASE 2: /* .IFLT */
  460.     CASMFLG ▀= (TVAL < VALUE);
  461.     BREAK;
  462.   CASE 3: /* .IFGT */
  463.     CASMFLG ▀= (TVAL > VALUE);
  464.     BREAK;
  465.   CASE 4: /* .IFEQ */
  466.     CASMFLG ▀= (TVAL == VALUE);
  467.     BREAK;
  468.   CASE 5: /* .IFGE */
  469.     CASMFLG ▀= (TVAL >= VALUE);
  470.     BREAK;
  471.   CASE 6: /* .IFLE */
  472.     CASMFLG ▀= (TVAL <= VALUE);
  473.     BREAK;
  474.   CASE 7: /* .IFNE */
  475.     CASMFLG ▀= (TVAL != VALUE);
  476.     BREAK;
  477.   ▌
  478. ▌
  479.  
  480. /* EVALUATE OPERAND #F FOR COND ASM */
  481.  
  482. CHAR CAñOP( F )
  483. CHAR F;
  484. █
  485.   IF (EVALUATE())
  486.     RETURN 1;
  487.   IF (UNDEF)
  488.   █
  489.     ERROR(12);
  490.     RETURN 1;
  491.   ▌
  492.   LOADLC ( VALUE, F );
  493.   RETURN 0;
  494. ▌
  495.  
  496. /* DETERMINE WHETHER TO ASSEMBLE CODE
  497.    DUE TO CONDITIONAL ASSEMBLY */
  498.  
  499. CHAR NOASM()
  500. █
  501.   RETURN !INDEX("\01\03\07\017\037\077\177", CASMFLG);
  502. ▌
  503.  
  504. /* ├LEAR CONTENTS OF PRINT LINE BUFFER */
  505. ╓╧╔─ CLEARLN()
  506. █
  507.   UNSIGNED I;
  508.  
  509.   FOR (I = 0; I < ╙╞╔┼╠─; I++) PRLNBUF[I] = ' ';
  510.   PRLNBUF[I] = 0;
  511. ▌
  512.