mirror of
https://github.com/ZDoom/gzdoom.git
synced 2024-11-18 10:21:42 +00:00
c54f2f66fc
while and killing centaurs with the flechette. - Fixed: Moving to an old level in a hub caused the old player's inventory to spawn owned by the current player (but still hanging off the old player), so the game would hang when trying to delete it. - Modified re2c so that it doesn't add a date to the file it generates. Thus, if it regenerates a file during a full rebuild, SVN won't see it as a change. Also updated it to 0.10.5. - Fixed: SC_GetString() did not properly terminate sc_String when the last token in the file had no white space after it. Since I could not actually find the problem (it works fine in debug mode and I saw no logic errors), I decided to take this opportunity to reimplement it using an re2c-generated scanner. Now it's 1.6x faster than before and correctness is easier to verify. - Fixed: FMODSoundRenderer::Shutdown() also needs to reset NumChannels. - Added back the Manifest to zdoom.rc for non-VC8 Windows compilers. - Fixed MinGW compilation again. Now it uses the same method as Makefile.linux to find all the source files so that it doesn't need to be manually updated each time source files are added or removed. - Added the SVN revision number to the version string. A new tool is used to obtain this information from the svnversion command and write it into a header file. If you don't have the svn command line tools installed or didn't check it out from the repository, you can still build. I added some rules for this to Makefile.linux, and I assume they work because they do for Makefile.mingw. - Fixed: MIDISong2 did not delete MusHeader in its destructor. SVN r200 (trunk)
1721 lines
28 KiB
C++
1721 lines
28 KiB
C++
/* $Id: code.cc,v 1.74 2006/05/14 13:38:26 helly Exp $ */
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include "substr.h"
|
|
#include "globals.h"
|
|
#include "dfa.h"
|
|
#include "parser.h"
|
|
#include "code.h"
|
|
|
|
namespace re2c
|
|
{
|
|
|
|
// there must be at least one span in list; all spans must cover
|
|
// same range
|
|
|
|
std::string indent(uint ind)
|
|
{
|
|
std::string str;
|
|
|
|
while (ind-- > 0)
|
|
{
|
|
str += indString;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static std::string space(uint this_label)
|
|
{
|
|
int nl = next_label > 9999 ? 4 : next_label > 999 ? 3 : next_label > 99 ? 2 : next_label > 9 ? 1 : 0;
|
|
int tl = this_label > 9999 ? 4 : this_label > 999 ? 3 : this_label > 99 ? 2 : this_label > 9 ? 1 : 0;
|
|
|
|
return std::string(std::max(1, nl - tl + 1), ' ');
|
|
}
|
|
|
|
void Go::compact()
|
|
{
|
|
// arrange so that adjacent spans have different targets
|
|
uint i = 0;
|
|
|
|
for (uint j = 1; j < nSpans; ++j)
|
|
{
|
|
if (span[j].to != span[i].to)
|
|
{
|
|
++i;
|
|
span[i].to = span[j].to;
|
|
}
|
|
|
|
span[i].ub = span[j].ub;
|
|
}
|
|
|
|
nSpans = i + 1;
|
|
}
|
|
|
|
void Go::unmap(Go *base, const State *x)
|
|
{
|
|
Span *s = span, *b = base->span, *e = &b[base->nSpans];
|
|
uint lb = 0;
|
|
s->ub = 0;
|
|
s->to = NULL;
|
|
|
|
for (; b != e; ++b)
|
|
{
|
|
if (b->to == x)
|
|
{
|
|
if ((s->ub - lb) > 1)
|
|
{
|
|
s->ub = b->ub;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (b->to != s->to)
|
|
{
|
|
if (s->ub)
|
|
{
|
|
lb = s->ub;
|
|
++s;
|
|
}
|
|
|
|
s->to = b->to;
|
|
}
|
|
|
|
s->ub = b->ub;
|
|
}
|
|
}
|
|
|
|
s->ub = e[ -1].ub;
|
|
++s;
|
|
nSpans = s - span;
|
|
}
|
|
|
|
void doGen(const Go *g, const State *s, uint *bm, uint f, uint m)
|
|
{
|
|
Span *b = g->span, *e = &b[g->nSpans];
|
|
uint lb = 0;
|
|
|
|
for (; b < e; ++b)
|
|
{
|
|
if (b->to == s)
|
|
{
|
|
for (; lb < b->ub && lb < 256; ++lb)
|
|
{
|
|
bm[lb-f] |= m;
|
|
}
|
|
}
|
|
|
|
lb = b->ub;
|
|
}
|
|
}
|
|
|
|
void prt(std::ostream& o, const Go *g, const State *s)
|
|
{
|
|
Span *b = g->span, *e = &b[g->nSpans];
|
|
uint lb = 0;
|
|
|
|
for (; b < e; ++b)
|
|
{
|
|
if (b->to == s)
|
|
{
|
|
printSpan(o, lb, b->ub);
|
|
}
|
|
|
|
lb = b->ub;
|
|
}
|
|
}
|
|
|
|
bool matches(const Go *g1, const State *s1, const Go *g2, const State *s2)
|
|
{
|
|
Span *b1 = g1->span, *e1 = &b1[g1->nSpans];
|
|
uint lb1 = 0;
|
|
Span *b2 = g2->span, *e2 = &b2[g2->nSpans];
|
|
uint lb2 = 0;
|
|
|
|
for (;;)
|
|
{
|
|
for (; b1 < e1 && b1->to != s1; ++b1)
|
|
{
|
|
lb1 = b1->ub;
|
|
}
|
|
|
|
for (; b2 < e2 && b2->to != s2; ++b2)
|
|
{
|
|
lb2 = b2->ub;
|
|
}
|
|
|
|
if (b1 == e1)
|
|
{
|
|
return b2 == e2;
|
|
}
|
|
|
|
if (b2 == e2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (lb1 != lb2 || b1->ub != b2->ub)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
++b1;
|
|
++b2;
|
|
}
|
|
}
|
|
|
|
BitMap *BitMap::first = NULL;
|
|
|
|
BitMap::BitMap(const Go *g, const State *x)
|
|
: go(g)
|
|
, on(x)
|
|
, next(first)
|
|
, i(0)
|
|
, m(0)
|
|
{
|
|
first = this;
|
|
}
|
|
|
|
BitMap::~BitMap()
|
|
{
|
|
if (next)
|
|
{
|
|
delete next;
|
|
}
|
|
}
|
|
|
|
const BitMap *BitMap::find(const Go *g, const State *x)
|
|
{
|
|
for (const BitMap *b = first; b; b = b->next)
|
|
{
|
|
if (matches(b->go, b->on, g, x))
|
|
{
|
|
return b;
|
|
}
|
|
}
|
|
|
|
return new BitMap(g, x);
|
|
}
|
|
|
|
const BitMap *BitMap::find(const State *x)
|
|
{
|
|
for (const BitMap *b = first; b; b = b->next)
|
|
{
|
|
if (b->on == x)
|
|
{
|
|
return b;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void BitMap::gen(std::ostream &o, uint ind, uint lb, uint ub)
|
|
{
|
|
BitMap *b = first;
|
|
|
|
if (b && bLastPass)
|
|
{
|
|
o << indent(ind) << "static unsigned char yybm[] = {";
|
|
|
|
uint c = 1, n = ub - lb;
|
|
|
|
while((b = const_cast<BitMap*>(b->next)) != NULL) {
|
|
++c;
|
|
}
|
|
b = first;
|
|
|
|
uint *bm = new uint[n];
|
|
|
|
for (uint i = 0, t = 1; b; i += n, t += 8)
|
|
{
|
|
memset(bm, 0, n * sizeof(uint));
|
|
|
|
for (uint m = 0x80; b && m; m >>= 1)
|
|
{
|
|
b->i = i;
|
|
b->m = m;
|
|
doGen(b->go, b->on, bm, lb, m);
|
|
b = const_cast<BitMap*>(b->next);
|
|
}
|
|
|
|
if (c > 8)
|
|
{
|
|
o << "\n" << indent(ind+1) << "/* table " << t << " .. " << std::min(c, t+7) << ": " << i << " */";
|
|
}
|
|
|
|
for (uint j = 0; j < n; ++j)
|
|
{
|
|
if (j % 8 == 0)
|
|
{
|
|
o << "\n" << indent(ind+1);
|
|
}
|
|
|
|
if (yybmHexTable)
|
|
{
|
|
prtHex(o, bm[j], false);
|
|
}
|
|
else
|
|
{
|
|
o << std::setw(3) << (uint)bm[j];
|
|
}
|
|
o << ", ";
|
|
}
|
|
}
|
|
|
|
o << "\n" << indent(ind) << "};\n";
|
|
/* stats(); */
|
|
|
|
delete[] bm;
|
|
}
|
|
}
|
|
|
|
void BitMap::stats()
|
|
{
|
|
uint n = 0;
|
|
|
|
for (const BitMap *b = first; b; b = b->next)
|
|
{
|
|
prt(std::cerr, b->go, b->on);
|
|
std::cerr << std::endl;
|
|
++n;
|
|
}
|
|
|
|
std::cerr << n << " bitmaps\n";
|
|
first = NULL;
|
|
}
|
|
|
|
void genGoTo(std::ostream &o, uint ind, const State *from, const State *to, bool & readCh)
|
|
{
|
|
if (readCh && from->label + 1 != to->label)
|
|
{
|
|
o << indent(ind) << "yych = *YYCURSOR;\n";
|
|
readCh = false;
|
|
}
|
|
|
|
o << indent(ind) << "goto yy" << to->label << ";\n";
|
|
vUsedLabels.insert(to->label);
|
|
}
|
|
|
|
void genIf(std::ostream &o, uint ind, const char *cmp, uint v, bool &readCh)
|
|
{
|
|
if (readCh)
|
|
{
|
|
o << indent(ind) << "if((yych = *YYCURSOR) ";
|
|
readCh = false;
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "if(yych ";
|
|
}
|
|
|
|
o << cmp << " ";
|
|
prtChOrHex(o, v);
|
|
o << ") ";
|
|
}
|
|
|
|
static void need(std::ostream &o, uint ind, uint n, bool & readCh, bool bSetMarker)
|
|
{
|
|
uint fillIndex = next_fill_index;
|
|
|
|
if (fFlag)
|
|
{
|
|
next_fill_index++;
|
|
o << indent(ind) << "YYSETSTATE(" << fillIndex << ");\n";
|
|
}
|
|
|
|
if (bUseYYFill)
|
|
{
|
|
if (n == 1)
|
|
{
|
|
o << indent(ind) << "if(YYLIMIT == YYCURSOR) YYFILL(1);\n";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "if((YYLIMIT - YYCURSOR) < " << n << ") YYFILL(" << n << ");\n";
|
|
}
|
|
}
|
|
|
|
if (fFlag)
|
|
{
|
|
o << "yyFillLabel" << fillIndex << ":\n";
|
|
}
|
|
|
|
if (bSetMarker)
|
|
{
|
|
o << indent(ind) << "yych = *(YYMARKER = YYCURSOR);\n";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "yych = *YYCURSOR;\n";
|
|
}
|
|
readCh = false;
|
|
}
|
|
|
|
void Match::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (state->link)
|
|
{
|
|
o << indent(ind) << "++YYCURSOR;\n";
|
|
}
|
|
else if (!readAhead())
|
|
{
|
|
/* do not read next char if match */
|
|
o << indent(ind) << "++YYCURSOR;\n";
|
|
readCh = true;
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "yych = *++YYCURSOR;\n";
|
|
readCh = false;
|
|
}
|
|
|
|
if (state->link)
|
|
{
|
|
need(o, ind, state->depth, readCh, false);
|
|
}
|
|
}
|
|
|
|
void Enter::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (state->link)
|
|
{
|
|
o << indent(ind) << "++YYCURSOR;\n";
|
|
if (vUsedLabels.count(label))
|
|
{
|
|
o << "yy" << label << ":\n";
|
|
}
|
|
need(o, ind, state->depth, readCh, false);
|
|
}
|
|
else
|
|
{
|
|
/* we shouldn't need 'rule-following' protection here */
|
|
o << indent(ind) << "yych = *++YYCURSOR;\n";
|
|
if (vUsedLabels.count(label))
|
|
{
|
|
o << "yy" << label << ":\n";
|
|
}
|
|
readCh = false;
|
|
}
|
|
}
|
|
|
|
void Initial::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (!startLabelName.empty())
|
|
{
|
|
o << startLabelName << ":\n";
|
|
}
|
|
|
|
if (vUsedLabels.count(1))
|
|
{
|
|
if (state->link)
|
|
{
|
|
o << indent(ind) << "++YYCURSOR;\n";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "yych = *++YYCURSOR;\n";
|
|
}
|
|
}
|
|
|
|
if (vUsedLabels.count(label))
|
|
{
|
|
o << "yy" << label << ":\n";
|
|
}
|
|
else if (!label)
|
|
{
|
|
o << "\n";
|
|
}
|
|
|
|
if (dFlag)
|
|
{
|
|
o << indent(ind) << "YYDEBUG(" << label << ", *YYCURSOR);\n";
|
|
}
|
|
|
|
if (state->link)
|
|
{
|
|
need(o, ind, state->depth, readCh, setMarker && bUsedYYMarker);
|
|
}
|
|
else
|
|
{
|
|
if (setMarker && bUsedYYMarker)
|
|
{
|
|
o << indent(ind) << "YYMARKER = YYCURSOR;\n";
|
|
}
|
|
readCh = false;
|
|
}
|
|
}
|
|
|
|
void Save::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (bUsedYYAccept)
|
|
{
|
|
o << indent(ind) << "yyaccept = " << selector << ";\n";
|
|
}
|
|
|
|
if (state->link)
|
|
{
|
|
if (bUsedYYMarker)
|
|
{
|
|
o << indent(ind) << "YYMARKER = ++YYCURSOR;\n";
|
|
}
|
|
need(o, ind, state->depth, readCh, false);
|
|
}
|
|
else
|
|
{
|
|
if (bUsedYYMarker)
|
|
{
|
|
o << indent(ind) << "yych = *(YYMARKER = ++YYCURSOR);\n";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "yych = *++YYCURSOR;\n";
|
|
}
|
|
readCh = false;
|
|
}
|
|
}
|
|
|
|
Move::Move(State *s) : Action(s)
|
|
{
|
|
;
|
|
}
|
|
|
|
void Move::emit(std::ostream &, uint, bool &) const
|
|
{
|
|
;
|
|
}
|
|
|
|
Accept::Accept(State *x, uint n, uint *s, State **r)
|
|
: Action(x), nRules(n), saves(s), rules(r)
|
|
{
|
|
;
|
|
}
|
|
|
|
void Accept::genRuleMap()
|
|
{
|
|
for (uint i = 0; i < nRules; ++i)
|
|
{
|
|
if (saves[i] != ~0u)
|
|
{
|
|
mapRules[saves[i]] = rules[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void Accept::emitBinary(std::ostream &o, uint ind, uint l, uint r, bool &readCh) const
|
|
{
|
|
if (l < r)
|
|
{
|
|
uint m = (l + r) >> 1;
|
|
|
|
o << indent(ind) << "if(yyaccept <= " << m << ") {\n";
|
|
emitBinary(o, ++ind, l, m, readCh);
|
|
o << indent(--ind) << "} else {\n";
|
|
emitBinary(o, ++ind, m + 1, r, readCh);
|
|
o << indent(--ind) << "}\n";
|
|
}
|
|
else
|
|
{
|
|
genGoTo(o, ind, state, mapRules.find(l)->second, readCh);
|
|
}
|
|
}
|
|
|
|
void Accept::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (mapRules.size() > 0)
|
|
{
|
|
bUsedYYMarker = true;
|
|
o << indent(ind) << "YYCURSOR = YYMARKER;\n";
|
|
|
|
if (readCh) // shouldn't be necessary, but might become at some point
|
|
{
|
|
o << indent(ind) << "yych = *YYCURSOR;\n";
|
|
readCh = false;
|
|
}
|
|
|
|
if (mapRules.size() > 1)
|
|
{
|
|
bUsedYYAccept = true;
|
|
|
|
if (gFlag && mapRules.size() >= cGotoThreshold)
|
|
{
|
|
o << indent(ind++) << "{\n";
|
|
o << indent(ind++) << "static void *yytarget[" << mapRules.size() << "] = {\n";
|
|
for (RuleMap::const_iterator it = mapRules.begin(); it != mapRules.end(); ++it)
|
|
{
|
|
o << indent(ind) << "&&yy" << it->second->label << ",\n";
|
|
vUsedLabels.insert(it->second->label);
|
|
}
|
|
o << indent(--ind) << "};\n";
|
|
o << indent(ind) << "goto *yytarget[yyaccept];\n";
|
|
o << indent(--ind) << "}\n";
|
|
}
|
|
else if (sFlag)
|
|
{
|
|
emitBinary(o, ind, 0, mapRules.size() - 1, readCh);
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "switch(yyaccept) {\n";
|
|
|
|
for (RuleMap::const_iterator it = mapRules.begin(); it != mapRules.end(); ++it)
|
|
{
|
|
o << indent(ind) << "case " << it->first << ": \t";
|
|
genGoTo(o, 0, state, it->second, readCh);
|
|
}
|
|
|
|
o << indent(ind) << "}\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no need to write if statement here since there is only case 0.
|
|
genGoTo(o, ind, state, mapRules.find(0)->second, readCh);
|
|
}
|
|
}
|
|
}
|
|
|
|
Rule::Rule(State *s, RuleOp *r) : Action(s), rule(r)
|
|
{
|
|
;
|
|
}
|
|
|
|
void Rule::emit(std::ostream &o, uint ind, bool &) const
|
|
{
|
|
uint back = rule->ctx->fixedLength();
|
|
|
|
if (back != 0u)
|
|
{
|
|
o << indent(ind) << "YYCURSOR = YYCTXMARKER;\n";
|
|
}
|
|
|
|
RuleLine rl(*rule);
|
|
|
|
o << file_info(sourceFileInfo, &rl);
|
|
o << indent(ind);
|
|
o << rule->code->text;
|
|
o << "\n";
|
|
o << outputFileInfo;
|
|
}
|
|
|
|
void doLinear(std::ostream &o, uint ind, Span *s, uint n, const State *from, const State *next, bool &readCh, uint mask)
|
|
{
|
|
for (;;)
|
|
{
|
|
State *bg = s[0].to;
|
|
|
|
while (n >= 3 && s[2].to == bg && (s[1].ub - s[0].ub) == 1)
|
|
{
|
|
if (s[1].to == next && n == 3)
|
|
{
|
|
if (!mask || (s[0].ub > 0x00FF))
|
|
{
|
|
genIf(o, ind, "!=", s[0].ub, readCh);
|
|
genGoTo(o, 0, from, bg, readCh);
|
|
}
|
|
if (next->label != from->label + 1)
|
|
{
|
|
genGoTo(o, ind, from, next, readCh);
|
|
}
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
if (!mask || (s[0].ub > 0x00FF))
|
|
{
|
|
genIf(o, ind, "==", s[0].ub, readCh);
|
|
genGoTo(o, 0, from, s[1].to, readCh);
|
|
}
|
|
}
|
|
|
|
n -= 2;
|
|
s += 2;
|
|
}
|
|
|
|
if (n == 1)
|
|
{
|
|
// if(bg != next){
|
|
if (s[0].to->label != from->label + 1)
|
|
{
|
|
genGoTo(o, ind, from, s[0].to, readCh);
|
|
}
|
|
// }
|
|
return ;
|
|
}
|
|
else if (n == 2 && bg == next)
|
|
{
|
|
if (!mask || (s[0].ub > 0x00FF))
|
|
{
|
|
genIf(o, ind, ">=", s[0].ub, readCh);
|
|
genGoTo(o, 0, from, s[1].to, readCh);
|
|
}
|
|
if (next->label != from->label + 1)
|
|
{
|
|
genGoTo(o, ind, from, next, readCh);
|
|
}
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
if (!mask || ((s[0].ub - 1) > 0x00FF))
|
|
{
|
|
genIf(o, ind, "<=", s[0].ub - 1, readCh);
|
|
genGoTo(o, 0, from, bg, readCh);
|
|
}
|
|
n -= 1;
|
|
s += 1;
|
|
}
|
|
}
|
|
|
|
if (next->label != from->label + 1)
|
|
{
|
|
genGoTo(o, ind, from, next, readCh);
|
|
}
|
|
}
|
|
|
|
void Go::genLinear(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh, uint mask) const
|
|
{
|
|
doLinear(o, ind, span, nSpans, from, next, readCh, mask);
|
|
}
|
|
|
|
bool genCases(std::ostream &o, uint ind, uint lb, Span *s, bool &newLine, uint mask)
|
|
{
|
|
bool used = false;
|
|
|
|
if (!newLine)
|
|
{
|
|
o << "\n";
|
|
}
|
|
newLine = true;
|
|
if (lb < s->ub)
|
|
{
|
|
for (;;)
|
|
{
|
|
if (!mask || lb > 0x00FF)
|
|
{
|
|
o << indent(ind) << "case ";
|
|
prtChOrHex(o, lb);
|
|
o << ":";
|
|
newLine = false;
|
|
used = true;
|
|
}
|
|
|
|
if (++lb == s->ub)
|
|
{
|
|
break;
|
|
}
|
|
|
|
o << "\n";
|
|
newLine = true;
|
|
}
|
|
}
|
|
return used;
|
|
}
|
|
|
|
void Go::genSwitch(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh, uint mask) const
|
|
{
|
|
bool newLine = true;
|
|
|
|
if ((mask ? wSpans : nSpans) <= 2)
|
|
{
|
|
genLinear(o, ind, from, next, readCh, mask);
|
|
}
|
|
else
|
|
{
|
|
State *def = span[nSpans - 1].to;
|
|
Span **sP = new Span * [nSpans - 1], **r, **s, **t;
|
|
|
|
t = &sP[0];
|
|
|
|
for (uint i = 0; i < nSpans; ++i)
|
|
{
|
|
if (span[i].to != def)
|
|
{
|
|
*(t++) = &span[i];
|
|
}
|
|
}
|
|
|
|
if (dFlag)
|
|
{
|
|
o << indent(ind) << "YYDEBUG(-1, yych);\n";
|
|
}
|
|
|
|
if (readCh)
|
|
{
|
|
o << indent(ind) << "switch((yych = *YYCURSOR)) {\n";
|
|
readCh = false;
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "switch(yych){\n";
|
|
}
|
|
|
|
while (t != &sP[0])
|
|
{
|
|
bool used = false;
|
|
|
|
r = s = &sP[0];
|
|
|
|
if (*s == &span[0])
|
|
{
|
|
used |= genCases(o, ind, 0, *s, newLine, mask);
|
|
}
|
|
else
|
|
{
|
|
used |= genCases(o, ind, (*s)[ -1].ub, *s, newLine, mask);
|
|
}
|
|
|
|
State *to = (*s)->to;
|
|
|
|
while (++s < t)
|
|
{
|
|
if ((*s)->to == to)
|
|
{
|
|
used |= genCases(o, ind, (*s)[ -1].ub, *s, newLine, mask);
|
|
}
|
|
else
|
|
{
|
|
*(r++) = *s;
|
|
}
|
|
}
|
|
|
|
if (used)
|
|
{
|
|
genGoTo(o, newLine ? ind+1 : 1, from, to, readCh);
|
|
newLine = true;
|
|
}
|
|
t = r;
|
|
}
|
|
|
|
o << indent(ind) << "default:";
|
|
genGoTo(o, 1, from, def, readCh);
|
|
o << indent(ind) << "}\n";
|
|
|
|
delete [] sP;
|
|
}
|
|
}
|
|
|
|
void doBinary(std::ostream &o, uint ind, Span *s, uint n, const State *from, const State *next, bool &readCh, uint mask)
|
|
{
|
|
if (n <= 4)
|
|
{
|
|
doLinear(o, ind, s, n, from, next, readCh, mask);
|
|
}
|
|
else
|
|
{
|
|
uint h = n / 2;
|
|
|
|
genIf(o, ind, "<=", s[h - 1].ub - 1, readCh);
|
|
o << "{\n";
|
|
doBinary(o, ind+1, &s[0], h, from, next, readCh, mask);
|
|
o << indent(ind) << "} else {\n";
|
|
doBinary(o, ind+1, &s[h], n - h, from, next, readCh, mask);
|
|
o << indent(ind) << "}\n";
|
|
}
|
|
}
|
|
|
|
void Go::genBinary(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh, uint mask) const
|
|
{
|
|
if (mask)
|
|
{
|
|
Span * sc = new Span[wSpans];
|
|
|
|
for (uint i = 0, j = 0; i < nSpans; i++)
|
|
{
|
|
if (span[i].ub > 0xFF)
|
|
{
|
|
sc[j++] = span[i];
|
|
}
|
|
}
|
|
|
|
doBinary(o, ind, sc, wSpans, from, next, readCh, mask);
|
|
|
|
delete[] sc;
|
|
}
|
|
else
|
|
{
|
|
doBinary(o, ind, span, nSpans, from, next, readCh, mask);
|
|
}
|
|
}
|
|
|
|
void Go::genBase(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh, uint mask) const
|
|
{
|
|
if ((mask ? wSpans : nSpans) == 0)
|
|
{
|
|
return ;
|
|
}
|
|
|
|
if (!sFlag)
|
|
{
|
|
genSwitch(o, ind, from, next, readCh, mask);
|
|
return ;
|
|
}
|
|
|
|
if ((mask ? wSpans : nSpans) > 8)
|
|
{
|
|
Span *bot = &span[0], *top = &span[nSpans - 1];
|
|
uint util;
|
|
|
|
if (bot[0].to == top[0].to)
|
|
{
|
|
util = (top[ -1].ub - bot[0].ub) / (nSpans - 2);
|
|
}
|
|
else
|
|
{
|
|
if (bot[0].ub > (top[0].ub - top[ -1].ub))
|
|
{
|
|
util = (top[0].ub - bot[0].ub) / (nSpans - 1);
|
|
}
|
|
else
|
|
{
|
|
util = top[ -1].ub / (nSpans - 1);
|
|
}
|
|
}
|
|
|
|
if (util <= 2)
|
|
{
|
|
genSwitch(o, ind, from, next, readCh, mask);
|
|
return ;
|
|
}
|
|
}
|
|
|
|
if ((mask ? wSpans : nSpans) > 5)
|
|
{
|
|
genBinary(o, ind, from, next, readCh, mask);
|
|
}
|
|
else
|
|
{
|
|
genLinear(o, ind, from, next, readCh, mask);
|
|
}
|
|
}
|
|
|
|
void Go::genCpGoto(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh) const
|
|
{
|
|
const char * sYych = readCh ? "(yych = *YYCURSOR)" : "yych";
|
|
|
|
readCh = false;
|
|
if (wFlag)
|
|
{
|
|
o << indent(ind) << "if(" << sYych <<" & 0xFF00) {\n";
|
|
genBase(o, ind+1, from, next, readCh, 1);
|
|
o << indent(ind++) << "} else {\n";
|
|
sYych = "yych";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind++) << "{\n";
|
|
}
|
|
o << indent(ind++) << "static void *yytarget[256] = {\n";
|
|
o << indent(ind);
|
|
|
|
uint ch = 0;
|
|
for (uint i = 0; i < lSpans; ++i)
|
|
{
|
|
vUsedLabels.insert(span[i].to->label);
|
|
for(; ch < span[i].ub; ++ch)
|
|
{
|
|
o << "&&yy" << span[i].to->label;
|
|
if (ch == 255)
|
|
{
|
|
o << "\n";
|
|
i = lSpans;
|
|
break;
|
|
}
|
|
else if (ch % 8 == 7)
|
|
{
|
|
o << ",\n" << indent(ind);
|
|
}
|
|
else
|
|
{
|
|
o << "," << space(span[i].to->label);
|
|
}
|
|
}
|
|
}
|
|
o << indent(--ind) << "};\n";
|
|
o << indent(ind) << "goto *yytarget[" << sYych << "];\n";
|
|
o << indent(--ind) << "}\n";
|
|
}
|
|
|
|
void Go::genGoto(std::ostream &o, uint ind, const State *from, const State *next, bool &readCh)
|
|
{
|
|
if ((gFlag || wFlag) && wSpans == ~0u)
|
|
{
|
|
uint nBitmaps = 0;
|
|
std::set<uint> vTargets;
|
|
wSpans = 0;
|
|
lSpans = 1;
|
|
dSpans = 0;
|
|
for (uint i = 0; i < nSpans; ++i)
|
|
{
|
|
if (span[i].ub > 0xFF)
|
|
{
|
|
wSpans++;
|
|
}
|
|
if (span[i].ub < 0x100 || !wFlag)
|
|
{
|
|
lSpans++;
|
|
|
|
State *to = span[i].to;
|
|
|
|
if (to && to->isBase)
|
|
{
|
|
const BitMap *b = BitMap::find(to);
|
|
|
|
if (b && matches(b->go, b->on, this, to))
|
|
{
|
|
nBitmaps++;
|
|
}
|
|
else
|
|
{
|
|
dSpans++;
|
|
vTargets.insert(to->label);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dSpans++;
|
|
vTargets.insert(to->label);
|
|
}
|
|
}
|
|
}
|
|
lTargets = vTargets.size() >> nBitmaps;
|
|
}
|
|
|
|
if (gFlag && (lTargets >= cGotoThreshold || dSpans >= cGotoThreshold))
|
|
{
|
|
genCpGoto(o, ind, from, next, readCh);
|
|
return;
|
|
}
|
|
else if (bFlag)
|
|
{
|
|
for (uint i = 0; i < nSpans; ++i)
|
|
{
|
|
State *to = span[i].to;
|
|
|
|
if (to && to->isBase)
|
|
{
|
|
const BitMap *b = BitMap::find(to);
|
|
const char * sYych;
|
|
|
|
if (b && matches(b->go, b->on, this, to))
|
|
{
|
|
Go go;
|
|
go.span = new Span[nSpans];
|
|
go.unmap(this, to);
|
|
sYych = readCh ? "(yych = *YYCURSOR)" : "yych";
|
|
readCh = false;
|
|
if (wFlag)
|
|
{
|
|
o << indent(ind) << "if(" << sYych << " & 0xFF00) {\n";
|
|
sYych = "yych";
|
|
genBase(o, ind+1, from, next, readCh, 1);
|
|
o << indent(ind) << "} else ";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind);
|
|
}
|
|
o << "if(yybm[" << b->i << "+" << sYych << "] & ";
|
|
if (yybmHexTable)
|
|
{
|
|
prtHex(o, b->m, false);
|
|
}
|
|
else
|
|
{
|
|
o << (uint) b->m;
|
|
}
|
|
o << ") {\n";
|
|
genGoTo(o, ind+1, from, to, readCh);
|
|
o << indent(ind) << "}\n";
|
|
go.genBase(o, ind, from, next, readCh, 0);
|
|
delete [] go.span;
|
|
return ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
genBase(o, ind, from, next, readCh, 0);
|
|
}
|
|
|
|
void State::emit(std::ostream &o, uint ind, bool &readCh) const
|
|
{
|
|
if (vUsedLabels.count(label))
|
|
{
|
|
o << "yy" << label << ":\n";
|
|
}
|
|
if (dFlag && !action->isInitial())
|
|
{
|
|
o << indent(ind) << "YYDEBUG(" << label << ", *YYCURSOR);\n";
|
|
}
|
|
if (isPreCtxt)
|
|
{
|
|
o << indent(ind) << "YYCTXMARKER = YYCURSOR + 1;\n";
|
|
}
|
|
action->emit(o, ind, readCh);
|
|
}
|
|
|
|
uint merge(Span *x0, State *fg, State *bg)
|
|
{
|
|
Span *x = x0, *f = fg->go.span, *b = bg->go.span;
|
|
uint nf = fg->go.nSpans, nb = bg->go.nSpans;
|
|
State *prev = NULL, *to;
|
|
// NB: we assume both spans are for same range
|
|
|
|
for (;;)
|
|
{
|
|
if (f->ub == b->ub)
|
|
{
|
|
to = f->to == b->to ? bg : f->to;
|
|
|
|
if (to == prev)
|
|
{
|
|
--x;
|
|
}
|
|
else
|
|
{
|
|
x->to = prev = to;
|
|
}
|
|
|
|
x->ub = f->ub;
|
|
++x;
|
|
++f;
|
|
--nf;
|
|
++b;
|
|
--nb;
|
|
|
|
if (nf == 0 && nb == 0)
|
|
{
|
|
return x - x0;
|
|
}
|
|
}
|
|
|
|
while (f->ub < b->ub)
|
|
{
|
|
to = f->to == b->to ? bg : f->to;
|
|
|
|
if (to == prev)
|
|
{
|
|
--x;
|
|
}
|
|
else
|
|
{
|
|
x->to = prev = to;
|
|
}
|
|
|
|
x->ub = f->ub;
|
|
++x;
|
|
++f;
|
|
--nf;
|
|
}
|
|
|
|
while (b->ub < f->ub)
|
|
{
|
|
to = b->to == f->to ? bg : f->to;
|
|
|
|
if (to == prev)
|
|
{
|
|
--x;
|
|
}
|
|
else
|
|
{
|
|
x->to = prev = to;
|
|
}
|
|
|
|
x->ub = b->ub;
|
|
++x;
|
|
++b;
|
|
--nb;
|
|
}
|
|
}
|
|
}
|
|
|
|
const uint cInfinity = ~0;
|
|
|
|
class SCC
|
|
{
|
|
|
|
public:
|
|
State **top, **stk;
|
|
|
|
public:
|
|
SCC(uint);
|
|
~SCC();
|
|
void traverse(State*);
|
|
|
|
#ifdef PEDANTIC
|
|
private:
|
|
SCC(const SCC& oth)
|
|
: top(oth.top)
|
|
, stk(oth.stk)
|
|
{
|
|
}
|
|
SCC& operator = (const SCC& oth)
|
|
{
|
|
new(this) SCC(oth);
|
|
return *this;
|
|
}
|
|
#endif
|
|
};
|
|
|
|
SCC::SCC(uint size)
|
|
: top(new State * [size])
|
|
, stk(top)
|
|
{
|
|
}
|
|
|
|
SCC::~SCC()
|
|
{
|
|
delete [] stk;
|
|
}
|
|
|
|
void SCC::traverse(State *x)
|
|
{
|
|
*top = x;
|
|
uint k = ++top - stk;
|
|
x->depth = k;
|
|
|
|
for (uint i = 0; i < x->go.nSpans; ++i)
|
|
{
|
|
State *y = x->go.span[i].to;
|
|
|
|
if (y)
|
|
{
|
|
if (y->depth == 0)
|
|
{
|
|
traverse(y);
|
|
}
|
|
|
|
if (y->depth < x->depth)
|
|
{
|
|
x->depth = y->depth;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (x->depth == k)
|
|
{
|
|
do
|
|
{
|
|
(*--top)->depth = cInfinity;
|
|
(*top)->link = x;
|
|
}
|
|
while (*top != x);
|
|
}
|
|
}
|
|
|
|
static bool state_is_in_non_trivial_SCC(const State* s)
|
|
{
|
|
|
|
// does not link to self
|
|
if (s->link != s)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// or exists i: (s->go.spans[i].to->link == s)
|
|
//
|
|
// Note: (s->go.spans[i].to == s) is allowed, corresponds to s
|
|
// looping back to itself.
|
|
//
|
|
for (uint i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
const State* t = s->go.span[i].to;
|
|
|
|
if (t && t->link == s)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
// otherwise no
|
|
return false;
|
|
}
|
|
|
|
uint maxDist(State *s)
|
|
{
|
|
if (s->depth != cInfinity)
|
|
{
|
|
// Already calculated, just return result.
|
|
return s->depth;
|
|
}
|
|
uint mm = 0;
|
|
|
|
for (uint i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
State *t = s->go.span[i].to;
|
|
|
|
if (t)
|
|
{
|
|
uint m = 1;
|
|
|
|
if (!t->link) // marked as non-key state
|
|
{
|
|
if (t->depth == cInfinity)
|
|
{
|
|
t->depth = maxDist(t);
|
|
}
|
|
m += t->depth;
|
|
}
|
|
|
|
if (m > mm)
|
|
{
|
|
mm = m;
|
|
}
|
|
}
|
|
}
|
|
|
|
s->depth = mm;
|
|
return mm;
|
|
}
|
|
|
|
void calcDepth(State *head)
|
|
{
|
|
State* s;
|
|
|
|
// mark non-key states by s->link = NULL ;
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
if (s != head && !state_is_in_non_trivial_SCC(s))
|
|
{
|
|
s->link = NULL;
|
|
}
|
|
//else: key state, leave alone
|
|
}
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
s->depth = cInfinity;
|
|
}
|
|
|
|
// calculate max number of transitions before guarantied to reach
|
|
// a key state.
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
maxDist(s);
|
|
}
|
|
}
|
|
|
|
void DFA::findSCCs()
|
|
{
|
|
SCC scc(nStates);
|
|
State *s;
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
s->depth = 0;
|
|
s->link = NULL;
|
|
}
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
if (!s->depth)
|
|
{
|
|
scc.traverse(s);
|
|
}
|
|
}
|
|
|
|
calcDepth(head);
|
|
}
|
|
|
|
void DFA::split(State *s)
|
|
{
|
|
State *move = new State;
|
|
(void) new Move(move);
|
|
addState(&s->next, move);
|
|
move->link = s->link;
|
|
move->rule = s->rule;
|
|
move->go = s->go;
|
|
s->rule = NULL;
|
|
s->go.nSpans = 1;
|
|
s->go.span = new Span[1];
|
|
s->go.span[0].ub = ubChar;
|
|
s->go.span[0].to = move;
|
|
}
|
|
|
|
void DFA::findBaseState()
|
|
{
|
|
Span *span = new Span[ubChar - lbChar];
|
|
|
|
for (State *s = head; s; s = s->next)
|
|
{
|
|
if (!s->link)
|
|
{
|
|
for (uint i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
State *to = s->go.span[i].to;
|
|
|
|
if (to && to->isBase)
|
|
{
|
|
to = to->go.span[0].to;
|
|
uint nSpans = merge(span, s, to);
|
|
|
|
if (nSpans < s->go.nSpans)
|
|
{
|
|
delete [] s->go.span;
|
|
s->go.nSpans = nSpans;
|
|
s->go.span = new Span[nSpans];
|
|
memcpy(s->go.span, span, nSpans*sizeof(Span));
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] span;
|
|
}
|
|
|
|
void DFA::emit(std::ostream &o, uint ind)
|
|
{
|
|
State *s;
|
|
uint i, bitmap_brace = 0;
|
|
|
|
findSCCs();
|
|
head->link = head;
|
|
|
|
uint nRules = 0;
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
s->depth = maxDist(s);
|
|
if (maxFill < s->depth)
|
|
{
|
|
maxFill = s->depth;
|
|
}
|
|
if (s->rule && s->rule->accept >= nRules)
|
|
{
|
|
nRules = s->rule->accept + 1;
|
|
}
|
|
}
|
|
|
|
uint nSaves = 0;
|
|
uint *saves = new uint[nRules];
|
|
memset(saves, ~0, (nRules)*sizeof(*saves));
|
|
|
|
// mark backtracking points
|
|
bool bSaveOnHead = false;
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
if (s->rule)
|
|
{
|
|
for (i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
if (s->go.span[i].to && !s->go.span[i].to->rule)
|
|
{
|
|
delete s->action;
|
|
|
|
if (saves[s->rule->accept] == ~0u)
|
|
{
|
|
saves[s->rule->accept] = nSaves++;
|
|
}
|
|
|
|
bSaveOnHead |= s == head;
|
|
(void) new Save(s, saves[s->rule->accept]); // sets s->action
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// insert actions
|
|
State **rules = new State * [nRules];
|
|
|
|
memset(rules, 0, (nRules)*sizeof(*rules));
|
|
|
|
State *accept = NULL;
|
|
Accept *accfixup = NULL;
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
State * ow;
|
|
|
|
if (!s->rule)
|
|
{
|
|
ow = accept;
|
|
}
|
|
else
|
|
{
|
|
if (!rules[s->rule->accept])
|
|
{
|
|
State *n = new State;
|
|
(void) new Rule(n, s->rule);
|
|
rules[s->rule->accept] = n;
|
|
addState(&s->next, n);
|
|
}
|
|
|
|
ow = rules[s->rule->accept];
|
|
}
|
|
|
|
for (i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
if (!s->go.span[i].to)
|
|
{
|
|
if (!ow)
|
|
{
|
|
ow = accept = new State;
|
|
accfixup = new Accept(accept, nRules, saves, rules);
|
|
addState(&s->next, accept);
|
|
}
|
|
|
|
s->go.span[i].to = ow;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (accfixup)
|
|
{
|
|
accfixup->genRuleMap();
|
|
}
|
|
|
|
// split ``base'' states into two parts
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
s->isBase = false;
|
|
|
|
if (s->link)
|
|
{
|
|
for (i = 0; i < s->go.nSpans; ++i)
|
|
{
|
|
if (s->go.span[i].to == s)
|
|
{
|
|
s->isBase = true;
|
|
split(s);
|
|
|
|
if (bFlag)
|
|
{
|
|
BitMap::find(&s->next->go, s);
|
|
}
|
|
|
|
s = s->next;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// find ``base'' state, if possible
|
|
findBaseState();
|
|
|
|
delete head->action;
|
|
|
|
if (bFlag)
|
|
{
|
|
o << indent(ind++) << "{\n";
|
|
bitmap_brace = 1;
|
|
BitMap::gen(o, ind, lbChar, ubChar <= 256 ? ubChar : 256);
|
|
}
|
|
|
|
bUsedYYAccept = false;
|
|
|
|
uint start_label = next_label;
|
|
|
|
(void) new Initial(head, next_label++, bSaveOnHead);
|
|
|
|
if (bUseStartLabel)
|
|
{
|
|
if (startLabelName.empty())
|
|
{
|
|
vUsedLabels.insert(start_label);
|
|
}
|
|
}
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
s->label = next_label++;
|
|
}
|
|
|
|
// Save 'next_fill_index' and compute information about code generation
|
|
// while writing to null device.
|
|
uint save_fill_index = next_fill_index;
|
|
null_stream null_dev;
|
|
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
bool readCh = false;
|
|
s->emit(null_dev, ind, readCh);
|
|
s->go.genGoto(null_dev, ind, s, s->next, readCh);
|
|
}
|
|
if (last_fill_index < next_fill_index)
|
|
{
|
|
last_fill_index = next_fill_index;
|
|
}
|
|
next_fill_index = save_fill_index;
|
|
|
|
// Generate prolog
|
|
o << "\n" << outputFileInfo;
|
|
o << indent(ind++) << "{\n";
|
|
|
|
if (!fFlag)
|
|
{
|
|
o << indent(ind) << "YYCTYPE yych;\n";
|
|
if (bUsedYYAccept)
|
|
{
|
|
o << indent(ind) << "unsigned int yyaccept = 0;\n";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
o << "\n";
|
|
}
|
|
|
|
genGetState(o, ind, start_label);
|
|
|
|
if (vUsedLabels.count(1))
|
|
{
|
|
vUsedLabels.insert(0);
|
|
o << indent(ind) << "goto yy0;\n";
|
|
}
|
|
|
|
// Generate code
|
|
for (s = head; s; s = s->next)
|
|
{
|
|
bool readCh = false;
|
|
s->emit(o, ind, readCh);
|
|
s->go.genGoto(o, ind, s, s->next, readCh);
|
|
}
|
|
|
|
// Generate epilog
|
|
o << indent(--ind) << "}\n";
|
|
if (bitmap_brace)
|
|
{
|
|
o << indent(--ind) << "}\n";
|
|
}
|
|
|
|
// Cleanup
|
|
if (BitMap::first)
|
|
{
|
|
delete BitMap::first;
|
|
BitMap::first = NULL;
|
|
}
|
|
|
|
delete [] saves;
|
|
delete [] rules;
|
|
|
|
bUseStartLabel = false;
|
|
}
|
|
|
|
void genGetState(std::ostream &o, uint& ind, uint start_label)
|
|
{
|
|
if (fFlag && !bWroteGetState)
|
|
{
|
|
vUsedLabels.insert(start_label);
|
|
o << indent(ind) << "switch(YYGETSTATE()) {\n";
|
|
if (bUseStateAbort)
|
|
{
|
|
o << indent(ind) << "default: abort();\n";
|
|
o << indent(ind) << "case -1: goto yy" << start_label << ";\n";
|
|
}
|
|
else
|
|
{
|
|
o << indent(ind) << "default: goto yy" << start_label << ";\n";
|
|
}
|
|
|
|
for (size_t i=0; i<last_fill_index; ++i)
|
|
{
|
|
o << indent(ind) << "case " << i << ": goto yyFillLabel" << i << ";\n";
|
|
}
|
|
|
|
o << indent(ind) << "}\n";
|
|
if (bUseStateNext)
|
|
{
|
|
o << "yyNext:\n";
|
|
}
|
|
bWroteGetState = true;
|
|
}
|
|
}
|
|
|
|
std::ostream& operator << (std::ostream& o, const file_info& li)
|
|
{
|
|
if (li.ln && !iFlag)
|
|
{
|
|
o << "#line " << li.ln->get_line() << " \"" << li.fname << "\"\n";
|
|
}
|
|
return o;
|
|
}
|
|
|
|
uint Scanner::get_line() const
|
|
{
|
|
return cline;
|
|
}
|
|
|
|
void Scanner::config(const Str& cfg, int num)
|
|
{
|
|
if (cfg.to_string() == "indent:top")
|
|
{
|
|
if (num < 0)
|
|
{
|
|
fatal("configuration 'indent:top' must be a positive integer");
|
|
}
|
|
topIndent = num;
|
|
}
|
|
else if (cfg.to_string() == "yybm:hex")
|
|
{
|
|
yybmHexTable = num != 0;
|
|
}
|
|
else if (cfg.to_string() == "startlabel")
|
|
{
|
|
bUseStartLabel = num != 0;
|
|
startLabelName = "";
|
|
}
|
|
else if (cfg.to_string() == "state:abort")
|
|
{
|
|
bUseStateAbort = num != 0;
|
|
}
|
|
else if (cfg.to_string() == "state:nextlabel")
|
|
{
|
|
bUseStateNext = num != 0;
|
|
}
|
|
else if (cfg.to_string() == "yyfill:enable")
|
|
{
|
|
bUseYYFill = num != 0;
|
|
}
|
|
else if (cfg.to_string() == "cgoto:threshold")
|
|
{
|
|
cGotoThreshold = num;
|
|
}
|
|
else
|
|
{
|
|
fatal("unrecognized configuration name or illegal integer value");
|
|
}
|
|
}
|
|
|
|
void Scanner::config(const Str& cfg, const Str& val)
|
|
{
|
|
if (cfg.to_string() == "indent:string")
|
|
{
|
|
if (val.len >= 2 && val.str[0] == val.str[val.len-1]
|
|
&& (val.str[0] == '"' || val.str[0] == '\''))
|
|
{
|
|
SubStr tmp(val.str + 1, val.len - 2);
|
|
unescape(tmp, indString);
|
|
}
|
|
else
|
|
{
|
|
indString = val.to_string();
|
|
}
|
|
return;
|
|
}
|
|
else if (cfg.to_string() == "startlabel")
|
|
{
|
|
if (val.len >= 2 && val.str[0] == val.str[val.len-1]
|
|
&& (val.str[0] == '"' || val.str[0] == '\''))
|
|
{
|
|
SubStr tmp(val.str + 1, val.len - 2);
|
|
unescape(tmp, startLabelName);
|
|
}
|
|
else
|
|
{
|
|
startLabelName = val.to_string();
|
|
}
|
|
bUseStartLabel = !startLabelName.empty();
|
|
}
|
|
else
|
|
{
|
|
fatal("unrecognized configuration name or illegal string value");
|
|
}
|
|
}
|
|
|
|
} // end namespace re2c
|