SubprogramDeclarationPtr Parser::parseSubprogramDeclaration()
{
SubprogramDeclarationPtr sub(new SubprogramDeclaration);
parseSubprogramHead(sub);
if (m_errorCode > ErrorCodes::NoError) {
panic(subprogramDeclarationFollow, subprogramDeclarationFollowSize);
return SubprogramDeclarationPtr();
}
DeclarationsPtr declarations = parseDeclarations();
if (m_errorCode > ErrorCodes::NoError) {
panic(subprogramDeclarationFollow, subprogramDeclarationFollowSize);
return SubprogramDeclarationPtr();
}
sub->declarations = declarations;
CompoundStatementPtr body = parseCompoundStatement();
if (m_errorCode > ErrorCodes::NoError) {
panic(subprogramDeclarationFollow, subprogramDeclarationFollowSize);
return SubprogramDeclarationPtr();
}
sub->body = body;
return sub;
}
void Parser::parseStatement(){
if(isNext(tc_ID)){
SymbolTableEntry* entry = m_currentToken->getSymTabEntry();
match(tc_ID);
parseStatementPrime(entry);
}
else if(isNext(tc_IF)){
match(tc_IF);
SymbolTableEntry* exp = parseExpression();
SymbolTableEntry* f = newLabel();
SymbolTableEntry* end = newLabel();
m_code->generate(cd_EQ, exp, m_symbolTable->lookup(CodeFalse), f);
match(tc_THEN);
if(m_parserError){
TokenCode synch[] = {tc_ID, tc_BEGIN, tc_IF, tc_WHILE, tc_NONE};
recover(synch);
// if(isNext(tc_THEN)){
// match(tc_THEN);
// }
}
parseStatement();
m_code->generate(cd_GOTO, NULL, NULL, end);
m_code->generate(cd_LABEL, NULL, NULL, f);
match(tc_ELSE);
if(m_parserError){
TokenCode synch[] = {tc_ID, tc_BEGIN, tc_IF, tc_WHILE, tc_NONE};
recover(synch);
// if(isNext(tc_ELSE)){
// match(tc_ELSE);
// }
}
parseStatement();
m_code->generate(cd_LABEL, NULL, NULL, end);
}
else if(isNext(tc_WHILE)){
match(tc_WHILE);
SymbolTableEntry* start = newLabel();
m_code->generate(cd_LABEL, NULL, NULL, start);
SymbolTableEntry* exp = parseExpression();
SymbolTableEntry* end = newLabel();
m_code->generate(cd_EQ, exp, m_symbolTable->lookup(CodeFalse), end);
match(tc_DO);
if(m_parserError){
TokenCode synch[] = {tc_ID, tc_BEGIN, tc_IF, tc_WHILE, tc_NONE};
recover(synch);
// if(isNext(tc_DO)){
// match(tc_DO);
// }
}
parseStatement();
m_code->generate(cd_GOTO, NULL, NULL, start);
m_code->generate(cd_LABEL, NULL, NULL, end);
}
else{
parseCompoundStatement();
}
}
void *NclConnectorsParser::parseCompoundStatement(
DOMElement *parentElement, void *objGrandParent) {
wclog << "parseCompoundStatement" << endl;
void *parentObject = NULL;
DOMNodeList *elementNodeList;
DOMElement *element;
DOMNode *node;
string elementTagName = "";
void *elementObject = NULL;
parentObject = createCompoundStatement(parentElement, objGrandParent);
if (parentObject == NULL) {
return NULL;
}
elementNodeList = parentElement->getChildNodes();
for (int i = 0; i < (int)elementNodeList->getLength(); i++) {
node = elementNodeList->item(i);
if(node->getNodeType()==DOMNode::ELEMENT_NODE){
element = (DOMElement*)node;
elementTagName = XMLString::transcode( element->getTagName() );
wclog << ">>" << elementTagName.c_str() << ": ";
wclog << XMLString::transcode(element->getAttribute(XMLString::transcode("id"))) << endl;
if (XMLString::compareIString(elementTagName.c_str(),
"assessmentStatement") == 0) {
elementObject = parseAssessmentStatement(
element, parentObject);
if (elementObject != NULL) {
addAssessmentStatementToCompoundStatement(
parentObject, elementObject);
}
} else if (XMLString::compareIString(elementTagName.c_str(),
"compoundStatement") == 0) {
elementObject = parseCompoundStatement(
element, parentObject);
if (elementObject != NULL) {
addCompoundStatementToCompoundStatement(
parentObject, elementObject);
}
}
}
}
return parentObject;
}
void Parser::parseProgram(){
match(tc_PROGRAM);
if(m_parserError){
TokenCode synch[] = {tc_ID, tc_NONE};
recover(synch);
// if(isNext(tc_PROGRAM)){
// match(tc_PROGRAM);
// }
}
SymbolTableEntry* start = NULL;
if(isNext(tc_ID)){
start = m_currentToken->getSymTabEntry();
}
match(tc_ID);
if(m_parserError){
TokenCode synch[] = {tc_SEMICOL, tc_NONE};
recover(synch);
// if(isNext(tc_ID)){
// match(tc_ID);
// }
}
match(tc_SEMICOL);
if(m_parserError){
TokenCode synch[] = {tc_VAR, tc_FUNCTION, tc_PROCEDURE, tc_BEGIN, tc_NONE};
recover(synch);
// if(isNext(tc_SEMICOL)){
// match(tc_SEMICOL);
// }
}
parseDeclarations();
m_code->generate(cd_GOTO, NULL, NULL, start);
parseSubprogramDeclarations();
m_code->generate(cd_LABEL, NULL, NULL, start);
parseCompoundStatement();
match(tc_DOT);
if(m_parserError){
TokenCode synch[] = {tc_EOF, tc_NONE};
recover(synch);
// if(isNext(tc_DOT)){
// match(tc_DOT);
// }
}
m_code->generate(cd_RETURN, NULL, NULL, NULL);
}
StatementPtr Parser::parseStatement()
{
if (m_curToken.tokenType() == TokenType::Begin) {
return parseCompoundStatement();
} else if (match(TokenType::If)) {
ExpressionPtr expression = parseExpression();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
if (!match(TokenType::Then)) {
reportError(ErrorCodes::ExpectedThen);
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
StatementPtr thenStatement = parseStatement();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
if (!match(TokenType::Else)) {
reportError(ErrorCodes::ExpectedElse);
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
StatementPtr elseStatement = parseStatement();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
IfStatementPtr statement(new IfStatement);
statement->expression = expression;
statement->thenPart = thenStatement;
statement->elsePart = elseStatement;
return statement;
} else if (match(TokenType::While)) {
ExpressionPtr expression = parseExpression();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
if (!match(TokenType::Do)) {
reportError(ErrorCodes::ExpectedDo);
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
StatementPtr doPart = parseStatement();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
WhileStatementPtr whileStatement(new WhileStatement);
whileStatement->expression = expression;
whileStatement->doPart = doPart;
return whileStatement;
}
IdentifierPtr identifier = parseIdentifier();
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
AssignmentOrCallStatementPtr statement(new AssignmentOrCallStatement);
statement->id = identifier;
parseStatement_p(statement);
if (m_errorCode > ErrorCodes::NoError) {
panic(statementFollow, statementFollowSize);
return StatementPtr();
}
return statement;
}
ProgramPtr Parser::parseProgram()
{
if (!match(TokenType::Program)) {
reportError(ErrorCodes::ExpectedProgram);
panic(programFollow, programFollowSize);
return ProgramPtr();
}
IdentifierPtr programName = parseIdentifier();
if (m_errorCode > ErrorCodes::NoError) {
panic(programFollow, programFollowSize);
return ProgramPtr();
}
if (!match(TokenType::LParen)) {
reportError(ErrorCodes::ExpectedLParen);
panic(programFollow, programFollowSize);
return ProgramPtr();
}
IdentifiersPtr inputOutput = parseIdentifierList();
if (m_errorCode > ErrorCodes::NoError) {
panic(programFollow, programFollowSize);
return ProgramPtr();
}
if (!match(TokenType::RParen)) {
reportError(ErrorCodes::ExpectedRParen);
panic(programFollow, programFollowSize);
return ProgramPtr();
}
if (!match(TokenType::Semicolon)) {
reportError(ErrorCodes::ExpectedSemicolon);
panic(programFollow, programFollowSize);
return ProgramPtr();
}
DeclarationsPtr globalVariables = parseDeclarations();
if (m_errorCode > ErrorCodes::NoError) {
panic(programFollow, programFollowSize);
return ProgramPtr();
}
SubprogramDeclarationsPtr functions = parseSubprogramDeclarations();
if (m_errorCode > ErrorCodes::NoError) {
panic(programFollow, programFollowSize);
return ProgramPtr();
}
CompoundStatementPtr mainProgram = parseCompoundStatement();
if (m_errorCode > ErrorCodes::NoError) {
panic(programFollow, programFollowSize);
return ProgramPtr();
}
if (!match(TokenType::Period)) {
reportError(ErrorCodes::ExpectedPeriod);
panic(programFollow, programFollowSize);
return ProgramPtr();
}
ProgramPtr program(new Program);
program->programName = programName;
program->inputOutput = inputOutput;
program->variables = globalVariables;
program->functions = functions;
program->mainProgram = mainProgram;
return program;
}
Symbol parseStatement(CharacterSource* source)
{
Symbol s = parseExpressionStatement(source);
if (s.valid())
return s;
s = parseFunctionDefinitionStatement(source);
if (s.valid())
return s;
s = parseVariableDefinitionStatement(source);
if (s.valid())
return s;
s = parseAssignmentStatement(source);
if (s.valid())
return s;
s = parseCompoundStatement(source);
if (s.valid())
return s;
s = parseTypeConstructorDefinitionStatement(source);
if (s.valid())
return s;
s = parseNothingStatement(source);
if (s.valid())
return s;
s = parseIncrementDecrementStatement(source);
if (s.valid())
return s;
s = parseConditionalStatement(source);
if (s.valid())
return s;
s = parseSwitchStatement(source);
if (s.valid())
return s;
s = parseReturnStatement(source);
if (s.valid())
return s;
s = parseIncludeStatement(source);
if (s.valid())
return s;
s = parseBreakOrContinueStatement(source);
if (s.valid())
return s;
s = parseForeverStatement(source);
if (s.valid())
return s;
s = parseWhileStatement(source);
if (s.valid())
return s;
s = parseForStatement(source);
if (s.valid())
return s;
s = parseEmitStatement(source);
if (s.valid())
return s;
s = parseLabelStatement(source);
if (s.valid())
return s;
s = parseGotoStatement(source);
if (s.valid())
return s;
return Symbol();
}
void Parser::parseSubprogramDeclaration(){
parseSubprogramHead();
parseDeclarations();
parseCompoundStatement();
m_code->generate(cd_RETURN, NULL, NULL, NULL);
}
