import { Store } from "./store/store"; import { Modes } from "./modes"; import { Context } from "./context"; import { Types } from "./../typeSystem/types"; import { Operators } from "./../ast/operators"; import { LanguageDefinedFunction } from "./definedFunctions"; import { resultTypeAfterInfixOp, resultTypeAfterUnaryOp, } from "./compatibilityTable"; import * as Commands from "./../ast/commands/"; // eslint-disable-next-line @typescript-eslint/no-unused-vars import { Command } from "./../ast/commands/command"; import * as Expressions from "./../ast/expressions/"; // eslint-disable-next-line @typescript-eslint/no-unused-vars import { Expression } from "./../ast/expressions/expression"; import * as Utils from "./../util/utils"; import { ArrayType } from "./../typeSystem/array_type"; import { convertToString, toInt } from "../typeSystem/parsers"; import { Config } from "../util/config"; import { ProcessorErrorFactory } from "./error/processorErrorFactory"; import { RuntimeError } from "./error/runtimeError"; import { Location } from "../memory/location"; import { StoreValue } from "./store/value/store_value"; import { StoreValueRef } from "./store/value/store_value_ref"; import { ArrayStoreValue } from "./store/value/array_store_value"; import { ArrayStoreValueRef } from "./store/value/array_store_value_ref"; import { StoreValueAddress } from "./store/value/store_value_address"; import { LocalizedStrings } from "../services/localizedStringsService"; export class IVProgProcessor { static get MAIN_INTERNAL_ID() { return "$main"; } constructor(ast) { this.ast = ast; this.globalStore = new Store("$global"); this.stores = [this.globalStore]; this.context = [Context.BASE]; this.input = null; this.forceKill = false; this.output = null; this.mode = Modes.RUN; /** * Stores the sourceInfo of every function call, command or expression */ this.function_call_stack = []; this.instruction_count = 0; this.function_call_count = 0; } registerInput(input) { if (this.input !== null) this.input = null; this.input = input; } registerOutput(output) { if (this.output !== null) this.output = null; this.output = output; } checkContext(context) { return this.context[this.context.length - 1] === context; } ignoreSwitchCases(store) { if (store.mode === Modes.RETURN) { return true; } else if (store.mode === Modes.BREAK) { return true; } else { return false; } } prepareState() { if (this.stores !== null) { for (let i = 0; i < this.stores.length; i++) { delete this.stores[i]; } this.stores = null; } if (this.globalStore !== null) this.globalStore = null; this.globalStore = new Store("$global"); this.stores = [this.globalStore]; this.context = [Context.BASE]; this.instruction_count = 0; this.mode = Modes.RUN; } async interpretAST() { this.prepareState(); Location.clear(); await this.initGlobal(); const mainFunc = this.findMainFunction(); if (mainFunc === null) { throw ProcessorErrorFactory.main_missing(); } return this.runFunction(mainFunc, [], this.globalStore); } async initGlobal() { if (!this.checkContext(Context.BASE)) { return ProcessorErrorFactory.invalid_global_var(); } return this.executeCommands(this.globalStore, this.ast.global); } findMainFunction() { return this.ast.functions.find((v) => v.isMain); } findFunction(name) { if (name.match(/^\$.+$/)) { if (name === IVProgProcessor.MAIN_INTERNAL_ID) { return this.findMainFunction(); } const fun = LanguageDefinedFunction.getFunction(name); if (!fun) { throw ProcessorErrorFactory.not_implemented(name); } return fun; } else { const val = this.ast.functions.find((v) => v.name === name); if (!val) { throw ProcessorErrorFactory.function_missing(name); } return val; } } async runFunction(func, actualParameters, store) { const funcName = func.isMain ? IVProgProcessor.MAIN_INTERNAL_ID : func.name; const funcStore = new Store(funcName); funcStore.extendStore(this.globalStore); await this.associateParameters( func.formalParameters, actualParameters, store, funcStore ); this.context.push(Context.FUNCTION); this.stores.push(funcStore); const stoWithVars = await this.executeCommands( funcStore, func.variablesDeclarations ); const finalSto = this.executeCommands(stoWithVars, func.commands); this.stores.pop(); this.context.pop(); return finalSto; } /** * * @param {import('./../ast/commands/formalParameter').FormalParameter[]} formal_params * @param {Expression[]} effective_params * @param {Store} caller_store * @param {Store} callee_store */ async associateParameters( formal_params, effective_params, caller_store, callee_store ) { const funcName = callee_store.name === IVProgProcessor.MAIN_INTERNAL_ID ? LanguageDefinedFunction.getMainFunctionName() : callee_store.name; const hasVariadic = formal_params.some(p => p.variadic); if ((formal_params.length != effective_params.length && !hasVariadic) || formal_params.length > effective_params.length) { throw ProcessorErrorFactory.invalid_parameters_size( funcName, formal_params.length, effective_params.length ); } for (let i = 0, j = 0; i < formal_params.length && j < effective_params.length; i += 1, j += 1) { const formalParameter = formal_params[i]; if (formalParameter.variadic) { [j, callee_store] = await this.associateVariadicParameter(funcName, formalParameter, j, effective_params, caller_store, callee_store); } else { const actualParam = effective_params[i]; callee_store = await this.associateParameter(funcName, formalParameter, actualParam, caller_store, callee_store); } } return callee_store; } /** * * @param {string} funcName * @param {import('./../ast/commands/formalParameter').FormalParameter} formalParameter * @param {number} index * @param {Expression[]} effective_params * @param {Store} caller_store * @param {Store} callee_store */ async associateVariadicParameter (funcName, formalParameter, index, effective_params, caller_store, callee_store) { let i; let count = 1 for (i = index; i < effective_params.length; i += 1) { const actualParam = effective_params[i]; callee_store = await this.associateParameter(funcName, formalParameter, actualParam, caller_store, callee_store, count); count += 1; } const variadicCount = new StoreValue(Types.INTEGER, count, undefined, true); callee_store.insertStore(`${formalParameter.id}.0`, variadicCount); return [i - 1, callee_store]; } /** * * @param {string} funcName * @param {import('./../ast/commands/formalParameter').FormalParameter} formalParameter * @param {Expression} actualParameter * @param {Store} callerStore * @param {Store} calleeStore * @param {number} variadicCount The number of the current value being assigned to the variadic parameter, default 0 */ async associateParameter (funcName, formalParameter, actualParameter, callerStore, calleeStore, variadicCount = 0 ) { const actualValue = await this.evaluateExpression( callerStore, actualParameter ); let shouldTypeCast = false; if (!formalParameter.type.isCompatible(actualValue.type)) { if ( Config.enable_type_casting && !formalParameter.byRef && Store.canImplicitTypeCast(formalParameter.type, actualValue.type) ) { shouldTypeCast = true; } else { throw ProcessorErrorFactory.invalid_parameter_type( funcName, actualParameter.toString() ); } } if (formalParameter.byRef && !actualValue.inStore()) { throw ProcessorErrorFactory.invalid_ref(funcName, actualParameter.toString()); } if (formalParameter.byRef) { const realObj = callerStore.getStoreObject(actualValue.id); let ref = null; if (actualValue instanceof ArrayStoreValue) { // it's a vector or matrix... const values = actualValue.get(); const array_type = actualValue.type; const addresses = values.map((v) => realObj.getLocAddressOf(v.line, v.column) ); const columns = actualValue.isVector() ? 0 : actualValue.columns; ref = new ArrayStoreValueRef( array_type, values, addresses, actualValue.lines, columns, realObj.id ); } else { if (actualValue instanceof StoreValueAddress) { const line = actualValue.line; const column = actualValue.column; ref = new StoreValueRef( actualValue.type, actualValue.get(), realObj.getLocAddressOf(line, column), realObj.id ); ref.setReferenceDimension(realObj.type.dimensions); } else { ref = new StoreValueRef( actualValue.type, actualValue.get(), realObj.locAddress, realObj.id ); } } let varID = formalParameter.id; if (formalParameter.variadic) varID = `${varID}.${variadicCount}`; calleeStore.insertStore(varID, ref); } else { let realValue = actualValue; if (shouldTypeCast) { realValue = Store.doImplicitCasting(formalParameter.type, realValue); } let varID = formalParameter.id; if (formalParameter.variadic) varID = `${varID}.${variadicCount}`; calleeStore.insertStore(varID, realValue); } return calleeStore; } /** * * @param {Store} store * @param {Command[]} cmds * * @returns {Promise} */ async executeCommands(store, cmds) { // helper to partially apply a function, in this case executeCommand let sto = store; for (let i = 0; i < cmds.length; i += 1) { sto = await this.executeCommand(sto, cmds[i]); } return sto; } /** * * @param {Store} store * @param {Command} cmd * * @returns {Promise} */ async executeCommand(store, cmd) { this.instruction_count += 1; if (this.instruction_count % Config.suspend_threshold == 0) { //every Config.suspend_threshold instruction should briefly delay its execution in order to allow the browser to process other things await Utils.sleep(5); } // Checks if it must interrupt the execution for some reason if (this.instruction_count >= Config.max_instruction_count) { throw ProcessorErrorFactory.exceed_max_instructions(); } else if (this.forceKill) { throw "FORCED_KILL!"; } else if (store.mode === Modes.PAUSE) { return this.executeCommand(store, cmd); } else if (store.mode === Modes.RETURN) { return store; } else if ( this.checkContext(Context.BREAKABLE) && store.mode === Modes.BREAK ) { return store; } else if (this.mode === Modes.ABORT) { throw LocalizedStrings.getMessage("aborted_execution"); } if (cmd instanceof Commands.Declaration) { return this.executeDeclaration(store, cmd); } else if (cmd instanceof Commands.ArrayIndexAssign) { return this.executeArrayIndexAssign(store, cmd); } else if (cmd instanceof Commands.Assign) { return this.executeAssign(store, cmd); } else if (cmd instanceof Commands.Break) { return this.executeBreak(store, cmd); } else if (cmd instanceof Commands.Return) { return this.executeReturn(store, cmd); } else if (cmd instanceof Commands.IfThenElse) { return this.executeIfThenElse(store, cmd); } else if (cmd instanceof Commands.RepeatUntil) { return this.executeRepeatUntil(store, cmd); } else if (cmd instanceof Commands.While) { return this.executeWhile(store, cmd); } else if (cmd instanceof Commands.For) { return this.executeFor(store, cmd); } else if (cmd instanceof Commands.Switch) { return this.executeSwitch(store, cmd); } else if (cmd instanceof Expressions.FunctionCall) { return this.executeFunctionCall(store, cmd); } else if (cmd instanceof Commands.SysCall) { return this.executeSysCall(store, cmd); } else { throw ProcessorErrorFactory.unknown_command(cmd.sourceInfo); } } /** * * @param {Store} store * @param {Commands.SysCall} cmd * * @returns {Promise} */ async executeSysCall(store, cmd) { const func = cmd.langFunc.bind(this); return func(store, cmd); } /** * * @param {Store} store * @param {Commands.FunctionCall} cmd * * @returns {Promise} */ async executeFunctionCall(store, cmd) { let func = null; if (cmd.isMainCall) { func = this.findMainFunction(); } else { func = this.findFunction(cmd.id); } this.function_call_stack.push(cmd.sourceInfo); const sto = await this.runFunction(func, cmd.actualParameters, store); sto.destroy(); if ( !Types.VOID.isCompatible(func.returnType) && sto.mode !== Modes.RETURN ) { const funcName = func.name === IVProgProcessor.MAIN_INTERNAL_ID ? LanguageDefinedFunction.getMainFunctionName() : func.name; throw ProcessorErrorFactory.function_no_return(funcName); } else { this.function_call_stack.pop(); return store; } } /** * * @param {Store} store * @param {Commands.Switch} cmd * * @returns {Promise} */ async executeSwitch(store, cmd) { this.context.push(Context.BREAKABLE); const switchCases = cmd.cases; let lastStore = store; let lastCaseCheckResult = false; for ( let i = 0; i < switchCases.length && !this.ignoreSwitchCases(lastStore); i += 1 ) { const switchCase = switchCases[i]; if (lastCaseCheckResult || switchCase.isDefault) { lastStore = await this.executeCommands(lastStore, switchCase.commands); } else { const equalityInfixApp = new Expressions.InfixApp( Operators.EQ, cmd.expression, switchCase.expression ); equalityInfixApp.sourceInfo = switchCase.sourceInfo; const result = await this.evaluateExpression( lastStore, equalityInfixApp ); if (result.get()) { lastStore = await this.executeCommands( lastStore, switchCase.commands ); } lastCaseCheckResult = result.get(); } } this.context.pop(); if (lastStore.mode === Modes.BREAK) { lastStore.mode = Modes.RUN; } return lastStore; } /** * * @param {Store} store * @param {Commands.For} cmd * * @returns {Promise} */ async executeFor(store, cmd) { //BEGIN for -> while rewrite const initCmd = new Commands.Assign(cmd.for_id.id, cmd.for_from); initCmd.sourceInfo = cmd.sourceInfo; // Assume for is iterating forward and that pass is not missing let passValue = cmd.for_pass; let condition = new Expressions.InfixApp( Operators.LT, cmd.for_id, cmd.for_to ); if (cmd.for_pass == null) { passValue = new Expressions.IntLiteral(toInt(1)); const checkEndGTBegin = await this.evaluateExpression( store, new Expressions.InfixApp(Operators.GE, cmd.for_to, cmd.for_from) ); if (!checkEndGTBegin.get()) { passValue = new Expressions.IntLiteral(toInt(-1)); condition = new Expressions.InfixApp( Operators.GT, cmd.for_id, cmd.for_to ); } } else { const isForward = await this.evaluateExpression( store, new Expressions.InfixApp( Operators.GE, cmd.for_pass, new Expressions.IntLiteral(toInt(0)) ) ); if (!isForward.get()) { condition = new Expressions.InfixApp( Operators.GT, cmd.for_id, cmd.for_to ); } } condition.sourceInfo = cmd.sourceInfo; const increment = new Commands.Assign( cmd.for_id.id, new Expressions.InfixApp(Operators.ADD, cmd.for_id, passValue) ); increment.sourceInfo = cmd.sourceInfo; const whileBlock = new Commands.CommandBlock( [], cmd.commands.concat(increment) ); const forAsWhile = new Commands.While(condition, whileBlock); forAsWhile.sourceInfo = cmd.sourceInfo; //END for -> while rewrite const newCmdList = [initCmd, forAsWhile]; return this.executeCommands(store, newCmdList); } /** * * @param {Store} store * @param {Commands.RepeatUntil} cmd * * @returns {Promise} */ async executeRepeatUntil(store, cmd) { this.context.push(Context.BREAKABLE); const sto = await this.executeCommands(store, cmd.commands); if (sto.mode === Modes.BREAK) { this.context.pop(); sto.mode = Modes.RUN; return sto; } const checkCondition = await this.evaluateExpression(sto, cmd.expression); if (!checkCondition.type.isCompatible(Types.BOOLEAN)) { throw ProcessorErrorFactory.loop_condition_type_full(cmd.sourceInfo); } this.context.pop(); if (checkCondition.get()) { return sto; } else { return this.executeCommand(sto, cmd); } } /** * * @param {Store} store * @param {Commands.While} cmd * * @returns {Promise} */ async executeWhile(store, cmd) { this.context.push(Context.BREAKABLE); const checkCondition = await this.evaluateExpression(store, cmd.expression); if (!checkCondition.type.isCompatible(Types.BOOLEAN)) { throw ProcessorErrorFactory.loop_condition_type_full( cmd.expression.toString(), cmd.sourceInfo ); } if (checkCondition.get()) { const sto = await this.executeCommands(store, cmd.commands); this.context.pop(); if (sto.mode === Modes.BREAK) { sto.mode = Modes.RUN; return sto; } return this.executeCommand(sto, cmd); } else { this.context.pop(); return store; } } /** * * @param {Store} store * @param {Commands.IfThenElse} cmd * * @returns {Promise} */ async executeIfThenElse(store, cmd) { const isTrue = await this.evaluateExpression(store, cmd.condition); if (!isTrue.type.isCompatible(Types.BOOLEAN)) { throw ProcessorErrorFactory.if_condition_type_full( cmd.condition.toString(), cmd.sourceInfo ); } if (isTrue.get()) { return this.executeCommands(store, cmd.ifTrue.commands); } else if (cmd.ifFalse !== null) { if (cmd.ifFalse instanceof Commands.IfThenElse) { return this.executeCommand(store, cmd.ifFalse); } else { return this.executeCommands(store, cmd.ifFalse.commands); } } else { return store; } } /** * * @param {Store} store * @param {Commands.Return} cmd * * @returns {Promise} */ async executeReturn(store, cmd) { const funcName = store.name === IVProgProcessor.MAIN_INTERNAL_ID ? LanguageDefinedFunction.getMainFunctionName() : store.name; // console.log(funcName, store.name === IVProgProcessor.MAIN_INTERNAL_ID); const func = this.findFunction(store.name); const funcType = func.returnType; const value = await this.evaluateExpression(store, cmd.expression); if (value === null && funcType.isCompatible(Types.VOID)) { store.mode = Modes.RETURN; return store; } let real_value = value; if (value === null || !funcType.isCompatible(value.type)) { if ( !Config.enable_type_casting || !Store.canImplicitTypeCast(funcType, value.type) ) { const stringInfo = funcType.stringInfo(); const info = stringInfo[0]; throw ProcessorErrorFactory.invalid_return_type_full( funcName, info.type, info.dim, cmd.sourceInfo ); } real_value = Store.doImplicitCasting(funcType, value); } store.insertStore("$", real_value); store.mode = Modes.RETURN; return store; } /** * * @param {Store} store * @param {Commands.Break} cmd * * @returns {Promise} */ async executeBreak(store, cmd) { if (this.checkContext(Context.BREAKABLE)) { store.mode = Modes.BREAK; return store; } else { throw ProcessorErrorFactory.unexpected_break_command_full(cmd.sourceInfo); } } /** * * @param {Store} store * @param {Commands.Assign} cmd * * @returns {Promise} */ async executeAssign(store, cmd) { const inStore = store.applyStore(cmd.id); if (inStore.isConst) { throw ProcessorErrorFactory.invalid_const_assignment_full( cmd.id, cmd.sourceInfo ); } const value = await this.evaluateExpression(store, cmd.expression); let realValue = value; if (!inStore.type.isCompatible(realValue.type)) { if ( Config.enable_type_casting && Store.canImplicitTypeCast(inStore.type, value.type) ) { realValue = Store.doImplicitCasting(inStore.type, realValue); } else { const stringInfo = inStore.type.stringInfo(); const info = stringInfo[0]; const exp_type_string_info = value.type.stringInfo(); const exp_type_info = exp_type_string_info[0]; const exp = cmd.expression.toString(); throw ProcessorErrorFactory.incompatible_types_full( info.type, info.dim, exp_type_info.type, exp_type_info.dim, exp, cmd.sourceInfo ); } } if (inStore instanceof ArrayStoreValue) { const columns = realValue.columns == null ? 0 : realValue.columns; if (inStore.lines !== realValue.lines || inStore.columns !== columns) { const exp = cmd.expression.toString(); if (inStore.isVector()) { throw ProcessorErrorFactory.invalid_vector_assignment_full( cmd.id, inStore.lines, exp, realValue.lines, cmd.sourceInfo ); } else { throw ProcessorErrorFactory.invalid_matrix_assignment_full( cmd.id, inStore.lines, inStore.columns, exp, realValue.lines, realValue.columns, cmd.sourceInfo ); } } } store.updateStore(cmd.id, realValue); return store; } /** * * @param {Store} store * @param {Commands.ArrayIndexAssign} cmd * * @returns {Promise} */ async executeArrayIndexAssign(store, cmd) { const mustBeArray = store.applyStore(cmd.id); let used_dims = 0; if (mustBeArray.isConst) { throw ProcessorErrorFactory.invalid_const_assignment_full( cmd.id, cmd.sourceInfo ); } if (!(mustBeArray.type instanceof ArrayType)) { throw ProcessorErrorFactory.invalid_array_access_full( cmd.id, cmd.sourceInfo ); } const lineSV = await this.evaluateExpression(store, cmd.line); if (!Types.INTEGER.isCompatible(lineSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo); } used_dims += 1; const line = lineSV.get().toNumber(); const columnSV = await this.evaluateExpression(store, cmd.column); let column = null; if (columnSV != null) { if (!Types.INTEGER.isCompatible(columnSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full( cmd.sourceInfo ); } column = columnSV.get().toNumber(); used_dims += 1; } const value = await this.evaluateExpression(store, cmd.expression); let actualValue = value; if (line >= mustBeArray.lines) { if (mustBeArray.isVector) { throw ProcessorErrorFactory.vector_line_outbounds_full( cmd.id, line, mustBeArray.lines, cmd.sourceInfo ); } else { throw ProcessorErrorFactory.matrix_line_outbounds_full( cmd.id, line, mustBeArray.lines, cmd.sourceInfo ); } } else if (line < 0) { throw ProcessorErrorFactory.array_dimension_not_positive_full( cmd.sourceInfo ); } if (column != null && mustBeArray.columns === 0) { throw ProcessorErrorFactory.vector_not_matrix_full( cmd.id, cmd.sourceInfo ); } if (column != null) { if (column >= mustBeArray.columns) { throw ProcessorErrorFactory.matrix_column_outbounds_full( cmd.id, column, mustBeArray.columns, cmd.sourceInfo ); } else if (column < 0) { throw ProcessorErrorFactory.array_dimension_not_positive_full( cmd.sourceInfo ); } } if (!mustBeArray.type.canAccept(value.type, used_dims)) { if ( !Config.enable_type_casting || !Store.canImplicitTypeCast(mustBeArray.type.innerType, value.type) ) { const type = mustBeArray.type.innerType; const stringInfo = type.stringInfo(); const info = stringInfo[0]; const exp_type_string_info = value.type.stringInfo(); const exp_type_info = exp_type_string_info[0]; const exp = cmd.expression.toString(); throw ProcessorErrorFactory.incompatible_types_full( info.type, info.dim, exp_type_info.type, exp_type_info.dim, exp, cmd.sourceInfo ); } actualValue = Store.doImplicitCasting(mustBeArray.type.innerType, value); } const current_value = mustBeArray.getAt(line, column); if (current_value instanceof ArrayStoreValue) { if ( current_value.lines !== actualValue.lines || current_value.columns !== actualValue.columns ) { const exp = cmd.expression.toString(); throw ProcessorErrorFactory.invalid_matrix_index_assign_full( cmd.id, line, current_value.lines, exp, actualValue.lines, cmd.sourceInfo ); } } return store.updateStoreArray(cmd.id, actualValue, line, column); } /** * * @param {Store} store * @param {Commands.Declaration} cmd * * @returns {Promise} */ async executeDeclaration(store, cmd) { if (cmd instanceof Commands.ArrayDeclaration) { return this.executeArrayDeclaration(store, cmd); } else { let temp = new StoreValue(cmd.type, null, null, cmd.isConst); if (cmd.initial !== null) { const value = await this.evaluateExpression(store, cmd.initial); let realValue = value; if (!value.type.isCompatible(cmd.type)) { if ( Config.enable_type_casting && Store.canImplicitTypeCast(cmd.type, value.type) ) { realValue = Store.doImplicitCasting(cmd.type, realValue); } else { const stringInfo = value.type.stringInfo(); const info = stringInfo[0]; const exp_type_string_info = value.type.stringInfo(); const exp_type_info = exp_type_string_info[0]; const exp = cmd.expression.toString(); throw ProcessorErrorFactory.incompatible_types_full( info.type, info.dim, exp_type_info.type, exp_type_info.dim, exp, cmd.sourceInfo ); } } temp = new StoreValue(cmd.type, realValue.get(), null, cmd.isConst); } store.insertStore(cmd.id, temp); return store; } } /** * * @param {Store} store * @param {Commands.ArrayDeclaration} cmd * * @returns {Promise} */ async executeArrayDeclaration(store, cmd) { const linesSV = await this.evaluateExpression(store, cmd.lines); if (!Types.INTEGER.isCompatible(linesSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo); } const line = linesSV.get().toNumber(); const columnsSV = await this.evaluateExpression(store, cmd.columns); let column = null; if (columnsSV !== null) { if (!Types.INTEGER.isCompatible(columnsSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full( cmd.sourceInfo ); } column = columnsSV.get().toNumber(); if (column < 0) { throw ProcessorErrorFactory.array_dimension_not_positive_full( cmd.sourceInfo ); } } let temp = new ArrayStoreValue( cmd.type, [], line, column, null, cmd.isConst ); if (cmd.initial !== null) { // array can only be initialized by a literal.... const valueList = await this.evaluateArrayLiteral( store, cmd.initial, cmd.type, line, column ); temp = new ArrayStoreValue( cmd.type, valueList, line, column, null, cmd.isConst ); } store.insertStore(cmd.id, temp); return store; } /** * * @param {Store} store * @param {Expression} exp * * @returns {Promise} */ async evaluateExpression(store, exp) { this.instruction_count += 1; if (this.instruction_count % Config.suspend_threshold == 0) { //every Config.suspend_threshold instruction should briefly delay its execution in order to allow the browser to process other things await Utils.sleep(5); } if (this.mode === Modes.ABORT) { throw LocalizedStrings.getMessage("aborted_execution"); } if (this.instruction_count >= Config.max_instruction_count) { throw new Error( "Número de instruções excedeu o limite definido. Verifique se seu código não possui laços infinitos ou muitas chamadas de funções recursivas." ); } if (exp instanceof Expressions.UnaryApp) { return this.evaluateUnaryApp(store, exp); } else if (exp instanceof Expressions.InfixApp) { return this.evaluateInfixApp(store, exp); } else if (exp instanceof Expressions.ArrayAccess) { return this.evaluateArrayAccess(store, exp); } else if (exp instanceof Expressions.VariableLiteral) { return this.evaluateVariableLiteral(store, exp); } else if (exp instanceof Expressions.IntLiteral) { return this.evaluateLiteral(store, exp); } else if (exp instanceof Expressions.RealLiteral) { return this.evaluateLiteral(store, exp); } else if (exp instanceof Expressions.BoolLiteral) { return this.evaluateLiteral(store, exp); } else if (exp instanceof Expressions.StringLiteral) { return this.evaluateLiteral(store, exp); } else if (exp instanceof Expressions.ArrayLiteral) { throw new Error( "Internal Error: The system should not eval an array literal." ); } else if (exp instanceof Expressions.FunctionCall) { return this.evaluateFunctionCall(store, exp); } return null; } async evaluateFunctionCall(store, exp) { if (exp.isMainCall) { throw ProcessorErrorFactory.void_in_expression_full( LanguageDefinedFunction.getMainFunctionName(), exp.sourceInfo ); } const func = this.findFunction(exp.id); if (Types.VOID.isCompatible(func.returnType)) { throw ProcessorErrorFactory.void_in_expression_full( exp.id, exp.sourceInfo ); } if (this.function_call_stack.length >= Config.max_call_stack) { throw ProcessorErrorFactory.exceeded_recursive_calls(exp.sourceInfo); } this.function_call_stack.push(exp.sourceInfo); const sto = await this.runFunction(func, exp.actualParameters, store); if (sto.mode !== Modes.RETURN) { throw new Error( "!!!Internal error: the function that was called did not have a return command or did not set the store mode properly -> " + exp.id ); } const val = sto.applyStore("$"); sto.destroy(); this.function_call_stack.pop(); return val; } /** * * @param {Store} store * @param {Expressions.ArrayLiteral} exp * @param {ArrayType} type * * @returns {Promise} */ async evaluateArrayLiteral(store, exp, type, lines, columns) { if (!exp.isVector) { if (columns == null) { throw new Error( "This should never happen: Vector cannot be initialized by a matrix" ); } const storeValueMatrix = await this.evaluateMatrix( store, exp, type, lines, columns ); return storeValueMatrix.reduce((prev, next) => prev.concat(next), []); } else { if (columns != null) { throw new Error( "This should never happen: Matrix cannot be initialized by a vector" ); } return this.evaluateVector(store, exp, type, lines); } } /** * Evalautes a list of literals and expression composing the vector * @param {Store} store * @param {Expressions.ArrayLiteral} exps * @param {ArrayType} type * @param {number} n_elements * * @returns {Promise} store object list */ async evaluateVector(store, exps, type, n_elements) { const values = exps.value; if (n_elements !== values.length) { throw ProcessorErrorFactory.invalid_number_elements_vector( n_elements, exps.toString(), values.length, exps.sourceInfo ); } const actualValues = await Promise.all( values.map((exp) => this.evaluateExpression(store, exp)) ); return actualValues.map((v, index) => { if (!type.canAccept(v.type, 1)) { if ( !Config.enable_type_casting || !Store.canImplicitTypeCast(type.innerType, v.type) ) { // const stringInfo = v.type.stringInfo(); // const info = stringInfo[0]; const exp_str = values[index].toString(); // TODO - fix error message throw ProcessorErrorFactory.invalid_array_literal_type_full( exp_str, values[index].sourceInfo ); } const newValue = Store.doImplicitCasting(type.innerType, v); return newValue; } return v; }); } /** * Evaluates a list of array literals composing the matrix * @param {Store} store * @param {Expressions.ArrayLiteral} exps * @param {ArrayType} type * * @returns {Promise} */ async evaluateMatrix(store, exps, type, lines, columns) { const values = exps.value; if (values.length !== lines) { throw ProcessorErrorFactory.invalid_number_lines_matrix( lines, exps.toString(), values.length, exps.sourceInfo ); } const vectors = values.map((vector) => { const vec_type = new ArrayType(type.innerType, 1); return this.evaluateVector(store, vector, vec_type, columns); }); return await Promise.all(vectors); } /** * * @param {Store} _ * @param {import('../ast/expressions/literal').Literal} exp * * @returns {import('./store/value/istore_value').IStoreValue} */ async evaluateLiteral(_, exp) { return new StoreValue(exp.type, exp.value); } /** * * @param {Store} store * @param {Expressions.VariableLiteral} exp * * @returns {import('./store/value/istore_value').IStoreValue} */ async evaluateVariableLiteral(store, exp) { const val = store.applyStore(exp.id); return val; } /** * * @param {Store} store * @param {Expressions.ArrayAccess} exp * * @returns {import('./store/value/istore_value').IStoreValue} */ async evaluateArrayAccess(store, exp) { const mustBeArray = store.getStoreObject(exp.id); if (!(mustBeArray.type instanceof ArrayType)) { throw ProcessorErrorFactory.invalid_array_access_full( exp.id, exp.sourceInfo ); } const lineSV = await this.evaluateExpression(store, exp.line); if (!Types.INTEGER.isCompatible(lineSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full(exp.sourceInfo); } const line = lineSV.get().toNumber(); const columnSV = await this.evaluateExpression(store, exp.column); let column = null; if (columnSV !== null) { if (!Types.INTEGER.isCompatible(columnSV.type)) { throw ProcessorErrorFactory.array_dimension_not_int_full( exp.sourceInfo ); } column = columnSV.get().toNumber(); } if (line >= mustBeArray.lines) { if (mustBeArray.isVector) { throw ProcessorErrorFactory.vector_line_outbounds_full( exp.id, line, mustBeArray.lines, exp.sourceInfo ); } else { throw ProcessorErrorFactory.matrix_line_outbounds_full( exp.id, line, mustBeArray.lines, exp.sourceInfo ); } } else if (line < 0) { throw ProcessorErrorFactory.array_dimension_not_positive_full( exp.sourceInfo ); } if (column !== null && mustBeArray.columns === 0) { throw ProcessorErrorFactory.vector_not_matrix_full( exp.id, exp.sourceInfo ); } if (column !== null) { if (column >= mustBeArray.columns) { throw ProcessorErrorFactory.matrix_column_outbounds_full( exp.id, column, mustBeArray.columns, exp.sourceInfo ); } else if (column < 0) { throw ProcessorErrorFactory.array_dimension_not_positive_full( exp.sourceInfo ); } } const result = mustBeArray.getAt(line, column); const type = mustBeArray.type.innerType; if (Array.isArray(result)) { const values = result.map((val, col) => { return new StoreValueAddress( type, val, line, col, mustBeArray.id, mustBeArray.readOnly ); }); return new ArrayStoreValue( new ArrayType(type, 1), values, mustBeArray.columns, null, mustBeArray.id, mustBeArray.readOnly ); } else { return new StoreValueAddress( type, result, line, column, mustBeArray.id, mustBeArray.readOnly ); } } /** * * @param {Store} store * @param {Expressions.UnaryApp} unaryApp * * @returns {import('./store/value/istore_value').IStoreValue} */ async evaluateUnaryApp(store, unaryApp) { const left = await this.evaluateExpression(store, unaryApp.left); const resultType = resultTypeAfterUnaryOp(unaryApp.op, left.type); if (Types.UNDEFINED.isCompatible(resultType)) { const stringInfo = left.type.stringInfo(); const info = stringInfo[0]; throw ProcessorErrorFactory.invalid_unary_op_full( unaryApp.op, info.type, info.dim, unaryApp.sourceInfo ); } switch (unaryApp.op.ord) { case Operators.ADD.ord: return new StoreValue(resultType, left.get()); case Operators.SUB.ord: return new StoreValue(resultType, left.get().negated()); case Operators.NOT.ord: return new StoreValue(resultType, !left.get()); default: throw new RuntimeError("!!!Critical Invalid UnaryApp " + unaryApp.op); } } /** * * @param {Store} store * @param {Expressions.InfixApp} infixApp * * @returns {import('./store/value/istore_value').IStoreValue} */ async evaluateInfixApp(store, infixApp) { const left = await this.evaluateExpression(store, infixApp.left); const right = await this.evaluateExpression(store, infixApp.right); let shouldImplicitCast = false; let resultType = resultTypeAfterInfixOp(infixApp.op, left.type, right.type); if (Types.UNDEFINED.isCompatible(resultType)) { if ( Config.enable_type_casting && Store.canImplicitTypeCast(left.type, right.type) ) { shouldImplicitCast = true; } else { const stringInfoLeft = left.type.stringInfo(); const infoLeft = stringInfoLeft[0]; const stringInfoRight = right.type.stringInfo(); const infoRight = stringInfoRight[0]; throw ProcessorErrorFactory.invalid_infix_op_full( infixApp.op, infoLeft.type, infoLeft.dim, infoRight.type, infoRight.dim, infixApp.sourceInfo ); } } let result = null; switch (infixApp.op.ord) { case Operators.ADD.ord: { if (Types.STRING.isCompatible(left.type)) { const rightStr = convertToString(right.get(), right.type); return new StoreValue(resultType, left.get() + rightStr); } else if (Types.STRING.isCompatible(right.type)) { const leftStr = convertToString(left.get(), left.type); return new StoreValue(resultType, leftStr + right.get()); } else { return new StoreValue(resultType, left.get().plus(right.get())); } } case Operators.SUB.ord: return new StoreValue(resultType, left.get().minus(right.get())); case Operators.MULT.ord: { result = left.get().times(right.get()); return new StoreValue(resultType, result); } case Operators.DIV.ord: { if (right.get() == 0) { throw ProcessorErrorFactory.divsion_by_zero_full( infixApp.toString(), infixApp.sourceInfo ); } if (Types.INTEGER.isCompatible(resultType)) result = left.get().divToInt(right.get()); else result = left.get().div(right.get()); return new StoreValue(resultType, result); } case Operators.MOD.ord: { let leftValue = left.get(); let rightValue = right.get(); if (shouldImplicitCast) { resultType = Types.INTEGER; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.modulo(rightValue); return new StoreValue(resultType, result); } case Operators.GT.ord: { let leftValue = left.get(); let rightValue = right.get(); if (Types.STRING.isCompatible(left.type)) { result = leftValue.length > rightValue.length; } else { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.gt(rightValue); } return new StoreValue(resultType, result); } case Operators.GE.ord: { let leftValue = left.get(); let rightValue = right.get(); if (Types.STRING.isCompatible(left.type)) { result = leftValue.length >= rightValue.length; } else { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.gte(rightValue); } return new StoreValue(resultType, result); } case Operators.LT.ord: { let leftValue = left.get(); let rightValue = right.get(); if (Types.STRING.isCompatible(left.type)) { result = leftValue.length < rightValue.length; } else { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.lt(rightValue); } return new StoreValue(resultType, result); } case Operators.LE.ord: { let leftValue = left.get(); let rightValue = right.get(); if (Types.STRING.isCompatible(left.type)) { result = leftValue.length <= rightValue.length; } else { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.lte(rightValue); } return new StoreValue(resultType, result); } case Operators.EQ.ord: { let leftValue = left.get(); let rightValue = right.get(); if ( Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type) ) { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = leftValue.eq(rightValue); } else { result = leftValue === rightValue; } return new StoreValue(resultType, result); } case Operators.NEQ.ord: { let leftValue = left.get(); let rightValue = right.get(); if ( Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type) ) { if (shouldImplicitCast) { resultType = Types.BOOLEAN; leftValue = leftValue.trunc(); rightValue = rightValue.trunc(); } result = !leftValue.eq(rightValue); } else { result = leftValue !== rightValue; } return new StoreValue(resultType, result); } case Operators.AND.ord: return new StoreValue(resultType, left.get() && right.get()); case Operators.OR.ord: return new StoreValue(resultType, left.get() || right.get()); default: throw new RuntimeError("!!!Critical Invalid InfixApp " + infixApp.op); } } }