projects
/
bison.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
lalr1.cc: check (and fix) %initial-action exception safety
[bison.git]
/
src
/
nullable.c
diff --git
a/src/nullable.c
b/src/nullable.c
index 082f2b3211a383fb289ef438feb85585d2c8add9..1e7f5d19257ecb8fdf444a47f5a4d5587a2d24dd 100644
(file)
--- a/
src/nullable.c
+++ b/
src/nullable.c
@@
-1,37
+1,45
@@
-/* Part of the bison parser generator,
- Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc.
+/* Calculate which nonterminals can expand into the null string for Bison.
+
+ Copyright (C) 1984, 1989, 2000-2006, 2009-2012 Free Software
+ Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
This file is part of Bison, the GNU Compiler Compiler.
-
Bison is free software;
you can redistribute it and/or modify
+
This program is free software:
you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
it under the terms of the GNU General Public License as published by
- the Free Software Foundation
; either version 2, or (at your option)
- any later version.
+ the Free Software Foundation
, either version 3 of the License, or
+
(at your option)
any later version.
-
Bison
is distributed in the hope that it will be useful,
+
This program
is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with Bison; see the file COPYING. If not, write to
- the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Set up NULLABLE, a vector saying which nonterminals can expand into
the null string. NULLABLE[I - NTOKENS] is nonzero if symbol I can
do so. */
/* Set up NULLABLE, a vector saying which nonterminals can expand into
the null string. NULLABLE[I - NTOKENS] is nonzero if symbol I can
do so. */
+#include <config.h>
#include "system.h"
#include "system.h"
+
#include "getargs.h"
#include "getargs.h"
-#include "symtab.h"
-#include "types.h"
#include "gram.h"
#include "gram.h"
-#include "reduce.h"
#include "nullable.h"
#include "nullable.h"
+#include "reduce.h"
+#include "symtab.h"
+
+/* Linked list of rules. */
+typedef struct rule_list
+{
+ struct rule_list *next;
+ rule *value;
+} rule_list;
-
char
*nullable = NULL;
+
bool
*nullable = NULL;
static void
nullable_print (FILE *out)
static void
nullable_print (FILE *out)
@@
-39,95
+47,96
@@
nullable_print (FILE *out)
int i;
fputs ("NULLABLE\n", out);
for (i = ntokens; i < nsyms; i++)
int i;
fputs ("NULLABLE\n", out);
for (i = ntokens; i < nsyms; i++)
- fprintf (out, "\t%s: %s\n", symbols[i]->tag, nullable[i] ? "yes" : "no");
+ fprintf (out, "\t%s: %s\n", symbols[i]->tag,
+ nullable[i - ntokens] ? "yes" : "no");
fputs ("\n\n", out);
}
void
fputs ("\n\n", out);
}
void
-
set_nullabl
e (void)
+
nullable_comput
e (void)
{
{
-
int
ruleno;
- s
hort
*s1;
- s
hort
*s2;
-
shorts
*p;
+
rule_number
ruleno;
+ s
ymbol_number
*s1;
+ s
ymbol_number
*s2;
+
rule_list
*p;
- s
hort *squeue = XCALLOC (short, nvars
);
- s
hort *rcount = XCALLOC (short, nrules + 1
);
+ s
ymbol_number *squeue = xnmalloc (nvars, sizeof *squeue
);
+ s
ize_t *rcount = xcalloc (nrules, sizeof *rcount
);
/* RITEM contains all the rules, including useless productions.
Hence we must allocate room for useless nonterminals too. */
/* RITEM contains all the rules, including useless productions.
Hence we must allocate room for useless nonterminals too. */
-
shorts **rsets = XCALLOC (shorts *, nvars) - ntokens
;
+
rule_list **rsets = xcalloc (nvars, sizeof *rsets)
;
/* This is said to be more elements than we actually use.
Supposedly NRITEMS - NRULES is enough. But why take the risk? */
/* This is said to be more elements than we actually use.
Supposedly NRITEMS - NRULES is enough. But why take the risk? */
- shorts *relts = XCALLOC (shorts, nritems + nvars + 1);
-
- if (trace_flag)
- fprintf (stderr, "Entering set_nullable\n");
+ rule_list *relts = xnmalloc (nritems + nvars + 1, sizeof *relts);
- nullable =
XCALLOC (char, nvars) - ntokens
;
+ nullable =
xcalloc (nvars, sizeof *nullable)
;
s1 = s2 = squeue;
p = relts;
s1 = s2 = squeue;
p = relts;
- for (ruleno =
1; ruleno < nrules + 1
; ++ruleno)
- if (rule
_table
[ruleno].useful)
+ for (ruleno =
0; ruleno < nrules
; ++ruleno)
+ if (rule
s
[ruleno].useful)
{
{
- if (ritem[rule_table[ruleno].rhs] >= 0)
+ rule *rules_ruleno = &rules[ruleno];
+ if (rules_ruleno->rhs[0] >= 0)
{
/* This rule has a non empty RHS. */
{
/* This rule has a non empty RHS. */
-
short *r
;
-
int any_tokens = 0
;
- for (r
= &ritem[rule_table[ruleno].rhs]; *r >= 0; ++r
)
- if (ISTOKEN (*r))
- any_tokens =
1
;
+
item_number *rp = NULL
;
+
bool any_tokens = false
;
+ for (r
p = rules_ruleno->rhs; *rp >= 0; ++rp
)
+ if (ISTOKEN (*r
p
))
+ any_tokens =
true
;
/* This rule has only nonterminals: schedule it for the second
pass. */
if (!any_tokens)
/* This rule has only nonterminals: schedule it for the second
pass. */
if (!any_tokens)
- for (r
= &ritem[rule_table[ruleno].rhs]; *r >= 0; ++r
)
+ for (r
p = rules_ruleno->rhs; *rp >= 0; ++rp
)
{
rcount[ruleno]++;
{
rcount[ruleno]++;
- p->next = rsets[*r];
- p->value = ruleno;
- rsets[*r] = p;
+ p->next = rsets[*r
p - ntokens
];
+ p->value = rule
s_rule
no;
+ rsets[*r
p - ntokens
] = p;
p++;
}
}
else
{
/* This rule has an empty RHS. */
p++;
}
}
else
{
/* This rule has an empty RHS. */
- assert (ritem[rule_table[ruleno].rhs] == -ruleno);
- if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
+ aver (item_number_as_rule_number (rules_ruleno->rhs[0])
+ == ruleno);
+ if (rules_ruleno->useful
+ && ! nullable[rules_ruleno->lhs->number - ntokens])
{
{
- nullable[rule
_table[ruleno].lhs] = 1
;
- *s2++ = rule
_table[ruleno].lhs
;
+ nullable[rule
s_ruleno->lhs->number - ntokens] = true
;
+ *s2++ = rule
s_ruleno->lhs->number
;
}
}
}
while (s1 < s2)
}
}
}
while (s1 < s2)
- for (p = rsets[*s1++]; p; p = p->next)
+ for (p = rsets[*s1++
- ntokens
]; p; p = p->next)
{
{
- rule
no
= p->value;
- if (--rcount[r
uleno
] == 0)
- if (r
ule_table[ruleno].useful && !nullable[rule_table[ruleno].lh
s])
+ rule
*r
= p->value;
+ if (--rcount[r
->number
] == 0)
+ if (r
->useful && ! nullable[r->lhs->number - ntoken
s])
{
{
- nullable[r
ule_table[ruleno].lhs] = 1
;
- *s2++ = r
ule_table[ruleno].lhs
;
+ nullable[r
->lhs->number - ntokens] = true
;
+ *s2++ = r
->lhs->number
;
}
}
}
}
-
XFREE
(squeue);
-
XFREE
(rcount);
-
XFREE (rsets + ntoken
s);
-
XFREE
(relts);
+
free
(squeue);
+
free
(rcount);
+
free (rset
s);
+
free
(relts);
- if (trace_flag)
+ if (trace_flag
& trace_sets
)
nullable_print (stderr);
}
void
nullable_print (stderr);
}
void
-
free_nullabl
e (void)
+
nullable_fre
e (void)
{
{
-
XFREE (nullable + ntokens
);
+
free (nullable
);
}
}