private void paramsArray(int argc1, int argc2)
{
int diff = argc1 - argc2;
VAL retAddr = SS.Pop();
VALL L1 = new VALL();
for (int i = 0; i < argc2 - 1; i++)
{
L1.Insert(SS.Pop());
}
VALL L2 = new VALL();
for (int i = 0; i <= diff; i++)
{
L2.Add(SS.Pop());
}
SS.Push(new VAL(L2));
for (int i = 0; i < argc2 - 1; i++)
{
SS.Push(L1[i]);
}
SS.Push(retAddr);
CS[retAddr.Intcon].operand.Addr += diff;
}
public static VAL Slice(VALL arr)
{
VAL V = arr[0];
int start = 0;
int stop = -1;
int step = 1;
switch (arr.Size)
{
case 1:
break;
case 2:
start = arr[1].Intcon;
break;
case 3:
start = arr[1].Intcon;
stop = arr[2].Intcon;
break;
case 4:
start = arr[1].Intcon;
stop = arr[2].Intcon;
step = arr[3].Intcon;
break;
}
return(new VAL(V.List.Slice(start, stop, step)));
}
private void UserFuncCall(VAL func, VAL instance, bool arg0)
{
int count1 = -CS[IP + 1].operand.Addr - 1;
if (moduleName == func.Class)
{
if (arg0)
{
VAL ip = SS.Pop();
SS.Push(instance);
SS.Push(ip);
count1++;
}
IP = (int)func.value;
paramsCheck(IP, count1);
}
else
{
VALL L = SysFuncBeginParameter();
if (arg0)
{
L.Insert(instance);
}
VAL ret = InternalUserFuncCall(func, instance, new VAL(L));
SysFuncEnd(ret);
}
}
public VAL GetValData()
{
VALL L = new VALL();
L.Add(new VAL(ty.FullName));
L.Add(new VAL(this));
return(new VAL(L));
}
//Add Association
public VALL Add(string key, VAL val)
{
VALL L = new VALL();
L.Add(new VAL(key));
L.Add(val);
list.Add(new VAL(L));
return(this);
}
public VALL Slice(int start, int stop, int step)
{
VALL L = new VALL();
for (int i = start; i <= Pos(stop); i += step)
{
L.Add(VAL.Clone(list[i]));
}
return(L);
}
//set union
public static VALL operator +(VALL L1, VALL L2)
{
VALL L = VALL.Clone(L1);
foreach (VAL v in L2.list)
{
L.list.Add(VAL.Clone(v));
}
return(L);
}
private void Callback(object sender, EventArgs e)
{
VALL L = new VALL();
L.Add(VAL.NewHostType(sender));
L.Add(VAL.NewHostType(e));
VAL arguments = new VAL(L);
ret = CPU.ExternalUserFuncCall(func, instance, arguments, context);
}
private bool SysFuncCall(object func, VAL proc, VAL instance, bool arg0)
{
if (proc.ty == VALTYPE.funccon)
{
UserFuncCall(proc, instance, arg0);
return(true);
}
VALL L = SysFuncBeginParameter();
if (arg0 && proc.temp is HostOffset)
{
object host = ((HostOffset)proc.temp).host;
if (host != instance.value)
{
L.Insert(instance); //extend method
arg0 = false;
}
}
VAL ret = HostOperation.HostTypeFunction(proc, L);
if (ret.Defined)
{
return(SysFuncEnd(ret));
}
if (arg0)
{
L.Insert(instance);
}
try
{
ret = context.InvokeFunction((string)func, new VAL(L), position);
}
catch (FunctionNotFoundException e1)
{
throw e1;
}
catch (Exception e2)
{
if (e2 is RuntimeException)
{
throw e2;
}
else
{
throw new RuntimeException(position, "Error: function {0}({1}) implementation, {2}", func, L.ToString2(), e2.Message);
}
}
return(SysFuncEnd(ret));
}
private static VAL WriteLine(VALL L)
{
StringWriter o = new StringWriter();
for (int i = 0; i < L.Size; i++)
{
o.Write(L[i].ToString2());
}
Logger.WriteLine(o.ToString());
return(new VAL(L)); //return void
}
private VALL SysFuncBeginParameter()
{
int count = SysFuncBegin();
VALL L = new VALL();
for (int i = 0; i < count; i++)
{
L.Add(SysFuncParam(i));
}
return(L);
}
internal static VAL Assemble(Memory memory)
{
VALL L = new VALL();
foreach (KeyValuePair <string, VAL> pair in memory.ds)
{
//if (pair.Value.ty == VALTYPE.funccon || pair.Value.ty == VALTYPE.classcon)
// continue;
L.Add(pair.Key, pair.Value);
}
return(new VAL(L));
}
public static VALL Clone(VALL l)
{
VALL L = new VALL();
L.ty = l.ty;
L.list = new List <VAL>();
foreach (VAL v in l.list)
{
L.list.Add(VAL.Clone(v));
}
return(L);
}
//set intersection
public static VALL operator *(VALL L1, VALL L2)
{
VALL L = new VALL();
for (int i = 0; i < L1.list.Count; i++)
{
if (L2.list.Contains(L1.list[i]))
{
L.list.Add(L1.list[i]);
}
}
return(L);
}
//set complmentary
public static VALL operator -(VALL L1, VALL L2)
{
VALL L = VALL.Clone(L1);
for (int i = 0; i < L1.list.Count; i++)
{
if (L2.list.Contains(L1.list[i]))
{
L.list.Remove(L1.list[i]);
}
}
return(L);
}
private static VAL LogInfo(VALL L)
{
StringWriter o = new StringWriter();
o.Write(System.DateTime.Now);
o.Write(" ");
for (int i = 0; i < L.Size; i++)
{
o.Write(L[i].ToString2());
}
Logger.WriteLine(o.ToString());
return(new VAL(L)); //return void
}
private Computer()
{
ds1 = new Memory();
ds2 = new Memory();
register("object", typeof(object));
register("bool", typeof(bool));
register("sbyte", typeof(sbyte));
register("byte", typeof(byte));
register("short", typeof(short));
register("ushort", typeof(ushort));
register("int", typeof(int));
register("uint", typeof(uint));
register("long", typeof(long));
register("ulong", typeof(ulong));
register("double", typeof(double));
register("float", typeof(float));
register("decimal", typeof(decimal));
register("char", typeof(char));
register("string", typeof(string));
VALL L = new VALL();
L.Add("VOID", new VAL((int)VALTYPE.voidcon));
L.Add("NULL", new VAL((int)VALTYPE.nullcon));
L.Add("BOOL", new VAL((int)VALTYPE.boolcon));
L.Add("INT", new VAL((int)VALTYPE.intcon));
L.Add("DOUBLE", new VAL((int)VALTYPE.doublecon));
L.Add("STRING", new VAL((int)VALTYPE.stringcon));
L.Add("LIST", new VAL((int)VALTYPE.listcon));
L.Add("FUNCTION", new VAL((int)VALTYPE.funccon));
L.Add("CLASS", new VAL((int)VALTYPE.classcon));
L.Add("HOST", new VAL((int)VALTYPE.hostcon));
ds1.Add("TYPE", new VAL(L));
//HostType.Register(new Type[]
//{
// typeof(DateTime),
// typeof(string),
// typeof(System.Reflection.Assembly),
// typeof(Tie.HostType)
//}, true);
}
public static VAL HostTypeFunction(VAL proc, VALL parameters)
{
VAL ret = VAL.VOID;
if (proc.ty == VALTYPE.hostcon && (proc.value is MethodInfo || proc.value is MethodInfo[]))
{
HostOffset temp = (HostOffset)proc.temp;
object host = temp.host;
object offset = temp.offset;
if (offset is MethodInfo)
{
ret = VAL.Boxing1(((MethodInfo)proc.value).Invoke(host, parameters.ObjectArray));
}
else
{
HostFunction hFunc = new HostFunction(host, (string)offset, parameters);
if (proc.value is MethodInfo[])
{
ret = hFunc.RunFunction((MethodInfo[])proc.value);
}
else
{
MethodInfo method = (MethodInfo)proc.value;
if (method.IsGenericMethod)
{
ret = hFunc.RunFunction(new MethodInfo[] { method });
}
else
{
ret = hFunc.RunFunction();
}
}
}
}
else if (proc.value is Delegate)
{
Delegate d = (Delegate)proc.value;
MethodInfo method = d.Method;
object[] arguments = parameters.ObjectArray;
return(HostFunction.InvokeMethod(method, d.Target, arguments));
}
return(ret);
}
bool NewInstance(VAL V) //new user defined class, .net object or a listcon
{
VALL L = SysFuncBeginParameter();
if (V.ty == VALTYPE.funccon)
{
string func = V.Str;
VAL userClass = GetVAL(func, true);
if (userClass.ty == VALTYPE.classcon)
{
//VAL instance = NewVAL.UserType(func);
VAL instance = new VAL();
VAL ret = InternalUserFuncCall(userClass, instance, new VAL(L));
return(SysFuncEnd(ret));
}
else
{
VAL args = new VAL(L);
VAL scope = new VAL();
if (!ES.IsEmpty())
{
scope = ES.Top();
}
VAL Clss = HostCoding.Decode(func, args, scope, context);
return(SysFuncEnd(Clss));
}
}
else if (V.value is Type) //generic class
{
VAL args = new VAL(L);
object instance = Activator.CreateInstance((Type)V.value, HostCoding.ConstructorArguments(args));
return(SysFuncEnd(VAL.NewHostType(instance)));
}
throw new RuntimeException(position, "new instance {0} failed", V);
}
private static VAL format(VALL L)
{
string fmt = L[0].Str;
object[] args = new object[L.Size - 1];
for (int i = 1; i < L.Size; i++)
{
if (L[i].ty != VALTYPE.listcon)
{
args[i - 1] = L[i].value; //use C# string.format string control
}
else
{
args[i - 1] = L[i].ToString2();
}
}
string s = string.Format(fmt, args);
return(new VAL(s));
}
public static VAL OperatorOverloading(Operator opr, VAL v1, VAL v2, bool silent)
{
VALL L = new VALL();
L.Add(v1);
if ((object)v2 != null)
{
L.Add(v2);
}
HostFunction hFunc = new HostFunction(v1.value, opr.ToString(), L);
if (silent)
{
return(hFunc.RunFunctionSilently(null));
}
else
{
return(hFunc.RunFunction(null));
}
}
public HostFunction(object host, string func, VALL parameters)
{
this.host = host;
this.func = func;
if (host is Type)
{
hostType = (Type)host;
}
else
{
hostType = host.GetType();
}
args1 = parameters.ObjectArray;
int count = args1.Length;
argTypes1 = new Type[count];
for (int i = 0; i < count; i++)
{
argTypes1[i] = parameters[i].Type;
}
}
internal VAL getter(VAL arr, bool created)
{
switch (arr.ty)
{
case VALTYPE.intcon:
if (arr.Intcon >= 0) //return row
{
//subscript number > size of array, increase size of array automatically
if (arr.Intcon >= list.Count && created)
{
while (arr.Intcon >= list.Count)
{
list.Add(new VAL());
}
}
if (arr.Intcon >= list.Count)
{
return(VAL.VOID);
}
return(list[arr.Intcon]);
}
else
{
// A={2,5,1,2,7,8}
// A[-1] return A's last item 8
// A[-2] return 7
int pos = Pos(arr.Intcon);
return(list[pos]);
}
case VALTYPE.stringcon:
{
string key = arr.Str;
foreach (VAL v in list)
{
if (v.ty != VALTYPE.listcon)
{
continue;
}
if (v.Size != 2 || v[0].ty != VALTYPE.stringcon)
{
continue;
}
string prop = v[0].Str;
if (key == prop)
{
return(v[1]);
}
else if (prop == Expression.BASE_INSTANCE)
{
VAL BS = v[1][key];
if (BS.Defined)
{
return(BS);
}
}
}
//not found, create new
if (created)
{
VAL val = new VAL();
this.Add(key, val);
return(val);
}
return(VAL.VOID);
}
case VALTYPE.listcon:
{
VALL L = this;
for (int i = 0; ; i++)
{
VAL R = L.getter(arr[i], created);
if (i < arr.Size - 1)
{
L = R.List;
}
else
{
return(R);
}
}
}
}
return(VAL.VOID);
}
public static VAL Function(string func, VAL parameters, Memory DS, Position position)
{
VALL L = (VALL)parameters.value;
VAL R0;
int size = L.Size;
VAL L0 = size > 0 ? L[0] : null;
VAL L1 = size > 1 ? L[1] : null;
switch (func)
{
/*
* register(Type type)
* register(Assembly assemby)
* */
case "register":
if (size == 1)
{
if (L0.ty == VALTYPE.hostcon)
{
object host = L0.HostValue;
if (host is Type)
{
return(new VAL(HostType.Register((Type)host)));
}
if (host is Type[])
{
return(new VAL(HostType.Register((Type[])host)));
}
else if (host is Assembly)
{
return(new VAL(HostType.Register((Assembly)host)));
}
}
}
break;
case "addreference":
if (size == 2 && L0.ty == VALTYPE.stringcon && L1.ty == VALTYPE.hostcon)
{
object host = L1.HostValue;
if (host is Assembly)
{
HostType.AddReference(L0.Str, (Assembly)host);
return(VAL.NewHostType(host));
}
}
break;
//return VAL type
case "type":
if (size == 1)
{
return(new VAL((int)L0.ty));
}
break;
case "GetType":
if (size == 1)
{
if (L0.value == null)
{
return(new VAL());
}
else
{
return(VAL.NewHostType(L0.value.GetType()));
}
}
break;
case "typeof":
if (size == 2)
{
if (L0.ty == VALTYPE.listcon && L1.ty == VALTYPE.stringcon) //1.
{
L0.Class = L1.Str;
return(L0);
}
}
else if (size == 1)
{
if (L0.value == null)
{
Type ty = HostType.GetType(L0.name);
if (ty != null)
{
return(VAL.NewHostType(ty));
}
else
{
return(new VAL());
}
}
else if (L0.ty == VALTYPE.listcon)
{
if (L0.Class == null)
{
return(VAL.VOID);
}
return(new VAL(L0.Class));
}
else if (L0.ty == VALTYPE.hostcon)
{
if (L0.value is Type)
{
return(L0);
}
else
{
return(VAL.NewHostType(L0.value.GetType()));
}
}
else if (L0.ty == VALTYPE.stringcon)
{
return(VAL.NewHostType(HostType.GetType(L0.Str))); //6.
}
}
break;
case "classof":
if (size == 1)
{
if (L0.ty == VALTYPE.hostcon)
{
return(HostValization.Host2Val(L0.value));
}
}
else if (size == 2)
{
if (L0.ty == VALTYPE.hostcon && L1.ty == VALTYPE.listcon) //1.
{
HostValization.Val2Host(L1, L0.value);
return(L0);
}
}
break;
case "valize":
if (size == 1)
{
return(VAL.Script(L0.Valor));
}
break;
case "isnull":
if (size == 2)
{
if (L0.ty == VALTYPE.nullcon)
{
return(L1);
}
else
{
return(L0);
}
}
break;
case "VAL":
if (size == 1)
{
R0 = VAL.Clone(L0);
R0.Class = "VAL"; //force to CAST VAL, don't do HostValue unboxing
return(R0);
}
break;
case "HOST": //cast to hostcon
if (size == 1)
{
R0 = VAL.Clone(L0);
R0.ty = VALTYPE.hostcon;
return(R0);
}
break;
case "ctype":
if (size == 2)
{
if (L1.value is Type)
{
return(VAL.cast(VAL.Clone(L0), (Type)L1.value));
}
else if (L[1].value is string)
{
Type ty = HostType.GetType(L1.Str);
if (ty != null)
{
return(VAL.cast(VAL.Clone(L0), ty));
}
}
}
break;
case "DateTime":
if (size == 6)
{
return(VAL.NewHostType(new DateTime(L0.Intcon, L1.Intcon, L[2].Intcon, L[3].Intcon, L[4].Intcon, L[5].Intcon)));
}
else if (size == 3)
{
return(VAL.NewHostType(new DateTime(L0.Intcon, L1.Intcon, L[2].Intcon)));
}
break;
//STRING
case "format":
if (size >= 1 && L0.ty == VALTYPE.stringcon)
{
return(format(L));
}
break;
#region LIST function
case "size":
if (size == 1)
{
return(new VAL(L0.Size));
}
break;
case "array": //array(2,3,4)
int[] A = new int[size];
for (int i = 0; i < size; i++)
{
if (L[1].ty != VALTYPE.intcon)
{
return(null);
}
A[i] = L[i].Intcon;
}
return(VAL.Array(A));
case "slice":
return(Slice(L));
case "append":
case "push":
if (size == 2 && L0.ty == VALTYPE.listcon)
{
R0 = L1;
L0.List.Add(VAL.Clone(R0));
return(L0);
}
break;
case "pop":
if (size == 1 && L0.ty == VALTYPE.listcon)
{
int index = L0.List.Size - 1;
R0 = L0.List[index];
L0.List.Remove(index);
return(R0);
}
else if (size == 2 && L0.ty == VALTYPE.listcon && L1.ty == VALTYPE.intcon)
{
int index = L1.Intcon;
R0 = L0.List[index];
L0.List.Remove(index);
return(R0);
}
break;
case "insert":
if (size == 3 && L0.ty == VALTYPE.listcon && L1.ty == VALTYPE.intcon)
{
L0.List.Insert(L1.Intcon, VAL.Clone(L[2]));
return(L0);
}
break;
case "remove":
if (size == 2 && L0.ty == VALTYPE.listcon && L1.ty == VALTYPE.intcon)
{
L0.List.Remove(L1.Intcon);
return(L0);
}
break;
#endregion
//DEBUG
case "echo":
return(new VAL(L));
case "write":
return(WriteLine(L));
case "loginfo":
return(LogInfo(L));
#region internal functions used by parser
case Constant.FUNC_CAST_TYPE_VALUE:
if (size == 2)
{
return(cast(L1, L0));
}
break;
case Constant.FUNC_CAST_VALUE_TYPE:
if (size == 2)
{
return(cast(L0, L1));
}
break;
case Constant.FUNC_IS_TYPE:
if (size == 2)
{
Type type = SystemFunction.GetValDefinitionType(L1);
if (type != null)
{
if (L0.value == null)
{
return(new VAL(false));
}
else
{
return(new VAL(type.IsAssignableFrom(L0.value.GetType())));
}
}
else
{
throw new RuntimeException(position, "{0} is not type or not registered.", L1.value);
}
}
break;
case Constant.FUNC_MAKE_ARRAY_TYPE:
if (size == 1 || size == 2)
{
Type ty = SystemFunction.GetValDefinitionType(L0);
if (ty != null)
{
if (size == 1)
{
return(VAL.Boxing1(ty.MakeArrayType()));
}
else if (L1.value is int)
{
return(VAL.Boxing1(ty.MakeArrayType(L1.Intcon)));
}
}
else
{
throw new RuntimeException(position, "declare array failed, {0} is not type.", L0.value);
}
}
break;
case Constant.FUNC_FUNCTION:
if (L[1].ty == VALTYPE.intcon)
{
return(new VAL(Operand.Func(L[1].Intcon, L[0].Str)));
}
else
{
return(new VAL(Operand.Func(L[1].Str, L[0].Str)));
}
case Constant.FUNC_CLASS:
return(new VAL(Operand.Clss(L[1].Intcon, L[0].Str)));
#endregion
#region propertyof, methodof, fieldof
case "propertyof":
if (size >= 2 && size <= 4)
{
object host = L0.value;
if (host == null)
{
break;
}
if (L0.ty == VALTYPE.hostcon && L1.ty == VALTYPE.stringcon)
{
if (size == 2 || size == 3)
{
return(HostFunction.propertyof(size == 2, null, (string)L1.value, host, size == 2 ? null: L[2].HostValue));
}
}
else if (L0.ty == VALTYPE.hostcon &&
L1.ty == VALTYPE.hostcon && L1.value is Type &&
L[2].ty == VALTYPE.stringcon)
{
if (size == 3 || size == 4)
{
return(HostFunction.propertyof(size == 3, (Type)L1.value, (string)L[2].value, host, size == 3 ? null : L[3].HostValue));
}
}
}
break;
case "fieldof":
if (size == 2 || size == 3)
{
object host = L0.value;
if (host == null)
{
break;
}
if (L0.ty == VALTYPE.hostcon && L1.ty == VALTYPE.stringcon)
{
Type ty = HostType.GetHostType(host);
FieldInfo fieldInfo = ty.GetField((string)L1.value, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
if (fieldInfo == null)
{
throw new RuntimeException(position, string.Format("Invalid field name: {0}.{1}", ty.FullName, L1.value));
}
if (size == 2)
{
return(VAL.Boxing1(fieldInfo.GetValue(host)));
}
else
{
fieldInfo.SetValue(host, L[2].HostValue);
return(VAL.VOID);
}
}
}
break;
case "methodof":
if (size == 4)
{
object host = L0.value;
if (host == null)
{
break;
}
VAL L2 = L[2];
object args = L[3].HostValue;
if (L0.ty == VALTYPE.hostcon &&
L1.ty == VALTYPE.hostcon && L1.value is Type &&
L2.ty == VALTYPE.stringcon &&
args is Type[])
{
MethodInfo methodInfo = HostFunction.methodof(host, (Type)L1.value, (string)L2.value, (Type[])args);
if (methodInfo != null)
{
VAL method = VAL.Boxing1(methodInfo);
method.temp = new HostOffset(host, methodInfo);
return(method);
}
else
{
throw new RuntimeException(position, "method {0} is not existed", L2.value);
}
}
}
break;
#endregion
}
return(null);
}
public VAL Run(int breakPoint)
{
L1:
Instruction I = CS[IP];
Operand operand = I.operand;
position.line = I.line;
position.col = I.col;
position.cur = I.cur;
position.block = I.block;
if (I.line == breakPoint)
{
return(null);
}
switch (I.cmd)
{
//----------------------------------------------------------------------------
#region MOV, STO,STO1, RMT. RCP
case INSTYPE.MOV:
if (operand.ty == OPRTYPE.identcon) // MOV [v]
{
if (CS[IP + 1].cmd == INSTYPE.OFS) // if this is offset of a struct, keep variable name
{
REG.Push(new VAL(operand));
}
else
{
REG.Push(GetVAL(operand.Str, false));
}
}
else if (operand.ty == OPRTYPE.addrcon) // MOV [BP-3]
{
//VAL opr = Register.BPAddr(BP, operand);
VAL opr = new VAL();
opr.ty = VALTYPE.addrcon;
opr.value = BP + operand.Addr;
opr.name = operand.name;
REG.Push(opr);
}
else
{
VAL x = new VAL(operand);
if (operand.ty == OPRTYPE.funccon)
{
if (ES.SP > -1)
{
x.temp = new ContextInstance(this.context, ES.Top());
}
else
{
x.temp = new ContextInstance(this.context, new VAL());
}
}
REG.Push(VAL.Clone(x)); // MOV 3
}
break;
//----------------------------------------------------------------------------
case INSTYPE.STO1:
case INSTYPE.STO:
R0 = REG.Pop();
R1 = REG.pop();
if (R1.ty == VALTYPE.addrcon)
{
SS[R1.Address] = R0;
}
else
{
HostOperation.Assign(R1, R0);
}
if (I.cmd == INSTYPE.STO)
{
REG.Push(R1);
}
break;
case INSTYPE.RMT:
if (CS[IP + 1].cmd != INSTYPE.HALT) //used for expression decoding,keep last value
{
REG.Pop();
}
break;
case INSTYPE.RCP:
REG.Push(VAL.Clone(REG.Top()));
break;
#endregion
//----------------------------------------------------------------------------
#region PUSH/POP/SP/ESI/ESO
case INSTYPE.ESI:
R0 = REG.Pop();
ES.Push(R0);
break;
case INSTYPE.ESO:
ES.Pop();
break;
case INSTYPE.PUSH:
if (operand != null && operand.ty == OPRTYPE.regcon)
{
switch (operand.SEG)
{
case SEGREG.BP: SS.Push(new VAL(BP)); break;
case SEGREG.SP: SS.Push(new VAL(SS.SP)); break;
case SEGREG.SI: SS.Push(new VAL(SI)); break;
case SEGREG.IP: SS.Push(new VAL(IP + 2)); break;
case SEGREG.EX: EX.Push((int)operand.value); break;
}
}
else
{
R0 = REG.Pop();
SS.Push(R0);
}
break;
case INSTYPE.POP:
if (operand.ty == OPRTYPE.regcon)
{
switch (operand.SEG)
{
case SEGREG.BP: BP = (SS.Pop()).Address; break;
case SEGREG.SI: SI = (SS.Pop()).Address; break;
case SEGREG.SP: SS.SP = (SS.Pop()).Address; break;
case SEGREG.EX: EX.Pop(); break;
}
}
else
{
R0 = SS.Pop();
REG.Push(R0);
}
break;
case INSTYPE.SP:
SS.SP += operand.Addr;
break;
#endregion
//----------------------------------------------------------------------------
#region OFS, ARR
//----------------------------------------------------------------------------
// Associative List
// Mike={{"street", "3620 Street"},{"zip", 20201},{"phone","111-222-333},{"apt",1111}}
// Mike.street = "3620 Street";
// Mike.zip = 40802;
case INSTYPE.OFS:
R0 = REG.Pop();
R1 = REG.pop();
{
VAL v = new VAL();
switch (R1.ty)
{
case VALTYPE.hostcon:
v = R1.getter(R0, true, OffsetType.STRUCT);
goto LOFS;
case VALTYPE.addrcon:
v = SS[R1.Address];
if (v.Undefined || v.IsNull)
{
v.ty = VALTYPE.listcon;
v.value = new VALL();
}
break;
case VALTYPE.listcon:
v = R1;
break;
default: // if assoicative arrary is empty or not list
R1.ty = VALTYPE.listcon;
R1.value = new VALL();
v = R1;
break;
}
switch (v.ty)
{
case VALTYPE.listcon:
VALL L = v.List;
v = L[R0.Str];
// if property is not found in the associative array
if (!v.Defined)
{
L[R0.Str] = v;
}
break;
case VALTYPE.hostcon:
//VAL.Assign(v, VAL.HostTypeOffset(v.value, R0.value));
v = HostOperation.HostTypeOffset(v, R0, OffsetType.STRUCT);
break;
}
LOFS:
if ((object)v == null)
{
v = new VAL();
}
v.name = R1.name + "." + R0.name;
REG.Push(v);
}
break;
case INSTYPE.ARR:
R0 = REG.Pop();
R1 = REG.pop();
{
VAL v = new VAL();
switch (R1.ty)
{
case VALTYPE.addrcon:
v = SS[R1.Address]; //indirect addressing
if (v.Undefined || v.IsNull)
{
v.ty = VALTYPE.listcon;
v.value = new VALL();
v = v.getter(R0, true, OffsetType.ARRAY);
}
else
{
v = v.getter(R0, true, OffsetType.ARRAY);
}
break;
case VALTYPE.listcon: //push reference
v = R1.getter(R0, true, OffsetType.ARRAY);
break;
case VALTYPE.hostcon:
v = R1.getter(R0, true, OffsetType.ARRAY);
if (!v.Defined)
{
throw new RuntimeException(position, "{0} does not have property {1}.", R1, R0);
}
break;
default:
//refer: public VAL this[VAL arr], when R1 == null, dynamically allocate a list
R1.ty = VALTYPE.listcon;
R1.value = new VALL();
v = R1.getter(R0, true, OffsetType.ARRAY);
//JError.OnRuntime(0);
break;
}
v.name = R1.name + "[" + R0.ToString() + "]";
REG.Push(v);
}
break;
#endregion
//----------------------------------------------------------------------------
#region CALL, NEW, ENDP, RET, GNRC
case INSTYPE.GNRC:
R0 = REG.Pop(); // R0 = new Type[] { string, int }
R1 = REG.Pop(); // R1 = System.Collection.Generic
{
Operand opr = I.operand;
VAL R2 = R1[opr.Str]; // I.val.Str == Dictionary`2
if (R2.Undefined) // Type is not registered
{
object t = HostType.GetType(R1.name + "." + opr.Str);
if (t != null)
{
R2 = VAL.NewHostType(t);
}
else
{
throw new RuntimeException(position, "Type {0}.{1} is not registered.", R1.name, opr.Str);
}
}
object A = R0.HostValue;
if (A is object[] && ((object[])A).Length == 0) //case: typeof(Dictionary<,>)
{
if (R2.value is Type)
{
REG.Push(VAL.NewHostType(R2.value));
}
else
{
throw new RuntimeException(position, "{0} is not System.Type.", R1);
}
}
else
{
if (!(A is Type[]))
{
throw new RuntimeException(position, "<{0}> is not System.Type[].", R0.ToString2());
}
if (R2.value is Type)
{
Type t = (Type)R2.value;
REG.Push(VAL.NewHostType(t.MakeGenericType((Type[])A)));
}
else if (R2.value is MethodInfo)
{
MethodInfo t = (MethodInfo)R2.value;
VAL m = VAL.NewHostType(t.MakeGenericMethod((Type[])A));
m.temp = R2.temp;
REG.Push(m);
}
else if (R2.value is MethodInfo[])
{
MethodInfo[] T = (MethodInfo[])R2.value;
for (int i = 0; i < T.Length; i++)
{
T[i] = T[i].MakeGenericMethod((Type[])A);
}
VAL m = VAL.NewHostType(T);
m.temp = R2.temp;
REG.Push(m);
}
else
{
throw new RuntimeException(position, "{0} is not System.Type.", R1);
}
}
}
break;
case INSTYPE.CALL:
if (operand.ty == OPRTYPE.intcon)
{
IP = operand.Addr;
}
else if (operand.ty == OPRTYPE.addrcon) // high-level programming
{
SysFuncCallByAddr(SS[operand.Addr + BP]);
}
else if (operand.ty == OPRTYPE.regcon)
{
SysFuncCallByAddr(SS[operand.Addr + SS.SP]);
}
else if (operand.ty == OPRTYPE.none) //used for Generic method
{
if (ES.IsEmpty())
{
R0 = REG.Pop();
}
else
{
R0 = ES.Top();
}
SysFuncCallByName(R0);
}
else
{
SysFuncCallByName(new VAL(operand));
}
goto L1;
case INSTYPE.NEW:
if (operand.ty == OPRTYPE.funccon)
{
NewInstance(new VAL(operand)); //system predifined class & user-defined class
}
else if (operand.ty == OPRTYPE.none) //used for Generic class
{
if (ES.IsEmpty())
{
R0 = REG.Pop();
}
else
{
R0 = ES.Top();
}
NewInstance(R0);
}
else if (operand.ty == OPRTYPE.intcon)
{
int opr = (int)operand.value;
if (opr > 1)
{
R0 = REG.Pop();
R1 = REG.Pop();
}
else
{
R1 = REG.Pop();
}
if (R1.value is Type)
{
Type ty = (Type)R1.value;
if (opr == 1)
{
if (ty.IsArray)
{
R0 = VAL.Array();
}
else
{
R0 = new VAL();
}
}
if (R0.ty == VALTYPE.listcon)
{
if (ty.IsArray)
{
R0.List.ty = ty;
}
else
{
throw new RuntimeException(position, "new object failed. {0} is not Array Type", R1);
}
}
R0.Class = ty.FullName;
REG.Push(R0);
}
else
{
throw new RuntimeException(position, "new object failed. {0} is not System.Type", R1);
}
IP++;
}
goto L1;
case INSTYPE.ENDP:
if ((OPRTYPE)operand.Intcon == OPRTYPE.classcon)
{
REG.Push(ES.Top()); //return this;
}
else
{
REG.Push(VAL.VOID); //return void;
}
SS.SP = BP; //PUSH BP; POP SP;
BP = (SS.Pop()).Address; //POP BP;
R0 = SS.Top(); //EXEC RET
IP = R0.Address;
goto L1;
case INSTYPE.RET:
if (!SS.IsEmpty())
{
R0 = SS.Top();
IP = R0.Address; //goto V.i
}
else
{
if (REG.IsEmpty())
{
return(VAL.VOID);
}
else
{
return(REG.Top());
}
}
goto L1;
#endregion
//----------------------------------------------------------------------------
#region +,-,*,/,%,>,<,!=,==,<=,>=, ++, --
//----------------------------------------------------------------------------
case INSTYPE.NEG:
R0 = REG.Pop();
if (operand.Intcon == -1)
{
R0 = -R0; //call VAL.operator -(VAL)
}
else
{
R0 = +R0; //call VAL.operator +(VAL)
}
REG.Push(R0);
break;
case INSTYPE.ADD: R0 = REG.Pop(); R1 = REG.Pop(); R1 += R0; REG.Push(R1); break;
case INSTYPE.SUB: R0 = REG.Pop(); R1 = REG.Pop(); R1 -= R0; REG.Push(R1); break;
case INSTYPE.MUL: R0 = REG.Pop(); R1 = REG.Pop(); R1 *= R0; REG.Push(R1); break;
case INSTYPE.DIV: R0 = REG.Pop(); R1 = REG.Pop(); R1 /= R0; REG.Push(R1); break;
case INSTYPE.MOD: R0 = REG.Pop(); R1 = REG.Pop(); R1 %= R0; REG.Push(R1); break;
case INSTYPE.GTR: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 > R0)); break;
case INSTYPE.LSS: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 < R0)); break;
case INSTYPE.GEQ: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 >= R0)); break;
case INSTYPE.LEQ: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 <= R0)); break;
case INSTYPE.EQL: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 == R0)); break;
case INSTYPE.NEQ: R0 = REG.Pop(); R1 = REG.Pop(); REG.Push(new VAL(R1 != R0)); break;
case INSTYPE.INC:
R0 = REG.pop();
R1 = VAL.Clone(R0);
if (R0.ty == VALTYPE.addrcon)
{
SS[R0.Address] += new VAL(1);
}
else //global varible
{
HostOperation.Assign(R0, R0 + new VAL(1));
}
REG.Push(R1);
break;
case INSTYPE.DEC:
R0 = REG.pop();
R1 = VAL.Clone(R0);
if (R0.ty == VALTYPE.addrcon)
{
SS[R0.Address] -= new VAL(1);
}
else //global varible
{
HostOperation.Assign(R0, R0 - new VAL(1));
}
REG.Push(R1);
break;
#endregion
//----------------------------------------------------------------------------
#region MARK, END, EACH, CAS, DIRC
case INSTYPE.MARK: REG.Push(Mark); break;
case INSTYPE.END:
{
VAL L = new VAL(new VALL());
while (REG.Top() != Mark)
{
L.List.Insert(REG.Pop());
}
REG.Pop(); // pop mark
REG.Push(L);
} break;
case INSTYPE.EACH:
R0 = REG.Pop(); //Collection
R1 = REG.pop(); //address of element [BP+addr]
REG.Push(ForEach(R0, SS[R1.Intcon], SS[R1.Intcon + 1]));
break;
case INSTYPE.CAS:
R0 = REG.Pop(); R1 = REG.Top();
if (R1 == R0)
{
REG.Pop(); IP = operand.Addr; goto L1;
} //goto V.i
break;
case INSTYPE.DIRC: //directive command
switch (operand.mod)
{
case Constant.SCOPE:
this.scope = (string)operand.value;
break;
}
break;
#endregion
//----------------------------------------------------------------------------
#region &&, ||, ~, &, |, >>, <<
//----------------------------------------------------------------------------
case INSTYPE.NOTNOT:
R0 = REG.Pop();
if (R0.ty == VALTYPE.stringcon)
{
REG.Push(Computer.Run(scope, R0.Str, CodeType.statements, context));
}
else
{
REG.Push(new VAL(!R0)); //call VAL.operator !(VAL)
}
break;
case INSTYPE.ANDAND: R0 = REG.pop(); R1 = REG.Pop();
REG.Push(new VAL(R0.ty == VALTYPE.boolcon && R1.ty == VALTYPE.boolcon? R0.Boolcon && R1.Boolcon: false));
break;
case INSTYPE.OROR: R0 = REG.pop(); R1 = REG.Pop();
REG.Push(new VAL(R0.ty == VALTYPE.boolcon && R1.ty == VALTYPE.boolcon ? R0.Boolcon || R1.Boolcon : false));
break;
//----------------------------------------------------------------------------
case INSTYPE.NOT: R0 = REG.Pop();
REG.Push(~R0); //call VAL.operator ~(VAL)
break;
case INSTYPE.AND: R0 = REG.pop(); R1 = REG.Pop();
REG.Push(R1 & R0);
break;
case INSTYPE.OR: R0 = REG.pop(); R1 = REG.Pop();
REG.Push(R1 | R0);
break;
case INSTYPE.XOR: R0 = REG.pop(); R1 = REG.Pop();
REG.Push(R1 ^ R0);
break;
//----------------------------------------------------------------------------
case INSTYPE.SHL: R0 = REG.pop(); R1 = REG.Pop();
if (!(R0.value is int))
{
throw new RuntimeException(position, "the 2nd operand {0} in << operation must be integer", R0);
}
REG.Push(R1 << (int)R0.value);
break;
case INSTYPE.SHR: R0 = REG.pop(); R1 = REG.Pop();
if (!(R0.value is int))
{
throw new RuntimeException(position, "the 2nd operand {0} in >> operation must be integer", R0);
}
REG.Push(R1 >> (int)R0.value);
break;
#endregion
//----------------------------------------------------------------------------
#region JUMP, ADR, VLU
case INSTYPE.JMP: IP = operand.Addr; goto L1;
case INSTYPE.LJMP: IP += operand.Addr; goto L1;
case INSTYPE.JNZ:
if (REG.Pop() == new VAL(true))
{
IP = operand.Addr; goto L1;
}
else
{
break;
}
case INSTYPE.JZ:
if (REG.Pop() != new VAL(true))
{
IP = operand.Addr; goto L1;
}
else
{
break;
}
case INSTYPE.LJZ:
if (REG.Pop() != new VAL(true))
{
IP += operand.Addr; goto L1;
}
else
{
break;
}
case INSTYPE.ADR:
R0 = REG.Pop();
REG.Push(new VAL(R0.name));
break;
case INSTYPE.VLU:
R0 = REG.Pop();
if (R0.ty == VALTYPE.stringcon)
{
REG.Push(Computer.Run(scope, R0.Str, CodeType.expression, context));
}
else
{
throw new RuntimeException(position, "Invalid address type:" + R0.ToString());
}
break;
#endregion
//----------------------------------------------------------------------------
#region THIS,BASE
case INSTYPE.THIS: //this.x
if (ES.SP > -1)
{
if (this.scope != "")
{
VAL NS = GetScopeVAL(this.scope);
if (NS != ES.Top())
{
REG.Push(NS);
}
}
else
{
REG.Push(ES.Top());
}
}
else if (this.scope != "")
{
if (operand.ty == OPRTYPE.intcon) //this.x=100;
{
REG.Push(GetScopeVAL(this.scope));
}
else
{
REG.Push(new VAL(this.scope)); //p=&this.x;
}
}
else
{
if (CS[IP + 2].cmd == INSTYPE.OFS)
{
CS[IP + 2].cmd = INSTYPE.NOP;
}
else
{
throw new RuntimeException(position, "Operator[this] is invalid since namespace is empty.");
}
}
break;
case INSTYPE.BASE: //base.x
//if (ES.SP > -1)
//{
// VAL BS = ES.Top()[JExpression.BASE_INSTANCE];
// if((object)BS!=null)
// REG.Push(BS);
// else
// throw new RuntimeException(string.Format("Operator[base] is invalid since class {0} does not have base class.",ES.Top()));
//}
if (this.scope != "")
{
string bv = "";
int n = 1;
if (operand.ty == OPRTYPE.intcon) //base.base.x=10;
{
n = operand.Intcon;
bv = GetBaseScope(this.scope, n);
if (bv != "")
{
REG.Push(GetScopeVAL(bv));
}
else
{
if (CS[IP + 2].cmd == INSTYPE.OFS)
{
CS[IP + 2].cmd = INSTYPE.NOP;
}
}
}
else
{
n = operand.Addr; // p = &base.base.x;
bv = GetBaseScope(this.scope, n);
REG.Push(new VAL(bv));
}
}
else
{
throw new RuntimeException(position, "Operator[base] is invalid since scope is root.");
}
break;
#endregion
//----------------------------------------------------------------------------
#region THRW, DDT, HALT
case INSTYPE.THRW:
R0 = REG.Top();
if (!(R0.HostValue is Exception))
{
throw new RuntimeException(position, "{0} is not type of System.Exception.", R0.HostValue);
}
if (EX.IsEmpty())
{
throw (Exception)R0.HostValue;
}
IP = EX.Pop();
if (IP == -1)
{
throw (Exception)R0.HostValue;
}
break;
case INSTYPE.DDT:
Logger.WriteLine(DebugInfo());
break;
case INSTYPE.HALT:
if (REG.IsEmpty())
{
return(VAL.VOID);
}
else
{
return(REG.Top());
}
#endregion
}
IP++;
goto L1;
}