Statement* Parser::readStatements()
{
if(currentToken.id == Token::leftBrace)
{
nextToken();
BlockStatement* blockStatement = new BlockStatement(*includeFile);
while(currentToken.id != Token::rightBrace)
blockStatement->statements.append(readStatement());
nextToken();
return blockStatement;
}
else
return readStatement();
}
Statement* Parser::readFile()
{
BlockStatement* statement = new BlockStatement(*includeFile);
while(currentToken.id != Token::eof)
statement->statements.append(readStatement());
return statement;
}
Statement* Parser::readValue()
{
switch(currentToken.id)
{
case Token::not_:
{
UnaryStatement* statement = new UnaryStatement(*includeFile);
statement->operation = currentToken.id;
nextToken();
statement->operand = readValue();
return statement;
}
case Token::leftParenthesis:
{
nextToken();
Statement* statement = readExpression();
expectToken(Token::rightParenthesis);
return statement;
}
case Token::leftBrace:
{
nextToken();
BlockStatement* statements = new BlockStatement(*includeFile);
while(currentToken.id != Token::rightBrace)
{
if(currentToken.id == Token::eof)
expectToken(Token::rightBrace);
statements->statements.append(readStatement());
}
nextToken();
return statements;
}
case Token::string:
if(currentToken.value == "true")
{
nextToken();
StringStatement* statement = new StringStatement(*includeFile);
statement->value = "true";
return statement;
}
else if(currentToken.value == "false")
{
nextToken();
return new StringStatement(*includeFile);
}
else
{
ReferenceStatement* statement = new ReferenceStatement(*includeFile);
readString(statement->variable);
return statement;
}
default: // quotedString
{
StringStatement* statement = new StringStatement(*includeFile);
readString(statement->value);
return statement;
}
}
}
// <statement> ::= <simple statement>
// | <complex statement>
void SyntaxAnalyzer::statement(std::set<symboltype> followers)
{
//ako neterminala ne se vika ot drugo mqsto
//ne se pravi startcheck & endcheck v tqh a samo v parenta
if (statementStarters.find(symbol) != statementStarters.end()) {
switch(symbol) {
case ident: assignment(followers); break;
case beginsy: compoundStatement(followers); break;
case ifsy: ifStatement(followers); break;
case whilesy: whileStatement(followers); break;
case readsy: readStatement(followers); break;
case writesy: writeStatement(followers); break;
default:
break;
} // swtich
} else {
syntaxerror(othersy);
}
} // statement()
bool DatabaseTracker::deleteDatabaseFileIfEmpty(const String& path)
{
if (!isZeroByteFile(path))
return false;
SQLiteDatabase database;
if (!database.open(path))
return false;
// Specify that we want the exclusive locking mode, so after the next read,
// we'll be holding the lock to this database file.
SQLiteStatement lockStatement(database, "PRAGMA locking_mode=EXCLUSIVE;");
if (lockStatement.prepare() != SQLITE_OK)
return false;
int result = lockStatement.step();
if (result != SQLITE_ROW && result != SQLITE_DONE)
return false;
lockStatement.finalize();
// Every sqlite database has a sqlite_master table that contains the schema for the database.
// http://www.sqlite.org/faq.html#q7
SQLiteStatement readStatement(database, "SELECT * FROM sqlite_master LIMIT 1;");
if (readStatement.prepare() != SQLITE_OK)
return false;
// We shouldn't expect any result.
if (readStatement.step() != SQLITE_DONE)
return false;
readStatement.finalize();
// At this point, we hold the exclusive lock to this file. Double-check again to make sure
// it's still zero bytes.
if (!isZeroByteFile(path))
return false;
return SQLiteFileSystem::deleteDatabaseFile(path);
}
void decompile4Action(FILE *f, int length, int indent)
{
Stack s, *statements = NULL;
int /*i, j,*/ off, nStatements = 0;
int end = fileOffset+length;
/* pass 1: read all statements */
while(fileOffset<end)
{
if(nStatements%STATEMENTS_INCREMENT == 0)
statements = (Stack *)realloc(statements,
(nStatements+STATEMENTS_INCREMENT) *
sizeof(Stack));
off = fileOffset;
s = readStatement(f);
if(s!=NULL)
{
s->offset = off;
statements[nStatements++] = s;
}
else
{
/* give branch something to target */
s = newStack();
statements[nStatements] = s;
s->offset = off;
if(fileOffset<end)
error("unexpected End action!");
}
}
/*
for(i=0; i<nStatements; ++i)
{
printf("%03i|%04i: ", i, statements[i]->offset);
listItem(statements[i], SWFACTION_END);
putchar(';');
putchar('\n');
}
*/
resolveOffsets(statements, nStatements);
untangleBranches(statements, 0, nStatements, BRANCH_NONE, 0);
putchar('\n');
if(stack != NULL)
{
printf("Decompiler error: stack not empty!\n");
printf("Here's what's left over:\n\n");
/* dump stack remains */
while(stack)
{
listItem(stack, SWFACTION_END);
putchar(';');
putchar('\n');
stack = stack->next;
}
destroy(stack);
stack = NULL;
}
}
