1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
inline Rules::Rules()
:
d_defaultAction(false),
d_currentRule(0),
d_currentProduction(0)
{}
inline void Rules::clearLocations()
{
d_location.clear();
}
inline void Rules::setExpectedConflicts(size_t value)
{
s_nExpectedConflicts = value;
}
inline Terminal const *Rules::eofTerminal()
{
return &s_eofTerminal;
}
inline Terminal const *Rules::errorTerminal()
{
return &s_errorTerminal;
}
inline size_t Rules::acceptProductionNr()
{
return s_acceptProductionNr;
}
inline size_t Rules::expectedConflicts()
{
return s_nExpectedConflicts;
}
inline Production const &Rules::lastProduction() const
{
return *d_currentProduction;
}
inline std::string const &Rules::name() const
{
return d_currentRule->name();
}
inline std::string const &Rules::sType() const
{
return d_currentRule->sType();
}
inline size_t Rules::nProductions() const
{
return d_currentRule->nProductions();
}
inline bool Rules::hasRules() const
{
return d_currentRule;
}
inline size_t Rules::nElements() const
{
return d_currentProduction->size();
}
inline void Rules::setLastTerminalValue(size_t value)
{
d_terminal.back()->setValue(value);
}
inline void Rules::setLastPrecedence(size_t value)
{
d_terminal.back()->setPrecedence(value);
}
inline void Rules::setStartRule(std::string const &start)
{
d_startRule = start;
}
inline std::string const &Rules::startRule() const
{
return d_startRule;
}
inline Production const *Rules::startProduction()
{
return d_currentProduction;
}
inline Symbol const *Rules::startSymbol()
{
return s_startSymbol;
}
inline std::vector<NonTerminal const *> const &Rules::nonTerminals() const
{
void const *vp = &d_nonTerminal;
return *reinterpret_cast<std::vector<NonTerminal const *> const *>
(vp);
}
inline std::vector<Terminal const *> const &Rules::terminals() const
{
void const *vp = &d_terminal;
return *reinterpret_cast<std::vector<Terminal const *> const *>(vp);
}
inline std::vector<Production const *> const &Rules::productions() const
{
void const *vp = &d_production;
return *reinterpret_cast<std::vector<Production const *> const *>(vp);
}
inline Rules::FileInfo const &Rules::fileInfo(NonTerminal const *nt) const
{
return d_location.find(nt)->second;
}
inline Symbol const *Rules::symbol(size_t idx) const
{
return d_currentProduction->rhs(idx - 1);
}
inline bool Rules::empty() const // true: production rule w/o symbols
{
return d_currentProduction->size() == 0;
}
|
