import { ProcessorErrorFactory } from './../error/processorErrorFactory'; import { LanguageDefinedFunction } from './../definedFunctions'; import { LanguageService } from './../../services/languageService'; import { ArrayDeclaration, While, For, Switch, Case, Declaration, Assign, Break, IfThenElse, Return } from '../../ast/commands'; import { InfixApp, UnaryApp, FunctionCall, IntLiteral, RealLiteral, StringLiteral, BoolLiteral, VariableLiteral, ArrayLiteral } from '../../ast/expressions'; import { Literal } from '../../ast/expressions/literal'; import { resultTypeAfterInfixOp, resultTypeAfterUnaryOp } from '../compatibilityTable'; import { Types } from '../../ast/types'; export class SemanticAnalyser { constructor(ast) { this.ast = ast; this.lexerClass = LanguageService.getCurrentLexer(); const lexer = new this.lexerClass(null); this.literalNames = lexer.literalNames; this.symbolMap = null; } pushMap () { if(this.symbolMap === null) { this.symbolMap = {map:{}, next: null}; } else { const n = {map:{}, next: this.symbolMap}; this.symbolMap = n; } } popMap () { if(this.symbolMap !== null) { this.symbolMap = this.symbolMap.next; } } insertSymbol (id, typeInfo) { this.symbolMap.map[id] = typeInfo; } findSymbol (id, symMap) { if(!symMap.map[id]) { if(symMap.next) { return this.findSymbol(id, symMap.next); } throw new Error("variable not defined"); } else { return symMap.map[id]; } } findFunction (name) { if(name.match(/^\$.+$/)) { const fun = LanguageDefinedFunction[name]; if(!!!fun) { throw new Error("!!!Internal Error. Language defined function not implemented -> " + name + "!!!"); } return fun; } else { const val = this.ast.functions.find( v => v.name === name); if (!!!val) { // TODO: better error message; throw new Error(`Function ${name} is not defined.`); } return val; } } analyseTree () { const globalVars = this.ast.global; this.pushMap(); this.assertDeclarations(globalVars); const functions = this.ast.functions; const mainFunc = functions.filter((f) => f.name === null); if (mainFunc.length <= 0) { throw new Error("no main func..."); } else if (mainFunc.length > 1) { throw new Error("only one main func..."); } for (let i = 0; i < functions.length; i++) { const fun = functions[i]; this.assertFunction(fun); } return this.ast; } assertDeclarations (list) { for (let i = 0; i < list.length; i++) { this.assertDeclaration(list[i]); } } assertDeclaration (declaration) { if (declaration instanceof ArrayDeclaration) { if(declaration.initial === null) { const lineType = this.evaluateExpressionType(declaration.lines); if (lineType !== Types.INTEGER) { throw new Error("dim must be int"); } if (declaration.columns !== null) { const columnType = this.evaluateExpressionType(declaration.columns); if (columnType !== Types.INTEGER) { throw new Error("dim must be int"); } } this.insertSymbol(declaration.id, {id: declaration.id, lines: declaration.lines, columns: declaration.columns, type: declaration.type, subtype: declaration.subtype}); return; } this.evaluateArrayLiteral(declaration.lines, declaration.columns, declaration.subtype, declaration.initial); this.insertSymbol(declaration.id, {id: declaration.id, lines: declaration.lines, columns: declaration.columns, type: declaration.type, subtype: declaration.subtype}); } else { if(declaration.initial === null) { this.insertSymbol(declaration.id, {id: declaration.id, type: declaration.type}); return; } const resultType = this.evaluateExpressionType(declaration.initial); if(declaration.type !== resultType) { throw new Error('Invalid type'); } else { this.insertSymbol(declaration.id, {id: declaration.id, type: declaration.type}) } } } evaluateExpressionType (expression) { if(expression instanceof UnaryApp) { const op = expression.op; const resultType = this.evaluateExpressionType(expression.left); return resultTypeAfterUnaryOp(op, resultType); } else if (expression instanceof InfixApp) { const op = expression.op; const resultTypeLeft = this.evaluateExpressionType(expression.left); const resultTypeRight = this.evaluateExpressionType(expression.right); return resultTypeAfterInfixOp(op, resultTypeLeft, resultTypeRight); } else if (expression instanceof Literal) { return this.evaluateLiteralType(expression); } else if (expression instanceof FunctionCall) { const fun = this.findFunction(expression.id); if (fun.returnType === Types.VOID) { throw new Error("void return"); } this.assertParameters(fun, expression.actualParameters); return fun.returnType; } } evaluateLiteralType (literal) { if(literal instanceof IntLiteral) { return literal.type; } else if (literal instanceof RealLiteral) { return literal.type; } else if (literal instanceof StringLiteral) { return literal.type; } else if (literal instanceof BoolLiteral) { return literal.type; } else if (literal instanceof VariableLiteral) { const typeInfo = this.findSymbol(literal.id, this.symbolMap); if (typeInfo.type === Types.ARRAY) { return typeInfo; } return typeInfo.type; } else { console.warn("Evaluating type only for an array literal..."); return Types.UNDEFINED; } } evaluateArrayLiteral (lines, columns, subtype, literal) { if (literal instanceof ArrayLiteral) { if (columns === null) { // it's a vector... const dimType = this.evaluateExpressionType(lines); if (dimType !== Types.INTEGER) { throw new Error("dim must be int"); } if ((lines instanceof IntLiteral) && lines.value !== literal.value.length) { throw new Error("invalid array size"); } literal.value.reduce((last, next) => { const eType = this.evaluateExpressionType(next); if (subtype !== eType || eType !== last) { throw new Error("invalid array type"); } return eType; }); return true; } else { const dimType = this.evaluateExpressionType(columns); if (dimType !== Types.INTEGER) { throw new Error("dim must be int"); } if ((columns instanceof IntLiteral) && columns.value !== literal.value.length) { throw new Error("invalid array size"); } for (let i = 0; i < columns; i++) { const anotherArray = literal.value[i]; this.evaluateArrayLiteral(lines, null, subtype, anotherArray) } } } else { const resultType = this.evaluateExpressionType(literal); if (!resultType.subtype) { throw new Error("initial must be of type array"); } if (resultType.subtype !== subtype) { throw new Error("invalid array type"); } else if (resultType.lines !== lines) { throw new Error("invalid array size"); } else if (resultType.columns !== columns) { throw new Error("invalid array size"); } return true; } } assertFunction (fun) { this.pushMap(); this.assertDeclarations(fun.variablesDeclarations); const optional = fun.returnType === Types.VOID; const valid = this.assertReturn(fun, optional); if (!valid) { throw new Error("function has no accessible return"); } this.popMap(); } assertReturn (fun, optional) { return fun.commands.reduce( (last, next) => this.checkCommand(fun.returnType, next, optional) || last, optional ); } checkCommand (type, cmd, optional) { if (cmd instanceof While) { const resultType = this.evaluateExpressionType(cmd.expression); if (resultType !== Types.BOOLEAN) { throw new Error("condition not boolean"); } this.checkCommands(type, cmd.commands, optional); return false; } else if (cmd instanceof For) { this.checkCommand(type, cmd.assignment, optional); const resultType = this.evaluateExpressionType(cmd.condition); if (resultType !== Types.BOOLEAN) { throw new Error("condition not boolean"); } this.checkCommand(type, cmd.increment, optional); this.checkCommands(type, cmd.commands, optional); return false; } else if (cmd instanceof Switch) { const sType = this.evaluateExpressionType(cmd.expression); let result = optional; let hasDefault = false; for (let i = 0; i < cmd.cases.length; i++) { const aCase = cmd.cases[i]; if (aCase.expression !== null) { const caseType = this.evaluateExpressionType(aCase.expression); if (sType !== caseType) { throw new Error("invalid type in case"); } } else { hasDefault = true; } result = result && this.checkCommands(type, aCase.commands, result); } return result && hasDefault; } else if (cmd instanceof Assign) { const typeInfo = this.findSymbol(cmd.id, this.symbolMap); const exp = cmd.expression; if(exp instanceof ArrayLiteral) { if(!typeInfo.subtype) { throw new Error("type not compatible"); } this.evaluateArrayLiteral(typeInfo.lines, typeInfo.columns, typeInfo.subtype, exp); } else { if(typeInfo.subtype) { throw new Error("type not compatible"); } const resultType = this.evaluateExpressionType(exp); if(resultType !== typeInfo.type) { throw new Error("type not compatible"); } } return optional; } else if (cmd instanceof Break) { return optional; } else if (cmd instanceof IfThenElse) { const resultType = this.evaluateExpressionType(cmd.condition); if (resultType !== Types.BOOLEAN) { throw new Error("condition not boolean"); } console.log(cmd); if(cmd.ifFalse instanceof IfThenElse) { return this.checkCommands(type, cmd.ifTrue.commands, optional) && this.checkCommand(type, cmd.ifFalse, optional); } else { return this.checkCommands(type, cmd.ifTrue.commands, optional) && this.checkCommands(type, cmd.ifFalse.commands,optional); } } else if (cmd instanceof FunctionCall) { const fun = this.findFunction(cmd.id); this.assertParameters(fun, cmd.actualParameters); return optional; } else if (cmd instanceof Return) { if (cmd.expression === null && type !== Types.VOID) { throw new Error('invalid return type'); } else if (cmd.expression !== null) { const resultType = this.evaluateExpressionType(cmd.expression); if (resultType !== type) { throw new Error('invalid return type'); } else { return true; } } else { return true; } } } checkCommands (type, cmds, optional) { return cmds.reduce( (last, next) => this.checkCommand(type, next, optional) || last, optional ); } assertParameters (fun, actualParametersList) { if (fun.formalParameters.length !== actualParametersList.length) { throw new Error("wrong number of parameters..."); } for (let i = 0; i < actualParametersList.length; i++) { const param = actualParametersList[i]; const formalParam = fun.formalParameters[i]; if(formalParam.byRef && !(param instanceof VariableLiteral)) { throw new Error("Invalid param type"); } const resultType = this.evaluateExpressionType(param); switch (formalParam.dimensions) { case 1: { if (!resultType.subtype) { throw new Error("invalid param type"); } else if (resultType.subtype !== formalParam.type) { throw new Error("invalid param type"); } else if (resultType.lines === null || resultType.columns !== null) { throw new Error("invalid param type"); } break; } case 2: { if (!resultType.subtype) { throw new Error("invalid param type"); } else if (resultType.subtype !== formalParam.type) { throw new Error("invalid param type"); } else if (resultType.lines === null || resultType.columns === null) { throw new Error("invalid param type"); } break; } default: { if (resultType.subtype) { throw new Error("invalid param type"); } if (formalParam.type !== Types.ALL && resultType !== formalParam.type) { throw new Error("invalid param type"); } break; } } } } }