static boolean
extractSequence(PassageMarkerI path, TightString * sequence)
{
PassageMarkerI marker;
Coordinate seqLength = 0;
Coordinate writeIndex = 0;
//velvetLog("Extracting sequence %li ... ", pathLength);
//Measure length
for (marker = getNextInSequence(path); !isTerminal(marker);
marker = getNextInSequence(marker))
seqLength += getNodeLength(getNode(marker));
if (seqLength > MAXREADLENGTH)
return false;
else
setTightStringLength(sequence, seqLength);
//Copy sequences
for (marker = getNextInSequence(path); !isTerminal(marker);
marker = getNextInSequence(marker)) {
appendNodeSequence(getNode(marker), sequence, writeIndex);
writeIndex += getNodeLength(getNode(marker));
}
return true;
}
std::ostream& clearLine(std::ostream& s)
{
#if 0
if (!isTerminal(s))
return s;
s.flush();
HANDLE handle = getHandle(s);
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(handle, &info))
return s;
info.dwCursorPosition.X = 0;
SetConsoleCursorPosition(handle, info.dwCursorPosition);
return s;
#endif
if (!isTerminal(s))
return s;
HANDLE handle = getHandle(s);
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(handle, &info))
return s;
s << '\r' << std::string(info.dwMaximumWindowSize.X - 1, ' ') << '\r';
return s;
}
void discoverStartSymbols()
{
bool again = true;
while(again)
{
again = false;
for(std::map<int, CFA>::iterator i = m.begin(); i != m.end(); ++i)
again |= doDiscoverStartSymbols(i->second);
}
// Make sure we really have a DFA.
for(std::map<int, CFA>::iterator i = m.begin(); i != m.end(); ++i)
{
std::set<int> starters;
CFA &cfa = i->second;
NewQDFAItems &startItems = cfa.dfa.transitionMap[cfa.dfa.start];
for(std::map<int, QDFASet>::iterator i = startItems.targets.begin();
i != startItems.targets.end(); ++i
)
{
if(isTerminal(i->first))
{
starters.insert(i->first);
}
}
for(std::map<int, QDFASet>::iterator i = startItems.targets.begin();
i != startItems.targets.end(); ++i
)
{
if(!isTerminal(i->first))
{
// Go thru all the start symbols for i->first.
// Make sure they are unique.
CFA &cfaNt = m[i->first];
for(std::set<int>::iterator ii = cfaNt.startSymbols.begin();
ii != cfaNt.startSymbols.end(); ++ii
)
{
if(starters.find(*ii) != starters.end())
{
std::cout << "Error with rule " << cfa.ruleName << ": ambiguous grammar on ";
if(*ii >= 33 && *ii <= 127)
std::cout << ((char)(*ii));
else
std::cout << *ii;
std::cout << " - " << cfaNt.ruleName;
std::cout << std::endl;
throw -1;
}
starters.insert(*ii);
}
}
}
}
}
/* build first
* */
set<string> Parser:: first(string non_terminal){
set<string> first_set;
map<string, vector<list<string> > >::iterator itr = grammar.find(non_terminal);
map<string, int> terminal_production; // for parsing table
int productionIndex = -1;
//iterator production
for(vector<list<string> >::iterator itr2 = (itr->second).begin(); itr2 != (itr-> second).end(); ++itr2 ){
productionIndex += 1;
// epsilon skip
if( (*itr2).front().compare("epsilon") == 0 ){
continue;
}
// insert terminal and continue
if ( isTerminal( (*itr2).front() ) ){
first_set.insert( (*itr2).front() );
terminal_production.insert( make_pair( (*itr2).front(), productionIndex ) );
continue;
}
// front element is non_terminal, iterator body
for(list<string>::iterator itr3 = (*itr2).begin(); itr3 != (*itr2).end(); ++itr3){
// insert terminal
if( isTerminal(*itr3) ){
first_set.insert( *itr3 );
terminal_production.insert( make_pair( (*itr3), productionIndex ) );
}
else{
// non_terminal
map<string, Nonterminal*>::iterator bodyElement = non_terminals_map.find(*itr3);
// not Nullable then insert first of that nonterminal
bodyElement -> second -> first = first(*itr3);
for(set<string>::iterator itr4 = bodyElement-> second -> first.begin(); \
itr4 != bodyElement -> second -> first.end(); ++itr4){
first_set.insert(*itr4);
terminal_production.insert( make_pair( (*itr4), productionIndex) );
}
if( (bodyElement->second)->nullable ){
continue;
}
}
break;
}
}
// insert to parsing table
parsingTable.insert( make_pair(non_terminal, terminal_production) );
return first_set;
}
// This is broken - why do some productions have NO start symbols?
bool doDiscoverStartSymbols(CFA &cfa)
{
bool again = false;
NewQDFAItems &startItems = cfa.dfa.transitionMap[cfa.dfa.start];
for(std::map<int, QDFASet>::iterator i = startItems.targets.begin();
i != startItems.targets.end(); ++i
)
{
if(isTerminal(i->first))
{
cfa.startSymbols.insert(i->first);
}
}
for(std::map<int, QDFASet>::iterator i = startItems.targets.begin();
i != startItems.targets.end(); ++i
)
{
if(!isTerminal(i->first))
{
// i->first is a nonterminal.
assert(m.find(i->first) != m.end());
CFA &cnfaNt = m[i->first];
if(cnfaNt.unknownStartSymbols)
again = true;
else
{
for(std::set<int>::iterator ii = cnfaNt.startSymbols.begin();
ii != cnfaNt.startSymbols.end(); ++ii
)
cfa.startSymbols.insert(*ii);
/*
NewQDFAItems &startItems = cnfaNt.dfa.transitionMap[cnfaNt.dfa.start];
for(std::map<int, QDFASet>::iterator ii = startItems.targets.begin();
ii != startItems.targets.end(); ++ii
)
{
if(isTerminal(ii->first))
{
cfa.startSymbols.insert(ii->first);
}
}
*/
}
}
}
cfa.unknownStartSymbols = again;
return again;
}
void
BddNodeV::drawBddRecur(ofstream& ofile) const
{
// TODO
BddNodeVInt* n = getBddNodeVInt();
if (n->isVisited())
return;
n->setVisited();
if(isTerminal())
return;
BddNodeV left = getLeft();
BddNodeV right = getRight();
ofile << " { rank = same; " << getLevel() << "; \"" << getLabel()
<< "\"; }\n";
ofile << " \"" << getLabel() << "\" -> \"" << left.getLabel() << "\"";
ofile << ((left.isNegEdge())? " [arrowhead=odot]" : ";") << endl;
ofile << " \"" << getLabel() << "\" -> \"" << right.getLabel()
<< "\"[style = dotted ] [color=red]";
ofile << ((right.isNegEdge())? " [arrowhead=odot]" : ";") << endl;
left.drawBddRecur(ofile);
right.drawBddRecur(ofile);
}
ASTNode* makeGlobalSymbolTableLinks(ASTNode* AT, GlobalTable* global_table, recordTable* record_table)
{
if(AT == NULL)
return NULL;
if(isTerminal(AT->nodeid))
{
AT->global_table = global_table;
AT->record_table = record_table;
return AT;
}
if(getNonTerminalfromStr("<typeDefinition>") == AT->nodeid)
return AT;
else if(getNonTerminalfromStr("<declaration>") == AT->nodeid)
{
AT->global_table = global_table;
AT->record_table = record_table;
if(AT->children[2] != NULL) // TK_GLOBAL
{
if(AT->children[0]->nodeid == TK_INT || AT->children[0]->nodeid == TK_REAL)
{
insertGlobalId(global_table, AT->children[1]->tk, AT->children[0]->nodeid);
}
else
{
insertGlobalRecord(global_table, AT->children[1]->tk, TK_RECORD, AT->children[0]->children[1]->tk.lexeme, record_table);
}
}
}
int i;
AT->global_table = global_table;
AT->record_table = record_table;
for (i = 0; i < AT->child_cnt; ++i)
AT->children[i] = makeGlobalSymbolTableLinks(AT->children[i], global_table, record_table);
return AT;
}
void displayASTHelper(ASTNode* a, FILE* fp)
{
if(a == NULL)
{
// fprintf(stderr, "abstract syntax tree is NULL\n");
return;
}
char empty[10] = "----";
char yes[10] = "YES";
char no[10] = "NO";
int space = 25;
int space_small = 15;
if(a->child_cnt == 0)
{
if(isTerminal(a->nodeid))
{
if(a->nodeid == TK_EPS)
fprintf(fp, "%*s%*s%*s%*s%*s%*s\n", 20, empty, space_small, empty, space_small, getIDStr(a->nodeid), space_small, empty, space_small, yes, space, empty);
else if(a->nodeid == TK_NUM || a->nodeid == TK_RNUM)
fprintf(fp, "%*s%*d%*s%*s%*s%*s\n", 20, empty, space_small, a->tk.lineNum, space_small, getIDStr(a->nodeid), space_small, a->tk.lexeme, space_small, yes, space, empty);
else
fprintf(fp, "%*s%*d%*s%*s%*s%*s\n", 20, a->tk.lexeme, space_small, a->tk.lineNum, space_small, getIDStr(a->nodeid), space_small, empty, space_small, yes, space, empty);
}
else
fprintf(fp, "%*s%*s%*s%*s%*s%*s\n", 20, empty, space_small, empty, space_small, empty, space_small, empty, space_small, no, space, getIDStr(a->nodeid));
return;
}
fprintf(fp, "%*s%*s%*s%*s%*s%*s\n", 20, empty, space_small, empty, space_small, empty, space_small, empty, space_small, no, space, getIDStr(a->nodeid));
int idx;
for (idx = 0; idx < a->child_cnt; ++idx)
displayASTHelper(a->children[idx], fp);
}
void Server::handleTransition(){
switch(waitingForMessage){
case(WAITING_FOR_MESSAGE::INFO):
break;
case(WAITING_FOR_MESSAGE::START):
play();
break;
case(WAITING_FOR_MESSAGE::PLAY):
computeNextTurn();
stepCounter++;
if(isTerminal()){
stop();
}
else{
play();
}
break;
case(WAITING_FOR_MESSAGE::DONE):
emit done();
break;
case(WAITING_FOR_MESSAGE::ABORT):
break;
default:
break;
}
}
int countNodes(TreeNode* root) {
if (root == NULL) return 0;
auto left = root, right = root;
int leftHeight = 0, rightHeight = 0;
while (left){
left = left->left;
leftHeight++;
}
while (right){
right = right->right;
rightHeight++;
}
int POW_HEIGHT = (1 << (leftHeight - 1));
if (leftHeight == rightHeight){
return POW_HEIGHT * 2 - 1;
}
int l = 0, r = POW_HEIGHT - 1, m = 0;
while (l < r){
m = l + (r - l) / 2;
if (isTerminal(m, leftHeight - 1, root))
l = m + 1;
else
r = m;
}
return (POW_HEIGHT - 1) + r;
}
int gameover(struct game *state)
{
printf("gameover: checking board '%s'\n",state->board);
char outcome = isTerminal(state->board);
switch( outcome )
{
case 'x':
printf("You have won!\n");
return 1;
break;
case 'o':
printf("You have lost.\n");
return 1;
break;
case 'd':
printf("A draw ...\n");
return 1;
break;
}
return 0;
}
const std::set<GrammarSymbol*>& GrammarSymbol::getFirstSet(const Grammar& myGrammar) {
if (! firstSetValid_) {
firstSetValid_ = true;
if (isEmptySymbol() == true)
firstSet_.insert(myGrammar.getEmptySymbol());
else if (isTerminal() == true)
firstSet_.insert(this);
else {
for (size_t i = 0; i < productions_.size(); ++i) {
const std::vector<GrammarSymbol*>& body = productions_[i].getBody();
bool allEmpty = true;
for (size_t k = 0; k < body.size(); ++k) {
std::set<GrammarSymbol*> firstK = body[k]->getFirstSet(myGrammar);
std::set<GrammarSymbol*>::iterator it = firstK.find(myGrammar.getEmptySymbol());
if (it == firstK.end())
allEmpty = false;
else
firstK.erase(it);
if ((allEmpty == false) && (firstK.empty() == false)) {
firstSet_.insert(firstK.begin(), firstK.end());
break;
}
} // for (k
if (allEmpty == true)
firstSet_.insert(myGrammar.getEmptySymbol());
} // for (i
} // else
} // if (! firstSetValid_
return firstSet_;
}
int alphabeta(struct game *state,int alpha, int beta)
{
/* printf("minimax: Calculating minimax for board '%s' with player %c\n",state->board,state->player); */
/* loop through next states getting minimax values */
char outcome = isTerminal(state->board);
switch(outcome)
{
case 'x':
return 1;
case 'o':
return -1;
case 'd':
return 0;
case ' ':
if (state->player == 'x') {
return maxvalue(gennextstates(state),alpha,beta);
} else {
return minvalue(gennextstates(state),alpha,beta);
}
}
}
std::ostream& setAttribute(std::ostream& s, int mask, int value)
{
if (!isTerminal(s))
return s;
s.flush();
HANDLE handle = getHandle(s);
static RestoreConsole restoreConsole(handle);
if (-1 == value)
{
restoreConsole.restore();
return s;
}
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(handle, &info))
return s;
info.wAttributes &= mask;
info.wAttributes |= value;
SetConsoleTextAttribute(handle, info.wAttributes);
return s;
}
BddNodeV
BddNodeV::existRecur(unsigned l, map<size_t, size_t>& existMap) const
{
if (isTerminal()) return (*this);
unsigned thisLevel = getLevel();
if (l > thisLevel) return (*this);
map<size_t, size_t>::iterator mi = existMap.find(_nodeV);
if (mi != existMap.end()) return (*mi).second;
BddNodeV left = getLeftCofactor(thisLevel);
BddNodeV right = getRightCofactor(thisLevel);
if (l == thisLevel) {
BddNodeV res = left | right;
existMap[_nodeV] = res();
return res;
}
// l must < getLevel()
bool isNegEdge = false;
BddNodeV t = left.existRecur(l, existMap);
BddNodeV e = right.existRecur(l, existMap);
if (t == e) {
existMap[_nodeV] = t();
return t;
}
if (t.isNegEdge()) {
t = ~t; e = ~e; isNegEdge = true;
}
BddNodeV res(_BddMgrV->uniquify(t(), e(), thisLevel));
if (isNegEdge) res = ~res;
existMap[_nodeV] = res();
return res;
}
/* The predictive parser */
int parser()
{
do
{
if(isTerminal(X))
{
if(X == curTok)
{
pop(stack, data);
readToken();
}
else
error();
}
else
{
if(table_lookup(X, curTok))
{
/* This part of algorithm handled by table_lookup */
}
else
error();
}
} while(X != END);
}
virtual void computeValue() {
if (isTerminal()) {
computeTerminalValue();
} else {
computeInteriorValue();
}
}
void printTreeNode(TreeNode* treeNode){
char *name = getNodeKindString(treeNode->nodekind);
int isTerm = isTerminal(treeNode->nodekind);
if (isTerm)
printf("<%s>[%s]{%d}(%s)\n", name, treeNode->tokenString, treeNode->lineno, type_string(treeNode->type));
else
printf("%s(%s)\n", name,type_string(treeNode->type));
}
/*****************************************************************************************
* Implementation of State
* NOTE: 20140612. From what I can tell from looking at the HSFC code a state isn't
* in some sense valid until it has had the legal moves calculated from it. Or at least
* you cannot run Play() from a state that has not had legal moves calculated. So as
* a hack I will calculate (and throw away) the legal moves whenever I create a state and
* whenever I run Play().
*****************************************************************************************/
void State::initialize(){
// Hack to calculate legal moves so that the state will now be in a good "state".
if (!isTerminal()) {
std::vector<PlayerMove> legalMoves;
legals(std::back_inserter(legalMoves));
} else {
goals();
}
}
static void cleanUpRedundancy_local()
{
PassageMarkerI current;
for (current = getNextInSequence(slowPath); !isTerminal(current);
current = getNextInSequence(current))
handicapNode(getNode(current));
destroyPaths();
}
static void trimLongReadTips()
{
IDnum index;
Node *node;
PassageMarkerI marker, next;
velvetLog("Trimming read tips\n");
for (index = 1; index <= nodeCount(graph); index++) {
node = getNodeInGraph(graph, index);
if (getUniqueness(node))
continue;
for (marker = getMarker(node); marker != NULL_IDX;
marker = next) {
next = getNextInNode(marker);
if (!isInitial(marker) && !isTerminal(marker))
continue;
if (isTerminal(marker))
marker = getTwinMarker(marker);
while (!getUniqueness(getNode(marker))) {
if (next != NULL_IDX
&& (marker == next
|| marker == getTwinMarker(next)))
next = getNextInNode(next);
if (getNextInSequence(marker) != NULL_IDX) {
marker = getNextInSequence(marker);
destroyPassageMarker
(getPreviousInSequence
(marker));
} else {
destroyPassageMarker(marker);
break;
}
}
}
}
}
set* getFirstSet(int id, set** firststs)
{
// ensure that computeFirstSets has been called for that id earlier
if(isTerminal(id))
{
set* st = createEmptySet();
st->val = id;
return st;
}
return firststs[id];
}
void
BddNodeV::unsetVisitedRecur() const
{
BddNodeVInt* n = getBddNodeVInt();
if (!n->isVisited()) return;
n->unsetVisited();
if (!isTerminal()) {
n->getLeft().unsetVisitedRecur();
n->getRight().unsetVisitedRecur();
}
}
std::string GrammarSymbol::toString() const {
std::ostringstream oss;
if (isTerminal() == true)
oss << name_;
//oss << "'" << name_ << "'";
else
oss << "[" << name_ << "]";
return oss.str();
}
// Don't put this->isNegEdge() on label
string
BddNodeV::getLabel() const
{
if (isTerminal())
return "One";
ostringstream str;
str << getBddNodeVInt();
return str.str();
}
int search(unsigned char *x, int m, unsigned char *y, int n) {
int k, R, L, r, ell, end, count;
int *ttrans, *tlength, *tsuffix;
int *ttransSMA;
char *tterminal;
unsigned char *xR;
BEGIN_PREPROCESSING
count = 0;
/* Preprocessing */
xR = reverse(x,m);
ttrans = (int *)malloc(3*m*SIGMA*sizeof(int));
memset(ttrans, -1, 3*m*SIGMA*sizeof(int));
tlength = (int *)calloc(3*m, sizeof(int));
tsuffix = (int *)calloc(3*m, sizeof(int));
tterminal = (char *)calloc(3*m, sizeof(char));
buildSimpleSuffixAutomaton(xR, m, ttrans, tlength, tsuffix, tterminal);
ttransSMA = (int *)malloc((m+1)*SIGMA*sizeof(int));
memset(ttransSMA, -1, (m+1)*SIGMA*sizeof(int));
preSMA(x, m, ttransSMA);
end = n/m;
if (n%m > 0) ++end;
END_PREPROCESSING
/* Searching */
BEGIN_SEARCHING
for (k = 1; k < end; ++k) {
R = L = r = ell = 0;
while (L != UNDEFINED && k*m-1-ell >= 0) {
L = getTarget(L, y[k*m-1-ell]);
++ell;
if (L != UNDEFINED && isTerminal(L))
R = ell;
}
while (R > r-k*m) {
if (R == m) OUTPUT(k*m+r-m);
++r;
if (r == m) break;
R = getSMA(R, y[k*m-1+r]);
}
}
for (k = (end-1)*m; k <= n - m; ++k) {
for (r = 0; r < m && x[r] == y[r + k]; ++r);
if (r >= m) count++;
}
free(ttrans);
free(tlength);
free(tsuffix);
free(ttransSMA);
free(tterminal);
END_SEARCHING
return count;
}
int nonTerminalsinProd(production_struct p){
int i,resp;
resp = 0;
for(i = 1; i <= p.rightsimbolslenght; i++){
char comp = getProductionComponent(p, i);
if (isTerminal(comp)){
resp++;
}
}
return resp;
}
bool Syntactic::step() throw (AnalysisError)
{
if (currentToken == 0) //Fim de Sentenca
{
int pos = 0;
if (previousToken != 0)
pos = previousToken->getPosition() + previousToken->getLexeme().size();
currentToken = new Token(DOLLAR, "$", pos, 1);
}
int a = currentToken->getId();
int x = stack.top();
stack.pop();
if (x == EPSILON)
{
return false;
}
else if (isTerminal(x))
{
if (x == a)
{
if (stack.empty())
return true;
else
{
if (previousToken != 0)
delete previousToken;
previousToken = currentToken;
currentToken = scanner->nextToken();
return false;
}
}
else
{
throw SyntacticError(PARSER_ERROR[x], currentToken);
}
}
else if (isNonTerminal(x))
{
if (pushProduction(x, a))
return false;
else
throw SyntacticError(PARSER_ERROR[x], currentToken);
}
else // isSemanticAction(x)
{
semanticAnalyser->executeAction(x-FIRST_SEMANTIC_ACTION, previousToken);
return false;
}
}
inline const bool isAcceptedByVocabulary ( const std::size_t idx,
const unordered_set<std::string>& vcb ) const {
if ( !vcb.size() ) return true;
std::vector<std::string> tx = getRHSSplitTranslation ( idx );
for ( uint k = 0; k < tx.size(); ++k ) {
if ( tx[k] == "<dr>" || tx[k] == "<oov>" || tx[k] == "<s>" || tx[k] == "</s>"
|| tx[k] == "<sep>") continue;
if ( !isTerminal ( tx[k] ) ) continue;
if ( vcb.find ( tx[k] ) == vcb.end() ) return false;
}
return true;
};
bool Rule::isTerminalState(State *state){
if (isTerminal(state->getStateString().at(0), state->getStateString().at(1), state->getStateString().at(2))
|| isTerminal(state->getStateString().at(3), state->getStateString().at(4), state->getStateString().at(5))
|| isTerminal(state->getStateString().at(6), state->getStateString().at(7), state->getStateString().at(8))
|| isTerminal(state->getStateString().at(0), state->getStateString().at(3), state->getStateString().at(6))
|| isTerminal(state->getStateString().at(1), state->getStateString().at(4), state->getStateString().at(7))
|| isTerminal(state->getStateString().at(2), state->getStateString().at(5), state->getStateString().at(8))
|| isTerminal(state->getStateString().at(0), state->getStateString().at(4), state->getStateString().at(8))
|| isTerminal(state->getStateString().at(2), state->getStateString().at(4), state->getStateString().at(6))
|| isNoDash(state)){
return true;
}
return false;
}
