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); }