home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 346_02 / m16adr.c < prev    next >
C/C++ Source or Header  |  1991-02-10  |  3KB  |  194 lines
  1. /* m16adr.c */
  2.  
  3. /*
  4.  * (C) Copyright 1991
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <setjmp.h>
  14. #include "asm.h"
  15. #include "m6816.h"
  16.  
  17. int
  18. addr(esp)
  19. register struct expr *esp;
  20. {
  21.     register c;
  22.     register struct area *espa;
  23.     register char *tcp;
  24.  
  25.     if ((c = getnb()) == '#') {
  26.         expr(esp, 0);
  27.         esp->e_mode = T_IMM;
  28.     } else
  29.     if (c == ',') {
  30.         esp->e_mode = 0;
  31.         esp->e_flag = 0;
  32.         esp->e_addr = 0;
  33.         esp->e_mode = 0;
  34.         esp->e_base.e_ap = NULL;
  35.         c = admode(xyz);
  36.         if (c && T_INDX) {
  37.             esp->e_mode = c;
  38.         } else {
  39.             aerr();
  40.         }
  41.     } else {
  42.         unget(c);
  43.         if(admode(e) != 0) {
  44.             comma();
  45.             esp->e_mode = 0;
  46.             esp->e_flag = 0;
  47.             esp->e_addr = 0;
  48.             esp->e_mode = 0;
  49.             esp->e_base.e_ap = NULL;
  50.             c = admode(xyz);
  51.             if (c && T_INDX) {
  52.                 esp->e_mode = T_E_I | (c & 0x30);
  53.             } else {
  54.                 aerr();
  55.             }
  56.         } else {
  57.             expr(esp, 0);
  58.             esp->e_mode = T_EXT;
  59.             if (more()) {
  60.                 comma();
  61.                 tcp = ip;
  62.                 if ((c = admode(xyz)) != 0) {
  63.                     if (c && T_INDX) {
  64.                         esp->e_mode = c;
  65.                     } else {
  66.                         aerr();
  67.                     }
  68.                 } else {
  69.                     ip = --tcp;
  70.                 }
  71.             }
  72.         }
  73.     }
  74.     return (esp->e_mode);
  75. }
  76.     
  77. /*
  78.  * Enter admode() to search a specific addressing mode table
  79.  * for a match. Return the addressing value on a match or
  80.  * zero for no match.
  81.  */
  82. int
  83. admode(sp)
  84. register struct adsym *sp;
  85. {
  86.     register char *ptr;
  87.     register int i;
  88.     unget(getnb());
  89.     i = 0;
  90.     while ( *(ptr = (char *) &sp[i]) ) {
  91.         if (srch(ptr)) {
  92.             return(sp[i].a_val);
  93.         }
  94.         i++;
  95.     }
  96.     return(0);
  97. }
  98.  
  99. /*
  100.  *      srch --- does string match ?
  101.  */
  102. int
  103. srch(str)
  104. register char *str;
  105. {
  106.     register char *ptr;
  107.     ptr = ip;
  108.  
  109. #if    CASE_SENSITIVE
  110.     while (*ptr && *str) {
  111.         if(*ptr != *str)
  112.             break;
  113.         ptr++;
  114.         str++;
  115.     }
  116.     if (*ptr == *str) {
  117.         ip = ptr;
  118.         return(1);
  119.     }
  120. #else
  121.     while (*ptr && *str) {
  122.         if(ccase[*ptr] != ccase[*str])
  123.             break;
  124.         ptr++;
  125.         str++;
  126.     }
  127.     if (ccase[*ptr] == ccase[*str]) {
  128.         ip = ptr;
  129.         return(1);
  130.     }
  131. #endif
  132.  
  133.     if (!*str)
  134.         if (any(*ptr," \t\n,];")) {
  135.             ip = ptr;
  136.             return(1);
  137.         }
  138.     return(0);
  139. }
  140.  
  141. /*
  142.  *      any --- does str contain c?
  143.  */
  144. int
  145. any(c,str)
  146. char    c, *str;
  147. {
  148.     while (*str)
  149.         if(*str++ == c)
  150.             return(1);
  151.     return(0);
  152. }
  153.  
  154. struct adsym    xyz[] = {    /* all indexed modes */
  155.     "x",    0x00 | T_INDX,
  156.     "y",    0x10 | T_INDX,
  157.     "z",    0x20 | T_INDX,
  158.     "x8",    0x00 | T_INDX | T_IND8,
  159.     "y8",    0x10 | T_INDX | T_IND8,
  160.     "z8",    0x20 | T_INDX | T_IND8,
  161.     "x16",    0x00 | T_INDX | T_IND16,
  162.     "y16",    0x10 | T_INDX | T_IND16,
  163.     "z16",    0x20 | T_INDX | T_IND16,
  164.     "",    0x00
  165. };
  166.  
  167. struct adsym    e[] = {        /* e register */
  168.     "e",    0x01,
  169.     "",    0x00
  170. };
  171.  
  172. struct adsym    pshm[] = {    /* push on system stack */
  173.     "d",    0x01,
  174.     "e",    0x02,
  175.     "x",    0x04,
  176.     "y",    0x08,
  177.     "z",    0x10,
  178.     "k",    0x20,
  179.     "ccr",    0x40,
  180.     "",    0x00
  181. };
  182.  
  183. struct adsym    pulm[] = {    /* pull from on system stack */
  184.     "ccr",    0x01,
  185.     "k",    0x02,
  186.     "z",    0x04,
  187.     "y",    0x08,
  188.     "x",    0x10,
  189.     "e",    0x20,
  190.     "d",    0x40,
  191.     "",    0x00
  192. };
  193.  
  194.