855fe447b747198c09fc65560f42e96971dd158d
[rmac] / symbol.c
1 ////////////////////////////////////////////////////////////////////////////////////////////////////
2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
3 // SYMBOL.C - Symbol Handling
4 // Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source Utilised with the Kind Permission of Landon Dyer
7
8 #include "symbol.h"
9 #include "listing.h"
10 #include "procln.h"
11 #include "error.h"
12
13 static SYM *sytab[NBUCKETS];                                // User symbol-table header
14 int curenv;                                                 // Current enviroment number
15 SYM *sorder;                                                // * -> Symbols, in order of reference
16 SYM *sordtail;                                              // * -> Last symbol in sorder list
17 SYM *sdecl;                                                 // * -> Symbols, in order of declaration
18 SYM *sdecltail;                                             // * -> Last symbol in sdecl list
19
20 // Tags for marking symbol spaces
21 // a = absolute
22 // t = text
23 // d = data
24 // ! = "impossible!"
25 // b = BSS
26 static char tdb_text[8] = {
27    'a', 't', 'd', '!', 'b', SPACE, SPACE, SPACE
28 };
29
30 //
31 // --- Initialize Symbol Table ---------------------------------------------------------------------
32 //
33
34 void init_sym(void) {
35    int i;                                                   // Iterator
36
37    for(i = 0; i < NBUCKETS; ++i)                            // Initialise symbol hash table
38       sytab[i] = NULL;
39
40    curenv = 1;                                              // Init local symbol enviroment
41    sorder = NULL;                                           // Init symbol-reference list
42    sordtail = NULL;
43    sdecl = NULL;                                            // Init symbol-decl list
44    sdecltail = NULL;
45 }
46
47 //
48 // --- Allocate and Return Pointer to a Copy of a String -------------------------------------------
49 //
50
51 char *nstring(char *str) {
52    long i;
53    char *s, *d;
54
55    for(i = 0; str[i]; ++i)
56       ;
57    s = d = amem(i + 1);
58    while(*str)
59       *d++ = *str++;
60    *d++ = '\0';
61    
62    return(s);
63 }
64
65 //
66 // --- Hash the Print Name and Enviroment Number ---------------------------------------------------
67 //
68 int syhash(char *name, int envno) {
69    int sum, k;                                              // Hash calculation
70
71    k = 0;
72    for(sum = envno; *name; ++name) {
73       if(k++ == 1)
74          sum += *name << 2;
75       else
76          sum += *name;
77    }
78
79    return(sum & (NBUCKETS - 1));
80 }
81
82 //
83 // --- Make a new symbol of type `type' in enviroment `envno' --------------------------------------
84 //
85
86 SYM *newsym(char *name, int type, int envno) {
87    int hash;                                                // Symbol hash value
88    SYM *sy;                                                 // Pointer to symbol
89
90    
91    // Allocate the symbol
92    sy = (SYM *)amem((long)(sizeof(SYM)));
93    if(sy == NULL) {
94       printf("SYMALLOC ERROR (%s)\n", name);
95       return(NULL);
96    }
97
98    sy->sname = nstring(name);
99
100    // Fill-in the symbol
101    sy->stype  = (BYTE)type;
102    sy->senv   = (WORD)envno;
103    sy->sattr  = 0;
104    if(rgpu || rdsp) sy->sattre = RISCSYM;
105    else sy->sattre = 0;
106    sy->svalue = 0;
107
108    // Install symbol in symbol table
109    hash = syhash(name, envno);
110    sy->snext = sytab[hash];
111    sytab[hash] = sy;
112
113    // Append symbol to symbol-order list
114    if(sorder == NULL)
115       sorder = sy;                                          // Add first symbol 
116    else
117       sordtail->sorder = sy;                                // Or append to tail of list
118
119    sy->sorder = NULL;
120    sordtail = sy;
121
122    return(sy);                                              // Return pointer to symbol
123 }
124
125 //
126 // --- Lookup the symbol `name', of the specified type, with the specified enviroment level --------
127 //
128
129 SYM *lookup(char *name, int type, int envno) {
130    SYM *sy;                                                 // Symbol record pointer
131    int k, sum;                                              // Hash bucket calculation
132    char *s;                                                 // String pointer
133
134    // Pick a hash-bucket (SAME algorithm as syhash())
135    k = 0;
136    s = name;
137    for(sum = envno; *s;) {
138       if(k++ == 1)
139          sum += *s++ << 2;
140       else sum += *s++;
141    }
142
143    sy = sytab[sum & (NBUCKETS-1)];
144
145    // Do linear-search for symbol in bucket
146    while(sy != NULL) {
147       if(sy->stype == type       &&                         // Type, envno and name must match
148          sy->senv  == envno      &&
149                         *name     == *sy->sname &&                         // Fast check for first character
150                         !strcmp(name, sy->sname))
151          break;
152       else sy = sy->snext;
153    }
154
155    return(sy);                                              // Return NULL or matching symbol
156 }
157
158 //
159 // --- Put symbol on "order-of-declaration" list of symbols ----------------------------------------
160 //
161
162 void sym_decl(SYM *sym) {
163    if(sym->sattr & SDECLLIST) return;                       // Already on list
164    sym->sattr |= SDECLLIST;                                 // Mark "already on list"
165
166    if(sdecl == NULL)
167       sdecl = sym;                                          // First on decl-list
168    else 
169       sdecltail->sdecl = sym;                               // Add to end of list
170
171    sym->sdecl = NULL;                                       // Fix up list's tail
172    sdecltail = sym;
173 }
174
175 //
176 // --- Make all referenced, undefined symbols global -----------------------------------------------
177 //
178
179 int syg_fix(void) {
180    SYM *sy;
181
182    DEBUG printf("~syg_fix()\n");
183
184    // Scan through all symbols;
185    // If a symbol is REFERENCED but not DEFINED, then make it global.
186    for(sy = sorder; sy != NULL; sy = sy->sorder)
187       if(sy->stype == LABEL && sy->senv == 0 &&
188                         ((sy->sattr & (REFERENCED|DEFINED)) == REFERENCED))
189          sy->sattr |= GLOBAL;
190
191    return(0);
192 }
193
194 //
195 // --- Convert string to uppercase -----------------------------------------------------------------
196 //
197
198 int uc_string(char *s) {
199    for(; *s; ++s)
200       if(*s >= 'a' && *s <= 'z')
201          *s -= 32;
202    return(0);
203 }
204
205 //
206 // -------------------------------------------------------------------------------------------------
207 // Assign numbers to symbols that are to be exported or imported.  The symbol number is put in 
208 // `.senv'. Return the number of symbols that will be in the symbol table.
209 // -------------------------------------------------------------------------------------------------
210 //
211
212 int sy_assign(char *buf, char *(*constr)()) {
213    SYM *sy;
214    int scount;
215    //int i;
216
217    scount = 0;
218
219    if(buf == NULL)
220       // Append all symbols not appearing on the .sdecl list to the end of the .sdecl list
221       for(sy = sorder; sy != NULL; sy = sy->sorder) {
222
223          // Essentially the same as 'sym_decl()' above:
224          if(sy->sattr & SDECLLIST) continue;                // Already on list 
225          sy->sattr |= SDECLLIST;                            // Mark "on the list"
226
227          if(sdecl == NULL) sdecl = sy;                      // First on decl-list 
228          else sdecltail->sdecl = sy;                        // Add to end of list
229
230          sy->sdecl = NULL;                                  // Fix up list's tail
231          sdecltail = sy;
232       }
233
234    // Run through all symbols (now on the .sdecl list) and assign numbers to them.  We also pick 
235    // which symbols should be global or not here.
236    for(sy = sdecl; sy != NULL; sy = sy->sdecl) {
237
238       if(sy->sattre & UNDEF_EQUR) continue;                 // Don't want undefined on our list
239       if(sy->sattre & UNDEF_CC) continue;                   
240       
241       // Export or import external references, and export COMMON blocks.
242       if((sy->stype == LABEL) &&
243          ((sy->sattr & (GLOBAL|DEFINED)) == (GLOBAL|DEFINED) ||
244          (sy->sattr & (GLOBAL|REFERENCED)) == (GLOBAL|REFERENCED)) ||
245          (sy->sattr & COMMON)) {
246          sy->senv = (WORD)scount++;
247          if(buf != NULL) buf = (*constr)(buf, sy, 1);
248       } else
249          // Export vanilla labels (but don't make them global). An exception is made for equates, 
250          // which are not exported unless they are referenced.
251          if(sy->stype == LABEL && lsym_flag &&
252             (sy->sattr & (DEFINED|REFERENCED)) != 0 &&
253             (!as68_flag || *sy->sname != 'L') ) {
254             sy->senv = (WORD)scount++;
255             if(buf != NULL) buf = (*constr)(buf, sy, 0);
256          }
257    }
258
259    return(scount);
260 }
261
262 //
263 // --- Generate symbol table for listing file ------------------------------------------------------
264 //
265
266 int symtable(void) {
267    int i;
268    int j;
269    SYM *q = NULL;
270    SYM *p;
271    SYM *r;
272    SYM *k;
273    SYM **sy;
274    SYM *colptr[4];
275    char ln[150];
276    char ln1[150];
277    char ln2[20];
278    char c, c1;
279    WORD w;
280    int ww;
281    int colhei;
282    extern int pagelen;
283
284    colhei = pagelen - 5;
285
286    // Allocate storage for list headers and partition all labels.  
287    // Throw away macros and macro arguments.
288    sy = (SYM **)amem((LONG)(128 * sizeof(LONG)));
289    for(i = 0; i < 128; ++i) sy[i] = NULL;
290
291    for(i = 0; i < NBUCKETS; ++i)
292       for(p = sytab[i]; p != NULL; p = k) {
293          k = p->snext;
294          j = *p->sname;
295          r = NULL;
296          if(p->stype != LABEL) continue;                    // Ignore non-labels
297          if(p->sattre & UNDEF_EQUR) continue;
298
299          for(q = sy[j]; q != NULL; q = q->snext)
300             if(strcmp(p->sname, q->sname) < 0)
301                break;
302             else r = q;
303
304          if(r == NULL) {                                    // Insert at front of list
305             p->snext = sy[j];
306             sy[j] = p;
307          } else {                                           // Insert in middle or append to list
308             p->snext = r->snext;
309             r->snext = p;
310          }
311       }
312
313    // Link all symbols onto one list again
314    p = NULL;
315    for(i = 0; i < 128; ++i)
316       if((r = sy[i]) != NULL) {
317          if(p == NULL)
318             q = r;
319          else q->snext = r;
320
321          while(q->snext != NULL)
322             q = q->snext;
323
324          if(p == NULL)
325             p = r;
326       }
327
328    eject();
329    strcpy(subttl, "Symbol Table");
330
331    while(p != NULL) {
332       for (i = 0; i < 4; ++i) {
333          colptr[i] = p;
334          for(j = 0; j < colhei; ++j)
335             if(p == NULL)
336                break;
337             else p = p->snext;
338       }
339
340       for(i = 0; i < colhei; ++i) {
341          *ln = EOS;
342          if(colptr[0] == NULL)
343             break;
344
345          for(j = 0; j < 4; ++j) {
346             if((q = colptr[j]) == NULL)
347                break;
348             colptr[j] = q->snext;
349             w = q->sattr;
350             ww = q->sattre;
351             // Pick a tag:
352             // c        common
353             // x        external reference
354             // g        global (export)
355             // space    nothing special
356             c1 = SPACE;
357             c = SPACE;
358
359             if(w & COMMON) c = 'c';
360             else if((w & (DEFINED|GLOBAL)) == GLOBAL) c = 'x';
361             else if(w & GLOBAL) c = 'g';
362
363             c1 = tdb_text[w & TDB];
364             if(c == 'x') strcpy(ln2, "external");
365             else {
366                sprintf(ln2, "%08lx", q->svalue);
367                uc_string(ln2);
368             }
369
370             sprintf(ln1, "  %16s %s %c%c%c", q->sname, ln2, (ww & EQUATEDREG) ? 'e' : SPACE, c1, c);
371
372             strcat(ln, ln1);
373          }
374          ship_ln(ln);
375       }
376       eject();
377    }
378
379    return(0);
380 }