iVProg/js/processor/ivprogProcessor.js

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

  async associateParameters (formal_params, effective_params, caller_store, callee_store) {
    const funcName = callee_store.name === IVProgProcessor.MAIN_INTERNAL_ID ?
      LanguageDefinedFunction.getMainFunctionName() : callee_store.name;

    if (formal_params.length != effective_params.length) {
      throw ProcessorErrorFactory.invalid_parameters_size(funcName, formal_params.length, effective_params.length);
    }
    for (let i = 0; i < effective_params.length; i += 1) {
      const actualParam = effective_params[i];
      const actualValue = await this.evaluateExpression(caller_store, actualParam);
      const exp = effective_params[i];
      let shouldTypeCast = false;
      const formalParameter = formal_params[i];
      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, exp.toString());
        }
      }

      if(formalParameter.byRef && !actualValue.inStore()) {
        throw ProcessorErrorFactory.invalid_ref(funcName, exp.toString());
      }

      if(formalParameter.byRef) {
        const realObj = caller_store.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);
          }
        }
        callee_store.insertStore(formalParameter.id, ref);
      } else {
        let realValue = actualValue;
        if (shouldTypeCast) {
          realValue = Store.doImplicitCasting(formalParameter.type, realValue);
        }
        callee_store.insertStore(formalParameter.id, realValue);
      }
    }
    return callee_store;
  }

  /**
   * 
   * @param {Store} store 
   * @param {Command[]} cmds
   * 
   * @returns {Promise<Store>} 
   */
  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<Store>}
   */
  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<Store>}
   */
  async executeSysCall (store, cmd) {
    const func = cmd.langFunc.bind(this);
    return func(store, cmd);
  }

  /**
   * 
   * @param {Store} store 
   * @param {Commands.FunctionCall} cmd 
   * 
   * @returns {Promise<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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.LE, 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.GE, 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.GE, 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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<Store>}
   */
  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<import('./store/value/istore_value').IStoreValue>} 
   */
  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<StoreValue[]>}
   */
  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<StoreValue[]>} 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<StoreValue[][]>}
   */
  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);
    }
  }

}