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