home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / language / motasms / do11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  5.4 KB  |  276 lines
  1. /*
  2.  *      MC68HC11 specific processing
  3.  */
  4.  
  5. #define PAGE1   0x00
  6. #define PAGE2   0x18
  7. #define PAGE3   0x1A
  8. #define PAGE4   0xCD
  9.  
  10. /* addressing modes */
  11. #define IMMED   0
  12. #define INDX    1
  13. #define INDY    2
  14. #define LIMMED  3       /* long immediate */
  15. #define OTHER   4
  16.  
  17. int     yflag = 0;      /* YNOIMM, YLIMM, and CPD flag */
  18.  
  19. /*
  20.  *      localinit --- machine specific initialization
  21.  */
  22. localinit()
  23. {
  24. }
  25.  
  26. /*
  27.  *      do_op --- process mnemonic
  28.  *
  29.  *    Called with the base opcode and it's class. Optr points to
  30.  *    the beginning of the operand field.
  31.  */
  32. do_op(opcode,class)
  33. int opcode;    /* base opcode */
  34. int class;    /* mnemonic class */
  35. {
  36.     int     dist;   /* relative branch distance */
  37.     int     amode;  /* indicated addressing mode */
  38.     char    *peek;
  39.  
  40.     /* guess at addressing mode */
  41.     peek = Optr;
  42.     amode = OTHER;
  43.     while( !delim(*peek) && *peek != EOS)  /* check for comma in operand field */
  44.         if( *peek++ == ',' ){
  45.             if( mapdn(*peek) == 'y' )
  46.                 amode = INDY;
  47.             else
  48.                 amode = INDX;
  49.             break;
  50.             }
  51.     if( *Optr == '#' ) amode = IMMED;
  52.  
  53.     yflag = 0;
  54.     switch(class){
  55.         case P2INH:
  56.             emit(PAGE2);
  57.         case INH:                       /* inherent addressing */
  58.             emit(opcode);
  59.             return;
  60.         case REL:                       /* relative branches */
  61.             eval();
  62.             dist = Result - (Pc+2);
  63.             emit(opcode);
  64.             if( (dist >127 || dist <-128) && Pass==2){
  65.                 error("Branch out of Range");
  66.                 emit(lobyte(-2));
  67.                 return;
  68.                 }
  69.             emit(lobyte(dist));
  70.             return;
  71.         case LONGIMM:
  72.             if( amode == IMMED )
  73.                 amode = LIMMED;
  74.         case NOIMM:
  75.             if( amode == IMMED ){
  76.                 error("Immediate Addressing Illegal");
  77.                 return;
  78.                 }
  79.         case GEN:                       /* general addressing */
  80.             do_gen(opcode,amode,PAGE1,PAGE1,PAGE2);
  81.             return;
  82.         case GRP2:
  83.             if( amode == INDY ){
  84.                 Cycles++;
  85.                 emit(PAGE2);
  86.                 amode = INDX;
  87.                 }
  88.             if( amode == INDX )
  89.                 do_indexed(opcode);
  90.             else{   /* extended addressing */
  91.                 eval();
  92.                 emit(opcode+0x10);
  93.                 eword(Result);
  94.                 }
  95.             return;
  96.         case CPD:               /* cmpd */
  97.             if( amode == IMMED )
  98.                 amode = LIMMED;
  99.             if( amode == INDY )
  100.                 yflag=1;
  101.             do_gen(opcode,amode,PAGE3,PAGE3,PAGE4);
  102.             return;
  103.         case XNOIMM:            /* stx */
  104.             if( amode == IMMED ){
  105.                 error("Immediate Addressing Illegal");
  106.                 return;
  107.                 }
  108.         case XLIMM:             /* cpx, ldx */
  109.             if( amode == IMMED )
  110.                 amode = LIMMED;
  111.             do_gen(opcode,amode,PAGE1,PAGE1,PAGE4);
  112.             return;
  113.         case YNOIMM:            /* sty */
  114.             if( amode == IMMED ){
  115.                 error("Immediate Addressing Illegal");
  116.                 return;
  117.                 }
  118.         case YLIMM:             /* cpy, ldy */
  119.             if(amode == INDY)
  120.                 yflag=1;
  121.             if( amode == IMMED )
  122.                 amode = LIMMED;
  123.             do_gen(opcode,amode,PAGE2,PAGE3,PAGE2);
  124.             return;
  125.         case BTB:               /* bset, bclr */
  126.         case SETCLR:            /* brset, brclr */
  127.             opcode = bitop(opcode,amode,class);
  128.  
  129.             if (amode == INDX)
  130.                 Cycles++;
  131.             if( amode == INDY ){
  132.                 Cycles+=2;
  133.                 emit(PAGE2);
  134.                 amode = INDX;
  135.                 }
  136.             emit(opcode);
  137.             eval();
  138.             emit(lobyte(Result));   /* address */
  139.             if( amode == INDX )
  140.                 Optr += 2;      /* skip ,x or ,y */
  141.             eval();
  142.             emit(lobyte(Result));   /* mask */
  143.             if( class == SETCLR )
  144.                 return;
  145.             eval();
  146.             dist = Result - (Pc+1);
  147.             if( (dist >127 || dist <-128) && Pass==2){
  148.                 error("Branch out of Range");
  149.                 dist = Old_pc - (Pc+1);
  150.                 }
  151.             emit(lobyte(dist));
  152.             return;
  153.         default:
  154.             fatal("Error in Mnemonic table");
  155.         }
  156. }
  157.  
  158. /*
  159.  *      bitop --- adjust opcode on bit manipulation instructions
  160.  */
  161. bitop(op,mode,class)
  162. int op;
  163. int mode;
  164. int class;
  165. {
  166.     if( mode == INDX || mode == INDY )
  167.         return(op);
  168.     if( class == SETCLR )
  169.         return(op-8);
  170.     else if(class==BTB)
  171.         return(op-12);
  172.     else
  173.         fatal("bitop");
  174. }
  175.  
  176. /*
  177.  *      do_gen --- process general addressing modes
  178.  */
  179. do_gen(op,mode,pnorm,px,py)
  180. int     op;     /* base opcode */
  181. int     mode;   /* addressing mode */
  182. int     pnorm;  /* page for normal addressing modes: IMM,DIR,EXT */
  183. int     px;     /* page for INDX addressing */
  184. int     py;     /* page for INDY addressing */
  185. {
  186.     switch(mode){
  187.     case LIMMED:
  188.         Optr++;
  189.         epage(pnorm);
  190.         emit(op);
  191.         eval();
  192.         eword(Result);
  193.         break;
  194.     case IMMED:
  195.         Optr++;
  196.         epage(pnorm);
  197.         emit(op);
  198.         eval();
  199.         emit(lobyte(Result));
  200.         break;
  201.     case INDY:
  202.         if(yflag)
  203.             Cycles += 2;
  204.         else
  205.             Cycles += 3;
  206.         epage(py);
  207.         do_indexed(op+0x20);
  208.         break;
  209.     case INDX:
  210.         Cycles+=2;
  211.         epage(px);
  212.         do_indexed(op+0x20);
  213.         break;
  214.     case OTHER:
  215.         eval();
  216.         epage(pnorm);
  217.         if(Force_word){
  218.             emit(op+0x30);
  219.             eword(Result);
  220.             Cycles+=2;
  221.             break;
  222.             }
  223.         if(Force_byte){
  224.             emit(op+0x10);
  225.             emit(lobyte(Result));
  226.             Cycles++;
  227.             break;
  228.             }
  229.         if(Result>=0 && Result <=0xFF){
  230.             emit(op+0x10);
  231.             emit(lobyte(Result));
  232.             Cycles++;
  233.             break;
  234.             }
  235.         else {
  236.             emit(op+0x30);
  237.             eword(Result);
  238.             Cycles+=2;
  239.             break;
  240.             }
  241.         break;
  242.     default:
  243.         error("Unknown Addressing Mode");
  244.     }
  245. }
  246.  
  247. /*
  248.  *      do_indexed --- handle all wierd stuff for indexed addressing
  249.  */
  250. do_indexed(op)
  251. int op;
  252. {
  253.     char c;
  254.  
  255.     emit(op);
  256.     eval();
  257.     if( *Optr++ != ',' )
  258.         error("Syntax");
  259.     c = mapdn(*Optr++);
  260.     if( c != 'x' && c != 'y')
  261.         warn("Indexed Addressing Assumed");
  262.     if( Result < 0 || Result > 255)
  263.         warn("Value Truncated");
  264.     emit(lobyte(Result));
  265. }
  266.  
  267. /*
  268.  *      epage --- emit page prebyte
  269.  */
  270. epage(p)
  271. int p;
  272. {
  273.     if( p != PAGE1 )        /* PAGE1 means no prebyte */
  274.         emit(p);
  275. }
  276.