src/ir/adfa/adfa.cc \
src/ir/adfa/prepare.cc \
src/ir/dfa/context_deduplication.cc \
- src/ir/dfa/context_selfoverlap.cc \
src/ir/dfa/determinization.cc \
src/ir/dfa/fallback.cc \
src/ir/dfa/fillpoints.cc \
{
return false;
}
- if (lb1 != lb2 || b1->ub != b2->ub)
+ // tags are forbidden: transitions on different symbols
+ // might go to the same state, but have different tag sets
+ if (lb1 != lb2
+ || b1->ub != b2->ub
+ || b1->tags != 0
+ || b2->tags != 0)
{
return false;
}
void emit_action(OutputFile &o, uint32_t ind, bool &readCh,
const DFA &dfa, const State *s, const std::set<label_t> &used_labels);
-void gen_goto(OutputFile &o, uint32_t ind, bool &readCh, const State *to);
-void gen_goto_case(OutputFile &o, uint32_t ind, bool &readCh, const State *to);
-void gen_goto_if(OutputFile &o, uint32_t ind, bool &readCh, const State *to);
+void gen_goto(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags);
+void gen_goto_case(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags);
+void gen_goto_if(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags);
+void gen_settags(OutputFile &o, uint32_t ind, const DFA &dfa, size_t tags);
} // namespace re2c
emit_rule(o, ind, dfa, s->action.info.rule);
break;
}
- if (s->tags != 0) {
- if (dfa.base_ctxmarker) {
- o.wstring(opts->input_api.stmt_dist(ind, dfa.tagpool[s->tags], dfa.contexts));
- } else {
- o.wstring(opts->input_api.stmt_backupctx(ind));
- }
- }
}
void emit_match(OutputFile &o, uint32_t ind, bool &readCh, const State *s)
o.wind(--ind).ws("}\n");
} else {
const accept_t &acc = *s->action.info.accepts;
- gen_goto(o, ind, readCh, acc[l]);
+ gen_goto(o, ind, readCh, acc[l].first, dfa, acc[l].second);
}
}
// only one possible 'yyaccept' value: unconditional jump
if (nacc == 1) {
- gen_goto(o, ind, readCh, acc[0]);
+ gen_goto(o, ind, readCh, acc[0].first, dfa, acc[0].second);
return;
}
+ bool have_tags = false;
+ for (size_t i = 0; i < nacc; ++i) {
+ if (acc[i].second != 0) {
+ have_tags = true;
+ break;
+ }
+ }
+
// jump table
- if (opts->gFlag && nacc >= opts->cGotoThreshold) {
+ if (opts->gFlag && nacc >= opts->cGotoThreshold && !have_tags) {
o.wind(ind).ws("{\n")
.wind(ind + 1).ws("static void *")
.wstring(opts->yytarget).ws("[")
.wu64(nacc).ws("] = {\n");
for (uint32_t i = 0; i < nacc; ++i) {
o.wind(ind + 2).ws("&&").wstring(opts->labelPrefix)
- .wlabel(acc[i]->label).ws(",\n");
+ .wlabel(acc[i].first->label).ws(",\n");
}
o.wind(ind + 1).ws("};\n")
.wind(ind + 1).ws("goto *")
o.wind(ind).ws("switch (").wstring(opts->yyaccept).ws(") {\n");
for (uint32_t i = 0; i < nacc - 1; ++i) {
o.wind(ind).ws("case ").wu32(i).ws(": ");
- gen_goto_case(o, ind, readCh, acc[i]);
+ gen_goto_case(o, ind, readCh, acc[i].first, dfa, acc[i].second);
}
o.wind(ind).ws("default:");
- gen_goto_case(o, ind, readCh, acc[nacc - 1]);
+ gen_goto_case(o, ind, readCh, acc[nacc - 1].first, dfa, acc[nacc - 1].second);
o.wind(ind).ws("}\n");
}
o.ws("\n");
}
-void gen_goto_case(OutputFile &o, uint32_t ind, bool &readCh, const State *to)
+void gen_goto_case(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags)
{
- const bool multiline = readCh;
+ const bool multiline = readCh || (tags != 0);
if (multiline) {
o.ws("\n");
- gen_goto(o, ind + 1, readCh, to);
+ gen_goto(o, ind + 1, readCh, to, dfa, tags);
} else {
- gen_goto(o, 1, readCh, to);
+ gen_goto(o, 1, readCh, to, dfa, tags);
}
}
-void gen_goto_if(OutputFile &o, uint32_t ind, bool &readCh, const State *to)
+void gen_goto_if(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags)
{
const int32_t linecount = (readCh && to != NULL)
- || (to != NULL);
+ + (tags != 0)
+ + (to != NULL);
if (linecount > 1) {
o.ws("{\n");
- gen_goto(o, ind + 1, readCh, to);
+ gen_goto(o, ind + 1, readCh, to, dfa, tags);
o.wind(ind).ws("}\n");
} else {
- gen_goto(o, 0, readCh, to);
+ gen_goto(o, 0, readCh, to, dfa, tags);
}
}
-void gen_goto(OutputFile &o, uint32_t ind, bool &readCh, const State *to)
+void gen_goto(OutputFile &o, uint32_t ind, bool &readCh,
+ const State *to, const DFA &dfa, size_t tags)
{
if (to == NULL) {
readCh = false;
o.wstring(opts->input_api.stmt_peek(ind));
readCh = false;
}
+ gen_settags(o, ind, dfa, tags);
if (to) {
o.wind(ind).ws("goto ").wstring(opts->labelPrefix)
.wlabel(to->label).ws(";\n");
}
}
+void gen_settags(OutputFile &o, uint32_t ind, const DFA &dfa, size_t tags)
+{
+ if (tags != 0) {
+ if (dfa.base_ctxmarker) {
+ o.wstring(opts->input_api.stmt_dist(ind,
+ dfa.tagpool[tags], dfa.contexts));
+ } else {
+ o.wstring(opts->input_api.stmt_backupctx(ind));
+ }
+ }
+}
+
} // namespace re2c
}
for (uint32_t i = 0; i < accepts.size (); ++i)
{
- used.insert (accepts[i]->label);
+ used.insert (accepts[i].first->label);
}
// must go last: it needs the set of used labels
if (used.count (head->label))
bool readCh = false;
emit_state(o, ind, s, used_labels.count(s->label));
emit_action(o, ind, readCh, *this, s, used_labels);
- s->go.emit(o, ind, readCh);
+ s->go.emit(o, ind, *this, readCh);
}
}
const accept_t &accepts = *s->action.info.accepts;
for (uint32_t i = 0; i < accepts.size(); ++i) {
o.wlabel(s->label).ws(" -> ")
- .wlabel(accepts[i]->label)
+ .wlabel(accepts[i].first->label)
.ws(" [label=\"yyaccept=")
.wu32(i).ws("\"]").ws("\n");
}
}
}
bool readCh = false;
- s->go.emit(o, 0, readCh);
+ s->go.emit(o, 0, *this, readCh);
}
if (!opts->cFlag || last_cond) {
o.ws("}\n");
namespace re2c
{
+struct DFA;
class BitMap;
class State;
struct If;
{
uint32_t ub;
State * to;
+ size_t tags;
FORBID_COPY (Span);
};
{
std::vector<std::pair<uint32_t, uint32_t> > ranges;
const State *to;
+ size_t tags;
void emit(OutputFile &o, uint32_t ind) const;
- inline Case(): ranges(), to(NULL) {}
+ inline Case(): ranges(), to(NULL), tags(0) {}
FORBID_COPY(Case);
};
Case *cases;
uint32_t cases_size;
- void add(uint32_t lb, uint32_t ub, State *to);
+ void add(uint32_t lb, uint32_t ub, State *to, size_t tags);
Cases(const Span *spans, uint32_t nspans);
~Cases();
- void emit(OutputFile &o, uint32_t ind, bool &readCh) const;
+ void emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh) const;
void used_labels(std::set<label_t> &used);
FORBID_COPY(Cases);
};
If * els;
Binary (const Span * s, uint32_t n, const State * next);
~Binary ();
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh);
void used_labels (std::set<label_t> & used);
FORBID_COPY (Binary);
{
const Cond *cond;
const State *to;
+ size_t tags;
- Branch(): cond(NULL), to(NULL) {}
- void init(const Cond *c, const State *s)
+ Branch(): cond(NULL), to(NULL), tags(0) {}
+ void init(const Cond *c, const State *s, size_t ts)
{
cond = c;
to = s;
+ tags = ts;
}
FORBID_COPY(Branch);
};
Linear(const Span *s, uint32_t n, const State *next);
~Linear();
- void emit(OutputFile &o, uint32_t ind, bool &readCh);
+ void emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh);
void used_labels(std::set<label_t> &used);
FORBID_COPY(Linear);
};
} info;
If (type_t t, const Span * sp, uint32_t nsp, const State * next);
~If ();
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh);
void used_labels (std::set<label_t> & used);
};
} info;
SwitchIf (const Span * sp, uint32_t nsp, const State * next);
~SwitchIf ();
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh);
void used_labels (std::set<label_t> & used);
};
SwitchIf * lgo;
GoBitmap (const Span * span, uint32_t nSpans, const Span * hspan, uint32_t hSpans, const BitMap * bm, const State * bm_state, const State * next);
~GoBitmap ();
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh);
void used_labels (std::set<label_t> & used);
FORBID_COPY (GoBitmap);
CpgotoTable * table;
Cpgoto (const Span * span, uint32_t nSpans, const Span * hspan, uint32_t hSpans, const State * next);
~Cpgoto ();
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh);
void used_labels (std::set<label_t> & used);
FORBID_COPY (Cpgoto);
Cases * cases;
Dot (const Span * sp, uint32_t nsp, const State * from);
~Dot ();
- void emit (OutputFile & o);
+ void emit (OutputFile & o, const DFA &dfa);
FORBID_COPY (Dot);
};
{
uint32_t nSpans; // number of spans
Span * span;
+ size_t tags;
enum
{
EMPTY,
Go ();
~Go ();
void init (const State * from);
- void emit (OutputFile & o, uint32_t ind, bool & readCh);
+ void emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh);
void used_labels (std::set<label_t> & used);
Go (const Go & g)
: nSpans (g.nSpans)
, span (g.span)
+ , tags (g.tags)
, type (g.type)
, info (g.info)
{}
{
nSpans = g.nSpans;
span = g.span;
+ tags = g.tags;
type = g.type;
info = g.info;
return * this;
Case &c = cases[cases_size++];
const Span &s = spans[nspans - 1];
c.to = s.to;
+ c.tags = s.tags;
for (uint32_t i = 0, lb = 0; i < nspans; ++i) {
const Span &s = spans[i];
- add(lb, s.ub, s.to);
+ add(lb, s.ub, s.to, s.tags);
lb = s.ub;
}
}
-void Cases::add(uint32_t lb, uint32_t ub, State *to)
+void Cases::add(uint32_t lb, uint32_t ub, State *to, size_t tags)
{
for (uint32_t i = 0; i < cases_size; ++i) {
Case &c = cases[i];
- if (c.to == to) {
+ if (c.to == to && c.tags == tags) {
c.ranges.push_back(std::make_pair(lb, ub));
return;
}
Case &c = cases[cases_size++];
c.ranges.push_back(std::make_pair(lb, ub));
c.to = to;
+ c.tags = tags;
}
Cond::Cond (const std::string & cmp, uint32_t val)
{
for (;;) {
if (n == 1 && s[0].to == next) {
- branches[nbranches++].init(NULL, NULL);
+ branches[nbranches++].init(NULL, NULL, s[0].tags);
return;
} else if (n == 1) {
- branches[nbranches++].init(NULL, s[0].to);
+ branches[nbranches++].init(NULL, s[0].to, s[0].tags);
return;
} else if (n == 2 && s[0].to == next) {
- branches[nbranches++].init(new Cond(">=", s[0].ub), s[1].to);
- branches[nbranches++].init(NULL, NULL);
+ branches[nbranches++].init(new Cond(">=", s[0].ub), s[1].to, s[1].tags);
+ branches[nbranches++].init(NULL, NULL, s[0].tags);
return;
} else if (n == 3
&& s[1].to == next
&& s[1].ub - s[0].ub == 1
- && s[2].to == s[0].to) {
- branches[nbranches++].init(new Cond("!=", s[0].ub), s[0].to);
- branches[nbranches++].init(NULL, NULL);
+ && s[2].to == s[0].to
+ && s[2].tags == s[0].tags) {
+ branches[nbranches++].init(new Cond("!=", s[0].ub), s[0].to, s[0].tags);
+ branches[nbranches++].init(NULL, NULL, s[1].tags);
return;
} else if (n >= 3
&& s[1].ub - s[0].ub == 1
- && s[2].to == s[0].to) {
- branches[nbranches++].init(new Cond("==", s[0].ub), s[1].to);
+ && s[2].to == s[0].to
+ && s[2].tags == s[0].tags) {
+ branches[nbranches++].init(new Cond("==", s[0].ub), s[1].to, s[1].tags);
n -= 2;
s += 2;
} else {
- branches[nbranches++].init(new Cond("<=", s[0].ub - 1), s[0].to);
+ branches[nbranches++].init(new Cond("<=", s[0].ub - 1), s[0].to, s[0].tags);
n -= 1;
s += 1;
}
Go::Go ()
: nSpans (0)
, span (NULL)
+ , tags (0)
, type (EMPTY)
, info ()
{}
}
}
+ bool low_spans_have_tags = false;
+ for (uint32_t i = 0; i < nSpans - hSpans; ++i) {
+ if (span[i].tags != 0) {
+ low_spans_have_tags = true;
+ break;
+ }
+ }
+
// initialize bitmaps
uint32_t nBitmaps = 0;
const BitMap * bitmap = NULL;
type = DOT;
info.dot = new Dot (span, nSpans, from);
}
- else if (opts->gFlag && (dSpans >= opts->cGotoThreshold))
+ else if (opts->gFlag && (dSpans >= opts->cGotoThreshold) && !low_spans_have_tags)
{
type = CPGOTO;
info.cpgoto = new Cpgoto (span, nSpans, hspan, hSpans, from->next);
{
if (old_span[i].to != x)
{
- if (new_nspans > 0 && new_span[new_nspans - 1].to == old_span[i].to)
+ if (new_nspans > 0
+ && new_span[new_nspans - 1].to == old_span[i].to
+ && new_span[new_nspans - 1].tags == old_span[i].tags)
new_span[new_nspans - 1].ub = old_span[i].ub;
else
{
new_span[new_nspans].to = old_span[i].to;
new_span[new_nspans].ub = old_span[i].ub;
+ new_span[new_nspans].tags = old_span[i].tags;
++new_nspans;
}
}
static void output_if (OutputFile & o, uint32_t ind, bool & readCh, const std::string & compare, uint32_t value);
static std::string output_yych (bool & readCh);
-static std::string output_hgo (OutputFile & o, uint32_t ind, bool & readCh, SwitchIf * hgo);
+static std::string output_hgo (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh, SwitchIf * hgo);
std::string output_yych (bool & readCh)
{
o.wind(ind).ws("if (").wstring(output_yych (readCh)).ws(" ").wstring(compare).ws(" ").wc_hex (value).ws(") ");
}
-std::string output_hgo (OutputFile & o, uint32_t ind, bool & readCh, SwitchIf * hgo)
+std::string output_hgo (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh, SwitchIf * hgo)
{
std::string yych = output_yych (readCh);
if (hgo != NULL)
{
o.wind(ind).ws("if (").wstring(yych).ws(" & ~0xFF) {\n");
- hgo->emit (o, ind + 1, readCh);
+ hgo->emit (o, ind + 1, dfa, readCh);
o.wind(ind).ws("} else ");
yych = opts->yych;
}
}
}
-void Cases::emit(OutputFile &o, uint32_t ind, bool &readCh) const
+void Cases::emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh) const
{
o.wind(ind).ws("switch (").wstring(output_yych(readCh)).ws(") {\n");
for (uint32_t i = 1; i < cases_size; ++i) {
const Case &c = cases[i];
c.emit(o, ind);
- gen_goto_case(o, ind, readCh, c.to);
+ gen_goto_case(o, ind, readCh, c.to, dfa, c.tags);
}
// default case must be the last one
const Case &c = cases[0];
o.wind(ind).ws("default:");
- gen_goto_case(o, ind, readCh, c.to);
+ gen_goto_case(o, ind, readCh, c.to, dfa, c.tags);
o.wind(ind).ws("}\n");
}
-void Binary::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void Binary::emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh)
{
- output_if (o, ind, readCh, cond->compare, cond->value);
+ output_if(o, ind, readCh, cond->compare, cond->value);
o.ws("{\n");
- thn->emit (o, ind + 1, readCh);
+ thn->emit(o, ind + 1, dfa, readCh);
o.wind(ind).ws("} else {\n");
- els->emit (o, ind + 1, readCh);
+ els->emit(o, ind + 1, dfa, readCh);
o.wind(ind).ws("}\n");
}
-void Linear::emit(OutputFile &o, uint32_t ind, bool &readCh)
+void Linear::emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh)
{
for (uint32_t i = 0; i < nbranches; ++i) {
const Branch &b = branches[i];
const Cond *cond = b.cond;
if (cond) {
output_if(o, ind, readCh, cond->compare, cond->value);
- gen_goto_if(o, ind, readCh, b.to);
+ gen_goto_if(o, ind, readCh, b.to, dfa, b.tags);
} else {
- gen_goto(o, ind, readCh, b.to);
+ gen_goto(o, ind, readCh, b.to, dfa, b.tags);
}
}
}
-void If::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void If::emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh)
{
- switch (type)
- {
- case BINARY:
- info.binary->emit (o, ind, readCh);
- break;
- case LINEAR:
- info.linear->emit (o, ind, readCh);
- break;
+ switch (type) {
+ case BINARY: info.binary->emit(o, ind, dfa, readCh); break;
+ case LINEAR: info.linear->emit(o, ind, dfa, readCh); break;
}
}
-void SwitchIf::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void SwitchIf::emit(OutputFile &o, uint32_t ind, const DFA &dfa, bool &readCh)
{
- switch (type)
- {
- case SWITCH:
- info.cases->emit (o, ind, readCh);
- break;
- case IF:
- info.ifs->emit (o, ind, readCh);
- break;
+ switch (type) {
+ case SWITCH: info.cases->emit(o, ind, dfa, readCh); break;
+ case IF: info.ifs->emit(o, ind, dfa, readCh); break;
}
}
-void GoBitmap::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void GoBitmap::emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh)
{
- std::string yych = output_hgo (o, ind, readCh, hgo);
+ std::string yych = output_hgo (o, ind, dfa, readCh, hgo);
o.ws("if (").wstring(opts->yybm).ws("[").wu32(bitmap->i).ws("+").wstring(yych).ws("] & ");
if (opts->yybmHexTable)
{
o.wu32(bitmap->m);
}
o.ws(") {\n");
- gen_goto(o, ind + 1, readCh, bitmap_state);
+ gen_goto(o, ind + 1, readCh, bitmap_state, dfa, 0);
o.wind(ind).ws("}\n");
if (lgo != NULL)
{
- lgo->emit (o, ind, readCh);
+ lgo->emit (o, ind, dfa, readCh);
}
}
o.wind(--ind).ws("};\n");
}
-void Cpgoto::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void Cpgoto::emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh)
{
- std::string yych = output_hgo (o, ind, readCh, hgo);
+ std::string yych = output_hgo (o, ind, dfa, readCh, hgo);
o.ws("{\n");
table->emit (o, ++ind);
o.wind(ind).ws("goto *").wstring(opts->yytarget).ws("[").wstring(yych).ws("];\n");
o.wind(--ind).ws("}\n");
}
-void Dot::emit (OutputFile & o)
+void Dot::emit(OutputFile &o, const DFA &dfa)
{
const uint32_t n = cases->cases_size;
if (n == 1) {
for (uint32_t j = 0; j < c.ranges.size(); ++j) {
o.wrange(c.ranges[j].first, c.ranges[j].second);
}
+ const bool *tags = dfa.tagpool[c.tags];
+ for (size_t j = 0; j < dfa.tagpool.ntags; ++j) {
+ if (tags[j]) {
+ o.ws("<").wstring(dfa.contexts[j].name()).ws(">");
+ }
+ }
o.ws("\"]\n");
}
}
}
-void Go::emit (OutputFile & o, uint32_t ind, bool & readCh)
+void Go::emit (OutputFile & o, uint32_t ind, const DFA &dfa, bool & readCh)
{
- switch (type)
- {
+ gen_settags(o, ind, dfa, tags);
+ switch (type) {
case EMPTY:
break;
case SWITCH_IF:
- info.switchif->emit (o, ind, readCh);
+ info.switchif->emit (o, ind, dfa, readCh);
break;
case BITMAP:
- info.bitmap->emit (o, ind, readCh);
+ info.bitmap->emit (o, ind, dfa, readCh);
break;
case CPGOTO:
- info.cpgoto->emit (o, ind, readCh);
+ info.cpgoto->emit (o, ind, dfa, readCh);
break;
case DOT:
- info.dot->emit (o);
+ info.dot->emit (o, dfa);
break;
}
}
{}
};
-typedef uniq_vector_t<const State *> accept_t;
+typedef uniq_vector_t<std::pair<const State*, size_t> > accept_t;
class Action
{
*p = s;
p = &s->next;
- s->tags = t->tags;
s->rule = t->rule;
+ s->rule_tags = t->rule_tags;
s->fill = fill[i];
s->go.span = allocate<Span>(nchars);
uint32_t j = 0;
for (uint32_t c = 0; c < nchars; ++j)
{
const size_t to = t->arcs[c];
- for (;++c < nchars && t->arcs[c] == to;);
+ const size_t tags = t->tags[c];
+ for (;++c < nchars && t->arcs[c] == to && t->tags[c] == tags;);
s->go.span[j].to = to == dfa_t::NIL ? NULL : i2s[to];
s->go.span[j].ub = charset[c];
+ s->go.span[j].tags = tags;
}
s->go.nSpans = j;
}
bool fallback;
size_t rule;
- size_t tags;
+ size_t rule_tags;
bool isBase;
Go go;
Action action;
, fill (0)
, fallback (false)
, rule (Rule::NONE)
- , tags (0)
+ , rule_tags (0)
, isBase (false)
, go ()
, action ()
void addState(State*, State *);
void split (State *);
void findBaseState ();
+ void hoist_tags();
void count_used_labels (std::set<label_t> & used, label_t prolog, label_t start, bool force_start) const;
void emit_body (OutputFile &, uint32_t &, const std::set<label_t> & used_labels, label_t initial) const;
void emit_dot(OutputFile &o, bool last_cond, const std::vector<std::string> &conds) const;
move->rule = s->rule;
move->fill = s->fill;
move->go = s->go;
+ move->rule_tags = s->rule_tags;
s->rule = Rule::NONE;
s->go.nSpans = 1;
s->go.span = allocate<Span> (1);
s->go.span[0].ub = ubChar;
s->go.span[0].to = move;
+ s->go.span[0].tags = 0;
}
static uint32_t merge(Span *x, State *fg, State *bg)
Span *const x0 = x;
for (;!(f == fe && b == be);) {
- if (f->to == b->to) {
+ if (f->to == b->to && f->tags == b->tags) {
x->to = bg;
+ x->tags = 0;
} else {
x->to = f->to;
+ x->tags = f->tags;
}
if (x == x0
- || x[-1].to != x->to) {
+ || x[-1].to != x->to
+ || x[-1].tags != x->tags) {
++x;
}
x[-1].ub = std::min(f->ub, b->ub);
for (uint32_t i = 0; i < s->go.nSpans; ++i) {
if (!s->go.span[i].to) {
s->go.span[i].to = rule2state[s->rule];
+ s->go.span[i].tags = s->rule_tags;
}
}
}
if (default_state) {
for (State *s = head; s; s = s->next) {
if (s->fallback) {
- const size_t accept = accepts.find_or_add(rule2state[s->rule]);
- s->action.set_save(accept);
+ const std::pair<const State*, size_t> acc(rule2state[s->rule], s->rule_tags);
+ s->action.set_save(accepts.find_or_add(acc));
}
}
default_state->action.set_accept(&accepts);
}
+ // tag hoisting should be done before tunneling, but after
+ // binding default arcs (which may introduce new tags)
+ hoist_tags();
+
// split ``base'' states into two parts
for (State * s = head; s; s = s->next)
{
}
}
}
-
// find ``base'' state, if possible
findBaseState();
need_accept = accepts.size () > 1;
}
+void DFA::hoist_tags()
+{
+ for (State * s = head; s; s = s->next) {
+ const size_t nsp = s->go.nSpans;
+ if (nsp > 0) {
+ Span *sp = s->go.span;
+ const size_t tags0 = sp[0].tags;
+ bool common_tags = tags0 != 0;
+ for (uint32_t i = 1; common_tags && i < nsp; ++i) {
+ common_tags &= sp[i].tags == tags0;
+ }
+ if (common_tags) {
+ s->go.tags = tags0;
+ for (uint32_t i = 0; i < nsp; ++i) {
+ sp[i].tags = 0;
+ }
+ }
+ }
+ }
+}
+
} // namespace re2c
*
* Tag T is alive in state S if either:
*
- * - There is a transition from S to default state, S does not set T,
+ * - There is a transition from S to default state that does not set T,
* S is final and T belongs to tag set associated with rule in S.
*
- * - There is a transition from S to default state, S does not set T
+ * - There is a transition from S to default state that does not set T
* and T belongs to any tag set associated with fallback rules.
*
- * - There is a transition from S to some state S' (maybe equal to S),
- * S does not set T and T is alive in S'.
+ * - There is a transition from S to some state S' (maybe equal to S)
+ * that does not set T and T is alive in S'.
*/
static void calc_live(const dfa_t &dfa,
const bool *fallback,
// final state, only rule tags are alive
add_tags_with_mask(&live[i * ntags],
dfa.rules[s->rule].tags,
- dfa.tagpool[s->tags],
+ dfa.tagpool[s->rule_tags],
ntags);
} else {
// transition to default state and dispatch on
calc_live(dfa, fallback, visited, live, j);
add_tags_with_mask(&live[i * ntags],
&live[j * ntags],
- dfa.tagpool[s->tags],
+ dfa.tagpool[s->tags[c]],
ntags);
}
}
const size_t ntags = dfa.contexts.size();
for (size_t i = 0; i < nstates; ++i) {
dfa_state_t *s = dfa.states[i];
- mask_dead_tags(dfa.tagpool, s->tags, &livetags[i * ntags]);
+ for (size_t c = 0; c < dfa.nchars; ++c) {
+ const size_t j = s->arcs[c];
+ if (j != dfa_t::NIL) {
+ s->tags[c] = mask_dead_tags(dfa.tagpool,
+ s->tags[c], &livetags[j * ntags]);
+ }
+ }
+ if (s->rule != Rule::NONE) {
+ s->rule_tags = mask_dead_tags(dfa.tagpool,
+ s->rule_tags, dfa.rules[s->rule].tags);
+ }
}
}
static void incompatibility_table(const dfa_t &dfa,
const bool *livetags,
+ const bool *deftags,
bool *incompattbl)
{
const size_t nstates = dfa.states.size();
const size_t ntags = dfa.contexts.size();
for (size_t i = 0; i < nstates; ++i) {
const dfa_state_t *s = dfa.states[i];
- incompatible(incompattbl, &livetags[i * ntags],
- dfa.tagpool[s->tags], ntags);
+ for (size_t c = 0; c < dfa.nchars; ++c) {
+ const size_t j = s->arcs[c];
+ if (j != dfa_t::NIL) {
+ incompatible(incompattbl,
+ &livetags[j * ntags],
+ dfa.tagpool[s->tags[c]],
+ ntags);
+ }
+ }
+ if (dangling_arcs(s->arcs, dfa.nchars)) {
+ if (s->rule != Rule::NONE) {
+ incompatible(incompattbl,
+ dfa.rules[s->rule].tags,
+ dfa.tagpool[s->rule_tags],
+ ntags);
+ } else {
+ incompatible(incompattbl,
+ deftags,
+ dfa.tagpool[s->rule_tags],
+ ntags);
+ }
+ }
}
}
const size_t nstates = dfa.states.size();
for (size_t i = 0; i < nstates; ++i) {
dfa_state_t *s = dfa.states[i];
- s->tags = patch_tagset(dfa.tagpool, s->tags, represent);
+ for (size_t c = 0; c < dfa.nchars; ++c) {
+ s->tags[c] = patch_tagset(dfa.tagpool, s->tags[c], represent);
+ }
+ s->rule_tags = patch_tagset(dfa.tagpool, s->rule_tags, represent);
}
const size_t ntags = dfa.contexts.size();
mask_dead(dfa, live);
bool *incompattbl = new bool[ntags * ntags]();
- incompatibility_table(dfa, live, incompattbl);
+ incompatibility_table(dfa, live, fbctxs, incompattbl);
std::vector<size_t> represent(ntags, 0);
const size_t nreps = equivalence_classes(incompattbl, ntags, represent);
+++ /dev/null
-#include <algorithm>
-#include <map>
-#include <vector>
-
-#include "src/conf/warn.h"
-#include "src/ir/dfa/dfa.h"
-#include "src/ir/nfa/nfa.h"
-#include "src/util/intersect_sorted.h"
-#include "src/globals.h"
-
-namespace re2c
-{
-
-static void g(nfa_state_t *n, std::vector<nfa_state_t*> &tail);
-static void e(nfa_state_t *n, std::vector<nfa_state_t*> &tail);
-static void f(nfa_state_t *n, std::vector<nfa_state_t*> &tail);
-
-void check_context_selfoverlap(
- ord_hash_set_t &kernels,
- const std::vector<CtxVar> &contexts,
- uint32_t line,
- const std::string &cond)
-{
- const size_t nctxs = contexts.size();
-
- std::vector<bool> bad(nctxs, false);
-
- std::map<nfa_state_t*, std::vector<nfa_state_t*> > shadows;
- for (size_t i = 0; i < kernels.size(); ++i) {
- nfa_state_t **kernel;
- const size_t kernel_size = kernels.deref<nfa_state_t*>(i, kernel);
- for (size_t j = 0; j < kernel_size; ++j) {
- nfa_state_t *n = kernel[j];
- if (n->type == nfa_state_t::CTX
- && !bad[n->value.ctx.info]) {
- std::vector<nfa_state_t*> &shadow = shadows[n];
- if (shadow.empty()) {
- f(n, shadow);
- }
- if (intersect_sorted(
- shadow.begin(), shadow.end(),
- kernel, kernel + kernel_size)) {
- bad[n->value.ctx.info] = true;
- }
- }
- }
- }
-
- for (size_t i = 0; i < nctxs; ++i) {
- if (bad[i]) {
- warn.selfoverlapping_contexts(line, cond, contexts[i]);
- }
- }
-}
-
-void f(nfa_state_t *n, std::vector<nfa_state_t*> &tail)
-{
- e(n, tail);
- std::sort(tail.begin(), tail.end());
-}
-
-void g(nfa_state_t *n, std::vector<nfa_state_t*> &tail)
-{
- if (!n->mark)
- {
- n->mark = true;
- tail.push_back(n);
- switch (n->type)
- {
- case nfa_state_t::ALT:
- g(n->value.alt.out2, tail);
- g(n->value.alt.out1, tail);
- break;
- case nfa_state_t::RAN:
- g(n->value.ran.out, tail);
- break;
- case nfa_state_t::CTX:
- g(n->value.ctx.out, tail);
- break;
- case nfa_state_t::FIN:
- break;
- }
- n->mark = false;
- }
-}
-
-static void e(nfa_state_t *n, std::vector<nfa_state_t*> &tail)
-{
- if (!n->mark)
- {
- n->mark = true;
- switch (n->type)
- {
- case nfa_state_t::ALT:
- e(n->value.alt.out2, tail);
- e(n->value.alt.out1, tail);
- break;
- case nfa_state_t::RAN:
- g(n->value.ran.out, tail);
- break;
- case nfa_state_t::CTX:
- e(n->value.ctx.out, tail);
- break;
- case nfa_state_t::FIN:
- break;
- }
- n->mark = false;
- }
-}
-
-} // namespace re2c
-
#include <algorithm>
#include <limits>
-#include <map>
-#include <set>
#include <vector>
+#include "src/conf/warn.h"
#include "src/ir/dfa/dfa.h"
#include "src/ir/nfa/nfa.h"
#include "src/ir/regexp/regexp.h"
#include "src/util/range.h"
+#include "src/globals.h"
namespace re2c
{
const size_t dfa_t::NIL = std::numeric_limits<size_t>::max();
-/*
- * note [marking DFA states]
+static void merge_tags(bool *oldtags, const bool *newtags,
+ bool *badtags, size_t ntags)
+{
+ for (size_t i = 0; i < ntags; ++i) {
+ badtags[i] |= oldtags[i] ^ newtags[i];
+ oldtags[i] |= newtags[i];
+ }
+}
+
+static void merge_tags_with_mask(bool *oldtags, const bool *newtags,
+ bool *oldmask, const bool *newmask,
+ bool *badtags, size_t ntags)
+{
+ for (size_t i = 0; i < ntags; ++i) {
+ badtags[i] |= oldmask[i] & newmask[i] & (oldtags[i] ^ newtags[i]);
+ oldtags[i] |= newtags[i];
+ oldmask[i] |= newmask[i];
+ }
+}
+struct kitem_t
+{
+ nfa_state_t *state;
+ union
+ {
+ bool *tagptr;
+ size_t tagidx;
+ };
+
+ bool operator <(const kitem_t &k)
+ {
+ return state < k.state
+ || (state == k.state && tagidx < k.tagidx);
+ }
+};
+
+/* note [epsilon-closures in tagged NFA]
*
* DFA state is a set of NFA states.
* However, DFA state includes not all NFA states that are in
* epsilon-closure (NFA states that have only epsilon-transitions
- * and are not context of final states are omitted).
+ * and are not final states are omitted).
* The included states are called 'kernel' states.
*
- * We mark visited NFA states during closure construction.
- * These marks serve two purposes:
- * - avoid loops in NFA
- * - avoid duplication of NFA states in kernel
- *
- * Note that after closure construction:
- * - all non-kernel states must be unmarked (these states are
- * not stored in kernel and it is impossible to unmark them
- * afterwards)
- * - all kernel states must be marked (because we may later
- * extend this kernel with epsilon-closure of another NFA
- * state). Kernel states are unmarked later (before finding
- * or adding DFA state).
+ * For tagged NFA we have to trace all epsilon-paths to each
+ * kernel state, accumulate tags along the way and compare
+ * resulting tag sets: if they differ, then NFA is tagwise
+ * ambiguous. All tags are merged together; ambiguity is reported.
*/
-static nfa_state_t **closure(nfa_state_t **cP, nfa_state_t *n)
+static void closure(kitem_t *const kernel, kitem_t *&kend,
+ nfa_state_t *n, bool *tags, bool *badtags, size_t ntags)
{
- if (!n->mark)
- {
- n->mark = true;
- switch (n->type)
- {
- case nfa_state_t::ALT:
- cP = closure(cP, n->value.alt.out2);
- cP = closure(cP, n->value.alt.out1);
- n->mark = false;
- break;
- case nfa_state_t::CTX:
- *(cP++) = n;
- cP = closure(cP, n->value.ctx.out);
- break;
- default:
- *(cP++) = n;
- break;
- }
+ if (n->mark) {
+ return;
}
- return cP;
+ n->mark = true;
+ switch (n->type) {
+ case nfa_state_t::ALT:
+ closure(kernel, kend, n->value.alt.out2, tags, badtags, ntags);
+ closure(kernel, kend, n->value.alt.out1, tags, badtags, ntags);
+ break;
+ case nfa_state_t::CTX: {
+ const size_t ctx = n->value.ctx.info;
+ const bool old = tags[ctx];
+ tags[ctx] = true;
+ closure(kernel, kend, n->value.ctx.out, tags, badtags, ntags);
+ tags[ctx] = old;
+ break;
+ }
+ case nfa_state_t::RAN:
+ case nfa_state_t::FIN: {
+ kitem_t *k = kernel;
+ while (k != kend && k->state != n) ++k;
+ if (k == kend) {
+ kend->state = n;
+ kend->tagptr = new bool[ntags];
+ memcpy(kend->tagptr, tags, ntags * sizeof(bool));
+ ++kend;
+ } else {
+ // it is impossible to reach the same NFA state from
+ // different rules, so no need to mess with masks here
+ merge_tags(k->tagptr, tags, badtags, ntags);
+ }
+ break;
+ }
+ }
+ n->mark = false;
}
-static size_t find_state
- ( nfa_state_t **kernel
- , nfa_state_t **end
- , ord_hash_set_t &kernels
- )
+static size_t find_state(kitem_t *kernel, kitem_t *kend,
+ ord_hash_set_t &kernels, Tagpool &tagpool)
{
+ const size_t kcount = static_cast<size_t>(kend - kernel);
+
// zero-sized kernel corresponds to default state
- if (kernel == end)
- {
+ if (kcount == 0) {
return dfa_t::NIL;
}
- // see note [marking DFA states]
- for (nfa_state_t **p = kernel; p != end; ++p)
- {
- (*p)->mark = false;
+ // dump tagsets to tagpool and address them by index:
+ // this simpifies storing and comparing kernels
+ for (kitem_t *k = kernel; k != kend; ++k) {
+ bool *tags = k->tagptr;
+ k->tagidx = tagpool.insert(tags);
+ delete[] tags;
}
- // sort kernel states: we need this to get stable hash
- // and to compare states with simple 'memcmp'
- std::sort(kernel, end);
- const size_t size = static_cast<size_t>(end - kernel) * sizeof(nfa_state_t*);
- return kernels.insert(kernel, size);
+ // sort kernel items to allow comparison by hash and 'memcmp'
+ std::sort(kernel, kend);
+
+ return kernels.insert(kernel, kcount * sizeof(kitem_t));
}
dfa_t::dfa_t(
{
const size_t ntags = contexts.size();
const size_t nrules = rules.size();
+ const size_t mask_size = (nchars + 1) * ntags;
ord_hash_set_t kernels;
- nfa_state_t **const buffer = new nfa_state_t*[nfa.size];
- std::vector<std::vector<nfa_state_t*> > arcs(nchars);
+ kitem_t *kstart = new kitem_t[nfa.size], *kend = kstart;
+ bool *ktags = new bool[ntags]();
+ bool *badtags = new bool[ntags]();
+ bool *tags = new bool[mask_size];
+ bool *mask = new bool[mask_size];
bool *fin = new bool[nrules];
- bool *tags = new bool[ntags];
+ std::vector<nfa_state_t*> *arcs = new std::vector<nfa_state_t*>[nchars];
+
+ closure(kstart, kend, nfa.root, ktags, badtags, ntags);
+ find_state(kstart, kend, kernels, tagpool);
+ for (size_t i = 0; i < kernels.size(); ++i) {
+ memset(fin, 0, nrules * sizeof(bool));
+ memset(tags, 0, mask_size * sizeof(bool));
+ memset(mask, 0, mask_size * sizeof(bool));
+ for(size_t c = 0; c < nchars; ++c) {
+ arcs[c].clear();
+ }
- find_state(buffer, closure(buffer, nfa.root), kernels);
- for (size_t i = 0; i < kernels.size(); ++i)
- {
dfa_state_t *s = new dfa_state_t(nchars);
states.push_back(s);
- memset(fin, 0, nrules * sizeof(bool));
- memset(tags, 0, ntags * sizeof(bool));
-
- nfa_state_t **kernel;
- const size_t kernel_size = kernels.deref<nfa_state_t*>(i, kernel);
- for (size_t j = 0; j < kernel_size; ++j)
- {
- nfa_state_t *n = kernel[j];
- switch (n->type)
- {
- case nfa_state_t::RAN:
- {
+ const kitem_t *kernel;
+ const size_t kcount = kernels.deref<const kitem_t>(i, kernel);
+ for (size_t j = 0; j < kcount; ++j) {
+ nfa_state_t *n = kernel[j].state;
+ const bool *newtags = tagpool[kernel[j].tagidx];
+ switch (n->type) {
+ case nfa_state_t::RAN: {
nfa_state_t *m = n->value.ran.out;
size_t c = 0;
- for (const Range *r = n->value.ran.ran; r; r = r->next ())
- {
+ for (const Range *r = n->value.ran.ran; r; r = r->next ()) {
for (; charset[c] != r->lower(); ++c);
- for (; charset[c] != r->upper(); ++c)
- {
+ for (; charset[c] != r->upper(); ++c) {
+ merge_tags_with_mask(&tags[c * ntags], newtags,
+ &mask[c * ntags], rules[m->rule].tags,
+ badtags, ntags);
arcs[c].push_back(m);
}
}
break;
}
- case nfa_state_t::CTX:
- tags[n->value.ctx.info] = true;
- break;
case nfa_state_t::FIN:
+ merge_tags_with_mask(&tags[nchars * ntags], newtags,
+ &mask[nchars * ntags], rules[n->rule].tags,
+ badtags, ntags);
fin[n->rule] = true;
break;
default:
+ assert(false);
break;
}
}
- for(size_t c = 0; c < nchars; ++c)
- {
- nfa_state_t **end = buffer;
- for (std::vector<nfa_state_t*>::const_iterator j = arcs[c].begin(); j != arcs[c].end(); ++j)
- {
- end = closure(end, *j);
+ for (size_t c = 0; c < nchars; ++c) {
+ kend = kstart;
+ const std::vector<nfa_state_t*> &a = arcs[c];
+ for (size_t j = 0; j < a.size(); ++j) {
+ closure(kstart, kend, a[j], ktags, badtags, ntags);
}
- s->arcs[c] = find_state(buffer, end, kernels);
+ s->arcs[c] = find_state(kstart, kend, kernels, tagpool);
+ s->tags[c] = tagpool.insert(&tags[c * ntags]);
}
- s->tags = tagpool.insert(tags);
+ s->rule_tags = tagpool.insert(&tags[nchars * ntags]);
// choose the first rule (the one with smallest rank)
size_t r;
rules[r].shadow.insert(rules[s->rule].info->loc.line);
}
}
+ }
- for(size_t c = 0; c < nchars; ++c)
- {
- arcs[c].clear();
+ for (size_t i = 0; i < ntags; ++i) {
+ if (badtags[i]) {
+ // TODO: use rule line, add rule reference to context struct
+ warn.selfoverlapping_contexts(line, cond, contexts[i]);
}
}
- delete[] buffer;
- delete[] fin;
- delete[] tags;
- check_context_selfoverlap(kernels, contexts, line, cond);
+ delete[] kstart;
+ delete[] ktags;
+ delete[] badtags;
+ delete[] tags;
+ delete[] mask;
+ delete[] fin;
+ delete[] arcs;
}
dfa_t::~dfa_t()
struct dfa_state_t
{
size_t *arcs;
+ size_t *tags;
size_t rule;
- size_t tags;
+ size_t rule_tags;
explicit dfa_state_t(size_t nchars)
: arcs(new size_t[nchars])
+ , tags(new size_t[nchars])
, rule(Rule::NONE)
- , tags(0)
+ , rule_tags(0)
{}
~dfa_state_t()
{
delete[] arcs;
+ delete[] tags;
}
FORBID_COPY(dfa_state_t);
DFA_MINIMIZATION_MOORE
};
-void check_context_selfoverlap(ord_hash_set_t &kernels,
- const std::vector<CtxVar> &contexts,
- uint32_t line, const std::string &cond);
void minimization(dfa_t &dfa);
void fillpoints(const dfa_t &dfa, std::vector<size_t> &fill);
void fallback_states(const dfa_t &dfa, std::vector<size_t> &fallback);
for (size_t j = 0; j < i; ++j)
{
dfa_state_t *s2 = states[j];
- tbl[i][j] = s1->tags != s2->tags
- || s1->rule != s2->rule;
+ tbl[i][j] = s1->rule != s2->rule
+ || s1->rule_tags != s2->rule_tags;
}
}
std::swap(oi, oj);
}
if (oi != oj &&
- (oi == dfa_t::NIL ||
- oj == dfa_t::NIL ||
- tbl[oi][oj]))
+ (oi == dfa_t::NIL
+ || oj == dfa_t::NIL
+ || tbl[oi][oj]
+ || memcmp(states[i]->tags, states[j]->tags, nchars * sizeof(size_t)) != 0))
{
tbl[i][j] = true;
loop = true;
for (size_t i = 0; i < count; ++i)
{
dfa_state_t *s = states[i];
- std::pair<size_t, size_t> key(s->rule, s->tags);
+ std::pair<size_t, size_t> key(s->rule, s->rule_tags);
if (init.insert(std::make_pair(key, i)).second)
{
part[i] = i;
size_t k = diff[n];
if (memcmp(&out[j * nchars],
&out[k * nchars],
- nchars * sizeof(size_t)) == 0)
+ nchars * sizeof(size_t)) == 0
+ && memcmp(states[j]->tags, states[k]->tags, nchars * sizeof(size_t)) == 0)
{
part[j] = k;
next[j] = next[k];
}
}
+Node::~Node()
+{
+ delete[] tags;
+}
+
bool Node::end() const
{
return arcs.size() == 0;
, contexts(dfa.contexts)
{
const size_t nc = cs.size() - 1;
+ const size_t ntags = dfa.tagpool.ntags;
// initialize skeleton nodes
for (size_t i = 0; i < nodes_count - 1; ++i) {
if (arcs.size() == 1 && arcs[0].first == nodes_count - 1) {
arcs.clear();
}
- nodes[i].init(dfa.tagpool[s->tags], s->rule, arcs);
+
+ // in skeleton we are only interested in trailing contexts
+ // which may be attributed to states rather than transitions
+ bool *tags = new bool[ntags]();
+ add_tags(tags, dfa.tagpool[s->rule_tags], ntags);
+ for (size_t c = 0; c < nc; ++c) {
+ add_tags(tags, dfa.tagpool[s->tags[c]], ntags);
+ }
+
+ nodes[i].init(tags, s->rule, arcs);
}
// initialize size of key
const bool *tags;
Node();
+ ~Node();
void init(const bool *ts, size_t r,
const std::vector<std::pair<size_t, uint32_t> > &arcs);
bool end() const;
yy919:
++p;
yych = *p;
- marker = p;
- if (yybm[0+yych] & 64) {
- goto yy923;
+ if (yybm[0+yych] & 16) {
+ goto yy919;
}
if (yych <= 0x00) goto yy917;
- if (yych <= '\n') goto yy925;
- goto yy919;
+ if (yych == '\n') {
+ marker = p;
+ goto yy925;
+ }
+ marker = p;
+ goto yy923;
yy921:
++p;
yych = *p;
- marker = p;
- if (yybm[0+yych] & 128) {
- goto yy927;
+ if (yybm[0+yych] & 32) {
+ goto yy921;
}
if (yych <= 0x00) goto yy917;
- if (yych <= '\n') goto yy929;
- goto yy921;
+ if (yych == '\n') {
+ marker = p;
+ goto yy929;
+ }
+ marker = p;
+ goto yy927;
yy923:
++p;
yych = *p;
yy940:
++p;
yych = *p;
- marker = p;
- if (yybm[0+yych] & 128) {
- goto yy944;
+ if (yybm[0+yych] & 32) {
+ goto yy940;
+ }
+ if (yych <= '\n') {
+ if (yych <= 0x08) goto yy938;
+ if (yych <= '\t') {
+ marker = p;
+ goto yy944;
+ }
+ marker = p;
+ goto yy946;
+ } else {
+ if (yych == ' ') {
+ marker = p;
+ goto yy944;
+ }
+ goto yy938;
}
- if (yych <= 0x08) goto yy938;
- if (yych <= '\n') goto yy946;
- if (yych == '`') goto yy940;
- goto yy938;
yy942:
++p;
yych = *p;
- marker = p;
if (yybm[0+yych] & 64) {
goto yy942;
}
if (yych <= '\n') {
if (yych <= 0x08) goto yy938;
- if (yych <= '\t') goto yy948;
+ if (yych <= '\t') {
+ marker = p;
+ goto yy948;
+ }
+ marker = p;
goto yy950;
} else {
- if (yych == ' ') goto yy948;
+ if (yych == ' ') {
+ marker = p;
+ goto yy948;
+ }
goto yy938;
}
yy944:
#line 107 "config10.c"
xx9:
curr = *++s.cur;
- s.ctx = s.cur;
switch (curr) {
case '0':
case '2':
case '6':
case '7':
case '8':
- case '9': goto xx10;
- case '1': goto xx13;
+ case '9':
+ s.ctx = s.cur;
+ goto xx10;
+ case '1':
+ s.ctx = s.cur;
+ goto xx13;
default: goto xx3;
}
xx10:
s.cur = s.ctx;
#line 56 "config10.re"
{ return KEYWORD; }
-#line 145 "config10.c"
+#line 148 "config10.c"
xx13:
++s.cur;
switch ((curr = *s.cur)) {
s.cur -= 1;
#line 55 "config10.re"
{ return KEYWORD; }
-#line 165 "config10.c"
+#line 168 "config10.c"
}
#line 70 "config10.re"
#line 107 "config8.c"
xx9:
curr = *++s.cur;
- s.ctx = s.cur;
switch (curr) {
case '0':
case '2':
case '6':
case '7':
case '8':
- case '9': goto xx10;
- case '1': goto xx13;
+ case '9':
+ s.ctx = s.cur;
+ goto xx10;
+ case '1':
+ s.ctx = s.cur;
+ goto xx13;
default: goto xx3;
}
xx10:
s.cur = s.ctx;
#line 55 "config8.re"
{ return KEYWORD; }
-#line 145 "config8.c"
+#line 148 "config8.c"
xx13:
++s.cur;
switch ((curr = *s.cur)) {
s.cur -= 1;
#line 54 "config8.re"
{ return KEYWORD; }
-#line 165 "config8.c"
+#line 168 "config8.c"
}
#line 69 "config8.re"
#line 123 "config9.b.c"
xx9:
curr = (unsigned char)*++s.cur;
- s.ctx = s.cur;
if (curr <= '/') goto xx3;
- if (curr == '1') goto xx13;
+ if (curr == '1') {
+ s.ctx = s.cur;
+ goto xx13;
+ }
if (curr >= ':') goto xx3;
+ s.ctx = s.cur;
xx10:
++s.cur;
if (s.lim <= s.cur) fill(1);
s.cur = s.ctx;
#line 57 "config9.b.re"
{ return KEYWORD; }
-#line 140 "config9.b.c"
+#line 143 "config9.b.c"
xx13:
++s.cur;
if ((curr = (unsigned char)*s.cur) <= '/') goto xx14;
s.cur -= 1;
#line 56 "config9.b.re"
{ return KEYWORD; }
-#line 149 "config9.b.c"
+#line 152 "config9.b.c"
}
#line 71 "config9.b.re"
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
switch (YYGETCONDITION()) {
case yycc1: goto yyc_c1;
}
/* *********************************** */
yyc_c1:
- YYBACKUPCTX ();
if (YYLESSTHAN (3)) YYFILL(3);
yych = YYPEEK ();
switch (yych) {
{}
yy5:
YYSKIP ();
- yyctx1 = YYDIST();
+ YYBACKUPCTX ();
switch ((yych = YYPEEK ())) {
case 'b': goto yy7;
default: goto yy6;
}
yy6:
- YYRESTORECTX (yyctx1);
+ YYRESTORECTX ();
{}
yy7:
YYSKIP ();
- yyctx0 = YYDIST();
switch ((yych = YYPEEK ())) {
case 'b': goto yy9;
- case 'c': goto yy11;
- default: goto yy8;
+ case 'c':
+ YYBACKUPCTX ();
+ goto yy11;
+ default:
+ YYBACKUPCTX ();
+ goto yy8;
}
yy8:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy9:
YYSKIP ();
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
switch (YYGETCONDITION()) {
case yycc1: goto yyc_c1;
}
/* *********************************** */
yyc_c1:
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
{}
yy5:
++YYCURSOR;
- yyctx1 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
switch ((yych = *YYCURSOR)) {
case 'b': goto yy7;
default: goto yy6;
}
yy6:
- YYCURSOR = YYCTXMARKER + yyctx1;
+ YYCURSOR = YYCTXMARKER;
{}
yy7:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch ((yych = *YYCURSOR)) {
case 'b': goto yy9;
- case 'c': goto yy11;
- default: goto yy8;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy11;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy8;
}
yy8:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy9:
++YYCURSOR;
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
switch (YYGETCONDITION()) {
case yycc1: goto yyc_c1;
case yycc2: goto yyc_c2;
}
/* *********************************** */
yyc_c1:
- YYBACKUPCTX ();
if (YYLESSTHAN (3)) YYFILL(3);
yych = YYPEEK ();
switch (yych) {
{}
yy5:
YYSKIP ();
- yyctx1 = YYDIST();
+ YYBACKUPCTX ();
switch ((yych = YYPEEK ())) {
case 'b': goto yy7;
default: goto yy6;
}
yy6:
- YYRESTORECTX (yyctx1);
+ YYRESTORECTX ();
{}
yy7:
YYSKIP ();
- yyctx0 = YYDIST();
switch ((yych = YYPEEK ())) {
case 'b': goto yy9;
- case 'c': goto yy11;
- default: goto yy8;
+ case 'c':
+ YYBACKUPCTX ();
+ goto yy11;
+ default:
+ YYBACKUPCTX ();
+ goto yy8;
}
yy8:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy9:
YYSKIP ();
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
switch (YYGETCONDITION()) {
case yycc1: goto yyc_c1;
case yycc2: goto yyc_c2;
}
/* *********************************** */
yyc_c1:
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
{}
yy5:
++YYCURSOR;
- yyctx1 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
switch ((yych = *YYCURSOR)) {
case 'b': goto yy7;
default: goto yy6;
}
yy6:
- YYCURSOR = YYCTXMARKER + yyctx1;
+ YYCURSOR = YYCTXMARKER;
{}
yy7:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch ((yych = *YYCURSOR)) {
case 'b': goto yy9;
- case 'c': goto yy11;
- default: goto yy8;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy11;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy8;
}
yy8:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy9:
++YYCURSOR;
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
- long yyctx3;
switch (YYGETCONDITION()) {
case yycc1: goto yyc_c1;
case yycc2: goto yyc_c2;
}
/* *********************************** */
yyc_c1:
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
{}
yy5:
++YYCURSOR;
- yyctx1 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
switch ((yych = *YYCURSOR)) {
case 'b': goto yy7;
default: goto yy6;
}
yy6:
- YYCURSOR = YYCTXMARKER + yyctx1;
+ YYCURSOR = YYCTXMARKER;
{}
yy7:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch ((yych = *YYCURSOR)) {
case 'b': goto yy9;
- case 'c': goto yy11;
- default: goto yy8;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy11;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy8;
}
yy8:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy9:
++YYCURSOR;
}
/* *********************************** */
yyc_c2:
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
}
yy15:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
goto yy20;
yy16:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy17:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case 'a': goto yy21;
- case 'b': goto yy23;
- case 'c': goto yy26;
- default: goto yy18;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy23;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy26;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy18;
}
yy18:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy19:
++YYCURSOR;
}
yy21:
yych = *++YYCURSOR;
- yyctx3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case 'b': goto yy28;
- case 'c': goto yy31;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy28;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy31;
default: goto yy22;
}
yy22:
YYCURSOR = YYMARKER;
+ YYCTXMARKER = YYCURSOR;
goto yy18;
yy23:
++YYCURSOR;
default: goto yy25;
}
yy25:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy26:
++YYCURSOR;
default: goto yy30;
}
yy30:
- YYCURSOR = YYCTXMARKER + yyctx3;
+ YYCURSOR = YYCTXMARKER;
{}
yy31:
++YYCURSOR;
default: goto yy33;
}
yy33:
- YYCURSOR = YYCTXMARKER + yyctx3;
+ YYCURSOR = YYCTXMARKER;
{}
}
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy18:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy18:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy18:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy18:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy18:
YYSKIP ();
yych = YYPEEK ();
- zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy18:
yych = *++YYCURSOR;
- zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy18:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy18:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy18:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy18:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy7:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
case '0':
case '1':
case '2':
yy8:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy9:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p1 = ZZ_DIST();
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = ZZ_DIST();
+ goto yy5;
default: goto yy6;
}
yy10:
yy11:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
case '0':
case '1':
case '2':
yy12:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
yy13:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p2 = ZZ_DIST();
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = ZZ_DIST();
+ goto yy10;
default: goto yy6;
}
yy14:
yy15:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
case '0':
case '1':
case '2':
parse_oct(ZZ_CTX(ctxs.zz_0p3) + 1, s));
return;
}
-#line 264 "contexts/conf6.--contexts--input(custom).c"
+#line 272 "contexts/conf6.--contexts--input(custom).c"
yy18:
YYSKIP ();
yych = YYPEEK ();
- ctxs.zz_0p3 = ZZ_DIST();
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = ZZ_DIST();
+ goto yy14;
default: goto yy6;
}
yy19:
#line 54 "contexts/conf6.--contexts.c"
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
goto yy3;
yy7:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
case '0':
case '1':
case '2':
}
yy8:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy9:
yych = *++YYCURSOR;
- ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy5;
+ case '.':
+ ctxs.zz_0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
default: goto yy6;
}
yy10:
}
yy11:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
case '0':
case '1':
case '2':
}
yy12:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
}
yy13:
yych = *++YYCURSOR;
- ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy10;
+ case '.':
+ ctxs.zz_0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
default: goto yy6;
}
yy14:
}
yy15:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
case '0':
case '1':
case '2':
parse_oct((YYCTXMARKER + ctxs.zz_0p3) + 1, YYCURSOR));
return;
}
-#line 244 "contexts/conf6.--contexts.c"
+#line 252 "contexts/conf6.--contexts.c"
yy18:
yych = *++YYCURSOR;
- ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case '.': goto yy14;
+ case '.':
+ ctxs.zz_0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy14;
default: goto yy6;
}
yy19:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
case 'a': goto yy5;
- case 'b': goto yy7;
- case 'c': goto yy10;
+ case 'b':
+ YYBACKUPCTX ();
+ goto yy7;
+ case 'c':
+ YYBACKUPCTX ();
+ goto yy10;
default: goto yy3;
}
yy5:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
- case 'z': goto yy13;
+ case 'z':
+ YYBACKUPCTX ();
+ goto yy13;
default: goto yy6;
}
yy6:
{}
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- YYCTXMARKER = YYCURSOR;
switch (yych) {
case 'a': goto yy5;
- case 'b': goto yy7;
- case 'c': goto yy10;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy7;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy10;
default: goto yy3;
}
yy5:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
switch (yych) {
- case 'z': goto yy13;
+ case 'z':
+ YYCTXMARKER = YYCURSOR;
+ goto yy13;
default: goto yy6;
}
yy6:
{
YYCTYPE yych;
- long yyctx0;
- long yyctx2;
- YYBACKUPCTX ();
if (YYLESSTHAN (3)) YYFILL(3);
yych = YYPEEK ();
switch (yych) {
}
yy2:
YYSKIP ();
- yyctx0 = YYDIST();
+ YYBACKUPCTX ();
yych = YYPEEK ();
goto yy7;
yy3:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy4:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- yyctx0 = YYDIST();
switch (yych) {
case 'a': goto yy8;
- default: goto yy11;
+ case 'b':
+ YYBACKUPCTX ();
+ goto yy10;
+ default:
+ YYBACKUPCTX ();
+ goto yy5;
}
yy5:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy6:
YYSKIP ();
yy8:
YYSKIP ();
yych = YYPEEK ();
- yyctx2 = YYDIST();
switch (yych) {
- case 'b': goto yy12;
- case 'c': goto yy15;
+ case 'b':
+ YYBACKUPCTX ();
+ goto yy12;
+ case 'c':
+ YYBACKUPCTX ();
+ goto yy15;
default: goto yy9;
}
yy9:
YYRESTORE ();
+ YYBACKUPCTX ();
goto yy5;
yy10:
YYSKIP ();
if (YYLESSTHAN (1)) YYFILL(1);
yych = YYPEEK ();
-yy11:
switch (yych) {
case 'b': goto yy10;
default: goto yy5;
default: goto yy14;
}
yy14:
- YYRESTORECTX (yyctx2);
+ YYRESTORECTX ();
{}
yy15:
YYSKIP ();
default: goto yy17;
}
yy17:
- YYRESTORECTX (yyctx2);
+ YYRESTORECTX ();
{}
}
{
YYCTYPE yych;
- long yyctx0;
- long yyctx2;
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
}
yy2:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
goto yy7;
yy3:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case 'a': goto yy8;
- default: goto yy11;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy10;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy5;
}
yy5:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy6:
++YYCURSOR;
}
yy8:
yych = *++YYCURSOR;
- yyctx2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case 'b': goto yy12;
- case 'c': goto yy15;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy12;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy15;
default: goto yy9;
}
yy9:
YYCURSOR = YYMARKER;
+ YYCTXMARKER = YYCURSOR;
goto yy5;
yy10:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
-yy11:
switch (yych) {
case 'b': goto yy10;
default: goto yy5;
default: goto yy14;
}
yy14:
- YYCURSOR = YYCTXMARKER + yyctx2;
+ YYCURSOR = YYCTXMARKER;
{}
yy15:
++YYCURSOR;
default: goto yy17;
}
yy17:
- YYCURSOR = YYCTXMARKER + yyctx2;
+ YYCURSOR = YYCTXMARKER;
{}
}
}
yy2:
YYSKIP ();
- YYBACKUPCTX ();
yych = YYPEEK ();
goto yy6;
YYRESTORECTX ();
{}
yy4:
YYSKIP ();
- YYBACKUPCTX ();
switch ((yych = YYPEEK ())) {
case 'a': goto yy10;
default: goto yy8;
goto yy8;
yy10:
YYSKIP ();
- YYBACKUPCTX ();
yych = YYPEEK ();
goto yy8;
}
}
yy2:
++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
goto yy6;
YYCURSOR = YYCTXMARKER;
{}
yy4:
++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
switch ((yych = *YYCURSOR)) {
case 'a': goto yy10;
default: goto yy8;
goto yy8;
yy10:
++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
goto yy8;
}
{
YYCTYPE yych;
- long yyctx0;
- long yyctx2;
- YYBACKUPCTX ();
if (YYLESSTHAN (3)) YYFILL(3);
yych = YYPEEK ();
switch (yych) {
}
yy2:
YYSKIP ();
- yyctx0 = YYDIST();
+ YYBACKUPCTX ();
yych = YYPEEK ();
goto yy7;
yy3:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy4:
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- yyctx0 = YYDIST();
switch (yych) {
case 'a': goto yy8;
- default: goto yy11;
+ case 'b':
+ YYBACKUPCTX ();
+ goto yy10;
+ default:
+ YYBACKUPCTX ();
+ goto yy5;
}
yy5:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy6:
YYSKIP ();
yy8:
YYSKIP ();
yych = YYPEEK ();
- yyctx2 = YYDIST();
switch (yych) {
- case 'b': goto yy12;
+ case 'b':
+ YYBACKUPCTX ();
+ goto yy12;
default: goto yy9;
}
yy9:
YYRESTORE ();
+ YYBACKUPCTX ();
goto yy5;
yy10:
YYSKIP ();
if (YYLESSTHAN (1)) YYFILL(1);
yych = YYPEEK ();
-yy11:
switch (yych) {
case 'b': goto yy10;
default: goto yy5;
default: goto yy14;
}
yy14:
- YYRESTORECTX (yyctx2);
+ YYRESTORECTX ();
{}
}
{
YYCTYPE yych;
- long yyctx0;
- long yyctx2;
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
}
yy2:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
goto yy7;
yy3:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case 'a': goto yy8;
- default: goto yy11;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy10;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy5;
}
yy5:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy6:
++YYCURSOR;
}
yy8:
yych = *++YYCURSOR;
- yyctx2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
- case 'b': goto yy12;
+ case 'b':
+ YYCTXMARKER = YYCURSOR;
+ goto yy12;
default: goto yy9;
}
yy9:
YYCURSOR = YYMARKER;
+ YYCTXMARKER = YYCURSOR;
goto yy5;
yy10:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
-yy11:
switch (yych) {
case 'b': goto yy10;
default: goto yy5;
default: goto yy14;
}
yy14:
- YYCURSOR = YYCTXMARKER + yyctx2;
+ YYCURSOR = YYCTXMARKER;
{}
}
long yyctx0p4;
YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
- yyctx0p4 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
+ case '1':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0p4 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
default: goto yy3;
}
yy2:
yy5:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0p4 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '1':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0p4 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0p4 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy7:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0p4 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '2':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0p4 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0p4 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy9:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0p4 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '3':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0p4 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0p4 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy11:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0p4 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '4':
+ yyctx0p4 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0p4 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy13:
++YYCURSOR;
long yyctx0p3;
YYBACKUPCTX ();
yych = YYPEEK ();
- yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
+ case '1':
+ yyctx0p1 = YYDIST();
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy13;
default: goto yy3;
}
yy2:
yy5:
YYSKIP ();
yych = YYPEEK ();
- yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '1':
+ yyctx0p1 = YYDIST();
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = YYDIST();
+ goto yy2;
}
yy7:
YYSKIP ();
yych = YYPEEK ();
- yyctx0 = yyctx0p3 = yyctx0p2 = YYDIST();
switch (yych) {
case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '2':
+ yyctx0p2 = YYDIST();
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = YYDIST();
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = YYDIST();
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = yyctx0p2 = YYDIST();
+ goto yy2;
}
yy9:
YYSKIP ();
yych = YYPEEK ();
- yyctx0 = yyctx0p3 = YYDIST();
switch (yych) {
case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '3':
+ yyctx0p3 = YYDIST();
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = YYDIST();
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = YYDIST();
+ goto yy2;
}
yy11:
YYSKIP ();
yych = YYPEEK ();
- yyctx0 = YYDIST();
switch (yych) {
case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '4':
+ yyctx0 = YYDIST();
+ goto yy13;
+ default:
+ yyctx0 = YYDIST();
+ goto yy2;
}
yy13:
YYSKIP ();
long yyctx0p3;
YYCTXMARKER = YYCURSOR;
yych = *YYCURSOR;
- yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
+ case '1':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
default: goto yy3;
}
yy2:
yy5:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '0': goto yy5;
- case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '1':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy7;
+ case '2':
+ yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = yyctx0p2 = yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy7:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '1': goto yy7;
- case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '2':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '3':
+ yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy9:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '2': goto yy9;
- case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '3':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ case '4':
+ yyctx0 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0 = yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy11:
++YYCURSOR;
yych = *YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '3': goto yy11;
- case '4': goto yy13;
- default: goto yy2;
+ case '4':
+ yyctx0 = (YYCURSOR - YYCTXMARKER);
+ goto yy13;
+ default:
+ yyctx0 = (YYCURSOR - YYCTXMARKER);
+ goto yy2;
}
yy13:
++YYCURSOR;
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '1':
- case '2': goto yy6;
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
+ case '2':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy8;
default: goto yy3;
}
yy5:
++YYCURSOR;
yych = *YYCURSOR;
-yy6:
switch (yych) {
case '1': goto yy5;
case '2': goto yy8;
goto yy3;
yy8:
yych = *++YYCURSOR;
- yyctx0p3 = (YYCURSOR - YYCTXMARKER);
- goto yy10;
+ switch (yych) {
+ case '3':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '4':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ default: goto yy7;
+ }
yy9:
++YYCURSOR;
yych = *YYCURSOR;
-yy10:
switch (yych) {
case '3': goto yy9;
case '4': goto yy11;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- yyctx0p1 = YYDIST();
switch (yych) {
case '1':
- case '2': goto yy6;
+ yyctx0p1 = YYDIST();
+ goto yy5;
+ case '2':
+ yyctx0p1 = YYDIST();
+ goto yy8;
default: goto yy3;
}
yy5:
YYSKIP ();
yych = YYPEEK ();
-yy6:
switch (yych) {
case '1': goto yy5;
case '2': goto yy8;
yy8:
YYSKIP ();
yych = YYPEEK ();
- yyctx0p3 = YYDIST();
- goto yy10;
+ switch (yych) {
+ case '3':
+ yyctx0p3 = YYDIST();
+ goto yy9;
+ case '4':
+ yyctx0p3 = YYDIST();
+ goto yy11;
+ default: goto yy7;
+ }
yy9:
YYSKIP ();
yych = YYPEEK ();
-yy10:
switch (yych) {
case '3': goto yy9;
case '4': goto yy11;
{ printf("error\n"); return; }
yy4:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0p1 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '1':
- case '2': goto yy6;
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy5;
+ case '2':
+ yyctx0p1 = (YYCURSOR - YYCTXMARKER);
+ goto yy8;
default: goto yy3;
}
yy5:
++YYCURSOR;
yych = *YYCURSOR;
-yy6:
switch (yych) {
case '1': goto yy5;
case '2': goto yy8;
goto yy3;
yy8:
yych = *++YYCURSOR;
- yyctx0p3 = (YYCURSOR - YYCTXMARKER);
- goto yy10;
+ switch (yych) {
+ case '3':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy9;
+ case '4':
+ yyctx0p3 = (YYCURSOR - YYCTXMARKER);
+ goto yy11;
+ default: goto yy7;
+ }
yy9:
++YYCURSOR;
yych = *YYCURSOR;
-yy10:
switch (yych) {
case '3': goto yy9;
case '4': goto yy11;
}
yy5:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '2':
- case '3': goto yy11;
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
+ case '3':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy12;
default: goto yy3;
}
yy6:
goto yy3;
yy9:
yych = *++YYCURSOR;
- yyctx0p2 = (YYCURSOR - YYCTXMARKER);
- goto yy11;
+ switch (yych) {
+ case '2':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
+ case '3':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy12;
+ default: goto yy8;
+ }
yy10:
++YYCURSOR;
yych = *YYCURSOR;
-yy11:
switch (yych) {
case '2': goto yy10;
case '3': goto yy12;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- yyctx0p2 = YYDIST();
switch (yych) {
case '2':
- case '3': goto yy11;
+ yyctx0p2 = YYDIST();
+ goto yy10;
+ case '3':
+ yyctx0p2 = YYDIST();
+ goto yy12;
default: goto yy3;
}
yy6:
yy9:
YYSKIP ();
yych = YYPEEK ();
- yyctx0p2 = YYDIST();
- goto yy11;
+ switch (yych) {
+ case '2':
+ yyctx0p2 = YYDIST();
+ goto yy10;
+ case '3':
+ yyctx0p2 = YYDIST();
+ goto yy12;
+ default: goto yy8;
+ }
yy10:
YYSKIP ();
yych = YYPEEK ();
-yy11:
switch (yych) {
case '2': goto yy10;
case '3': goto yy12;
}
yy5:
yych = *(YYMARKER = ++YYCURSOR);
- yyctx0p2 = (YYCURSOR - YYCTXMARKER);
switch (yych) {
case '2':
- case '3': goto yy11;
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
+ case '3':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy12;
default: goto yy3;
}
yy6:
goto yy3;
yy9:
yych = *++YYCURSOR;
- yyctx0p2 = (YYCURSOR - YYCTXMARKER);
- goto yy11;
+ switch (yych) {
+ case '2':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy10;
+ case '3':
+ yyctx0p2 = (YYCURSOR - YYCTXMARKER);
+ goto yy12;
+ default: goto yy8;
+ }
yy10:
++YYCURSOR;
yych = *YYCURSOR;
-yy11:
switch (yych) {
case '2': goto yy10;
case '3': goto yy12;
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
- YYBACKUPCTX ();
if (YYLESSTHAN (3)) YYFILL(3);
yych = YYPEEK ();
switch (yych) {
{}
yy4:
YYSKIP ();
- yyctx1 = YYDIST();
+ YYBACKUPCTX ();
switch ((yych = YYPEEK ())) {
case 'b': goto yy6;
default: goto yy5;
}
yy5:
- YYRESTORECTX (yyctx1);
+ YYRESTORECTX ();
{}
yy6:
YYSKIP ();
- yyctx0 = YYDIST();
switch ((yych = YYPEEK ())) {
case 'b': goto yy8;
- case 'c': goto yy10;
- default: goto yy7;
+ case 'c':
+ YYBACKUPCTX ();
+ goto yy10;
+ default:
+ YYBACKUPCTX ();
+ goto yy7;
}
yy7:
- YYRESTORECTX (yyctx0);
+ YYRESTORECTX ();
{}
yy8:
YYSKIP ();
{
YYCTYPE yych;
- long yyctx0;
- long yyctx1;
- YYCTXMARKER = YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 3) YYFILL(3);
yych = *YYCURSOR;
switch (yych) {
{}
yy4:
++YYCURSOR;
- yyctx1 = (YYCURSOR - YYCTXMARKER);
+ YYCTXMARKER = YYCURSOR;
switch ((yych = *YYCURSOR)) {
case 'b': goto yy6;
default: goto yy5;
}
yy5:
- YYCURSOR = YYCTXMARKER + yyctx1;
+ YYCURSOR = YYCTXMARKER;
{}
yy6:
++YYCURSOR;
- yyctx0 = (YYCURSOR - YYCTXMARKER);
switch ((yych = *YYCURSOR)) {
case 'b': goto yy8;
- case 'c': goto yy10;
- default: goto yy7;
+ case 'c':
+ YYCTXMARKER = YYCURSOR;
+ goto yy10;
+ default:
+ YYCTXMARKER = YYCURSOR;
+ goto yy7;
}
yy7:
- YYCURSOR = YYCTXMARKER + yyctx0;
+ YYCURSOR = YYCTXMARKER;
{}
yy8:
++YYCURSOR;
{ printf("error\n"); return; }
yy4:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
switch (yych) {
- case 'a': goto yy5;
+ case 'a':
+ YYCTXMARKER = YYCURSOR;
+ goto yy5;
default: goto yy3;
}
yy5:
++YYCURSOR;
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
switch (yych) {
- case 'a': goto yy5;
+ case 'a':
+ YYCTXMARKER = YYCURSOR;
+ goto yy5;
default: goto yy7;
}
yy7:
--- /dev/null
+/* Generated by re2c */
+// Normally re2c generates one 'yyaccept' value for each rule
+// that is shadowed by a longer rule.
+// However, if two different accepting states accept the same
+// rule, but their epsilon-transitions to this rule have
+// different sets of tags, re2c should split 'yyaccept' value.
+
+
+{
+ YYCTYPE yych;
+ unsigned int yyaccept = 0;
+ if ((YYLIMIT - YYCURSOR) < 5) YYFILL(5);
+ yych = *YYCURSOR;
+ switch (yych) {
+ case 'a': goto yy4;
+ default: goto yy2;
+ }
+yy2:
+ ++YYCURSOR;
+ {}
+yy4:
+ yyaccept = 0;
+ yych = *(YYMARKER = ++YYCURSOR);
+ YYCTXMARKER = YYCURSOR;
+ switch (yych) {
+ case 'b': goto yy6;
+ default: goto yy5;
+ }
+yy5:
+ YYCURSOR = YYCTXMARKER;
+ {}
+yy6:
+ yych = *++YYCURSOR;
+ switch (yych) {
+ case 'c': goto yy8;
+ default: goto yy7;
+ }
+yy7:
+ YYCURSOR = YYMARKER;
+ if (yyaccept == 0) {
+ YYCTXMARKER = YYCURSOR;
+ goto yy5;
+ } else {
+ goto yy5;
+ }
+yy8:
+ yyaccept = 1;
+ yych = *(YYMARKER = ++YYCURSOR);
+ switch (yych) {
+ case 'd': goto yy9;
+ default: goto yy5;
+ }
+yy9:
+ yych = *++YYCURSOR;
+ switch (yych) {
+ case 'e': goto yy10;
+ default: goto yy7;
+ }
+yy10:
+ ++YYCURSOR;
+ {}
+}
+
--- /dev/null
+// Normally re2c generates one 'yyaccept' value for each rule
+// that is shadowed by a longer rule.
+// However, if two different accepting states accept the same
+// rule, but their epsilon-transitions to this rule have
+// different sets of tags, re2c should split 'yyaccept' value.
+
+/*!re2c
+ "a" / "bc"? {}
+ "abcde" {}
+ * {}
+*/
#line 127 "ctx.b.c"
yy9:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych <= '/') goto yy3;
- if (yych == '1') goto yy13;
+ if (yych == '1') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy13;
+ }
if (yych >= ':') goto yy3;
+ YYCTXMARKER = YYCURSOR;
yy10:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
YYCURSOR = YYCTXMARKER;
#line 49 "ctx.b.re"
{ return KEYWORD; }
-#line 144 "ctx.b.c"
+#line 147 "ctx.b.c"
yy13:
++YYCURSOR;
if ((yych = *YYCURSOR) <= '/') goto yy14;
YYCURSOR -= 1;
#line 48 "ctx.b.re"
{ return KEYWORD; }
-#line 153 "ctx.b.c"
+#line 156 "ctx.b.c"
}
#line 63 "ctx.b.re"
#line 111 "ctx.c"
yy9:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
switch (yych) {
case '0':
case '2':
case '6':
case '7':
case '8':
- case '9': goto yy10;
- case '1': goto yy13;
+ case '9':
+ YYCTXMARKER = YYCURSOR;
+ goto yy10;
+ case '1':
+ YYCTXMARKER = YYCURSOR;
+ goto yy13;
default: goto yy3;
}
yy10:
YYCURSOR = YYCTXMARKER;
#line 49 "ctx.re"
{ return KEYWORD; }
-#line 149 "ctx.c"
+#line 152 "ctx.c"
yy13:
++YYCURSOR;
switch ((yych = *YYCURSOR)) {
YYCURSOR -= 1;
#line 48 "ctx.re"
{ return KEYWORD; }
-#line 169 "ctx.c"
+#line 172 "ctx.c"
}
#line 63 "ctx.re"
#line 94 "ctx.s.c"
yy9:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych <= '/') goto yy3;
- if (yych == '1') goto yy13;
+ if (yych == '1') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy13;
+ }
if (yych >= ':') goto yy3;
+ YYCTXMARKER = YYCURSOR;
yy10:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
YYCURSOR = YYCTXMARKER;
#line 49 "ctx.s.re"
{ return KEYWORD; }
-#line 111 "ctx.s.c"
+#line 114 "ctx.s.c"
yy13:
++YYCURSOR;
if ((yych = *YYCURSOR) <= '/') goto yy14;
YYCURSOR -= 1;
#line 48 "ctx.s.re"
{ return KEYWORD; }
-#line 120 "ctx.s.c"
+#line 123 "ctx.s.c"
}
#line 63 "ctx.s.re"
yy15:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
- case '[': goto yy16;
+ case '[':
+ YYBACKUPCTX ();
+ goto yy16;
default: goto yy6;
}
yy16:
YYRESTORECTX ();
#line 15 "input_custom_default.--input(custom).re"
{ return true; }
-#line 154 "input_custom_default.--input(custom).c"
+#line 155 "input_custom_default.--input(custom).c"
}
#line 17 "input_custom_default.--input(custom).re"
yy15:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
- case '[': goto yy16;
+ case '[':
+ YYBACKUPCTX ();
+ goto yy16;
default: goto yy6;
}
yy16:
YYRESTORECTX ();
#line 24 "input_custom_fgetc.--input(custom).re"
{ return true; }
-#line 163 "input_custom_fgetc.--input(custom).c"
+#line 164 "input_custom_fgetc.--input(custom).c"
}
#line 26 "input_custom_fgetc.--input(custom).re"
yy15:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
- case '[': goto yy16;
+ case '[':
+ YYBACKUPCTX ();
+ goto yy16;
default: goto yy6;
}
yy16:
YYRESTORECTX ();
#line 17 "input_custom_istringstream.--input(custom).re"
{ return true; }
-#line 156 "input_custom_istringstream.--input(custom).c"
+#line 157 "input_custom_istringstream.--input(custom).c"
}
#line 19 "input_custom_istringstream.--input(custom).re"
yy173:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
case '!':
case '.':
case 'x':
case 'y':
case 'z': goto yy72;
- default: goto yy248;
+ default:
+ YYBACKUPCTX ();
+ goto yy248;
}
yy174:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
case '!':
case '.':
case 'x':
case 'y':
case 'z': goto yy72;
- default: goto yy250;
+ default:
+ YYBACKUPCTX ();
+ goto yy250;
}
yy175:
YYSKIP ();
if (YYLESSTHAN (2)) YYFILL(2);
yych = YYPEEK ();
- YYBACKUPCTX ();
switch (yych) {
case '\t':
case ' ': goto yy427;
case '\r': goto yy429;
- case '/': goto yy431;
- default: goto yy425;
+ case '/':
+ YYBACKUPCTX ();
+ goto yy431;
+ default:
+ YYBACKUPCTX ();
+ goto yy425;
}
yy425:
YYSKIP ();
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy50:
if (yych <= 0x1F) {
if (yych == '\t') goto yy49;
} else {
if (yych <= ' ') goto yy49;
if (yych <= '0') goto yy13;
- if (yych <= '9') goto yy57;
+ if (yych <= '9') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy57;
+ }
goto yy13;
}
yy51:
goto yy126;
yy136:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
goto yy174;
yy137:
yyaccept = 4;
}
yy139:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == 'e') goto yy182;
goto yy174;
yy140:
}
yy167:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
- goto yy194;
+ if (yych <= '9') {
+ if (yych <= '\t') {
+ if (yych <= 0x08) goto yy144;
+ YYCTXMARKER = YYCURSOR;
+ goto yy193;
+ } else {
+ if (yych == ' ') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy193;
+ }
+ goto yy144;
+ }
+ } else {
+ if (yych <= '=') {
+ if (yych <= ':') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy195;
+ }
+ if (yych <= '<') goto yy144;
+ YYCTXMARKER = YYCURSOR;
+ goto yy196;
+ } else {
+ if (yych == '{') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy197;
+ }
+ goto yy144;
+ }
+ }
yy168:
++YYCURSOR;
yy169:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy174:
if (yybm[0+yych] & 32) {
goto yy173;
}
if (yych <= ' ') {
- if (yych == '\t') goto yy170;
+ if (yych == '\t') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy170;
+ }
if (yych <= 0x1F) goto yy168;
+ YYCTXMARKER = YYCURSOR;
goto yy170;
} else {
if (yych <= ',') {
if (yych <= '+') goto yy168;
+ YYCTXMARKER = YYCURSOR;
goto yy171;
} else {
if (yych <= '<') goto yy168;
- if (yych <= '>') goto yy171;
+ if (yych <= '>') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy171;
+ }
goto yy168;
}
}
}
yy182:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == '2') goto yy206;
goto yy174;
yy183:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
-yy194:
if (yych <= '9') {
if (yych <= '\t') {
if (yych <= 0x08) goto yy144;
}
yy206:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == 'c') goto yy214;
goto yy174;
yy207:
goto yy144;
yy214:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == ':') goto yy222;
goto yy174;
yy215:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy230:
if (yych <= 0x1F) {
if (yych == '\t') goto yy229;
} else {
if (yych <= ' ') goto yy229;
if (yych <= '0') goto yy144;
- if (yych <= '9') goto yy233;
+ if (yych <= '9') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy233;
+ }
goto yy144;
}
yy231:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy279:
if (yych <= 0x1F) {
if (yych == '\t') goto yy278;
if (yych <= ' ') goto yy278;
if (yych <= '0') goto yy265;
if (yych >= ':') goto yy265;
+ YYCTXMARKER = YYCURSOR;
}
yy280:
++YYCURSOR;
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy313:
if (yych <= 0x1F) {
if (yych == '\t') goto yy312;
if (yych <= ' ') goto yy312;
if (yych <= '0') goto yy301;
if (yych >= ':') goto yy301;
+ YYCTXMARKER = YYCURSOR;
}
yy314:
++YYCURSOR;
49 -> 50
50 -> 13 [label="[0x00-0x08][0x0A-0x1F][!-0][:-0xFF]"]
50 -> 49 [label="[0x09][ ]"]
-50 -> 57 [label="[1-9]"]
+50 -> 57 [label="[1-9]<yyctx9>"]
51 -> 13 [label="[0x00-s][u-0xFF]"]
51 -> 59 [label="[t]"]
52 -> 13 [label="[0x00-q][s-0xFF]"]
164 [label="scanner_re2c_default.--emit-dot.re:258"]
165 -> 166
166 [label="scanner_re2c_default.--emit-dot.re:331"]
-167 -> 194
+167 -> 144 [label="[0x00-0x08][0x0A-0x1F][!-9][;-<][>-z][|-0xFF]"]
+167 -> 193 [label="[0x09][ ]<yyctx13>"]
+167 -> 195 [label="[:]<yyctx13>"]
+167 -> 196 [label="[=]<yyctx13>"]
+167 -> 197 [label="[{]<yyctx13>"]
168 -> 169
169 [label="scanner_re2c_default.--emit-dot.re:403"]
170 -> 202
172 [label="scanner_re2c_default.--emit-dot.re:397"]
173 -> 174
174 -> 168 [label="[0x00-0x08][0x0A-0x1F][!-+][--/][:-<][?-@][[-^][`][{-0xFF]"]
-174 -> 170 [label="[0x09][ ]"]
-174 -> 171 [label="[,][=->]"]
+174 -> 170 [label="[0x09][ ]<yyctx13>"]
+174 -> 171 [label="[,][=->]<yyctx13>"]
174 -> 173 [label="[0-9][A-Z][_][a-z]"]
175 -> 176
176 -> 175 [label="[0x00-0x09][0x0B-[][^-0xFF]"]
229 -> 230
230 -> 144 [label="[0x00-0x08][0x0A-0x1F][!-0][:-0xFF]"]
230 -> 229 [label="[0x09][ ]"]
-230 -> 233 [label="[1-9]"]
+230 -> 233 [label="[1-9]<yyctx13>"]
231 -> 144 [label="[0x00-@][[-^][`][{-0xFF]"]
231 -> 226 [label="[A-Z][_][a-z]"]
232 -> 144 [label="[0x00-@][[-^][`][{-0xFF]"]
280 -> 281
281 -> 265 [label="[0x00-0x08][0x0A-0x1F][!-0][:-0xFF]"]
281 -> 280 [label="[0x09][ ]"]
-281 -> 282 [label="[1-9]"]
+281 -> 282 [label="[1-9]<yyctx2>"]
282 -> 283
283 -> 265 [label="[0x00-0x08][0x0B-0x0C][0x0E-0x1F][!-/][:-0xFF]"]
283 -> 284 [label="[0x09][ ]"]
314 -> 315
315 -> 303 [label="[0x00-0x08][0x0A-0x1F][!-0][:-0xFF]"]
315 -> 314 [label="[0x09][ ]"]
-315 -> 316 [label="[1-9]"]
+315 -> 316 [label="[1-9]<yyctx2>"]
316 -> 317
317 -> 303 [label="[0x00-0x08][0x0B-0x0C][0x0E-0x1F][!-/][:-0xFF]"]
317 -> 318 [label="[0x09][ ]"]
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy50:
if (yych <= 0x1F) {
if (yych == '\t') goto yy49;
} else {
if (yych <= ' ') goto yy49;
if (yych <= '0') goto yy13;
- if (yych <= '9') goto yy57;
+ if (yych <= '9') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy57;
+ }
goto yy13;
}
yy51:
goto yy126;
yy136:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
goto yy174;
yy137:
yyaccept = 4;
}
yy139:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == 'e') goto yy182;
goto yy174;
yy140:
}
yy167:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
- goto yy194;
+ if (yych <= '9') {
+ if (yych <= '\t') {
+ if (yych <= 0x08) goto yy144;
+ YYCTXMARKER = YYCURSOR;
+ goto yy193;
+ } else {
+ if (yych == ' ') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy193;
+ }
+ goto yy144;
+ }
+ } else {
+ if (yych <= '=') {
+ if (yych <= ':') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy195;
+ }
+ if (yych <= '<') goto yy144;
+ YYCTXMARKER = YYCURSOR;
+ goto yy196;
+ } else {
+ if (yych == '{') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy197;
+ }
+ goto yy144;
+ }
+ }
yy168:
++YYCURSOR;
yy169:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy174:
if (yybm[0+yych] & 32) {
goto yy173;
}
if (yych <= ' ') {
- if (yych == '\t') goto yy170;
+ if (yych == '\t') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy170;
+ }
if (yych <= 0x1F) goto yy168;
+ YYCTXMARKER = YYCURSOR;
goto yy170;
} else {
if (yych <= ',') {
if (yych <= '+') goto yy168;
+ YYCTXMARKER = YYCURSOR;
goto yy171;
} else {
if (yych <= '<') goto yy168;
- if (yych <= '>') goto yy171;
+ if (yych <= '>') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy171;
+ }
goto yy168;
}
}
}
yy182:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == '2') goto yy206;
goto yy174;
yy183:
++YYCURSOR;
if ((YYLIMIT - YYCURSOR) < 2) YYFILL(2);
yych = *YYCURSOR;
-yy194:
if (yych <= '9') {
if (yych <= '\t') {
if (yych <= 0x08) goto yy144;
}
yy206:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == 'c') goto yy214;
goto yy174;
yy207:
goto yy144;
yy214:
yych = *++YYCURSOR;
- YYCTXMARKER = YYCURSOR;
if (yych == ':') goto yy222;
goto yy174;
yy215:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy230:
if (yych <= 0x1F) {
if (yych == '\t') goto yy229;
} else {
if (yych <= ' ') goto yy229;
if (yych <= '0') goto yy144;
- if (yych <= '9') goto yy233;
+ if (yych <= '9') {
+ YYCTXMARKER = YYCURSOR;
+ goto yy233;
+ }
goto yy144;
}
yy231:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy281:
if (yych <= 0x1F) {
if (yych == '\t') goto yy280;
if (yych <= ' ') goto yy280;
if (yych <= '0') goto yy265;
if (yych >= ':') goto yy265;
+ YYCTXMARKER = YYCURSOR;
}
yy282:
++YYCURSOR;
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
yych = *YYCURSOR;
- YYCTXMARKER = YYCURSOR;
yy315:
if (yych <= 0x1F) {
if (yych == '\t') goto yy314;
if (yych <= ' ') goto yy314;
if (yych <= '0') goto yy303;
if (yych >= ':') goto yy303;
+ YYCTXMARKER = YYCURSOR;
}
yy316:
++YYCURSOR;
YYSKIP ();
YYBACKUP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
- if (yych == '/') goto yy7;
+ if (yych == '/') {
+ YYBACKUPCTX ();
+ goto yy7;
+ }
goto yy3;
yy5:
YYSKIP ();
yy9:
YYSKIP ();
yych = YYPEEK ();
- YYBACKUPCTX ();
- if (yych == '/') goto yy7;
+ if (yych == '/') {
+ YYBACKUPCTX ();
+ goto yy7;
+ }
goto yy8;
yy10:
YYSKIP ();
projects / re2c / commitdiff