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

Diff of /bison/src/nullable.c

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

revision 1.37 by eggert, Thu Nov 21 05:18:57 2002 UTC revision 1.38 by eggert, Wed Dec 11 06:38:17 2002 UTC
# Line 24  Line 24 
24     do so.  */     do so.  */
25    
26  #include "system.h"  #include "system.h"
27    
28  #include "getargs.h"  #include "getargs.h"
 #include "symtab.h"  
29  #include "gram.h"  #include "gram.h"
 #include "reduce.h"  
30  #include "nullable.h"  #include "nullable.h"
31    #include "reduce.h"
32    #include "symtab.h"
33    
34  /* Linked list of rules.  */  /* Linked list of rules.  */
35  typedef struct rule_list_s  typedef struct rule_list
36  {  {
37    struct rule_list_s *next;    struct rule_list *next;
38    rule_t *value;    rule *value;
39  } rule_list_t;  } rule_list;
40    
41  bool *nullable = NULL;  bool *nullable = NULL;
42    
# Line 52  nullable_print (FILE *out) Line 53  nullable_print (FILE *out)
53  void  void
54  nullable_compute (void)  nullable_compute (void)
55  {  {
56    rule_number_t ruleno;    rule_number ruleno;
57    symbol_number_t *s1;    symbol_number *s1;
58    symbol_number_t *s2;    symbol_number *s2;
59    rule_list_t *p;    rule_list *p;
60    
61    symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);    symbol_number *squeue = XCALLOC (symbol_number, nvars);
62    short *rcount = XCALLOC (short, nrules);    short *rcount = XCALLOC (short, nrules);
63    /* RITEM contains all the rules, including useless productions.    /* RITEM contains all the rules, including useless productions.
64       Hence we must allocate room for useless nonterminals too.  */       Hence we must allocate room for useless nonterminals too.  */
65    rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;    rule_list **rsets = XCALLOC (rule_list *, nvars) - ntokens;
66    /* This is said to be more elements than we actually use.    /* This is said to be more elements than we actually use.
67       Supposedly NRITEMS - NRULES is enough.  But why take the risk?  */       Supposedly NRITEMS - NRULES is enough.  But why take the risk?  */
68    rule_list_t *relts = XCALLOC (rule_list_t, nritems + nvars + 1);    rule_list *relts = XCALLOC (rule_list, nritems + nvars + 1);
69    
70    nullable = XCALLOC (bool, nvars) - ntokens;    nullable = XCALLOC (bool, nvars) - ntokens;
71    
# Line 74  nullable_compute (void) Line 75  nullable_compute (void)
75    for (ruleno = 0; ruleno < nrules; ++ruleno)    for (ruleno = 0; ruleno < nrules; ++ruleno)
76      if (rules[ruleno].useful)      if (rules[ruleno].useful)
77        {        {
78          rule_t *rule = &rules[ruleno];          rule *rules_ruleno = &rules[ruleno];
79          if (rule->rhs[0] >= 0)          if (rules_ruleno->rhs[0] >= 0)
80            {            {
81              /* This rule has a non empty RHS. */              /* This rule has a non empty RHS. */
82              item_number_t *r = NULL;              item_number *r = NULL;
83              int any_tokens = 0;              int any_tokens = 0;
84              for (r = rule->rhs; *r >= 0; ++r)              for (r = rules_ruleno->rhs; *r >= 0; ++r)
85                if (ISTOKEN (*r))                if (ISTOKEN (*r))
86                  any_tokens = 1;                  any_tokens = 1;
87    
88              /* This rule has only nonterminals: schedule it for the second              /* This rule has only nonterminals: schedule it for the second
89                 pass.  */                 pass.  */
90              if (!any_tokens)              if (!any_tokens)
91                for (r = rule->rhs; *r >= 0; ++r)                for (r = rules_ruleno->rhs; *r >= 0; ++r)
92                  {                  {
93                    rcount[ruleno]++;                    rcount[ruleno]++;
94                    p->next = rsets[*r];                    p->next = rsets[*r];
95                    p->value = rule;                    p->value = rules_ruleno;
96                    rsets[*r] = p;                    rsets[*r] = p;
97                    p++;                    p++;
98                  }                  }
# Line 99  nullable_compute (void) Line 100  nullable_compute (void)
100          else          else
101            {            {
102              /* This rule has an empty RHS. */              /* This rule has an empty RHS. */
103              if (item_number_as_rule_number (rule->rhs[0]) != ruleno)              if (item_number_as_rule_number (rules_ruleno->rhs[0]) != ruleno)
104                abort ();                abort ();
105              if (rule->useful && !nullable[rule->lhs->number])              if (rules_ruleno->useful && !nullable[rules_ruleno->lhs->number])
106                {                {
107                  nullable[rule->lhs->number] = 1;                  nullable[rules_ruleno->lhs->number] = 1;
108                  *s2++ = rule->lhs->number;                  *s2++ = rules_ruleno->lhs->number;
109                }                }
110            }            }
111        }        }
# Line 112  nullable_compute (void) Line 113  nullable_compute (void)
113    while (s1 < s2)    while (s1 < s2)
114      for (p = rsets[*s1++]; p; p = p->next)      for (p = rsets[*s1++]; p; p = p->next)
115        {        {
116          rule_t *rule = p->value;          rule *r = p->value;
117          if (--rcount[rule->number] == 0)          if (--rcount[r->number] == 0)
118            if (rule->useful && !nullable[rule->lhs->number])            if (r->useful && !nullable[r->lhs->number])
119              {              {
120                nullable[rule->lhs->number] = 1;                nullable[r->lhs->number] = 1;
121                *s2++ = rule->lhs->number;                *s2++ = r->lhs->number;
122              }              }
123        }        }
124    

Legend:
Removed from v.1.37  
changed lines
  Added in v.1.38

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