home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 1 / RISC_DISC_1.iso / pd_share / games / inform / compiler / source / c / symbols < prev    next >
Encoding:
Text File  |  1994-10-02  |  11.8 KB  |  372 lines
  1. /* ------------------------------------------------------------------------- */
  2. /*   "symbols" :  The symbols table                                          */
  3. /*                                                                           */
  4. /*   Part of Inform release 5                                                */
  5. /*                                                                           */
  6. /* ------------------------------------------------------------------------- */
  7.  
  8. #include "header.h"
  9.  
  10. int used_local_variable[16];
  11. char *local_varname[16];
  12. int routine_starts_line;
  13.  
  14. /* ------------------------------------------------------------------------- */
  15. /*   Symbols table arrays                                                    */
  16. /* ------------------------------------------------------------------------- */
  17.  
  18. #ifndef ALLOCATE_BIG_ARRAYS
  19.   static char *  symbs[MAX_SYMBOLS];
  20.   int32   svals[MAX_SYMBOLS];
  21. #ifdef VAX
  22.   char    stypes[MAX_SYMBOLS];
  23. #else
  24.   signed char  stypes[MAX_SYMBOLS];
  25. #endif
  26.   static int     bank1_next[MAX_BANK_SIZE];
  27.   static int32   bank1_hash[HASH_TAB_SIZE];
  28.   static int     bank6_next[MAX_BANK_SIZE];
  29.   static int32   bank6_hash[HASH_TAB_SIZE];
  30.   static int     routine_keys[MAX_ROUTINES];
  31. #else
  32.   static int32 *  *symbs;
  33.   int32   *svals;
  34. #ifdef VAX
  35.   char    *stypes;
  36. #else
  37.   signed char  *stypes;
  38. #endif
  39.   static int     *routine_keys;
  40.   static int     *bank1_next;
  41.   static int32   *bank1_hash;
  42.   static int     *bank6_next;
  43.   static int32   *bank6_hash;
  44. #endif
  45.  
  46. static int banksize[7];
  47.  
  48. static int bank_chunks_made[7];
  49. static int32 *bank_chunks[7][32];
  50.  
  51. extern void symbols_allocate_arrays(void)
  52. {   
  53. #ifdef ALLOCATE_BIG_ARRAYS
  54.     symbs      = my_calloc(sizeof(char *),  MAX_SYMBOLS, "symbols");
  55.     svals      = my_calloc(sizeof(int32),   MAX_SYMBOLS, "symbol values");
  56.     stypes     = my_calloc(sizeof(char),    MAX_SYMBOLS, "symbol types");
  57.     bank1_next = my_calloc(sizeof(int),     MAX_BANK_SIZE, "bank 1 next");
  58.     bank1_hash = my_calloc(sizeof(int32),   MAX_BANK_SIZE, "bank 1 hash");
  59.     bank6_next = my_calloc(sizeof(int),     MAX_BANK_SIZE, "bank 6 next");
  60.     bank6_hash = my_calloc(sizeof(int32),   MAX_BANK_SIZE, "bank 6 hash");
  61.     routine_keys = my_calloc(sizeof(int),   MAX_ROUTINES,  "routine keys");
  62. #endif
  63. }
  64.  
  65. extern void symbols_free_arrays(void)
  66. {   
  67. #ifdef ALLOCATE_BIG_ARRAYS
  68.     int i, j;
  69.  
  70.     my_free(symbs, "symbols");
  71.     my_free(svals, "symbol values");
  72.     my_free(stypes, "symbol types");
  73.     my_free(bank1_next, "bank 1 next");
  74.     my_free(bank1_hash, "bank 1 hash");
  75.     my_free(bank6_next, "bank 6 next");
  76.     my_free(bank6_hash, "bank 6 hash");
  77.     my_free(routine_keys, "routine keys");
  78.  
  79.     for (i=0; i<7; i++)
  80.         for (j=0; j<=bank_chunks_made[i]; j++)
  81.             my_free(bank_chunks[i][j], "symbols banks chunk");
  82.  
  83.     if (memout_mode==1)
  84.     {   for (i=0; i<7; i++)
  85.             printf("Bank %d: %d entries, %d chunks (size %d bytes)\n",
  86.                 i,banksize[i],bank_chunks_made[i]+1,
  87.                 (bank_chunks_made[i]+1)*BANK_CHUNK_SIZE);
  88.     }
  89.  
  90. #endif
  91. }
  92.  
  93. /* ------------------------------------------------------------------------- */
  94. /*   Symbols table and address fixing                                        */
  95. /* ------------------------------------------------------------------------- */
  96.  
  97. extern void init_symbol_banks(void)
  98. {   int i;
  99.  
  100.     for (i=0; i<7; i++) { banksize[i]=0; bank_chunks_made[i]=-1; }
  101.     
  102.     for (i=0; i<MAX_ROUTINES; i++) routine_keys[i]= -1;
  103.     for (i=0;i<HASH_TAB_SIZE;i++) { bank1_hash[i]= -1; bank6_hash[i]= -1; }
  104. }
  105.  
  106. static int read_banks(int number, int32 entry)
  107. {   int *x, chunk=-1, i;
  108.  
  109.  
  110.     chunk = entry/BANK_CHUNK_SIZE;
  111.     i = entry%BANK_CHUNK_SIZE;
  112.  
  113. /*    printf("RB %d, entry %d, chunk %d, slot %d\n",
  114.              number, entry, chunk, i);
  115. */
  116.  
  117.     if (bank_chunks_made[number] < chunk) return(-1);
  118.  
  119.     x= (int *) bank_chunks[number][chunk];
  120.     return x[i];
  121. }
  122.  
  123. static void write_banks(int number, int32 entry, int value)
  124. {   int *x, chunk=-1, i, j, k;
  125.  
  126.     chunk = entry/BANK_CHUNK_SIZE;
  127.     i = entry%BANK_CHUNK_SIZE;
  128.  
  129. /*    printf("WB %d, entry %d, chunk %d, slot %d -> %d\n",
  130.              number, entry, chunk, i, value);
  131. */
  132.     while (bank_chunks_made[number] < chunk)
  133.     {   j=++bank_chunks_made[number];
  134.         if (j==32)
  135.             memoryerror("BANK_CHUNK_SIZE", BANK_CHUNK_SIZE);
  136.  
  137.         bank_chunks[number][j] = my_calloc(sizeof(int), BANK_CHUNK_SIZE,
  138.                                            "symbols banks chunk");
  139.         for (k=0; k<BANK_CHUNK_SIZE; k++)
  140.             *( (int *)bank_chunks[number][j] + k) = -1;
  141.     }
  142.  
  143.     x=(int *) bank_chunks[number][chunk];
  144.     x[i] = value;
  145. }
  146.  
  147. static char reserveds_buffer[32];
  148.  
  149. extern void prim_new_symbol(char *p, int32 value, int type, int bank)
  150. {   int32 i, j, this, last, key, start; char *r;
  151.     if (p[0]==0) { error("Symbol name expected"); return; }
  152.     if (bank==6)
  153.     {   strcpy(reserveds_buffer,p); p=reserveds_buffer; }
  154.     make_lower_case(p);
  155.     if (bank==0)
  156.     {   start=routine_keys[no_routines]; if (start<0) goto NotDupl;
  157.         for (i=start; i<banksize[bank]; i++)
  158.         {   j=read_banks(bank,i);
  159.             if (strcmp((char *)symbs[j],p)==0)
  160.             {   error_named("Duplicated symbol name:",p);
  161.                 return;
  162.             }
  163.         }
  164.         NotDupl: j=banksize[bank]++;
  165.     }
  166.     else
  167.     if (bank==1)
  168.     {   for(r=p,key=0; *r; r++) key=(key*67+*r)%HASH_TAB_SIZE;
  169.         for(this=bank1_hash[key], j= -1, last= -1;
  170.            this!=-1 && (j=strcmp((char *)symbs[read_banks(1,this)],p))<0;
  171.            last=this, this=bank1_next[this]);
  172.         if(!j)
  173.         { if (pass_number==1)
  174.           { error_named("Duplicated symbol name:",p); return;}
  175.           return;
  176.         }
  177.         j=banksize[1]++;
  178.     }
  179.     else
  180.     if (bank==6)
  181.     {   for(r=p,key=0; *r; r++) key=(key*67+*r)%HASH_TAB_SIZE;
  182.         for(this=bank6_hash[key], j= -1, last= -1;
  183.            this!=-1 && (j=strcmp((char *)symbs[read_banks(6,this)],p))<0;
  184.            last=this, this=bank6_next[this]);
  185.         if(!j)
  186.         { if (pass_number==1)
  187.           { error_named("Duplicated symbol name:",p); return;}
  188.           return;
  189.         }
  190.         j=banksize[6]++;
  191.     }
  192.     else
  193.     {   j=atoi(p+2);
  194.         if (read_banks(bank,j)!=-1)
  195.         {   error_named("Duplicated system symbol name:",p);
  196.             return;
  197.         }
  198.     }
  199.  
  200. /*
  201.     if (j>=MAX_BANK_SIZE)
  202.         memoryerror("MAX_BANK_SIZE", MAX_BANK_SIZE);
  203. */
  204.  
  205.     write_banks(bank,j,no_symbols);
  206.  
  207.     if (bank==0)
  208.     {   if (routine_keys[no_routines]==-1) routine_keys[no_routines]=j;
  209.         if (nowarnings_mode==0)
  210.         {   local_varname[value]=symbols_p;
  211.         }
  212.     }
  213.     if (bank==1) 
  214.     { if (last==-1) {bank1_next[j]=bank1_hash[key];bank1_hash[key]=j;}
  215.       else          {bank1_next[j]=this; bank1_next[last]=j;}
  216.     }
  217.     if (bank==6) 
  218.     { if (last==-1) {bank6_next[j]=bank6_hash[key];bank6_hash[key]=j;}
  219.       else          {bank6_next[j]=this; bank6_next[last]=j;}
  220.     }
  221.  
  222.     if (no_symbols==MAX_SYMBOLS)
  223.         memoryerror("MAX_SYMBOLS", MAX_SYMBOLS);
  224.  
  225.     if (symbols_p+strlen(p)+1 >= symbols_top)
  226.     {   symbols_p=my_malloc(SYMBOLS_CHUNK_SIZE,"symbols table chunk");
  227.         symbols_top=symbols_p+SYMBOLS_CHUNK_SIZE;
  228.     }
  229.     strcpy(symbols_p,p); symbs[no_symbols]=(int32 *) symbols_p;
  230.     symbols_p+=strlen(symbols_p)+1;
  231.  
  232.     svals[no_symbols]=value; stypes[no_symbols]=type;
  233.  
  234.     no_symbols++;
  235. }
  236.  
  237. extern int prim_find_symbol(char *q, int bank)
  238. {   char c[50], *r; int i, j, start, finish=banksize[bank];
  239.     int32 key, this;
  240.  
  241.     if (strlen(q)>49) return -1;
  242.  
  243.     strcpy(c,q); make_lower_case(c);
  244.  
  245.     if (bank==0)
  246.     {   start=routine_keys[no_routines]; if (start<0) return -1;
  247.         i=routine_keys[no_routines+1]; if (i>=0) finish=i;
  248.         if (finish>start+15) finish=start+15;
  249.         for (i=start; i<finish; i++)
  250.         {   j=read_banks(bank,i);
  251.             if (strcmp((char *) symbs[j],c)==0)
  252.             {   used_local_variable[svals[j]]=1;
  253.                 return(j);
  254.             }
  255.         }
  256.         return(-1);
  257.     }
  258.     else
  259.     if (bank==1)
  260.     { for(r=c, key=0; *r; r++) key=(key*67+*r)%HASH_TAB_SIZE;
  261.       for(this=bank1_hash[key],j= -1;
  262.           this!=-1 && (j=strcmp((char *)symbs[read_banks(1,this)],c))<0;
  263.           this=bank1_next[this]);
  264.       if(!j) return read_banks(1,this);
  265.       return(-1);
  266.     }
  267.     else
  268.     if (bank==6)
  269.     { for(r=c, key=0; *r; r++) key=(key*67+*r)%HASH_TAB_SIZE;
  270.       for(this=bank6_hash[key],j= -1;
  271.           this!=-1 && (j=strcmp((char *)symbs[read_banks(6,this)],c))<0;
  272.           this=bank6_next[this]);
  273.       if(!j) return read_banks(6,this);
  274.       return(-1);
  275.     }
  276.  
  277.     j=atoi(c+2);
  278.     return(read_banks(bank,j));
  279. }
  280.  
  281. extern int find_symbol(char *q)
  282. {   if (q[0]!='_') return(prim_find_symbol(q,1));
  283.     if (q[1]=='s') return(prim_find_symbol(q,2));
  284.     if (q[1]=='S') return(prim_find_symbol(q,2));
  285.     if (q[1]=='w') return(prim_find_symbol(q,3));
  286.     if (q[1]=='W') return(prim_find_symbol(q,3));
  287.     if (q[1]=='f') return(prim_find_symbol(q,4));
  288.     if (q[1]=='F') return(prim_find_symbol(q,4));
  289.     if (q[1]=='x') return(prim_find_symbol(q,5));
  290.     if (q[1]=='X') return(prim_find_symbol(q,5));
  291.     error("Names are not permitted to start with an _");
  292.     return(-1);
  293. }
  294.  
  295. extern int local_find_symbol(char *q)
  296. {   return(prim_find_symbol(q,0));
  297. }
  298.  
  299. extern void new_symbol(char *p, int32 value, int type)
  300. {   if (pass_number==2) return;
  301.     if (strlen(p)>MAX_IDENTIFIER_LENGTH)
  302.     {   error_named("Symbol name is too long:",p);
  303.         return;
  304.     }
  305.     if (type==3) { prim_new_symbol(p,value,type,0); return; }
  306.     if (p[0]!='_') { prim_new_symbol(p,value,type,1); return; }
  307.     if (p[1]=='s') { prim_new_symbol(p,value,type,2); return; }
  308.     if (p[1]=='S') { prim_new_symbol(p,value,type,2); return; }
  309.     if (p[1]=='w') { prim_new_symbol(p,value,type,3); return; }
  310.     if (p[1]=='W') { prim_new_symbol(p,value,type,3); return; }
  311.     if (p[1]=='f') { prim_new_symbol(p,value,type,4); return; }
  312.     if (p[1]=='F') { prim_new_symbol(p,value,type,4); return; }
  313.     if (p[1]=='x') { prim_new_symbol(p,value,type,5); return; }
  314.     if (p[1]=='X') { prim_new_symbol(p,value,type,5); return; }
  315.     error("Symbol names are not permitted to start with an '_'");
  316. }
  317.  
  318. /* ------------------------------------------------------------------------- */
  319. /*   Printing diagnostics                                                    */
  320. /* ------------------------------------------------------------------------- */
  321.  
  322. static char *typename(int type)
  323. {   switch(type)
  324.     {   case 1: return("Global label");
  325.         case 2: return("Global variable");
  326.         case 3: return("Local variable");
  327.         case 4: return("Reserved word");
  328.         case 5: return("Static string");
  329.         case 6: return("Local label");
  330.         case 7: return("Attribute");
  331.         case 8: return("Integer constant");
  332.         case 9: return("Object");
  333.         case 10: return("Condition");
  334.         case 11: return("Constant string address");
  335.         case 12: return("Property");
  336.         case 13: return("Class");
  337.         case 14: return("Assembler directive");
  338.         case 15: return("Compiler-modified opcode");
  339.         case 16: return("Compiled command");
  340.         case 17: return("Opcode");
  341.         case 18: return("Fake action");
  342.         case 19: return("Replacement name");
  343.         default: return("(Unknown type)");
  344.     }
  345. }
  346.  
  347. extern void list_symbols(void)
  348. {   int i, j, k;
  349.     for (j=0; j<2; j++)
  350.     {   printf("In bank %d\n", j);
  351.         for (i=0; i<banksize[j]; i++)
  352.         {   k=read_banks(j,i);
  353.             printf("%4d  %-16s  %04x  %s\n",
  354.                 k,symbs[k],svals[k],typename(stypes[k]));
  355.         }
  356.     }
  357.     for (j=2; j<6; j++)
  358.     {   printf("In bank %d\n", j);
  359.         for (i=0; i<MAX_BANK_SIZE; i++)
  360.         {   k=read_banks(j,i);
  361.             if (k!=-1)
  362.             {   printf("%4d  %-16s  %04x  %s\n",
  363.                     k,symbs[k],svals[k],typename(stypes[k]));
  364.             }
  365.         }
  366.     }
  367.     printf("Full list:\n");
  368.     for (i=0; i<no_symbols; i++)
  369.         printf("%-16s  %04x  %s\n",
  370.             symbs[i],svals[i],typename(stypes[i]));
  371. }
  372.