import { CommonTokenStream, InputStream } from "antlr4/index"; import * as Expressions from "./expressions"; import * as Commands from "./commands"; import * as AstHelpers from "./ast_helpers"; import * as Parsers from "../typeSystem/parsers"; import { Types } from "../typeSystem/types"; import { ArrayType } from "../typeSystem/array_type"; import { SourceInfo } from "./sourceInfo"; import { convertFromString } from "./operators"; import { SyntaxErrorFactory } from "./error/syntaxErrorFactory"; import { LanguageDefinedFunction } from "../processor/definedFunctions"; import { LanguageService } from "../services/languageService"; export class IVProgParser { static createParser (input) { const lexerClass = LanguageService.getCurrentLexer(); return new IVProgParser(input, lexerClass); } // static get BASE () { return 0; } static get FUNCTION () { return 1; } static get COMMAND () { return 2; } static get BREAKABLE () { return 4; } // constructor (input, lexerClass) { this.lexerClass = lexerClass; this.inputStream = new InputStream(input); this.lexer = new lexerClass(this.inputStream); this.lexer.recover = AstHelpers.recover.bind(this.lexer); this.tokenStream = new CommonTokenStream(this.lexer); this.tokenStream.fill(); this.pos = 1; this.variableTypes = [ this.lexerClass.RK_INTEGER, this.lexerClass.RK_REAL, this.lexerClass.RK_BOOLEAN, this.lexerClass.RK_STRING, this.lexerClass.RK_CHARACTER, ]; this.functionTypes = this.variableTypes.concat(this.lexerClass.RK_VOID); this.parsingArrayDimension = 0; this.scope = []; this.langFuncs = LanguageService.getCurrentLangFuncs(); this.definedFuncsNameList = []; this.definedVariablesStack = []; } parseTree () { return this.parseProgram(); } getToken (index = this.pos) { // if(index === null) // index = this.pos; return this.tokenStream.LT(index); } insideScope (scope) { if (this.scope.length <= 0) { return IVProgParser.BASE === scope; } else { return this.scope[this.scope.length - 1] === scope; } } pushScope (scope) { this.scope.push(scope); } pushVariableStack () { this.definedVariablesStack.push([]); } popScope () { return this.scope.pop(); } popVariableStack () { return this.definedVariablesStack.pop(); } getCurrentVariableStack () { return this.definedVariablesStack[this.definedVariablesStack.length - 1]; } isEOF () { this.getToken(this.pos); return this.tokenStream.fetchedEOF; } parseProgram () { this.consumeNewLines(); const token = this.getToken(); let globalVars = []; let functions = []; if (this.lexerClass.RK_PROGRAM === token.type) { this.pos++; this.consumeNewLines(); this.checkOpenCurly(); this.pos++; this.pushVariableStack(); for (;;) { this.consumeNewLines(); const token = this.getToken(); if ( token.type === this.lexerClass.RK_CONST || this.isVariableType(token) ) { globalVars = globalVars.concat(this.parseGlobalVariables()); } else if (token.type === this.lexerClass.RK_FUNCTION) { this.pushVariableStack(); functions = functions.concat(this.parseFunction()); this.popVariableStack(); } else { break; } } this.consumeNewLines(); this.checkCloseCurly(); this.pos++; this.consumeNewLines(); if (!this.isEOF()) { throw SyntaxErrorFactory.extra_lines(); } this.popVariableStack(); return { global: globalVars, functions: functions }; } else { throw SyntaxErrorFactory.token_missing_one( this.lexer.literalNames[this.lexerClass.RK_PROGRAM], token ); } } checkOpenCurly (attempt = false) { const token = this.getToken(); if (this.lexerClass.OPEN_CURLY !== token.type) { if (!attempt) throw SyntaxErrorFactory.token_missing_one("{", token); else return false; } return true; } checkCloseCurly (attempt = false) { const token = this.getToken(); if (this.lexerClass.CLOSE_CURLY !== token.type) { if (!attempt) throw SyntaxErrorFactory.token_missing_one("}", token); else return false; } return true; } /* It checks if the current token at position pos is a ']'. * As a check function it doesn't increment pos. * * @params bool:attempt, indicates that the token is optional. Defaults: false * * @returns true if the attempt is true and current token is '[', * false is attempt is true and current token is not '[' **/ checkOpenBrace (attempt = false) { const token = this.getToken(); if (this.lexerClass.OPEN_BRACE !== token.type) { if (!attempt) { throw SyntaxErrorFactory.token_missing_one("[", token); } else { return false; } } return true; } checkCloseBrace (attempt = false) { const token = this.getToken(); if (this.lexerClass.CLOSE_BRACE !== token.type) { if (!attempt) { throw SyntaxErrorFactory.token_missing_one("]", token); } else { return false; } } return true; } checkOpenParenthesis (attempt = false) { const token = this.getToken(); if (this.lexerClass.OPEN_PARENTHESIS !== token.type) { if (!attempt) { throw SyntaxErrorFactory.token_missing_one("(", token); } else { return false; } } return true; } checkCloseParenthesis (attempt = false) { const token = this.getToken(); if (this.lexerClass.CLOSE_PARENTHESIS !== token.type) { if (!attempt) { throw SyntaxErrorFactory.token_missing_one(")", token); } else { return false; } } return true; } checkEOS (attempt = false) { const eosToken = this.getToken(); if (eosToken.type !== this.lexerClass.EOS) { if (!attempt) throw SyntaxErrorFactory.eos_missing(eosToken); else return false; } return true; } checkFunctionDuplicate (functionID, funcIDToken) { const id = functionID === null ? "$main" : functionID; const index = this.definedFuncsNameList.indexOf(id); if (index !== -1) { throw SyntaxErrorFactory.duplicate_function(funcIDToken); } this.definedFuncsNameList.push(id); } checkVariableDuplicate (variableID, sourceInfo) { const index = this.getCurrentVariableStack().indexOf(variableID); if (index !== -1) { throw SyntaxErrorFactory.duplicate_variable(sourceInfo); } this.getCurrentVariableStack().push(variableID); } consumeForSemiColon () { const eosToken = this.getToken(); if (eosToken.type === this.lexerClass.EOS && eosToken.text.match(";")) { this.pos++; return; } throw SyntaxErrorFactory.token_missing_one(";", eosToken); } parseGlobalVariables () { const decl = this.parseMaybeConst(); this.checkEOS(); this.pos++; return decl; } /* * Checks if the next token is PR_CONST. It's only available * at global variables declaration level * @returns Declararion(const, type, id, initVal?) **/ parseMaybeConst () { const constToken = this.getToken(); if (constToken.type === this.lexerClass.RK_CONST) { this.pos++; const typeString = this.parseType(); return this.parseDeclaration(typeString, true); } else if (this.isVariableType(constToken)) { const typeString = this.parseType(); return this.parseDeclaration(typeString); } else { throw SyntaxErrorFactory.token_missing_list( [this.lexer.literalNames[this.lexerClass.RK_CONST]].concat( this.getTypeArray() ), constToken ); } } /* * Parses a declarion of the form: type --- id --- (= --- EAnd)? * @returns a list of Declararion(const, type, id, initVal?) **/ parseDeclaration (typeString, isConst = false) { let initial = null; let dim1 = null; let dim2 = null; let dimensions = 0; const sourceInfo = SourceInfo.createSourceInfo(this.getToken()); const idString = this.parseID(); this.checkVariableDuplicate(idString, sourceInfo); // Check for array or vector // ID[int/IDi?][int/IDj?] if (this.checkOpenBrace(true)) { this.pos += 1; this.consumeNewLines(); dim1 = this.parseArrayDimension(); this.consumeNewLines(); this.checkCloseBrace(); this.pos += 1; dimensions += 1; if (this.checkOpenBrace(true)) { this.pos += 1; this.consumeNewLines(); dim2 = this.parseArrayDimension(); this.consumeNewLines(); this.checkCloseBrace(); this.pos += 1; dimensions += 1; } return this.parseArrayDeclaration( typeString, isConst, idString, sourceInfo, dimensions, dim1, dim2 ); } else { const equalsToken = this.getToken(); if (isConst && equalsToken.type !== this.lexerClass.EQUAL) { throw SyntaxErrorFactory.const_not_init(sourceInfo); } if (equalsToken.type === this.lexerClass.EQUAL) { this.pos++; initial = this.parseExpressionOR(); } const declaration = new Commands.Declaration( idString, typeString, initial, isConst ); declaration.sourceInfo = sourceInfo; const commaToken = this.getToken(); if (commaToken.type === this.lexerClass.COMMA) { this.pos++; this.consumeNewLines(); return [declaration].concat(this.parseDeclaration(typeString, isConst)); } else { return [declaration]; } } } parseArrayDeclaration ( typeString, isConst, idString, sourceInfo, dimensions, dim1, dim2 ) { const equalsToken = this.getToken(); let n_lines = dim1; let n_columns = dim2; let initial = null; let dim_is_id = false; if ( dim1 instanceof Expressions.VariableLiteral || dim2 instanceof Expressions.VariableLiteral ) { dim_is_id = true; if (dimensions > 1 && (dim1 == null || dim2 == null)) { throw SyntaxErrorFactory.invalid_matrix_id_dimension( SourceInfo.createSourceInfo(equalsToken) ); } } if (isConst && equalsToken.type !== this.lexerClass.EQUAL) { throw SyntaxErrorFactory.const_not_init(sourceInfo); } if (equalsToken.type === this.lexerClass.EQUAL) { if (dim_is_id) { if (dimensions == 1) { throw SyntaxErrorFactory.invalid_vector_init( SourceInfo.createSourceInfo(equalsToken) ); } else { throw SyntaxErrorFactory.invalid_matrix_init( SourceInfo.createSourceInfo(equalsToken) ); } } this.pos += 1; initial = this.parseArrayLiteral(typeString); } if (initial == null && dim1 == null) { if (dimensions > 1) { throw SyntaxErrorFactory.cannot_infer_matrix_line(idString, sourceInfo); } throw SyntaxErrorFactory.cannot_infer_vector_size(idString, sourceInfo); } if (dimensions > 1) { if (initial == null && dim2 == null) { throw SyntaxErrorFactory.cannot_infer_matrix_column( idString, sourceInfo ); } } if (dimensions === 1 && initial != null && !initial.isVector) { const expString = initial.toString(); throw SyntaxErrorFactory.matrix_to_vector_literal_attr( idString, expString, initial.sourceInfo ); } else if (dimensions > 1 && initial != null && initial.isVector) { const expString = initial.toString(); throw SyntaxErrorFactory.vector_to_matrix_literal_attr( idString, expString, initial.sourceInfo ); } if (dim1 == null) { n_lines = new Expressions.IntLiteral(Parsers.toInt(initial.lines)); n_lines.sourceInfo = sourceInfo; } if (dimensions > 1) { if (dim2 == null) { n_columns = new Expressions.IntLiteral(Parsers.toInt(initial.columns)); n_columns.sourceInfo = sourceInfo; } } const declaration = new Commands.ArrayDeclaration( idString, new ArrayType(typeString, dimensions), n_lines, n_columns, initial, isConst ); declaration.sourceInfo = sourceInfo; const commaToken = this.getToken(); if (commaToken.type === this.lexerClass.COMMA) { this.pos++; this.consumeNewLines(); return [declaration].concat(this.parseDeclaration(typeString, isConst)); } else { return [declaration]; } } consumeNewLines () { let token = this.getToken(); while (token.type === this.lexerClass.EOS && token.text.match("[\r\n]+")) { this.pos++; token = this.getToken(); } } isVariableType (token) { return this.variableTypes.find((v) => v === token.type); } /* * Reads the next token of the stream to check if it is a Integer or an ID. * @returns Integer | ID **/ parseArrayDimension () { const dimToken = this.getToken(); if (dimToken.type === this.lexerClass.INTEGER) { //parse as int literal this.pos++; return this.getIntLiteral(dimToken); } else if (dimToken.type === this.lexerClass.ID) { //parse as variable this.pos++; return this.parseVariable(dimToken); } else if (dimToken.type === this.lexerClass.CLOSE_BRACE) { return null; } else { throw SyntaxErrorFactory.invalid_array_dimension( this.lexer.literalNames[this.lexerClass.RK_INTEGER], dimToken ); } } /* * Returns an object {type: 'int', value: value}. * It checks for binary and hexadecimal integers. * @returns object with fields type and value **/ getIntLiteral (token) { const text = token.text; const sourceInfo = SourceInfo.createSourceInfo(token); const exp = new Expressions.IntLiteral(Parsers.toInt(text)); exp.sourceInfo = sourceInfo; return exp; } getRealLiteral (token) { const sourceInfo = SourceInfo.createSourceInfo(token); const exp = new Expressions.RealLiteral(Parsers.toReal(token.text)); exp.sourceInfo = sourceInfo; return exp; } getStringLiteral (token) { const text = token.text; const sourceInfo = SourceInfo.createSourceInfo(token); const exp = new Expressions.StringLiteral(Parsers.toString(text)); exp.sourceInfo = sourceInfo; return exp; } getCharLiteral (token) { const text = token.text; const exp = new Expressions.CharLiteral(Parsers.toChar(text)); exp.sourceInfo = SourceInfo.createSourceInfo(token); return exp; } getBoolLiteral (token) { const val = Parsers.toBool(token.text); const exp = new Expressions.BoolLiteral(val); exp.sourceInfo = SourceInfo.createSourceInfo(token); return exp; } parseArrayLiteral (typeString) { const openCurly = this.checkOpenCurly(true); if (!openCurly) { const invalid_token = this.getToken(); throw SyntaxErrorFactory.array_init_not_literal( SourceInfo.createSourceInfo(invalid_token) ); } const beginArray = this.getToken(); if (this.parsingArrayDimension >= 2) { throw SyntaxErrorFactory.array_exceeds_2d( SourceInfo.createSourceInfo(beginArray) ); } this.pos += 1; this.parsingArrayDimension += 1; this.consumeNewLines(); let data = null; const maybeCurlyOpen = this.checkOpenCurly(true); if (maybeCurlyOpen) { // This is potentially a list of vectors data = this.parseVectorList(typeString); } else { data = this.parseExpressionList(); } this.consumeNewLines(); this.checkCloseCurly(); const endArray = this.getToken(); this.pos += 1; this.parsingArrayDimension -= 1; const sourceInfo = SourceInfo.createSourceInfoFromList( beginArray, endArray ); let dataDim = 1; if (data[0] instanceof Expressions.ArrayLiteral) { dataDim += 1; } else if (data.length == 1) { console.log("Talvez uma variável seja uma melhor opção"); } const type = new ArrayType(typeString, dataDim); const exp = new Expressions.ArrayLiteral(type, data); exp.sourceInfo = sourceInfo; return exp; } /** * Returns a list of ArrayLiterals. Helper function for parsing matrices */ parseVectorList (typeString) { const list = []; let lastSize = null; for (;;) { this.checkOpenCurly(); const beginArray = this.getToken(); if (this.parsingArrayDimension >= 2) { throw SyntaxErrorFactory.array_exceeds_2d( SourceInfo.createSourceInfo(beginArray) ); } this.pos += 1; this.parsingArrayDimension += 1; this.consumeNewLines(); const data = this.parseExpressionList(); this.consumeNewLines(); this.checkCloseCurly(); const endArray = this.getToken(); this.pos += 1; this.parsingArrayDimension -= 1; const sourceInfo = SourceInfo.createSourceInfoFromList( beginArray, endArray ); if (lastSize == null) { lastSize = data.length; } else if (lastSize !== data.length) { const expString = this.inputStream.getText( beginArray.start, endArray.stop ); throw SyntaxErrorFactory.invalid_matrix_literal_line( expString, sourceInfo ); } const type = new ArrayType(typeString, 1); const exp = new Expressions.ArrayLiteral(type, data); exp.sourceInfo = sourceInfo; list.push(exp); const commaToken = this.getToken(); if (commaToken.type !== this.lexerClass.COMMA) { break; } this.pos += 1; this.consumeNewLines(); } if (list.length == 1) { console.log("Talvez um vetor seja uma melhor opção"); } return list; } /* * Returns an object {type: 'variable', value: value}. * @returns object with fields type and value **/ parseVariable (token) { const sourceInfo = SourceInfo.createSourceInfo(token); const exp = new Expressions.VariableLiteral(token.text); exp.sourceInfo = sourceInfo; return exp; } /* * Returns an object representing a function. It has * four attributes: returnType, id, formalParams and block. * The block object has two attributes: declarations and commands **/ parseFunction () { this.pushScope(IVProgParser.FUNCTION); let formalParams = []; const token = this.getToken(); if (token.type !== this.lexerClass.RK_FUNCTION) { //throw SyntaxError.createError(this.lexer.literalNames[this.lexerClass.PR_FUNCAO], token); return null; } this.pos++; const funType = this.parseType(); let dimensions = 0; if (this.checkOpenBrace(true)) { this.pos++; this.checkCloseBrace(); this.pos++; dimensions++; if (this.checkOpenBrace(true)) { this.pos++; this.checkCloseBrace(); this.pos++; dimensions++; } } const funcIDToken = this.getToken(); const functionID = this.parseID(); this.checkFunctionDuplicate(functionID, funcIDToken); this.checkOpenParenthesis(); this.pos++; this.consumeNewLines(); if (!this.checkCloseParenthesis(true)) { formalParams = this.parseFormalParameters(); // formal parameters this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; } else { this.pos++; } this.consumeNewLines(); const commandsBlock = this.parseCommandBlock(); let returnType = funType; if (dimensions > 0) { returnType = new ArrayType(funType, dimensions); } const func = new Commands.Function( functionID, returnType, formalParams, commandsBlock ); if (functionID === null && !func.isMain) { throw SyntaxErrorFactory.invalid_main_return( LanguageDefinedFunction.getMainFunctionName(), this.lexer.literalNames[this.lexerClass.RK_VOID], token.line ); } else if (func.isMain && formalParams.length !== 0) { throw SyntaxErrorFactory.main_parameters(); } this.popScope(); return func; } /* * Parse the formal parameters of a function. * @returns a list of objects with the following attributes: type, id and dimensions. **/ parseFormalParameters () { const list = []; for (;;) { let dimensions = 0; let reference = false; const typeString = this.parseType(); let maybeIDToken = this.getToken(); if (maybeIDToken.type === this.lexerClass.RK_REFERENCE) { reference = true; this.pos += 1; maybeIDToken = this.getToken(); } const idString = this.parseID(); this.checkVariableDuplicate(idString, maybeIDToken); if (this.checkOpenBrace(true)) { this.pos += 1; dimensions += 1; this.checkCloseBrace(); this.pos += 1; if (this.checkOpenBrace(true)) { this.pos += 1; dimensions += 1; this.checkCloseBrace(); this.pos += 1; } } let type = null; if (dimensions > 0) { type = new ArrayType(typeString, dimensions); } else { type = typeString; } const parameter = new Commands.FormalParameter(type, idString, reference); parameter.sourceInfo = SourceInfo.createSourceInfo(maybeIDToken); list.push(parameter); const commaToken = this.getToken(); if (commaToken.type !== this.lexerClass.COMMA) break; this.pos++; this.consumeNewLines(); } return list; } parseID () { const token = this.getToken(); if (token.type !== this.lexerClass.ID) { throw SyntaxErrorFactory.id_missing(token); } this.pos++; if (this.insideScope(IVProgParser.FUNCTION)) { if (token.text === LanguageDefinedFunction.getMainFunctionName()) { return null; } } return token.text; } parseMaybeLibID () { const token = this.getToken(); if ( token.type !== this.lexerClass.ID && token.type !== this.lexerClass.LIB_ID ) { throw SyntaxErrorFactory.id_missing(token); } this.pos++; return token.text; } parseType () { const token = this.getToken(); if ( token.type === this.lexerClass.ID && this.insideScope(IVProgParser.FUNCTION) ) { return Types.VOID; } else if ( token.type === this.lexerClass.RK_VOID && this.insideScope(IVProgParser.FUNCTION) ) { this.pos++; return Types.VOID; } else if (this.isVariableType(token)) { this.pos++; switch (token.type) { case this.lexerClass.RK_INTEGER: return Types.INTEGER; case this.lexerClass.RK_BOOLEAN: return Types.BOOLEAN; case this.lexerClass.RK_REAL: return Types.REAL; case this.lexerClass.RK_STRING: return Types.STRING; case this.lexerClass.RK_CHARACTER: return Types.CHAR; default: break; } } throw SyntaxErrorFactory.invalid_type(this.getTypeArray(), token); } parseCommandBlock (optionalCurly = false) { let variablesDecl = []; const commands = []; let hasOpen = false; if (this.checkOpenCurly(optionalCurly)) { this.pos++; hasOpen = true; } this.consumeNewLines(); let parsedCommand = false; for (;;) { const cmd = this.parseCommand(); if (cmd === null) break; if (cmd !== -1) { if (cmd instanceof Array) { if (parsedCommand) { const lastToken = this.getToken(this.pos - 1); throw SyntaxErrorFactory.invalid_var_declaration(lastToken); } variablesDecl = variablesDecl.concat(cmd); } else { parsedCommand = true; commands.push(cmd); } } } this.consumeNewLines(); if (hasOpen) { this.checkCloseCurly(); this.pos++; this.consumeNewLines(); } return new Commands.CommandBlock(variablesDecl, commands); } parseCommand () { const token = this.getToken(); if (this.isVariableType(token)) { if (!this.insideScope(IVProgParser.FUNCTION)) { throw SyntaxErrorFactory.invalid_var_declaration(token); } this.pushScope(IVProgParser.BASE); const varType = this.parseType(); this.popScope(); const cmd = this.parseDeclaration(varType); this.checkEOS(); this.pos++; return cmd; } else if (token.type === this.lexerClass.ID) { return this.parseIDCommand(); } else if (token.type === this.lexerClass.LIB_ID) { return this.parseIDCommand(); } else if (token.type === this.lexerClass.RK_RETURN) { return this.parseReturn(); } else if ( token.type === this.lexerClass.RK_WHILE || token.type === this.lexerClass.RK_WHILE_ALT ) { return this.parseWhile(); } else if ( token.type === this.lexerClass.RK_FOR || token.type === this.lexerClass.RK_FOR_ALT ) { return this.parseFor(); } else if (token.type === this.lexerClass.RK_BREAK) { if (!this.insideScope(IVProgParser.BREAKABLE)) { throw SyntaxErrorFactory.invalid_break_command( this.lexer.literalNames[this.lexerClass.RK_BREAK], token ); } return this.parseBreak(); } else if (token.type === this.lexerClass.RK_SWITCH) { return this.parseSwitchCase(); } else if (token.type === this.lexerClass.RK_DO) { return this.parseRepeatUntil(); } else if (token.type === this.lexerClass.RK_IF) { return this.parseIfThenElse(); } else if (this.checkEOS(true)) { this.pos++; return -1; } else { return null; } } parseSwitchCase () { this.pushScope(IVProgParser.BREAKABLE); this.pos++; this.checkOpenParenthesis(); this.pos++; this.consumeNewLines(); const exp = this.parseExpressionOR(); this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; this.consumeNewLines(); this.checkOpenCurly(); this.pos++; this.consumeNewLines(); const casesList = this.parseCases(); this.consumeNewLines(); this.checkCloseCurly(); this.pos++; this.consumeNewLines(); this.popScope(); return new Commands.Switch(exp, casesList); } parseRepeatUntil () { this.pos++; this.consumeNewLines(); this.pushScope(IVProgParser.BREAKABLE); const commandsBlock = this.parseCommandBlock(); this.consumeNewLines(); //Maybe not... const whileToken = this.getToken(); if (whileToken.type !== this.lexerClass.RK_DO_UNTIL) { throw SyntaxErrorFactory.token_missing_one( this.lexer.literalNames[this.lexerClass.RK_DO_UNTIL], whileToken ); } this.pos++; this.checkOpenParenthesis(); this.pos++; this.consumeNewLines(); const condition = this.parseExpressionOR(); this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; this.checkEOS(); this.popScope(); return new Commands.RepeatUntil(condition, commandsBlock); } parseIfThenElse () { if (this.insideScope(IVProgParser.BREAKABLE)) { this.pushScope(IVProgParser.BREAKABLE); } else { this.pushScope(IVProgParser.COMMAND); } const token = this.getToken(); this.pos++; this.checkOpenParenthesis(); this.pos++; this.consumeNewLines(); const logicalExpression = this.parseExpressionOR(); this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; this.consumeNewLines(); const cmdBlocks = this.parseCommandBlock(); const maybeElse = this.getToken(); if (maybeElse.type === this.lexerClass.RK_ELSE) { this.pos++; this.consumeNewLines(); const maybeIf = this.getToken(); let elseBlock = null; if (this.checkOpenCurly(true)) { elseBlock = this.parseCommandBlock(); } else if (maybeIf.type === this.lexerClass.RK_IF) { elseBlock = this.parseIfThenElse(); } else { throw SyntaxErrorFactory.token_missing_list( [this.lexer.literalNames[this.lexerClass.RK_IF], "{"], maybeIf ); } this.popScope(); const cmd = new Commands.IfThenElse( logicalExpression, cmdBlocks, elseBlock ); cmd.sourceInfo = SourceInfo.createSourceInfo(token); return cmd; } this.popScope(); const cmd = new Commands.IfThenElse(logicalExpression, cmdBlocks, null); cmd.sourceInfo = SourceInfo.createSourceInfo(token); return cmd; } parseFor () { this.pushScope(IVProgParser.BREAKABLE); const for_token = this.getToken(); this.pos += 1; // parse ID const id_token = this.getToken(); const id = this.parseID(); const for_id = new Expressions.VariableLiteral(id); for_id.sourceInfo = SourceInfo.createSourceInfo(id_token); // END parse ID const for_from = this.parseForParameters(this.lexerClass.RK_FOR_FROM); const for_to = this.parseForParameters(this.lexerClass.RK_FOR_TO); const maybePass = this.parseForParameters(this.lexerClass.RK_FOR_PASS); this.consumeNewLines(); const commandsBlock = this.parseCommandBlock(); this.popScope(); const cmd = new Commands.For( for_id, for_from, for_to, maybePass, commandsBlock ); cmd.sourceInfo = SourceInfo.createSourceInfo(for_token); return cmd; } parseWhile () { this.pushScope(IVProgParser.BREAKABLE); const token = this.getToken(); this.pos++; this.checkOpenParenthesis(); this.pos++; this.consumeNewLines(); const logicalExpression = this.parseExpressionOR(); this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; this.consumeNewLines(); const cmdBlocks = this.parseCommandBlock(); this.popScope(); const cmd = new Commands.While(logicalExpression, cmdBlocks); cmd.sourceInfo = SourceInfo.createSourceInfo(token); return cmd; } parseBreak () { const token = this.getToken(); this.pos++; this.checkEOS(); this.pos++; const command = new Commands.Break(); command.sourceInfo = SourceInfo.createSourceInfo(token); return command; } parseReturn () { this.pos++; let exp = null; if (!this.checkEOS(true)) { exp = this.parseExpressionOR(); this.checkEOS(); } this.pos++; return new Commands.Return(exp); } parseIDCommand () { const refToken = this.getToken(); const isID = refToken.type === this.lexerClass.ID; const id = this.parseMaybeLibID(); if (this.checkOpenBrace(true)) { this.pos++; let lineExpression = null; let columnExpression = null; this.consumeNewLines(); lineExpression = this.parseExpression(); this.consumeNewLines(); this.checkCloseBrace(); this.pos++; if (this.checkOpenBrace(true)) { this.pos++; this.consumeNewLines(); columnExpression = this.parseExpression(); this.consumeNewLines(); this.checkCloseBrace(); this.pos++; } const equalToken = this.getToken(); if (equalToken.type !== this.lexerClass.EQUAL) { throw SyntaxErrorFactory.token_missing_one("=", equalToken); } this.pos++; const exp = this.parseExpressionOR(); this.checkEOS(); this.pos++; const cmd = new Commands.ArrayIndexAssign( id, lineExpression, columnExpression, exp ); cmd.sourceInfo = SourceInfo.createSourceInfo(equalToken); return cmd; } const equalOrParenthesis = this.getToken(); if (isID && equalOrParenthesis.type === this.lexerClass.EQUAL) { this.pos++; const exp = this.parseExpressionOR(); this.checkEOS(); this.pos++; const cmd = new Commands.Assign(id, exp); cmd.sourceInfo = SourceInfo.createSourceInfo(equalOrParenthesis); return cmd; } else if (equalOrParenthesis.type === this.lexerClass.OPEN_PARENTHESIS) { const funcCall = this.parseFunctionCallCommand(id); this.checkEOS(); this.pos++; return funcCall; } else if (isID) { throw SyntaxErrorFactory.token_missing_list( ["=", "("], equalOrParenthesis ); } else { throw SyntaxErrorFactory.invalid_id_format(refToken); } } parseForParameters (keyword_code) { if (keyword_code === this.lexerClass.RK_FOR_PASS) { if (this.checkOpenCurly(true)) { return null; } } const from_token = this.getToken(); if (from_token.type !== keyword_code) { // TODO better error message const keyword = this.lexer.literalNames[keyword_code]; throw new Error( "Error de sintaxe no comando repita_para: esperava-se " + keyword + " mas encontrou " + from_token.text ); } this.pos += 1; let int_or_id = this.getToken(); let is_unary_op = false; let op = null; if (int_or_id.type === this.lexerClass.SUM_OP) { is_unary_op = true; op = int_or_id.text; this.pos += 1; int_or_id = this.getToken(); } let for_from = null; if (int_or_id.type === this.lexerClass.ID) { for_from = new Expressions.VariableLiteral(this.parseID()); for_from.sourceInfo = SourceInfo.createSourceInfo(int_or_id); } else if (int_or_id.type === this.lexerClass.INTEGER) { this.pos += 1; for_from = this.getIntLiteral(int_or_id); } if (for_from == null) { // TODO better error message const keyword = this.lexer.literalNames[keyword_code]; throw new Error( "Error de sintaxe no comando repeita_para: " + int_or_id.text + " não é compativel com o esperado para o paramentro " + keyword + ". O valor deve ser um inteiro ou variável." ); } if (is_unary_op) { for_from = new Expressions.UnaryApp(convertFromString(op), for_from); } return for_from; } parseCases () { const token = this.getToken(); if (token.type !== this.lexerClass.RK_CASE) { throw SyntaxErrorFactory.token_missing_one( this.lexer.literalNames[this.lexerClass.RK_CASE], token ); } this.pos++; const nextToken = this.getToken(); if (nextToken.type === this.lexerClass.RK_DEFAULT) { this.pos++; const colonToken = this.getToken(); if (colonToken.type !== this.lexerClass.COLON) { throw SyntaxErrorFactory.token_missing_one(":", colonToken); } this.pos++; this.consumeNewLines(); const block = this.parseCommandBlock(true); const defaultCase = new Commands.Case(null); defaultCase.setCommands(block.commands); return [defaultCase]; } else { const exp = this.parseExpressionOR(); const colonToken = this.getToken(); if (colonToken.type !== this.lexerClass.COLON) { throw SyntaxErrorFactory.token_missing_one(":", colonToken); } this.pos++; this.consumeNewLines(); const block = this.parseCommandBlock(true); const aCase = new Commands.Case(exp); aCase.setCommands(block.commands); const caseToken = this.getToken(); if (caseToken.type === this.lexerClass.RK_CASE) { return [aCase].concat(this.parseCases()); } else { return [aCase]; } } } /* * Parses an Expression following the structure: * * EOR => EAnd ( 'or' EOR)? #expression and * * EOR => ENot ('and' EOR)? #expression or * * ENot => 'not'? ER #expression not * * ER => E ((>=, <=, ==, >, <) E)? #expression relational * * E => factor ((+, -) E)? #expression * * factor=> term ((*, /, %) factor)? * * term => literal || arrayAccess || FuncCall || ID || '('EAnd')' **/ parseExpressionOR () { let exp1 = this.parseExpressionAND(); while (this.getToken().type === this.lexerClass.OR_OPERATOR) { const opToken = this.getToken(); this.pos++; const or = convertFromString("or"); this.consumeNewLines(); const exp2 = this.parseExpressionAND(); const finalExp = new Expressions.InfixApp(or, exp1, exp2); finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken); exp1 = finalExp; } return exp1; } parseExpressionAND () { let exp1 = this.parseExpressionNot(); while (this.getToken().type === this.lexerClass.AND_OPERATOR) { const opToken = this.getToken(); this.pos++; const and = convertFromString("and"); this.consumeNewLines(); const exp2 = this.parseExpressionNot(); const finalExp = new Expressions.InfixApp(and, exp1, exp2); finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken); exp1 = finalExp; } return exp1; } parseExpressionNot () { const maybeNotToken = this.getToken(); if (maybeNotToken.type === this.lexerClass.NOT_OPERATOR) { const opToken = this.getToken(); this.pos++; const not = convertFromString("not"); const exp1 = this.parseExpressionRel(); const finalExp = new Expressions.UnaryApp(not, exp1); finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken); return finalExp; } else { return this.parseExpressionRel(); } } parseExpressionRel () { let exp1 = this.parseExpression(); while (this.getToken().type === this.lexerClass.RELATIONAL_OPERATOR) { const relToken = this.getToken(); this.pos++; const rel = convertFromString(relToken.text); const exp2 = this.parseExpression(); const finalExp = new Expressions.InfixApp(rel, exp1, exp2); finalExp.sourceInfo = SourceInfo.createSourceInfo(relToken); exp1 = finalExp; } return exp1; } parseExpression () { let factor = this.parseFactor(); while (this.getToken().type === this.lexerClass.SUM_OP) { const sumOpToken = this.getToken(); this.pos++; const op = convertFromString(sumOpToken.text); const factor2 = this.parseFactor(); const finalExp = new Expressions.InfixApp(op, factor, factor2); finalExp.sourceInfo = SourceInfo.createSourceInfo(sumOpToken); factor = finalExp; } return factor; } parseFactor () { let term = this.parseTerm(); while (this.getToken().type === this.lexerClass.MULTI_OP) { const multOpToken = this.getToken(); this.pos++; const op = convertFromString(multOpToken.text); const term2 = this.parseTerm(); const finalExp = new Expressions.InfixApp(op, term, term2); finalExp.sourceInfo = SourceInfo.createSourceInfo(multOpToken); term = finalExp; } return term; } parseTerm () { const token = this.getToken(); let sourceInfo = null; let exp = null; switch (token.type) { case this.lexerClass.SUM_OP: this.pos++; sourceInfo = SourceInfo.createSourceInfo(token); exp = new Expressions.UnaryApp( convertFromString(token.text), this.parseTerm() ); exp.sourceInfo = sourceInfo; return exp; case this.lexerClass.INTEGER: this.pos++; return this.getIntLiteral(token); case this.lexerClass.REAL: this.pos++; return this.getRealLiteral(token); case this.lexerClass.STRING: this.pos++; return this.getStringLiteral(token); case this.lexerClass.CHARACTER: this.pos++; return this.getCharLiteral(token); case this.lexerClass.RK_TRUE: case this.lexerClass.RK_FALSE: this.pos++; return this.getBoolLiteral(token); case this.lexerClass.OPEN_CURLY: // No more annonymous array // return this.parseArrayLiteral(); throw SyntaxErrorFactory.annonymous_array_literal(token); case this.lexerClass.ID: case this.lexerClass.LIB_ID: return this.parseIDTerm(); case this.lexerClass.OPEN_PARENTHESIS: return this.parseParenthesisExp(); default: throw SyntaxErrorFactory.invalid_terminal(token); } } parseIDTerm () { const tokenA = this.getToken(); const id = this.parseMaybeLibID(); const isID = tokenA.type === this.lexerClass.ID; if (isID && this.checkOpenBrace(true)) { let tokenB = null; this.pos++; const firstIndex = this.parseExpression(); let secondIndex = null; this.consumeNewLines(); this.checkCloseBrace(); tokenB = this.getToken(); this.pos++; if (this.checkOpenBrace(true)) { this.pos++; secondIndex = this.parseExpression(); this.consumeNewLines(); this.checkCloseBrace(); tokenB = this.getToken(); this.pos++; } const sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB); const exp = new Expressions.ArrayAccess(id, firstIndex, secondIndex); exp.sourceInfo = sourceInfo; return exp; } else if (this.checkOpenParenthesis(true)) { return this.parseFunctionCallExpression(id); } else if (isID) { const sourceInfo = SourceInfo.createSourceInfo(tokenA); const exp = new Expressions.VariableLiteral(id); exp.sourceInfo = sourceInfo; return exp; } else { throw SyntaxErrorFactory.invalid_id_format(tokenA); } } getFunctionName (id) { const name = LanguageDefinedFunction.getInternalName(id); if (name === null) { if (id === LanguageDefinedFunction.getMainFunctionName()) { return null; } return id; } else { return name; } } parseFunctionCallExpression (id) { const tokenA = this.getToken(this.pos - 1); const actualParameters = this.parseActualParameters(); const tokenB = this.getToken(this.pos - 1); const funcName = this.getFunctionName(id); const sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB); const cmd = new Expressions.FunctionCall(funcName, actualParameters); cmd.sourceInfo = sourceInfo; return cmd; } parseFunctionCallCommand (id) { return this.parseFunctionCallExpression(id); } parseParenthesisExp () { this.checkOpenParenthesis(); const tokenA = this.getToken(); this.pos += 1; this.consumeNewLines(); const exp = this.parseExpressionOR(); this.consumeNewLines(); this.checkCloseParenthesis(); const tokenB = this.getToken(); this.pos += 1; exp.sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB); exp.parenthesis = true; return exp; } parseActualParameters () { this.checkOpenParenthesis(); this.pos++; if (this.checkCloseParenthesis(true)) { this.pos++; return []; } this.consumeNewLines(); const list = this.parseExpressionList(); this.consumeNewLines(); this.checkCloseParenthesis(); this.pos++; return list; } parseExpressionList () { const list = []; for (;;) { const exp = this.parseExpressionOR(); list.push(exp); const maybeToken = this.getToken(); if (maybeToken.type !== this.lexerClass.COMMA) { break; } else { this.pos++; this.consumeNewLines(); } } return list; } getTypeArray () { const types = this.insideScope(IVProgParser.FUNCTION) ? this.functionTypes : this.variableTypes; return types.map((x) => this.lexer.literalNames[x]); } }