home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / progasm / asca11.arj / ASSYM.C < prev    next >
C/C++ Source or Header  |  1990-11-23  |  4KB  |  252 lines
  1. /* assym.c */
  2.  
  3. /*
  4.  * (C) Copyright 1989,1990
  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 <string.h>
  15. #include <alloc.h>
  16. #include "asm.h"
  17.  
  18. /*
  19.  * This routine is called early in the
  20.  * game to set up the hashtables. First
  21.  * all buckets in a table are cleared.
  22.  * Then a pass is made through the respective
  23.  * symbol lists, linking them into their hash
  24.  * buckets. Finally the area list and
  25.  * 'dca' are set up.
  26.  */
  27. VOID
  28. syminit()
  29. {
  30.     register struct mne  *mp;
  31.     struct mne **mpp;
  32.     register struct sym  *sp;
  33.     struct sym **spp;
  34.     register h;
  35.  
  36.     mpp = &mnehash[0];
  37.     while (mpp < &mnehash[NHASH])
  38.         *mpp++ = NULL;
  39.     mp = &mne[0];
  40.     for (;;) {
  41.         h = hash(mp->m_id);
  42.         mp->m_mp = mnehash[h];
  43.         mnehash[h] = mp;
  44.         if (mp->m_flag&S_END)
  45.             break;
  46.         ++mp;
  47.     }
  48.  
  49.     spp = &symhash[0];
  50.     while (spp < &symhash[NHASH])
  51.         *spp++ = NULL;
  52.     sp = &sym[0];
  53.     for (;;) {
  54.         h = hash(sp->s_id);
  55.         sp->s_sp = symhash[h];
  56.         symhash[h] = sp;
  57.         if (sp->s_flag&S_END)
  58.             break;
  59.         ++sp;
  60.     }
  61.  
  62.     areap = &dca;
  63. }
  64.  
  65. /*
  66.  * Lookup the area `id'.
  67.  */
  68. struct area *
  69. alookup(id)
  70. char *id;
  71. {
  72.     register struct area *ap;
  73.  
  74.     ap = areap;
  75.     while (ap) {
  76.         if (symeq(id, ap->a_id)) {
  77.             return (ap);
  78.         }
  79.         ap = ap->a_ap;
  80.     }
  81.     return(NULL);
  82. }
  83.  
  84. /*
  85.  * Lookup the mnemonic (or directive) `id' in the hashtable.
  86.  * If it is not found return a NULL.
  87.  */
  88. struct mne *
  89. mlookup(id)
  90. char *id;
  91. {
  92.     register struct mne *mp;
  93.     register h;
  94.  
  95.     h = hash(id);
  96.     mp = mnehash[h];
  97.     while (mp) {
  98.         if (symeq(id, mp->m_id))
  99.             return (mp);
  100.         mp = mp->m_mp;
  101.     }
  102.     return (NULL);
  103. }
  104.  
  105. /*
  106.  * Lookup the label `id' in the hashtable.
  107.  * If it is not found return a
  108.  * pointer to a newly created hash table
  109.  * entry.
  110.  */
  111. struct sym *
  112. lookup(id)
  113. char *id;
  114. {
  115.     register struct sym *sp;
  116.     register h;
  117.  
  118.     h = hash(id);
  119.     sp = symhash[h];
  120.     while (sp) {
  121.         if (symeq(id, sp->s_id))
  122.             return (sp);
  123.         sp = sp->s_sp;
  124.     }
  125.     sp = (struct sym *) new (sizeof(struct sym));
  126.     sp->s_sp = symhash[h];
  127.     symhash[h] = sp;
  128.     sp->s_tsym = NULL;
  129.     strncpy(sp->s_id, id, NCPS);
  130.     sp->s_type = S_NEW;
  131.     sp->s_flag = 0;
  132.     sp->s_area = NULL;
  133.     sp->s_ref = 0;
  134.     sp->s_addr = 0;
  135.     return (sp);
  136. }
  137.  
  138. /*
  139.  * Mark all symbols of type `S_NEW' global.
  140.  * Called at the beginning of pass 1 if '-g'.
  141.  */
  142. VOID
  143. symglob()
  144. {
  145.     register struct sym *sp;
  146.     register i;
  147.  
  148.     for (i=0; i<NHASH; ++i) {
  149.         sp = symhash[i];
  150.         while (sp != NULL) {
  151.             if (sp->s_type == S_NEW)
  152.                 sp->s_flag |= S_GBL;
  153.             sp = sp->s_sp;
  154.         }
  155.     }
  156. }
  157.  
  158. /*
  159.  * Mark all symbols of type `S_USER' global.
  160.  * Called at the beginning of pass 1 if '-a'.
  161.  */
  162. VOID
  163. allglob()
  164. {
  165.     register struct sym *sp;
  166.     register i;
  167.  
  168.     for (i=0; i<NHASH; ++i) {
  169.         sp = symhash[i];
  170.         while (sp != NULL) {
  171.             if (sp != &dot && sp->s_type == S_USER)
  172.                 sp->s_flag |= S_GBL;
  173.             sp = sp->s_sp;
  174.         }
  175.     }
  176. }
  177.  
  178. /*
  179.  * Compare two symbol names.
  180.  */
  181. int
  182. symeq(p1, p2)
  183. register char *p1, *p2;
  184. {
  185.     register n;
  186.  
  187.     n = NCPS;
  188.     do {
  189.  
  190. #if    CASE_SENSITIVE
  191.         if (*p1++ != *p2++)
  192.             return (0);
  193. #else
  194.         if (ccase[*p1++] != ccase[*p2++])
  195.             return (0);
  196. #endif
  197.  
  198.     } while (--n);
  199.     return (1);
  200. }
  201.  
  202. /*
  203.  * Given a pointer to a symbol name
  204.  * compute and return the hash table
  205.  * bucket.
  206.  * The `sum of all the characters mod
  207.  * table size' algorithm is perhaps
  208.  * not the best.
  209.  */
  210. int
  211. hash(p)
  212. register char *p;
  213. {
  214.     register h, n;
  215.  
  216.     h = 0;
  217.     n = NCPS;
  218.     do {
  219.  
  220. #if    CASE_SENSITIVE
  221.         h += *p++;
  222. #else
  223.         h += ccase[*p++];
  224. #endif
  225.  
  226.     } while (--n);
  227.     return (h&HMASK);
  228. }
  229.  
  230. /*
  231.  * Allocate a block of space.
  232.  * Leave if there is no space left
  233.  * at all.
  234.  */
  235. VOID *
  236. new(n)
  237. unsigned int n;
  238. {
  239.     register VOID *p;
  240.  
  241.     if ((p = (VOID *) malloc(n)) == NULL) {
  242.         fprintf(stderr, "Out of space!\n");
  243.         exit(1);
  244.     }
  245.     return (p);
  246. }
  247. ;
  248.         }
  249.     }
  250.     if (xflag == 0) {
  251.         fprintf(ofp, "X%c\n", hilo ? 'H' : 'L');
  252.