tesses50
/
tlang-runtime-compiler
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
tlang-runtime-compiler/TLang.VM/ChunkExecuter.cs

1216 lines
41 KiB
C#
Raw Permalink Normal View History

Working on VM
2023-07-29 00:11:09 +00:00
using System;
using System.Collections.Generic;
using TLang.BytecodeCompiler;
using TLang.Common;
namespace TLang.VM
{
public class ChunkExecuter
{
public string ClassName {get;set;}="";
public ChunkExecuter(TVMFile file,Chunk chunk,TLangEnvironment env)
{
File =file;
Chunk = chunk;
VM works
2023-07-30 07:55:10 +00:00
Environment = env.GetSubEnvironment();
Working on VM
2023-07-29 00:11:09 +00:00
}
public TLangEnvironment Environment {get;set;}
public TVMFile File {get;}
public Chunk Chunk {get;}
public int IP {get;set;}=0;
public Stack<TObject> Stack {get;}=new Stack<TObject>();
VM works
2023-07-30 07:55:10 +00:00
Working on VM
2023-07-29 00:11:09 +00:00
public TObject Execute(params TObject[] args)
{
VM works
2023-07-30 07:55:10 +00:00
Working on VM
2023-07-29 00:11:09 +00:00
for(int i = 0;i< args.Length;i++)
{
if(i<Chunk.Arguments.Count)
{
VM works
2023-07-30 07:55:10 +00:00
Environment.SetObject(Chunk.Arguments[i],args[i]);
Working on VM
2023-07-29 00:11:09 +00:00
}
}
while(IP < Chunk.Code.Length)
{
var instruction = Chunk.Code[IP++];
switch(instruction)
{
case Instruction.ADD:
Stack.Push(Add(Stack.Pop(),Stack.Pop()));
break;
case Instruction.SUB:
Stack.Push(Sub(Stack.Pop(),Stack.Pop()));
break;
case Instruction.TIMES:
Stack.Push(Times(Stack.Pop(),Stack.Pop()));
break;
case Instruction.DIVIDE:
Stack.Push(Divide(Stack.Pop(),Stack.Pop()));
break;
case Instruction.MOD:
Stack.Push(Mod(Stack.Pop(),Stack.Pop()));
break;
VM works
2023-07-30 07:55:10 +00:00
case Instruction.POW:
Stack.Push(Pow(Stack.Pop(),Stack.Pop()));
break;
case Instruction.LT:
Stack.Push(LT(Stack.Pop(),Stack.Pop()));
break;
case Instruction.LTE:
Stack.Push(LTE(Stack.Pop(),Stack.Pop()));
break;
case Instruction.GT:
Stack.Push(GT(Stack.Pop(),Stack.Pop()));
break;
case Instruction.GTE:
Stack.Push(GTE(Stack.Pop(),Stack.Pop()));
break;
case Instruction.LAND:
Stack.Push(LAnd(Stack.Pop(),Stack.Pop()));
break;
case Instruction.LOR:
Stack.Push(LOr(Stack.Pop(),Stack.Pop()));
break;
case Instruction.XOR:
Stack.Push(XOr(Stack.Pop(),Stack.Pop()));
break;
case Instruction.LSHIFT:
Stack.Push(LShift(Stack.Pop(),Stack.Pop()));
break;
case Instruction.RSHIFT:
Stack.Push(RShift(Stack.Pop(),Stack.Pop()));
break;
case Instruction.BAND:
Stack.Push(BAnd(Stack.Pop(),Stack.Pop()));
break;
case Instruction.BNOT:
Stack.Push(BNot(Stack.Pop()));
break;
case Instruction.BOR:
Stack.Push(BOr(Stack.Pop(),Stack.Pop()));
break;
case Instruction.EQ:
Stack.Push(Eq(Stack.Pop(),Stack.Pop()));
break;
case Instruction.NEQ:
Stack.Push(NEq(Stack.Pop(),Stack.Pop()));
break;
case Instruction.NEG:
Stack.Push(Negative(Stack.Pop()));
break;
Working on VM
2023-07-29 00:11:09 +00:00
case Instruction.RET:
VM works
2023-07-30 07:55:10 +00:00
return Stack.Pop();
Working on VM
2023-07-29 00:11:09 +00:00
case Instruction.SCOPE_BEGIN:
VM works
2023-07-30 07:55:10 +00:00
Environment = Environment.GetSubEnvironment();
Working on VM
2023-07-29 00:11:09 +00:00
break;
case Instruction.SCOPE_END:
VM works
2023-07-30 07:55:10 +00:00
Environment = Environment.GetParentEnvironment();
Working on VM
2023-07-29 00:11:09 +00:00
break;
case Instruction.PUSH_DOUBLE:
Stack.Push(new TNumber(ReadDouble()));
break;
case Instruction.PUSH_CLOSURE:
int closureId = ReadInt();
if(closureId >= File.Chunks.Count) throw new IndexOutOfRangeException($"No chunk with id {closureId}");
VM works
2023-07-30 07:55:10 +00:00
Stack.Push(new TClosure(File,File.Chunks[closureId],Environment){ClassName = ClassName});
Working on VM
2023-07-29 00:11:09 +00:00
break;
case Instruction.PUSH_STRING:
Stack.Push(new TString(ReadString()));
break;
case Instruction.PUSH_VARIABLE_VALUE:
{
var res=EnsurePop<TString>();
VM works
2023-07-30 07:55:10 +00:00
Stack.Push(Environment.GetObject(res.Value));
}
break;
case Instruction.PUSH_FIELD_VALUE:
{
var res= EnsurePop<TString>();
var symbol = Stack.Pop();
Stack.Push(GetFieldValue(symbol,res.Value));
}
break;
case Instruction.POP_FIELD_VALUE:
{
var val = Stack.Pop();
var res= EnsurePop<TString>();
var symbol = Stack.Pop();
SetFieldValue(symbol, res.Value, val);
Working on VM
2023-07-29 00:11:09 +00:00
}
break;
case Instruction.POP_VARIABLE_VALUE:
{
VM works
2023-07-30 07:55:10 +00:00
var val = Stack.Pop();
Working on VM
2023-07-29 00:11:09 +00:00
var res=EnsurePop<TString>();
VM works
2023-07-30 07:55:10 +00:00
Environment.SetObject(res.Value,val);
Working on VM
2023-07-29 00:11:09 +00:00
}
break;
VM works
2023-07-30 07:55:10 +00:00
case Instruction.NOP:
break;
case Instruction.PUSH_CHAR:
Stack.Push(new TChar((char)Chunk.Code[IP++]));
break;
case Instruction.PUSH_ARRAY_VALUE:
{
var expr = Stack.Pop();
var symbol = Stack.Pop();
Stack.Push(GetArrayValue(symbol,expr));
}
break;
case Instruction.POP_ARRAY_VALUE:
{
var val = Stack.Pop();
var expr = Stack.Pop();
var symbol = Stack.Pop();
SetArrayValue(symbol,expr,val);
}
break;
case Instruction.PUSH_UNDEFINED:
Stack.Push(new TUndefined());
break;
case Instruction.PUSH_NULL:
Stack.Push(new TNull());
break;
case Instruction.PUSH_TRUE:
Stack.Push(new TBool(true));
break;
case Instruction.PUSH_FALSE:
Stack.Push(new TBool(false));
break;
Working on VM
2023-07-29 00:11:09 +00:00
case Instruction.CALL_FUNC:
{
var argC = (int)EnsurePop<TNumber>().Value;
TObject[] argV = new TObject[argC];
for(int i = argC;i>0;i--)
{
VM works
2023-07-30 07:55:10 +00:00
argV[i-1] = Stack.Pop();
Working on VM
2023-07-29 00:11:09 +00:00
}
var name = EnsurePop<TString>();
VM works
2023-07-30 07:55:10 +00:00
var callable=Environment.GetObject(name.Value) as TCallable;
Working on VM
2023-07-29 00:11:09 +00:00
if(callable != null)
{
Stack.Push(callable.Execute(argV));
}else{
Stack.Push(new TUndefined());
}
}
break;
case Instruction.CALL_METHOD:
{
var argC = (int)EnsurePop<TNumber>().Value;
TObject[] argV = new TObject[argC];
for(int i = argC;i>0;i--)
{
VM works
2023-07-30 07:55:10 +00:00
argV[i-1] = Stack.Pop();
Working on VM
2023-07-29 00:11:09 +00:00
}
var name = EnsurePop<TString>();
var symbol = Stack.Pop();
Stack.Push(ExecuteMethod(symbol,name.Value,argV));
}
break;
VM works
2023-07-30 07:55:10 +00:00
case Instruction.JMP:
IP=ReadInt();
break;
case Instruction.JMPC:
{
int jmpPos = ReadInt();
if(Stack.Pop().True)
IP = jmpPos;
}
break;
case Instruction.LNOT:
{
var res=Stack.Pop();
Stack.Push(LNot(res));
}
break;
case Instruction.POP:
Stack.Pop();
break;
Working on VM
2023-07-29 00:11:09 +00:00
}
}
if(Stack.Count > 0)
return Stack.Pop();
return new TNull();
}
VM works
2023-07-30 07:55:10 +00:00
private TObject SetArrayValue(TObject symbol,TObject expr,TObject value)
{
var classMethod = symbol as TClassInstance;
var dict = symbol as TDictionary;
var array = symbol as TArray;
if(array != null)
{
var index = expr as TNumber;
if(index != null && ((int)index.Value) < array.Items.Count)
{
array.Items[(int)index.Value] = value;
return new TUndefined();
}
}
if(classMethod != null)
{
if(classMethod.MethodExists(ClassName,"iset"))
{
return classMethod.CallMethod(ClassName,"iset",expr,value);
}
var index = expr as TString;
if(index != null)
{
classMethod.SetField(ClassName,index.Value,value);
return new TUndefined();
}
}
if(dict != null)
{
if(dict.HasValue("iset"))
{
var iget = dict.GetValue("iset") as TCallable;
if(iget != null)
{
return iget.Execute(expr,value);
}
var index = expr as TString;
if(index != null)
dict.SetValue(index.Value,value);
}
}
return new TUndefined();
}
private TObject GetArrayValue(TObject symbol, TObject expr)
{
var classMethod = symbol as TClassInstance;
var dict = symbol as TDictionary;
var str = symbol as TString;
var array = symbol as TArray;
if(str != null)
{
var index = expr as TNumber;
if(index != null && ((int)index.Value) < str.Value.Length)
{
return new TChar(str.Value[(int)index.Value]);
}
}
if(array != null)
{
var index = expr as TNumber;
if(index != null && ((int)index.Value) < array.Items.Count)
{
return array.Items[(int)index.Value];
}
}
if(classMethod != null)
{
if(classMethod.MethodExists(ClassName,"iget"))
{
return classMethod.CallMethod(ClassName,"iget",expr);
}
var index = expr as TString;
if(index != null)
{
return classMethod.GetField(ClassName,index.Value);
}
}
if(dict != null)
{
if(dict.HasValue("iget"))
{
var iget = dict.GetValue("iget") as TCallable;
if(iget != null)
{
return iget.Execute(expr);
}
var index = expr as TString;
if(index != null)
return dict.GetValue(index.Value);
}
}
return new TUndefined();
}
private TObject LNot(TObject res)
{
var classMethod = res as TClassInstance;
var dict = res as TDictionary;
if(classMethod != null)
{
return classMethod.CallMethod(ClassName,"lnot",res);
}
if(dict != null)
{
var callable= dict.GetValue("lnot") as TCallable;
if(callable != null)
{
return callable.Execute(res);
}
}
return new TBool(!res.True);
}
private TObject Negative(TObject object1)
{
var left = object1 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null)
{
return new TNumber(-(left.Value));
}
if(lcls != null && lcls.MethodExists(ClassName,"neg"))
{
return lcls.CallMethod(ClassName,"neg");
}
if(ldict != null)
{
var callable =ldict.GetValue("neg") as TCallable;
if(callable != null) return callable.Execute();
}
return new TNumber(0);
}
private TObject BNot(TObject object1)
{
var left = object1 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null)
{
return new TNumber(~((long)left.Value));
}
if(lcls != null && lcls.MethodExists(ClassName,"band"))
{
return lcls.CallMethod(ClassName,"bnot");
}
if(ldict != null)
{
var callable =ldict.GetValue("bnot") as TCallable;
if(callable != null) return callable.Execute();
}
return new TNumber(0);
}
private TObject GetFieldValue(TObject symbol, string name)
{
var classField = symbol as TClassInstance;
var dict = symbol as TDictionary;
var tArray = symbol as TArray;
var tString = symbol as TString;
if(tArray != null)
{
if(name == "count")
{
return new TNumber(tArray.Items.Count);
}
if(name == "empty")
{
return new TBool(!tArray.True);
}
if(name == "ittr")
{
return TDictionary.FromIEnumerator(tArray.Items.GetEnumerator());
}
}
if(tString != null)
{
if(name == "count")
{
return new TNumber(tString.Value.Length);
}
if(name == "empty")
{
return new TBool(tString.Value.Length == 0);
}
if(name == "ittr")
{
return TDictionary.FromIEnumerator(tString.GetObjects().GetEnumerator());
}
}
if(classField != null)
{
if(classField.MethodExists(ClassName,$"get{name}"))
{
return classField.CallMethod(ClassName,$"get{name}");
}
return classField.GetField(ClassName,name);
}
if(dict != null)
{
var callable= dict.GetValue($"get{name}") as TCallable;
if(callable != null)
{
return callable.Execute();
}
else
{
return dict.GetValue(name);
}
}
return new TUndefined();
}
public void SetFieldValue(TObject symbol, string name,TObject newValue)
{
var classField = symbol as TClassInstance;
var dict = symbol as TDictionary;
if(classField != null)
{
if(classField.MethodExists(ClassName,$"set{name}"))
{
classField.CallMethod(ClassName,$"set{name}",newValue);
}
else
{
classField.SetField(ClassName,name,newValue);
}
}
if(dict != null)
{
var callable= dict.GetValue($"set{name}") as TCallable;
if(callable != null)
{
callable.Execute(newValue);
}
else
{
dict.SetValue(name,newValue);
}
}
}
Working on VM
2023-07-29 00:11:09 +00:00
private TObject ExecuteMethod(TObject symbol, string name, params TObject[] argV)
{
VM works
2023-07-30 07:55:10 +00:00
if(name == "toString" && argV.Length == 0) return new TString(symbol.ToString());
var classMethod = symbol as TClassInstance;
var number = symbol as TNumber;
var dict = symbol as TDictionary;
var tArray = symbol as TArray;
var tString = symbol as TString;
if(tString != null)
{
if(name == "count")
{
return new TNumber(tString.Value.Length);
}
if(name == "empty")
{
return new TBool(tString.Value.Length == 0);
}
var strP=Environment.GetObject("String") as TDictionary;
if(strP != null)
{
var func = strP.GetValue(name) as TCallable;
if(func != null)
{
List<TObject> arguments = new List<TObject>();
arguments.Add(symbol);
arguments.AddRange(argV);
return func.Execute(arguments.ToArray());
}
}
}
if(classMethod != null)
{
return classMethod.CallMethod(ClassName,name,argV);
}
if(dict != null)
{
var callable= dict.GetValue(name) as TCallable;
if(callable != null)
{
return callable.Execute(argV);
}
}
if(tArray != null)
{
if(name == "add")
{
if(argV.Length > 0)
{
tArray.Add(argV[0]);
}
return tArray;
}
if(name == "remove")
{
if(argV.Length > 0)
{
tArray.Remove(argV[0]);
}
return tArray;
}
if(name == "removeat")
{
if(argV.Length > 0)
{
var num = argV[0] as TNumber;
if(num != null)
{
tArray.Items.RemoveAt((int)num.Value);
}
}
return tArray;
}
if(name == "clear")
{
tArray.Items.Clear();
return tArray;
}
if(name == "count")
{
return new TNumber(tArray.Items.Count);
}
if(name == "empty")
{
return new TBool(!tArray.True);
}
var strP=Environment.GetObject("Array") as TDictionary;
if(strP != null)
{
var func = strP.GetValue(name) as TCallable;
if(func != null)
{
List<TObject> arguments = new List<TObject>();
arguments.Add(symbol);
arguments.AddRange(argV);
return func.Execute(arguments.ToArray());
}
}
}
if(number != null)
{
if(name == "floor")
{
return new TNumber(Math.Floor(number.Value));
}
if(name == "ceil")
{
return new TNumber(Math.Ceiling(number.Value));
}
if(name == "round")
{
if(argV.Length > 0)
{
var n = argV[0] as TNumber;
if(n !=null)
return new TNumber(Math.Round(number.Value,(int)n.Value));
}
return new TNumber(Math.Round(number.Value));
}
if(name == "toChar")
{
return new TChar((char)(int)number.Value);
}
var strP=Environment.GetObject("Number") as TDictionary;
if(strP != null)
{
var func = strP.GetValue(name) as TCallable;
if(func != null)
{
List<TObject> arguments = new List<TObject>();
arguments.Add(symbol);
arguments.AddRange(argV);
return func.Execute(arguments.ToArray());
}
}
return new TNull();
}
Working on VM
2023-07-29 00:11:09 +00:00
VM works
2023-07-30 07:55:10 +00:00
return new TUndefined();
Working on VM
2023-07-29 00:11:09 +00:00
}
private T EnsurePop<T>() where T : TObject
{
var item = Stack.Pop() as T;
if(item == null) throw new Exception("Pop failed");
return item;
}
private double ReadDouble()
{
VM works
2023-07-30 07:55:10 +00:00
if(IP + 8 <= Chunk.Code.Length)
Working on VM
2023-07-29 00:11:09 +00:00
{
byte[] data =new byte[8];
Array.Copy(Chunk.Code,IP,data,0,8);
IP += 8;
if(BitConverter.IsLittleEndian) Array.Reverse(data);
return BitConverter.ToDouble(data,0);
}
throw new Exception("Malformed binary");
}
private int ReadInt()
{
VM works
2023-07-30 07:55:10 +00:00
if(IP + 4 <= Chunk.Code.Length)
Working on VM
2023-07-29 00:11:09 +00:00
{
byte[] data =new byte[4];
Array.Copy(Chunk.Code,IP,data,0,4);
IP += 4;
if(BitConverter.IsLittleEndian) Array.Reverse(data);
return BitConverter.ToInt32(data,0);
}
throw new Exception("Malformed binary");
}
private string ReadString()
{
int strLen = ReadInt();
VM works
2023-07-30 07:55:10 +00:00
if(IP + strLen <= Chunk.Code.Length)
Working on VM
2023-07-29 00:11:09 +00:00
{
var str=System.Text.Encoding.UTF8.GetString(Chunk.Code,IP,strLen);
IP += strLen;
return str;
}
throw new Exception("Malformed binary");
}
VM works
2023-07-30 07:55:10 +00:00
private TObject BAnd(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber((long)left.Value & (long)right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"band"))
{
return lcls.CallMethod(ClassName,"band",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("band") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject BOr(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber((long)left.Value | (long)right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"bor"))
{
return lcls.CallMethod(ClassName,"bor",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("bor") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject NEq(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lChr = object1 as TChar;
var rChr = object2 as TChar;
var lBool = object1 as TBool;
var rBool = object2 as TBool;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TBool(left.Value != right.Value);
}
if(lStr != null && rStr != null)
{
return new TBool(lStr.Value != lStr.Value);
}
if(lChr != null && rChr != null)
{
return new TBool(lChr.Value != lChr.Value);
}
if(lBool != null && rBool != null)
{
return new TBool(lBool.Value != lBool.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"neq"))
{
return lcls.CallMethod(ClassName,"neq",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("neq") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TBool(object1 != object2);
}
private TObject Eq(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lChr = object1 as TChar;
var rChr = object2 as TChar;
var lBool = object1 as TBool;
var rBool = object2 as TBool;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TBool(left.Value == right.Value);
}
if(lStr != null && rStr != null)
{
return new TBool(lStr.Value == lStr.Value);
}
if(lChr != null && rChr != null)
{
return new TBool(lChr.Value == lChr.Value);
}
if(lBool != null && rBool != null)
{
return new TBool(lBool.Value == lBool.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"eq"))
{
return lcls.CallMethod(ClassName,"eq",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("eq") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TBool(object1 == object2);
}
private TObject RShift(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber((long)left.Value >> (int)right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"rs"))
{
return lcls.CallMethod(ClassName,"rs",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("rs") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject LShift(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber((long)left.Value << (int)right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"ls"))
{
return lcls.CallMethod(ClassName,"ls",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("ls") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject XOr(TObject object2, TObject object1)
{
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(lcls != null && lcls.MethodExists(ClassName,"lte"))
{
return lcls.CallMethod(ClassName,"lte",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("lte") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TBool(object1.True ^ object2.True);
}
private TObject LOr(TObject object2, TObject object1)
{
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(lcls != null && lcls.MethodExists(ClassName,"lor"))
{
return lcls.CallMethod(ClassName,"lor",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("lor") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TBool(object1.True || object2.True);
}
private TObject LAnd(TObject object2, TObject object1)
{
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(lcls != null && lcls.MethodExists(ClassName,"land"))
{
return lcls.CallMethod(ClassName,"land",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("land") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TBool(object1.True && object2.True);
}
private TObject Pow(TObject object1, TObject object2)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber(Math.Pow(left.Value,right.Value));
}
if(lcls != null && lcls.MethodExists(ClassName,"pow"))
{
return lcls.CallMethod(ClassName,"pow",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("pow") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
Working on VM
2023-07-29 00:11:09 +00:00
private TObject Mod(TObject object1, TObject object2)
{
VM works
2023-07-30 07:55:10 +00:00
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber(left.Value % right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"mod"))
{
return lcls.CallMethod(ClassName,"mod",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("mod") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
Working on VM
2023-07-29 00:11:09 +00:00
}
private TObject Divide(TObject object1, TObject object2)
{
VM works
2023-07-30 07:55:10 +00:00
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber(left.Value / right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"div"))
{
return lcls.CallMethod(ClassName,"div",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("div") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
Working on VM
2023-07-29 00:11:09 +00:00
}
private TObject Times(TObject object1, TObject object2)
{
VM works
2023-07-30 07:55:10 +00:00
var left = object1 as TNumber;
var right = object2 as TNumber;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TNumber(left.Value + right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"times"))
{
return lcls.CallMethod(ClassName,"times",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("times") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
Working on VM
2023-07-29 00:11:09 +00:00
}
private TObject Sub(TObject object2, TObject object1)
{
VM works
2023-07-30 07:55:10 +00:00
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
var lArray = object1 as TArray;
if(left != null && right != null)
{
return new TNumber(left.Value - right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"sub"))
{
return lcls.CallMethod(ClassName,"sub",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("sub") as TCallable;
if(callable != null) return callable.Execute(object2);
}
if(lArray != null)
{
lArray.Remove(object2);
return lArray;
}
return new TNumber(0);
}
private TObject GTE(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TBool(left.Value >= right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"gte"))
{
return lcls.CallMethod(ClassName,"gte",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("gte") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject GT(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TBool(left.Value > right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"gt"))
{
return lcls.CallMethod(ClassName,"gt",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("gt") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
private TObject LTE(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
if(left != null && right != null)
{
return new TBool(left.Value <= right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"lte"))
{
return lcls.CallMethod(ClassName,"lte",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("lte") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
Working on VM
2023-07-29 00:11:09 +00:00
}
VM works
2023-07-30 07:55:10 +00:00
private TObject LT(TObject object2, TObject object1)
{
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
Working on VM
2023-07-29 00:11:09 +00:00
VM works
2023-07-30 07:55:10 +00:00
if(left != null && right != null)
{
return new TBool(left.Value < right.Value);
}
if(lcls != null && lcls.MethodExists(ClassName,"lt"))
{
return lcls.CallMethod(ClassName,"lt",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("lt") as TCallable;
if(callable != null) return callable.Execute(object2);
}
return new TNumber(0);
}
Working on VM
2023-07-29 00:11:09 +00:00
private TObject Add(TObject object2, TObject object1)
{
VM works
2023-07-30 07:55:10 +00:00
var left = object1 as TNumber;
var right = object2 as TNumber;
var lStr = object1 as TString;
var rStr = object2 as TString;
var lcls = object1 as TClassInstance;
var ldict = object1 as TDictionary;
var lArray = object1 as TArray;
Working on VM
2023-07-29 00:11:09 +00:00
if(left != null && right != null)
{
return new TNumber(left.Value + right.Value);
}
if(lStr != null && rStr != null)
{
return new TString(lStr.Value + rStr.Value);
}
VM works
2023-07-30 07:55:10 +00:00
if(lcls != null && lcls.MethodExists(ClassName,"add"))
{
return lcls.CallMethod(ClassName,"add",object2);
}
if(ldict != null)
{
var callable =ldict.GetValue("add") as TCallable;
if(callable != null) return callable.Execute(object2);
}
if(lArray != null)
{
lArray.Add(object2);
return lArray;
}
Working on VM
2023-07-29 00:11:09 +00:00
return new TNumber(0);
}
}
}