import { Store } from './store/store'; import { StoreObject } from './store/storeObject'; import { StoreObjectArray } from './store/storeObjectArray'; import { StoreObjectRef } from './store/storeObjectRef'; 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/'; import * as Expressions from './../ast/expressions/'; import { StoreObjectArrayAddress } from './store/storeObjectArrayAddress'; import { StoreObjectArrayAddressRef } from './store/storeObjectArrayAddressRef'; import { CompoundType } from './../typeSystem/compoundType'; import { convertToString } from '../typeSystem/parsers'; import { Config } from '../util/config'; import Decimal from 'decimal.js'; export class IVProgProcessor { static get LOOP_TIMEOUT () { return Config.loopTimeout; } static set LOOP_TIMEOUT (ms) { Config.setConfig({loopTimeout: ms}); } 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.loopTimers = []; this.output = null; } registerInput (input) { this.input = input; } registerOutput (output) { 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; } } interpretAST () { this.initGlobal(); const mainFunc = this.findMainFunction(); if(mainFunc === null) { // TODO: Better error message throw new Error("Missing main funciton."); } return this.runFunction(mainFunc, [], this.globalStore); } initGlobal () { if(!this.checkContext(Context.BASE)) { throw new Error("!!!CRITICAL: Invalid call to initGlobal outside BASE context!!!"); } this.ast.global.forEach(decl => { this.executeCommand(this.globalStore, decl).then(sto => this.globalStore = sto); }); } findMainFunction () { return this.ast.functions.find(v => v.isMain); } findFunction (name) { if(name.match(/^\$.+$/)) { const fun = LanguageDefinedFunction.getFunction(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; } } runFunction (func, actualParameters, store) { const funcName = func.isMain ? 'main' : func.name; let funcStore = new Store(funcName); funcStore.extendStore(this.globalStore); let returnStoreObject = null; if(func.returnType instanceof CompoundType) { if(func.returnType.dimensions > 1) { returnStoreObject = new StoreObjectArray(func.returnType,-1,-1,[[]]); } else { returnStoreObject = new StoreObjectArray(func.returnType,-1,null,[]); } } else { returnStoreObject = new StoreObject(func.returnType, null); } funcStore.insertStore('$', returnStoreObject); const newFuncStore$ = this.associateParameters(func.formalParameters, actualParameters, store, funcStore); return newFuncStore$.then(sto => { this.context.push(Context.FUNCTION); this.stores.push(sto); return this.executeCommands(sto, func.variablesDeclarations) .then(stoWithVars => this.executeCommands(stoWithVars, func.commands)).then(finalSto => { this.stores.pop(); this.context.pop(); return finalSto; }); }); } associateParameters (formalList, actualList, callerStore, calleeStore) { if (formalList.length != actualList.length) { // TODO: Better error message throw new Error("Numbers of parameters doesn't match"); } const promises$ = actualList.map(actualParameter => this.evaluateExpression(callerStore, actualParameter)); return Promise.all(promises$).then(values => { for (let i = 0; i < values.length; i++) { const stoObj = values[i]; const formalParameter = formalList[i]; if(formalParameter.type.isCompatible(stoObj.type)) { if(formalParameter.byRef && !stoObj.inStore) { throw new Error('You must inform a variable as parameter'); } if(formalParameter.byRef) { let ref = null; if (stoObj instanceof StoreObjectArrayAddress) { ref = new StoreObjectArrayAddressRef(stoObj); } else { ref = new StoreObjectRef(stoObj.id, callerStore); } calleeStore.insertStore(formalParameter.id, ref); } else { let realValue = this.parseStoreObjectValue(stoObj); calleeStore.insertStore(formalParameter.id, realValue); } } else { throw new Error(`Parameter ${formalParameter.id} is not compatible with the value given.`); } } return calleeStore; }); } executeCommands (store, cmds) { // helper to partially apply a function, in this case executeCommand const outerRef = this; const partial = (fun, cmd) => (sto) => fun(sto, cmd); return cmds.reduce((lastCommand, next) => { const nextCommand = partial(outerRef.executeCommand.bind(outerRef), next); return lastCommand.then(nextCommand); }, Promise.resolve(store)); } executeCommand (store, cmd) { if(this.forceKill) { return Promise.reject("Interrupção forçada do programa!"); } else if (store.mode === Modes.PAUSE) { return Promise.resolve(this.executeCommand(store, cmd)); } else if(store.mode === Modes.RETURN) { return Promise.resolve(store); } else if(this.checkContext(Context.BREAKABLE) && store.mode === Modes.BREAK) { return Promise.resolve(store); } 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.While) { return this.executeWhile(store, cmd); } else if (cmd instanceof Commands.DoWhile) { return this.executeDoWhile(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 Commands.FunctionCall) { return this.executeFunctionCall(store, cmd); } else if (cmd instanceof Commands.SysCall) { return this.executeSysCall(store, cmd); } else { throw new Error("!!!CRITICAL A unknown command was found!!!\n" + cmd); } } executeSysCall (store, cmd) { const func = cmd.langFunc.bind(this); return func(store, cmd); } executeFunctionCall (store, cmd) { let func = null; if(cmd.isMainCall) { func = this.findMainFunction(); } else { func = this.findFunction(cmd.id); } return this.runFunction(func, cmd.actualParameters, store) .then(sto => { if(!Types.VOID.isCompatible(func.returnType) && sto.mode !== Modes.RETURN) { // TODO: better error message return Promise.reject(new Error(`Function ${func.name} must have a return command`)); } else { return store; } }) } executeSwitch (store, cmd) { this.context.push(Context.BREAKABLE); const auxCaseFun = (promise, switchExp, aCase) => { return promise.then( result => { const sto = result.sto; if (this.ignoreSwitchCases(sto)) { return Promise.resolve(result); } else if (result.wasTrue || aCase.isDefault) { const $newSto = this.executeCommands(result.sto,aCase.commands); return $newSto.then(nSto => { return Promise.resolve({wasTrue: true, sto: nSto}); }); } else { const $value = this.evaluateExpression(sto, new Expressions.InfixApp(Operators.EQ, switchExp, aCase.expression)); return $value.then(vl => { if (vl.value) { const $newSto = this.executeCommands(result.sto,aCase.commands); return $newSto.then(nSto => { return Promise.resolve({wasTrue: true, sto: nSto}); }); } else { return Promise.resolve({wasTrue: false, sto: sto}); } }); } }); } try { let breakLoop = false; let $result = Promise.resolve({wasTrue: false, sto: store}); for (let index = 0; index < cmd.cases.length && !breakLoop; index++) { const aCase = cmd.cases[index]; $result = auxCaseFun($result, cmd.expression, aCase); $result.then( r => breakLoop = this.ignoreSwitchCases(r.sto)); } return $result.then(r => { this.context.pop(); if(r.sto.mode === Modes.BREAK) { r.sto.mode = Modes.RUN; } return r.sto; }); } catch (error) { return Promise.reject(error); } } executeFor (store, cmd) { try { //BEGIN for -> while rewrite const initCmd = cmd.assignment; const condition = cmd.condition; const increment = cmd.increment; const whileBlock = new Commands.CommandBlock([], cmd.commands.concat(increment)); const forAsWhile = new Commands.While(condition, whileBlock); //END for -> while rewrite const newCmdList = [initCmd,forAsWhile]; return this.executeCommands(store, newCmdList); } catch (error) { return Promise.reject(error); } } executeDoWhile (store, cmd) { const outerRef = this; try { outerRef.loopTimers.push(Date.now()); outerRef.context.push(Context.BREAKABLE); const $newStore = outerRef.executeCommands(store, cmd.commands); return $newStore.then(sto => { if(sto.mode === Modes.BREAK) { outerRef.context.pop(); sto.mode = Modes.RUN; outerRef.loopTimers.pop(); return sto; } const $value = outerRef.evaluateExpression(sto, cmd.expression); return $value.then(vl => { if (!vl.type.isCompatible(Types.BOOLEAN)) { // TODO: Better error message -- Inform line and column from token!!!! // THIS IF SHOULD BE IN A SEMANTIC ANALYSER return Promise.reject(new Error(`DoWhile expression must be of type boolean`)); } if (vl.value) { outerRef.context.pop(); for (let i = 0; i < outerRef.loopTimers.length; i++) { const time = outerRef.loopTimers[i]; if(Date.now() - time >= IVProgProcessor.LOOP_TIMEOUT) { console.log("Kill by Timeout..."); outerRef.forceKill = true; return Promise.reject(new Error("Potential endless loop detected.")); } } return outerRef.executeCommand(sto, cmd); } else { outerRef.context.pop(); outerRef.loopTimers.pop(); console.log("Clear Timeout..."); return sto; } }) }) } catch (error) { return Promise.reject(error); } } executeWhile (store, cmd) { const outerRef = this; try { outerRef.loopTimers.push(Date.now()); outerRef.context.push(Context.BREAKABLE); const $value = outerRef.evaluateExpression(store, cmd.expression); return $value.then(vl => { if(vl.type.isCompatible(Types.BOOLEAN)) { if(vl.value) { const $newStore = outerRef.executeCommands(store, cmd.commands); return $newStore.then(sto => { outerRef.context.pop(); if (sto.mode === Modes.BREAK) { outerRef.loopTimers.pop(); sto.mode = Modes.RUN; return sto; } for (let i = 0; i < outerRef.loopTimers.length; i++) { const time = outerRef.loopTimers[i]; if(Date.now() - time >= IVProgProcessor.LOOP_TIMEOUT) { console.log("Kill by Timeout..."); outerRef.forceKill = true; return Promise.reject(new Error("Potential endless loop detected.")); } } return outerRef.executeCommand(sto, cmd); }); } else { outerRef.context.pop(); outerRef.loopTimers.pop(); console.log("Clear Timeout..."); return store; } } else { // TODO: Better error message -- Inform line and column from token!!!! // THIS IF SHOULD BE IN A SEMANTIC ANALYSER return Promise.reject(new Error(`Loop condition must be of type boolean`)); } }) } catch (error) { return Promise.reject(error); } } executeIfThenElse (store, cmd) { try { const $value = this.evaluateExpression(store, cmd.condition); return $value.then(vl => { if(vl.type.isCompatible(Types.BOOLEAN)) { if(vl.value) { 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 Promise.resolve(store); } } else { // TODO: Better error message -- Inform line and column from token!!!! // THIS IF SHOULD BE IN A SEMANTIC ANALYSER return Promise.reject(new Error(`If expression must be of type boolean`)); } }); } catch (error) { return Promise.reject(error); } } executeReturn (store, cmd) { try { const funcType = store.applyStore('$').type; const $value = this.evaluateExpression(store, cmd.expression); const funcName = store.name; return $value.then(vl => { if(vl === null && funcType.isCompatible(Types.VOID)) { return Promise.resolve(store); } if (vl === null || !funcType.isCompatible(vl.type)) { // TODO: Better error message -- Inform line and column from token!!!! // THIS IF SHOULD BE IN A SEMANTIC ANALYSER return Promise.reject(new Error(`Function ${funcName} must return ${funcType.type} instead of ${vl.type}.`)); } else { let realValue = this.parseStoreObjectValue(vl); store.updateStore('$', realValue); store.mode = Modes.RETURN; return Promise.resolve(store); } }); } catch (error) { return Promise.reject(error); } } executeBreak (store, _) { if(this.checkContext(Context.BREAKABLE)) { store.mode = Modes.BREAK; return Promise.resolve(store); } else { return Promise.reject(new Error("!!!CRITIAL: Break command outside Loop/Switch scope!!!")); } } executeAssign (store, cmd) { try { const $value = this.evaluateExpression(store, cmd.expression); return $value.then( vl => { let realValue = this.parseStoreObjectValue(vl); store.updateStore(cmd.id, realValue) return store; }); } catch (error) { return Promise.reject(error); } } executeArrayIndexAssign (store, cmd) { const mustBeArray = store.applyStore(cmd.id); if(!(mustBeArray.type instanceof CompoundType)) { return Promise.reject(new Error(cmd.id + " is not a vector/matrix")); } const line$ = this.evaluateExpression(store, cmd.line); const column$ = this.evaluateExpression(store, cmd.column); const value$ = this.evaluateExpression(store, cmd.expression); return Promise.all([line$, column$, value$]).then(results => { const lineSO = results[0]; if(!Types.INTEGER.isCompatible(lineSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } const line = lineSO.number; const columnSO = results[1]; let column = null if (columnSO !== null) { if(!Types.INTEGER.isCompatible(columnSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } column = columnSO.number; } const value = this.parseStoreObjectValue(results[2]); if (line >= mustBeArray.lines) { // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${lines}`)); } if (column !== null && mustBeArray.columns === null ){ // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${column}`)); } if(column !== null && column >= mustBeArray.columns) { // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${column}`)); } const newArray = Object.assign(new StoreObjectArray(null,null,null), mustBeArray); if (column !== null) { if (value.type instanceof CompoundType) { return Promise.reject(new Error("Invalid operation. This must be a value: line "+cmd.sourceInfo.line)); } newArray.value[line].value[column] = value; store.updateStore(cmd.id, newArray); } else { if(mustBeArray.columns !== null && value.type instanceof CompoundType) { return Promise.reject(new Error("Invalid operation. This must be a vector: line "+cmd.sourceInfo.line)); } newArray.value[line] = value; store.updateStore(cmd.id, newArray); } return store; }); } executeDeclaration (store, cmd) { try { const $value = this.evaluateExpression(store, cmd.initial); if(cmd instanceof Commands.ArrayDeclaration) { const $lines = this.evaluateExpression(store, cmd.lines); const $columns = cmd.columns === null ? null: this.evaluateExpression(store, cmd.columns); return Promise.all([$lines, $columns, $value]).then(values => { const lineSO = values[0]; if(!Types.INTEGER.isCompatible(lineSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } const line = lineSO.number; const columnSO = values[1]; let column = null if (columnSO !== null) { if(!Types.INTEGER.isCompatible(columnSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } column = columnSO.number; } const value = values[2]; const temp = new StoreObjectArray(cmd.type, line, column, null); store.insertStore(cmd.id, temp); let realValue = value; if (value !== null) { if(value instanceof StoreObjectArrayAddress) { if(value.type instanceof CompoundType) { realValue = Object.assign(new StoreObjectArray(null,null,null), value.refValue); } else { realValue = Object.assign(new StoreObject(null,null), value.refValue); } } } else { realValue = new StoreObjectArray(cmd.type, line, column, []) if(column !== null) { for (let i = 0; i < line; i++) { realValue.value.push(new StoreObjectArray(new CompoundType(cmd.type.innerType, 1), column, null, [])); } } } realValue.readOnly = cmd.isConst; store.updateStore(cmd.id, realValue); return store; }); } else { const temp = new StoreObject(cmd.type, null); store.insertStore(cmd.id, temp); return $value.then(vl => { let realValue = vl; if (vl !== null) { if(vl instanceof StoreObjectArrayAddress) { if(vl.type instanceof CompoundType) { realValue = Object.assign(new StoreObjectArray(null,null,null), vl.refValue); } else { realValue = Object.assign(new StoreObject(null,null), vl.refValue); } } } else { realValue = new StoreObject(cmd.type,0); } realValue.readOnly = cmd.isConst; store.updateStore(cmd.id, realValue); return store; }); } } catch (e) { return Promise.reject(e); } } evaluateExpression (store, exp) { 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) { return this.evaluateArrayLiteral(store, exp); } else if (exp instanceof Expressions.FunctionCall) { return this.evaluateFunctionCall(store, exp); } return Promise.resolve(null); } evaluateFunctionCall (store, exp) { if(exp.isMainCall) { return Promise.reject(new Error(`Main function cannot be used inside an expression`)); } const func = this.findFunction(exp.id); if(Types.VOID.isCompatible(func.returnType)) { // TODO: better error message return Promise.reject(new Error(`Function ${exp.id} cannot be used inside an expression`)); } const $newStore = this.runFunction(func, exp.actualParameters, store); return $newStore.then( sto => { if(sto.mode !== Modes.RETURN) { return Promise.reject(new Error("The function that was called did not had a return command: "+exp.id)); } const val = sto.applyStore('$'); if (val instanceof StoreObjectArray) { return Promise.resolve(Object.assign(new StoreObjectArray(null,null,null,null,null), val)); } else { return Promise.resolve(Object.assign(new StoreObject(null,null), val)); } }); } evaluateArrayLiteral (store, exp) { if(!exp.isVector) { const $matrix = this.evaluateMatrix(store, exp.value); return $matrix.then(list => { const type = new CompoundType(list[0].type.innerType, 2); const arr = new StoreObjectArray(type, list.length, list[0].lines, list); if(arr.isValid) return Promise.resolve(arr); else return Promise.reject(new Error(`Invalid array`)) }); } else { return this.evaluateVector(store, exp.value).then(list => { const type = new CompoundType(list[0].type, 1); const stoArray = new StoreObjectArray(type, list.length, null, list); if(stoArray.isValid) return Promise.resolve(stoArray); else return Promise.reject(new Error(`Invalid array`)) }); } } evaluateVector (store, exps) { return Promise.all(exps.map( exp => this.evaluateExpression(store, exp))); } evaluateMatrix (store, exps) { return Promise.all(exps.map( vector => { const $vector = this.evaluateVector(store, vector.value) return $vector.then(list => { const type = new CompoundType(list[0].type, 1); return new StoreObjectArray(type, list.length, null, list) }); } )); } evaluateLiteral (_, exp) { return Promise.resolve(new StoreObject(exp.type, exp.value)); } evaluateVariableLiteral (store, exp) { try { const val = store.applyStore(exp.id); if (val instanceof StoreObjectArray) { return Promise.resolve(Object.assign(new StoreObjectArray(null,null,null,null), val)); } else { return Promise.resolve(Object.assign(new StoreObject(null,null), val)); } } catch (error) { return Promise.reject(error); } } evaluateArrayAccess (store, exp) { const mustBeArray = store.applyStore(exp.id); if (!(mustBeArray.type instanceof CompoundType)) { // TODO: better error message console.log(mustBeArray.type); return Promise.reject(new Error(`${exp.id} is not of type array`)); } const $line = this.evaluateExpression(store, exp.line); const $column = this.evaluateExpression(store, exp.column); return Promise.all([$line, $column]).then(values => { const lineSO = values[0]; const columnSO = values[1]; if(!Types.INTEGER.isCompatible(lineSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } const line = lineSO.number; let column = null; if(columnSO !== null) { if(!Types.INTEGER.isCompatible(columnSO.type)) { // TODO: better error message //SHOULD NOT BE HERE. IT MUST HAVE A SEMANTIC ANALYSIS return Promise.reject(new Error("Array dimension must be of type int")); } column = columnSO.number; } if (line >= mustBeArray.lines) { // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${lines}`)); } if (column !== null && mustBeArray.columns === null ){ // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${column}`)); } if(column !== null && column >= mustBeArray.columns) { // TODO: better error message return Promise.reject(new Error(`${exp.id}: index out of bounds: ${column}`)); } return Promise.resolve(new StoreObjectArrayAddress(mustBeArray.id, line, column, store)); }); } evaluateUnaryApp (store, unaryApp) { const $left = this.evaluateExpression(store, unaryApp.left); return $left.then( left => { const resultType = resultTypeAfterUnaryOp(unaryApp.op, left.type); if (Types.UNDEFINED.isCompatible(resultType)) { // TODO: better urgent error message return Promise.reject(new Error(`Cannot use this op to ${left.type}`)); } switch (unaryApp.op.ord) { case Operators.ADD.ord: return new StoreObject(resultType, left.value); case Operators.SUB.ord: return new StoreObject(resultType, left.value.negated()); case Operators.NOT.ord: return new StoreObject(resultType, !left.value); default: return Promise.reject(new Error('!!!Critical Invalid UnaryApp '+ unaryApp.op)); } }); } evaluateInfixApp (store, infixApp) { const $left = this.evaluateExpression(store, infixApp.left); const $right = this.evaluateExpression(store, infixApp.right); return Promise.all([$left, $right]).then(values => { const left = values[0]; const right = values[1]; const resultType = resultTypeAfterInfixOp(infixApp.op, left.type, right.type); if (Types.UNDEFINED.isCompatible(resultType)) { // TODO: better urgent error message return Promise.reject(new Error(`Cannot use this ${infixApp.op} to ${left.type} and ${right.type}`)); } let result = null; switch (infixApp.op.ord) { case Operators.ADD.ord: { if(Types.STRING.isCompatible(left.type)) { const rightStr = convertToString(right.value, right.type); return new StoreObject(resultType, left.value + rightStr); } else if (Types.STRING.isCompatible(right.type)) { const leftStr = convertToString(left.value, left.type); return new StoreObject(resultType, leftStr + right.value); } else { return new StoreObject(resultType, left.value.plus(right.value)); } } case Operators.SUB.ord: return new StoreObject(resultType, left.value.minus(right.value)); case Operators.MULT.ord: { result = left.value.times(right.value); if(result.dp() > Config.decimalPlaces) { result = new Decimal(result.toFixed(Config.decimalPlaces)); } return new StoreObject(resultType, result); } case Operators.DIV.ord: { if (Types.INTEGER.isCompatible(resultType)) result = left.value.divToInt(right.value); else result = left.value.div(right.value); if(result.dp() > Config.decimalPlaces) { result = new Decimal(result.toFixed(Config.decimalPlaces)); } return new StoreObject(resultType, result); } case Operators.MOD.ord: { result = left.value.modulo(right.value); if(result.dp() > Config.decimalPlaces) { result = new Decimal(result.toFixed(Config.decimalPlaces)); } return new StoreObject(resultType, result); } case Operators.GT.ord: { if (Types.STRING.isCompatible(left.type)) { result = left.value.length > right.value.length; } else { result = left.value.gt(right.value); } return new StoreObject(resultType, result); } case Operators.GE.ord: { if (Types.STRING.isCompatible(left.type)) { result = left.value.length >= right.value.length; } else { result = left.value.gte(right.value); } return new StoreObject(resultType, result); } case Operators.LT.ord: { if (Types.STRING.isCompatible(left.type)) { result = left.value.length < right.value.length; } else { result = left.value.lt(right.value); } return new StoreObject(resultType, result); } case Operators.LE.ord: { if (Types.STRING.isCompatible(left.type)) { result = left.value.length <= right.value.length; } else { result = left.value.lte(right.value); } return new StoreObject(resultType, result); } case Operators.EQ.ord: { if (Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type)) { result = left.value.eq(right.value); } else { result = left.value === right.value; } return new StoreObject(resultType, result); } case Operators.NEQ.ord: { if (Types.INTEGER.isCompatible(left.type) || Types.REAL.isCompatible(left.type)) { result = !left.value.eq(right.value); } else { result = left.value !== right.value; } return new StoreObject(resultType, result); } case Operators.AND.ord: return new StoreObject(resultType, left.value && right.value); case Operators.OR.ord: return new StoreObject(resultType, left.value || right.value); default: return Promise.reject(new Error('!!!Critical Invalid InfixApp '+ infixApp.op)); } }); } parseStoreObjectValue (vl) { let realValue = vl; if(vl instanceof StoreObjectArrayAddress) { if(vl.type instanceof CompoundType) { switch(vl.type.dimensions) { case 1: { realValue = new StoreObjectArray(vl.type, vl.value); break; } default: { throw new Error("Three dimensional array address..."); } } } else { realValue = new StoreObject(vl.type, vl.value); } } return realValue; } }