/[bison]/bison/src/LR0.c
ViewVC logotype

Diff of /bison/src/LR0.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.15.2.9 by akim, Mon Nov 19 09:25:36 2001 UTC revision 1.15.2.10 by akim, Mon Nov 19 09:26:43 2001 UTC
# Line 50  static short *redset = NULL; Line 50  static short *redset = NULL;
50  static short *shiftset = NULL;  static short *shiftset = NULL;
51    
52  static short **kernel_base = NULL;  static short **kernel_base = NULL;
53  static short **kernel_end = NULL;  static size_t *kernel_size = NULL;
54  static short *kernel_items = NULL;  static short *kernel_items = NULL;
55    
56  /* hash table for states, to recognize equivalent ones.  */  /* hash table for states, to recognize equivalent ones.  */
# Line 94  allocate_itemsets (void) Line 94  allocate_itemsets (void)
94      }      }
95    
96    shift_symbol = symbol_count;    shift_symbol = symbol_count;
97    kernel_end = XCALLOC (short *, nsyms);    kernel_size = XCALLOC (size_t, nsyms);
98  }  }
99    
100    
# Line 116  free_storage (void) Line 116  free_storage (void)
116    XFREE (redset);    XFREE (redset);
117    XFREE (shiftset);    XFREE (shiftset);
118    XFREE (kernel_base);    XFREE (kernel_base);
119    XFREE (kernel_end);    XFREE (kernel_size);
120    XFREE (kernel_items);    XFREE (kernel_items);
121    XFREE (state_table);    XFREE (state_table);
122  }  }
# Line 132  free_storage (void) Line 132  free_storage (void)
132  | shift_symbol is set to a vector of the symbols that can be      |  | shift_symbol is set to a vector of the symbols that can be      |
133  | shifted.  For each symbol in the grammar, kernel_base[symbol]   |  | shifted.  For each symbol in the grammar, kernel_base[symbol]   |
134  | points to a vector of item numbers activated if that symbol is  |  | points to a vector of item numbers activated if that symbol is  |
135  | shifted, and kernel_end[symbol] points after the end of that    |  | shifted, and kernel_size[symbol] is their numbers.              |
 | vector.                                                         |  
136  `----------------------------------------------------------------*/  `----------------------------------------------------------------*/
137    
138  static void  static void
# Line 147  new_itemsets (void) Line 146  new_itemsets (void)
146               this_state->number);               this_state->number);
147    
148    for (i = 0; i < nsyms; i++)    for (i = 0; i < nsyms; i++)
149      kernel_end[i] = NULL;      kernel_size[i] = 0;
150    
151    shiftcount = 0;    shiftcount = 0;
152    
# Line 156  new_itemsets (void) Line 155  new_itemsets (void)
155        int symbol = ritem[itemset[i]];        int symbol = ritem[itemset[i]];
156        if (symbol > 0)        if (symbol > 0)
157          {          {
158            short *ksp = kernel_end[symbol];            if (!kernel_size[symbol])
   
           if (!ksp)  
159              {              {
160                shift_symbol[shiftcount] = symbol;                shift_symbol[shiftcount] = symbol;
               ksp = kernel_base[symbol];  
161                shiftcount++;                shiftcount++;
162              }              }
163    
164            *ksp++ = itemset[i] + 1;            kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
165            kernel_end[symbol] = ksp;            kernel_size[symbol]++;
166          }          }
167      }      }
168    
# Line 183  new_itemsets (void) Line 179  new_itemsets (void)
179  static core *  static core *
180  new_state (int symbol)  new_state (int symbol)
181  {  {
   int n;  
182    core *p;    core *p;
183    
184    if (trace_flag)    if (trace_flag)
# Line 193  new_state (int symbol) Line 188  new_state (int symbol)
188    if (nstates >= MAXSHORT)    if (nstates >= MAXSHORT)
189      fatal (_("too many states (max %d)"), MAXSHORT);      fatal (_("too many states (max %d)"), MAXSHORT);
190    
191    n = kernel_end[symbol] - kernel_base[symbol];    p = CORE_ALLOC (kernel_size[symbol]);
   
   p = CORE_ALLOC (n);  
192    p->accessing_symbol = symbol;    p->accessing_symbol = symbol;
193    p->number = nstates;    p->number = nstates;
194    p->nitems = n;    p->nitems = kernel_size[symbol];
195    
196    shortcpy (p->items, kernel_base[symbol], n);    shortcpy (p->items, kernel_base[symbol], kernel_size[symbol]);
197    
198    last_state->next = p;    last_state->next = p;
199    last_state = p;    last_state = p;
# Line 224  get_state (int symbol) Line 217  get_state (int symbol)
217    int i;    int i;
218    core *sp;    core *sp;
219    
   int n = kernel_end[symbol] - kernel_base[symbol];  
   
220    if (trace_flag)    if (trace_flag)
221      fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",      fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
222               this_state->number, symbol, tags[symbol]);               this_state->number, symbol, tags[symbol]);
# Line 233  get_state (int symbol) Line 224  get_state (int symbol)
224    /* Add up the target state's active item numbers to get a hash key.    /* Add up the target state's active item numbers to get a hash key.
225       */       */
226    key = 0;    key = 0;
227    for (i = 0; i < n; ++i)    for (i = 0; i < kernel_size[symbol]; ++i)
228      key += kernel_base[symbol][i];      key += kernel_base[symbol][i];
229    key = key % STATE_TABLE_SIZE;    key = key % STATE_TABLE_SIZE;
230    sp = state_table[key];    sp = state_table[key];
# Line 243  get_state (int symbol) Line 234  get_state (int symbol)
234        int found = 0;        int found = 0;
235        while (!found)        while (!found)
236          {          {
237            if (sp->nitems == n)            if (sp->nitems == kernel_size[symbol])
238              {              {
239                int i;                int i;
240                found = 1;                found = 1;
241                for (i = 0; i < n; ++i)                for (i = 0; i < kernel_size[symbol]; ++i)
242                  if (kernel_base[symbol][i] != sp->items[i])                  if (kernel_base[symbol][i] != sp->items[i])
243                    found = 0;                    found = 0;
244              }              }

Legend:
Removed from v.1.15.2.9  
changed lines
  Added in v.1.15.2.10

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26