public RunExpressions(Func<SpokeObject[], SpokeObject>[] internalMethods, SpokeMethod[] mets) { Methods = mets; InternalMethods = internalMethods; ints=new SpokeObject[100]; for (int i = 0; i < 100; i++) { ints[i] = new SpokeObject(ObjectType.Int) {IntVal = i}; } }
public void loadUp(Func<SpokeObject[], SpokeObject>[] internalMethods, SpokeMethod[] mets) { Methods = mets; InternalMethods = internalMethods; ints = new SpokeObject[100]; for (int i = 0; i < 100; i++) { ints[i] = new SpokeObject(i); } }
public RunInstructions(Func<SpokeObject[], SpokeObject>[] internalMethods, SpokeMethod[] mets, string stack, int returnIndex, Dictionary<string, string[]> variableLookup) { Methods = mets; myVariableLookup = variableLookup; InternalMethods = internalMethods; ints = new SpokeObject[100]; for (int i = 0; i < 100; i++) { ints[i] = new SpokeObject(ObjectType.Int) { IntVal = i }; } if (stack.Length != 0) { deserialize(stack); reprintStackTrace[reprintStackIndex - 1].Answer = new SpokeObject(returnIndex); } }
private SpokeObject evaluate(SpokeMethod fm, SpokeObject parent, SpokeObject[] paras) { #if Stacktrace dfss.AppendLine(fm.MethodName); #endif SpokeObject[] variables = new SpokeObject[fm.NumOfVars]; for (int i = 0; i < fm.Parameters.Length; i++) { variables[i] = paras[i]; } var sm = new SpokeMethodRun(); sm.RunningClass = parent; return evaluateLines(fm.Lines, sm, variables); }
private void runClass2(Func<SpokeObject[], SpokeObject>[] rv, SpokeMethod[] dms, SpokeConstruct k) { RunClass2 d = new RunClass2(); d.loadUp(rv, dms); d.Run(); }
private void runClass(Command d, Func<SpokeObject[], SpokeObject>[] rv, SpokeMethod[] methods) { d.loadUp(rv, methods); d.Run(); }
private Tuple<string, List<PostParseExpression>> buildMethod(SpokeMethod fm) { StringBuilder sb = new StringBuilder(); #if stacktrace dfss.AppendLine( fm.Class.Name +" : : "+fm.MethodName+" Start"); #endif List<PostParseExpression> exps = new List<PostParseExpression>(); for (int index = 0; index < fm.Instructions.Length; index++) { var ins = fm.Instructions[index]; #if stacktrace dfss.AppendLine(stackIndex + " :: " + ins.ToString()); #endif int gj; PostParseVariable[] pps; switch (ins.Type) { case SpokeInstructionType.CreateReference: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("new SpokeObject(new SpokeObject[{0}])", ins.Index)), false)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(new SpokeObject[{1}]);", ins.StackBefore_, ins.Index)); break; case SpokeInstructionType.Comment: exps.Add(new PostParseString(string.Format("/*{0}*/", ins.StringVal))); sb.AppendLine(string.Format("/*{0}*/", ins.StringVal)); break; case SpokeInstructionType.CreateArray: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("new SpokeObject(new List<SpokeObject>(20))")), false)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(new List<SpokeObject>(20) );", ins.StackBefore_)); break; case SpokeInstructionType.CreateMethod: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("NULL")), false)); sb.AppendLine(string.Format("stack[{0}]=NULL;", ins.StackBefore_)); break; case SpokeInstructionType.Label: exps.Add(new PostParseString(ins.labelGuy + ":")); sb.AppendLine(string.Format("{0}:", ins.labelGuy)); break; case SpokeInstructionType.Goto: exps.Add(new PostParseString("goto " + ins.gotoGuy + ";")); sb.AppendLine(string.Format("goto {0};", ins.gotoGuy)); break; case SpokeInstructionType.CallMethod: pps = new PostParseVariable[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) pps[i] = new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1 - i); exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseMethod(Methods[ins.Index].Class.Name + Methods[ins.Index].CleanMethodName, pps.Reverse().ToArray(), ins.Index3), true)); sb.AppendLine(string.Format("sps = new SpokeObject[{0}];", Methods[ins.Index].NumOfVars)); gj = ins.StackBefore_ - 1; for (int i = ins.Index3 - 1; i >= 0; i--) { sb.AppendLine(string.Format("sps[{1}] = stack[{0}];", gj--, i)); } sb.AppendLine(string.Format("stack[{0}] = {1}(sps);", ins.StackAfter_ - 1, Methods[ins.Index].Class.Name + Methods[ins.Index].CleanMethodName)); break; case SpokeInstructionType.CallMethodFunc: pps = new PostParseVariable[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { pps[i] = new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1 - i); } exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseMethod(string.Format("Methods[{0}].MethodFunc", ins.Index), pps.Reverse().ToArray(), ins.Index3), true)); sb.AppendLine(string.Format("sps = new SpokeObject[{0}];", ins.Index3)); gj = ins.StackBefore_ - 1; for (int i = ins.Index3 - 1; i >= 0; i--) { sb.AppendLine(string.Format("sps[{1}] = stack[{0}];", gj--, i)); } sb.AppendLine(string.Format("stack[{0}] = Methods[{1}].MethodFunc(sps);", ins.StackAfter_ - 1, ins.Index)); break; case SpokeInstructionType.CallInternal: pps = new PostParseVariable[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { pps[i] = new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1 - i); } exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseMethod(string.Format("InternalMethods[{0}]", ins.Index), pps.Reverse().ToArray(), ins.Index3), true)); sb.AppendLine(string.Format("sps = new SpokeObject[{0}];", ins.Index3)); gj = ins.StackBefore_ - 1; for (int i = ins.Index3 - 1; i >= 0; i--) { sb.AppendLine(string.Format("sps[{1}] = stack[{0}];", gj--, i)); } sb.AppendLine(string.Format("stack[{0}] = InternalMethods[{1}](sps);", ins.StackAfter_ - 1, ins.Index)); break; case SpokeInstructionType.BreakpointInstruction: Console.WriteLine("BreakPoint"); break; case SpokeInstructionType.Return: exps.Add(new PostParseStatement("return {0};", new PostParseVariable(VariableType.Stack, ins.StackBefore_))); sb.AppendLine(string.Format("return stack[{0}];", ins.StackBefore_)); break; case SpokeInstructionType.IfTrueContinueElse: exps.Add(new PostParseStatement("if(!({0}).BoolVal) ", new PostParseVariable(VariableType.Stack, ins.StackBefore_))); exps.Add(new PostParseString("goto " + ins.elseGuy + ";")); sb.AppendLine(string.Format("if(!stack[{0}].BoolVal) goto {1};", ins.StackBefore_, ins.elseGuy)); break; case SpokeInstructionType.Or: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.BoolVal || {1}.BoolVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}] = (stack[{0}].BoolVal || stack[{1}].BoolVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackBefore_)); break; case SpokeInstructionType.And: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.BoolVal && {1}.BoolVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}] = (stack[{0}].BoolVal && stack[{1}].BoolVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackBefore_)); break; case SpokeInstructionType.StoreLocalInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Variable, ins.Index), new PostParseStatement("intCache({0}.IntVal)", new PostParseVariable(VariableType.Stack, ins.StackBefore_)), true)); sb.AppendLine(string.Format("variables[{0}] = intCache(stack[{1}].IntVal);", ins.Index, ins.StackBefore_)); break; case SpokeInstructionType.StoreLocalFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Variable, ins.Index), new PostParseStatement("new SpokeObject({0}.FloatVal)", new PostParseVariable(VariableType.Stack, ins.StackBefore_)), true)); sb.AppendLine(string.Format("variables[{0}] = new SpokeObject(stack[{1}].FloatVal);", ins.Index, ins.StackBefore_)); break; case SpokeInstructionType.StoreLocalBool: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Variable, ins.Index), new PostParseStatement("new SpokeObject({0}.BoolVal)", new PostParseVariable(VariableType.Stack, ins.StackBefore_)), true)); sb.AppendLine(string.Format("variables[{0}] = stack[{1}].BoolVal ? TRUE : FALSE;", ins.Index, ins.StackBefore_)); // variables[ins.Index] = lastStack.BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.StoreLocalString: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Variable, ins.Index), new PostParseStatement("new SpokeObject({0}.StringVal)", new PostParseVariable(VariableType.Stack, ins.StackBefore_)), true)); sb.AppendLine(string.Format("variables[{0}] = new SpokeObject(stack[{1}].StringVal);", ins.Index, ins.StackBefore_)); break; case SpokeInstructionType.StoreLocalMethod: case SpokeInstructionType.StoreLocalObject: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Variable, ins.Index), new PostParseVariable(VariableType.Stack, ins.StackBefore_), true)); sb.AppendLine(string.Format("variables[{0}] = stack[{1}];", ins.Index, ins.StackBefore_)); break; case SpokeInstructionType.StoreLocalRef: exps.Add( new PostParseStatement( @" //{1}={0}; lastStack = {0}; bm2 = {1}; bm2.Variables = lastStack.Variables; bm2.ArrayItems = lastStack.ArrayItems; bm2.StringVal = lastStack.StringVal; bm2.IntVal = lastStack.IntVal; bm2.BoolVal = lastStack.BoolVal; bm2.FloatVal = lastStack.FloatVal; ", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Variable, ins.Index))); sb.AppendLine(string.Format("lastStack = stack[{0}];", ins.StackBefore_)); sb.AppendLine(string.Format("bm = variables[{0}];", ins.Index)); sb.AppendLine(@" bm.Variables = lastStack.Variables; bm.ArrayItems = lastStack.ArrayItems; bm.StringVal = lastStack.StringVal; bm.IntVal = lastStack.IntVal; bm.BoolVal = lastStack.BoolVal; bm.FloatVal = lastStack.FloatVal; "); break; case SpokeInstructionType.StoreFieldBool: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "]={1}.BoolVal?TRUE:FALSE;", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1))); sb.AppendLine(string.Format("stack[{0}].Variables[{2}]=stack[{1}].BoolVal?TRUE:FALSE;", ins.StackBefore_, ins.StackAfter_, ins.Index)); break; case SpokeInstructionType.StoreFieldInt: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "]=intCache({1}.IntVal);", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1))); sb.AppendLine(string.Format("stack[{0}].Variables[{2}]=intCache(stack[{1}].IntVal );", ins.StackBefore_, ins.StackAfter_, ins.Index)); break; case SpokeInstructionType.StoreFieldFloat: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "]=new SpokeObject({1}.FloatVal);", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1))); sb.AppendLine(string.Format("stack[{0}].Variables[{2}]=new SpokeObject( stack[{1}].FloatVal );", ins.StackBefore_, ins.StackAfter_, ins.Index)); break; case SpokeInstructionType.StoreFieldString: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "]=new SpokeObject({1}.StringVal);", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1))); sb.AppendLine(string.Format("stack[{0}].Variables[{2}]=new SpokeObject(stack[{1}].StringVal );", ins.StackBefore_, ins.StackAfter_, ins.Index)); break; case SpokeInstructionType.StoreFieldMethod: case SpokeInstructionType.StoreFieldObject: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "]={1};", new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1))); sb.AppendLine(string.Format("stack[{0}].Variables[{2}]=stack[{1}];", ins.StackBefore_, ins.StackAfter_, ins.Index)); break; case SpokeInstructionType.StoreToReference: exps.Add(new PostParseStatement("{0}.Variables[" + ins.Index + "] = {1};", new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_))); sb.AppendLine(string.Format("stack[{1}].Variables[{2}] = stack[{0}];", ins.StackBefore_, ins.StackBefore_ - 1, ins.Index)); break; case SpokeInstructionType.GetField: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseStatement("{0}.Variables[" + ins.Index + "]", new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1)), true)); sb.AppendLine(string.Format("stack[{0}] = stack[{0}].Variables[{1}];", ins.StackBefore_ - 1, ins.Index)); break; case SpokeInstructionType.GetLocal: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseVariable(VariableType.Variable, ins.Index), true)); sb.AppendLine(string.Format("stack[{0}] = variables[{1}];", ins.StackBefore_, ins.Index)); break; case SpokeInstructionType.PopStack: var d = (PostParseSet)exps.Last(a => a.ExpressionType == PPExpressionType.Set); if (d.Right.ItemType == PPItemType.Variable) { d.MarkForRemoval = true; } else d.RemoveLeft = true; break; case SpokeInstructionType.Not: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseStatement("{0}.BoolVal?FALSE:TRUE", new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1)), true)); sb.AppendLine(string.Format("stack[{0}] = stack[{0}].BoolVal?FALSE:TRUE;", ins.StackBefore_ - 1)); break; case SpokeInstructionType.IntConstant: if (ins.Index >= 0 && ins.Index < 100) { exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("ints[{0}]", ins.Index)), true)); sb.AppendLine(string.Format("stack[{0}] = ints[{1}];", ins.StackBefore_, ins.Index)); } else { exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("new SpokeObject( {0} )", ins.Index)), true)); sb.AppendLine(string.Format("stack[{0}] = new SpokeObject( {1} );", ins.StackBefore_, ins.Index)); } break; case SpokeInstructionType.BoolConstant: sb.AppendLine(string.Format("stack[{0}] = {1};", ins.StackBefore_, ins.BoolVal ? "TRUE" : "FALSE")); exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(ins.BoolVal ? "TRUE" : "FALSE"), true)); break; case SpokeInstructionType.FloatConstant: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("new SpokeObject( {0}f )", ins.FloatVal)), true)); sb.AppendLine(string.Format("stack[{0}] = new SpokeObject({1}f );", ins.StackBefore_, ins.FloatVal)); break; case SpokeInstructionType.StringConstant: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString(string.Format("new SpokeObject( \"{0}\" )", ins.StringVal)), true)); sb.AppendLine(string.Format("stack[{0}] = new SpokeObject( \"{1}\" );", ins.StackBefore_, ins.StringVal)); break; case SpokeInstructionType.Null: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_), new PostParseString("NULL"), true)); sb.AppendLine(string.Format("stack[{0}] = NULL;", ins.StackBefore_)); break; case SpokeInstructionType.AddIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "intCache({0}.IntVal + {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=intCache(stack[{0}].IntVal + stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddStringInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.StringVal + {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject( stack[{0}].StringVal + stack[{1}].IntVal );", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddIntString: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.IntVal + {1}.StringVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal + stack[{1}].StringVal );", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddFloatString: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal + {1}.StringVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject( stack[{0}].FloatString + stack[{1}].StringVal );", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddStringFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.StringVal + {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].StringVal + stack[{1}].FloatVal );", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddStringString: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.StringVal + {1}.StringVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].StringVal + stack[{1}].StringVal );", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.SubtractIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "intCache({0}.IntVal - {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=intCache (stack[{0}].IntVal - stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.MultiplyIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "intCache({0}.IntVal * {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=intCache (stack[{0}].IntVal * stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.DivideIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "intCache({0}.IntVal / {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=intCache (stack[{0}].IntVal / stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal > {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal > stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal > {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal > stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal > {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal > stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal > {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal > stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal < {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal < stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal < {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal < stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal < {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal < stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal < {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal < stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterEqualIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal >= {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal >= stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterEqualIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal >= {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal >= stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterEqualFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal >= {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal >= stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.GreaterEqualFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal >= {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal >= stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessEqualIntInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal <= {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal <= stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessEqualIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.IntVal <= {1}.FloatVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].IntVal <= stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessEqualFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.FloatVal <= {1}.IntVal)?TRUE:FALSE)"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal <= stack[{1}].IntVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.LessEqualFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "({0}.FloatVal <= {1}.FloatVal)?TRUE:FALSE"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].FloatVal <= stack[{1}].FloatVal)?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.Equal: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation( new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_), "(({0}.Compare({1})?TRUE:FALSE))"), true)); sb.AppendLine(string.Format("stack[{0}]=(stack[{0}].Compare(stack[{1}]))?TRUE:FALSE;", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddToArray: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseStatement("{0}.AddArray({1})", new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_)), true)); sb.AppendLine(string.Format("stack[{0}].AddArray(stack[{1}]);", ins.StackAfter_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddRangeToArray: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseStatement("{0}.AddArrayRange({1})", new PostParseVariable(VariableType.Stack, ins.StackAfter_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_)), true)); sb.AppendLine(string.Format("stack[{0}].AddArrayRange(stack[{1}]);", ins.StackAfter_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.ArrayElem: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseStatement("{0}.ArrayItems[{1}.IntVal]", new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_)), true)); sb.AppendLine(string.Format("stack[{0}]=stack[{0}].ArrayItems[stack[{1}].IntVal];", ins.StackBefore_ - 1, ins.StackBefore_)); break; case SpokeInstructionType.StoreArrayElem: exps.Add(new PostParseStatement("{0}.ArrayItems[{1}.IntVal] = {2};", new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 2), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 3))); sb.AppendLine(string.Format("stack[{1}].ArrayItems[stack[{0}].IntVal] = stack[{2}];", ins.StackBefore_ - 1, ins.StackBefore_ - 2, ins.StackBefore_ - 3)); break; case SpokeInstructionType.AddIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.IntVal + {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal + stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal + {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal + stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.AddFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal + {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal + stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.SubtractIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.IntVal - {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal + stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.SubtractFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal - {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal -stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.SubtractFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal - {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal - stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.MultiplyIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.IntVal * {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal * stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.MultiplyFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal * {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal * stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.MultiplyFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal *{1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal + stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.DivideIntFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.IntVal / {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].IntVal / stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.DivideFloatInt: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal / {1}.IntVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal / stack[{1}].IntVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; case SpokeInstructionType.DivideFloatFloat: exps.Add(new PostParseSet(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseOperation(new PostParseVariable(VariableType.Stack, ins.StackBefore_ - 1), new PostParseVariable(VariableType.Stack, ins.StackAfter_), "new SpokeObject({0}.FloatVal / {1}.FloatVal)"), true)); sb.AppendLine(string.Format("stack[{0}]=new SpokeObject(stack[{0}].FloatVal / stack[{1}].FloatVal);", ins.StackBefore_ - 1, ins.StackAfter_)); break; default: throw new ArgumentOutOfRangeException(); } } return new Tuple<string, List<PostParseExpression>>(sb.ToString(), exps); }
private SpokeObject evaluateMethod(SpokeMethod fm, SpokeObject[] paras) { SpokeObject[] variables; #if stacktrace dfss.AppendLine( fm.Class.Name +" : : "+fm.MethodName+" Start"); #endif SpokeObject lastStack; int stackIndex = 0; SpokeObject[] stack = new SpokeObject[3000]; int index = 0; StackTracer st; if (reprintStackIndex == -1) { variables = new SpokeObject[fm.NumOfVars]; for (int i = 0; i < fm.Parameters.Length; i++) { variables[i] = paras[i]; } stackTrace.Add(st = new StackTracer(stack, variables)); } else { StackTracer rp = reprintStackTrace[stackTrace.Count]; stack = rp.StackObjects; variables = rp.StackVariables; index = rp.InstructionIndex; stackIndex = rp.StackIndex; stackTrace.Add(st = new StackTracer(stack, variables)); if (stackTrace.Count == reprintStackIndex) { stack[stackIndex++] = rp.Answer; reprintStackIndex = -1; reprintStackTrace = null; } } for (; index < fm.Instructions.Length; index++) { var ins = fm.Instructions[index]; #if stacktrace dfss.AppendLine(stackIndex + " :: " + ins.ToString()); #endif // var fs = new fixStackTracer(stackTrace.ToArray()); // stackTrace = new List<StackTracer>(fs.Start(true)); SpokeObject[] sps; SpokeObject bm; switch (ins.Type) { case SpokeInstructionType.CreateReference: stack[stackIndex++] = new SpokeObject(new SpokeObject[ins.Index], ins.StringVal); break; case SpokeInstructionType.CreateArray: stack[stackIndex++] = new SpokeObject(new List<SpokeObject>(20)); break; case SpokeInstructionType.CreateMethod: stack[stackIndex++] = NULL;//new SpokeObject(ObjectType.Method) { AnonMethod = ins.anonMethod }; break; case SpokeInstructionType.Label: // throw new NotImplementedException(""); break; case SpokeInstructionType.Goto: index = ins.Index; break; case SpokeInstructionType.Comment: break; case SpokeInstructionType.CallMethod: st.InstructionIndex = index; st.StackIndex = stackIndex; sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } stack[stackIndex++] = evaluateMethod(Methods[ins.Index], sps); break; case SpokeInstructionType.CallMethodFunc: st.InstructionIndex = index; st.StackIndex = stackIndex; sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } stack[stackIndex++] = Methods[ins.Index].MethodFunc(sps); break; case SpokeInstructionType.CallInternal: sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } st.InstructionIndex = index + 1; st.StackIndex = stackIndex; SpokeObject l = InternalMethods[ins.Index](sps); if (ins.Index == 16) { GameBoard d = buildBoard(sps[4]); throw new AskQuestionException(stackTrace, new SpokeQuestion(sps[1].Variables[0].StringVal, sps[2].StringVal, sps[3].ArrayItems.Select(a => a.StringVal).ToArray()), d); } else { stack[stackIndex++] = l; } break; case SpokeInstructionType.BreakpointInstruction: Console.WriteLine("BreakPoint"); break; case SpokeInstructionType.Return: #if stacktrace dfss.AppendLine(fm.Class.Name + " : : " + fm.MethodName + " End"); #endif stackTrace.Remove(st); return stack[--stackIndex]; break; case SpokeInstructionType.IfTrueContinueElse: if (stack[--stackIndex].BoolVal) continue; index = ins.Index; break; case SpokeInstructionType.Or: stack[stackIndex - 2] = (stack[stackIndex - 2].BoolVal || stack[stackIndex - 1].BoolVal) ? TRUE : FALSE; stackIndex--; break; case SpokeInstructionType.And: stack[stackIndex - 2] = (stack[stackIndex - 2].BoolVal && stack[stackIndex - 1].BoolVal) ? TRUE : FALSE; stackIndex--; break; case SpokeInstructionType.StoreLocalInt: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.Int) { IntVal = lastStack.IntVal }; break; case SpokeInstructionType.StoreLocalFloat: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.Float) { FloatVal = lastStack.FloatVal }; break; case SpokeInstructionType.StoreLocalBool: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = lastStack.BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.StoreLocalString: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.String) { StringVal = lastStack.StringVal }; break; case SpokeInstructionType.StoreLocalMethod: case SpokeInstructionType.StoreLocalObject: lastStack = stack[--stackIndex]; variables[ins.Index] = lastStack; break; case SpokeInstructionType.StoreLocalRef: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; bm.ClassName = lastStack.ClassName; bm.Type = lastStack.Type; //bm.Variables = lastStack.Variables; //bm.ArrayItems = lastStack.ArrayItems; bm.StringVal = lastStack.StringVal; bm.IntVal = lastStack.IntVal; bm.BoolVal = lastStack.BoolVal; bm.FloatVal = lastStack.FloatVal; break; case SpokeInstructionType.StoreFieldBool: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = stack[--stackIndex].BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.StoreFieldInt: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.Int) { IntVal = stack[--stackIndex].IntVal }; break; case SpokeInstructionType.StoreFieldFloat: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.Float) { FloatVal = stack[--stackIndex].FloatVal }; break; case SpokeInstructionType.StoreFieldString: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.String) { StringVal = stack[--stackIndex].StringVal }; break; case SpokeInstructionType.StoreFieldMethod: case SpokeInstructionType.StoreFieldObject: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = stack[--stackIndex]; break; case SpokeInstructionType.IfEqualsContinueAndPopElseGoto: if (SpokeObject.Compare(stack[stackIndex - 2], stack[stackIndex - 1])) { stackIndex = stackIndex - 2; continue; } stackIndex = stackIndex - 1; index = ins.Index; break; case SpokeInstructionType.StoreToReference: lastStack = stack[--stackIndex]; stack[stackIndex - 1].Variables[ins.Index] = lastStack; break; case SpokeInstructionType.GetField: stack[stackIndex - 1] = stack[stackIndex - 1].Variables[ins.Index]; break; case SpokeInstructionType.GetLocal: stack[stackIndex++] = variables[ins.Index]; break; case SpokeInstructionType.PopStack: stackIndex--; break; case SpokeInstructionType.Not: stack[stackIndex - 1] = stack[stackIndex - 1].BoolVal ? FALSE : TRUE; break; case SpokeInstructionType.AddStringInt: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].IntVal }; stackIndex--; break; case SpokeInstructionType.AddIntString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].IntVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.IntConstant: stack[stackIndex++] = intCache(ins.Index); break; case SpokeInstructionType.BoolConstant: stack[stackIndex++] = ins.BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.FloatConstant: stack[stackIndex++] = new SpokeObject(ObjectType.Float) { FloatVal = ins.FloatVal }; break; case SpokeInstructionType.StringConstant: stack[stackIndex++] = new SpokeObject(ObjectType.String) { StringVal = ins.StringVal }; break; case SpokeInstructionType.Null: stack[stackIndex++] = NULL; break; case SpokeInstructionType.AddIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal + stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.AddIntFloat: break; case SpokeInstructionType.AddFloatInt: break; case SpokeInstructionType.AddFloatFloat: break; case SpokeInstructionType.AddFloatString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].FloatVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.AddStringFloat: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].FloatVal }; stackIndex--; break; case SpokeInstructionType.AddStringString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.SubtractIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal - stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.SubtractIntFloat: break; case SpokeInstructionType.SubtractFloatInt: break; case SpokeInstructionType.SubtractFloatFloat: break; case SpokeInstructionType.MultiplyIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal * stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.MultiplyIntFloat: break; case SpokeInstructionType.MultiplyFloatInt: break; case SpokeInstructionType.MultiplyFloatFloat: break; case SpokeInstructionType.DivideIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal / stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.DivideIntFloat: break; case SpokeInstructionType.DivideFloatInt: break; case SpokeInstructionType.DivideFloatFloat: break; case SpokeInstructionType.GreaterIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal > stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal > stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal > stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal > stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal < stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal < stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal < stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal < stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal >= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal >= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal >= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal >= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal <= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal <= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal <= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal <= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.Equal: stack[stackIndex - 2] = SpokeObject.Compare(stack[stackIndex - 2], stack[stackIndex - 1]) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.InsertToArray: break; case SpokeInstructionType.RemoveToArray: break; case SpokeInstructionType.AddToArray: lastStack = stack[--stackIndex]; stack[stackIndex - 1].AddArray(lastStack); break; case SpokeInstructionType.AddRangeToArray: lastStack = stack[--stackIndex]; stack[stackIndex - 1].AddRangeArray(lastStack); break; case SpokeInstructionType.LengthOfArray: break; case SpokeInstructionType.ArrayElem: lastStack = stack[--stackIndex]; stack[stackIndex - 1] = stack[stackIndex - 1].ArrayItems[lastStack.IntVal]; break; case SpokeInstructionType.StoreArrayElem: var indexs = stack[--stackIndex]; var ars = stack[--stackIndex]; ars.ArrayItems[indexs.IntVal] = stack[--stackIndex]; break; default: throw new ArgumentOutOfRangeException(); } } #if stacktrace dfss.AppendLine(fm.Class.Name + " : : " + fm.MethodName + " End"); #endif stackTrace.Remove(st); return null; }
public List<SpokeClass> Run(List<Class> someClasses, List<TokenMacroPiece> tp) { allMacros_ = tp; List<SpokeClass> classes = new List<SpokeClass>(); SpokeClass cl = new SpokeClass(); classes.Add(cl); cl.Name = "Array"; cl.Methods = new List<SpokeMethod>() { new SpokeMethod() { MethodFunc = (a) => { a[0].ArrayItems.Add(a[1]); return null; }, MethodName = "add", Class = cl, returnType = new SpokeType(ObjectType.Void), Parameters = new string[]{"this","v"} },new SpokeMethod() { MethodFunc = (a) => { a[0].ArrayItems.Clear(); return null; }, MethodName = "clear", returnType = new SpokeType(ObjectType.Void), Class = cl, Parameters = new string[]{"this"} }, new SpokeMethod() { MethodFunc = (a) => new SpokeObject(a[0].ArrayItems.Count), MethodName = "length", Class = cl, returnType = new SpokeType(ObjectType.Int), Parameters = new string[]{"this"} }, new SpokeMethod() { MethodFunc = (a) => { a[0].ArrayItems.RemoveAll(b => SpokeObject.Compare(b,a[1])); return null; }, MethodName = "remove", Class = cl, returnType = new SpokeType(ObjectType.Void), Parameters = new string[]{"this","v"} },new SpokeMethod() { MethodFunc = (a) => { return a[0].ArrayItems.Last(); }, MethodName = "last", Class = cl, returnType = new SpokeType(ObjectType.Null), Parameters = new string[]{"this"} },new SpokeMethod() { MethodFunc = (a) => { return a[0].ArrayItems.First(); }, MethodName = "first", returnType = new SpokeType(ObjectType.Null), Class = cl, Parameters = new string[]{"this"} }, new SpokeMethod() { MethodFunc = (a) => { a[0].ArrayItems.Insert(a[1].IntVal, a[2]); return null; }, MethodName = "insert", Class = cl, returnType = new SpokeType(ObjectType.Void), Parameters = new string[]{"this","v","v2"} } }; foreach (var @class in someClasses) { classes.Add(cl = new SpokeClass()); cl.Variables = @class.VariableNames.ToArray(); cl.Name = @class.Name; foreach (var method in @class.Methods) { SpokeMethod me; cl.Methods.Add(me = new SpokeMethod()); me.MethodName = method.Name; me.Parameters = new string[method.paramNames.Count + 1]; me.Parameters[0] = "this"; for (int index = 0; index < method.paramNames.Count; index++) { me.Parameters[index + 1] = method.paramNames[index]; } me.Class = cl; TokenEnumerator enumerator = new TokenEnumerator(method.Lines.ToArray()); #if DEBUGs sb.AppendLine("Evaluating " + cl.Name + ": " + me.MethodName); #endif me.Lines = getLines(enumerator, 2, new evalInformation()).ToArray(); me.HasYieldReturn = linesHave(me.Lines, ISpokeLine.YieldReturn); me.HasYield = linesHave(me.Lines, ISpokeLine.Yield); me.HasReturn = linesHave(me.Lines, ISpokeLine.Return); } } return classes; }
public PrintExpressions(SpokeMethod[] cla2, bool showIndex) { myCla2 = cla2.ToDictionary(a => a.Class.Name + a.MethodName); myShowIndex = showIndex; }
private SpokeType evaluateMethod(SpokeMethod fm, SpokeType parent, SpokeType[] paras) { if (fm.Evaluated) { parent.Variables = fm.VariableRefs; return fm.returnType; } var db = anonMethodsEntered; anonMethodsEntered = new Dictionary<string, bool>(); fm.Evaluated = true; SpokeVariableInfo variables = new SpokeVariableInfo(); for (int i = 0; i < fm.Parameters.Length; i++) { variables.Add(fm.Parameters[i], paras[i], null); } var sm = new SpokeMethodParse(); sm.RunningClass = parent; sm.Method = fm; if (fm.HasYield) { sm.ForYieldArray = new SpokeType(ObjectType.Unset) { }; sm.ReturnType = new SpokeType(ObjectType.Array) { Type = ObjectType.Array, ArrayItemType = sm.ForYieldArray }; } else { sm.ReturnType = new SpokeType(ObjectType.Unset); } fm.VariableRefs = parent.Variables; var toCotninue = SpokeInstruction.ins; SpokeInstruction.Beginner(); var de = evaluateLines(ref fm.Lines, sm, variables); fm.Instructions = SpokeInstruction.Ender(); SpokeInstruction.ins = toCotninue; fm.NumOfVars = variables.index; anonMethodsEntered = db; return de; }
public PreparseInstructions(SpokeMethod[] item1) { mets = item1; preparseInstructions(mets); }
private void preparseInstructions(SpokeMethod[] mets) { foreach (var spokeMethod in mets) { Dictionary<string, int> labels = new Dictionary<string, int>(); if (spokeMethod.Instructions == null) { continue; } for (int index = 0; index < spokeMethod.Instructions.Length; index++) { var spokeInstruction = spokeMethod.Instructions[index]; if (spokeInstruction.Type == SpokeInstructionType.Label) { labels.Add(spokeInstruction.labelGuy, index); } } for (int index = 0; index < spokeMethod.Instructions.Length; index++) { var spokeInstruction = spokeMethod.Instructions[index]; if (spokeInstruction.Type == SpokeInstructionType.Goto && spokeInstruction.gotoGuy != null) { spokeInstruction.Index = labels[spokeInstruction.gotoGuy]; } if (spokeInstruction.Type == SpokeInstructionType.IfTrueContinueElse) { spokeInstruction.Index = labels[spokeInstruction.elseGuy]; } if (spokeInstruction.Type == SpokeInstructionType.IfEqualsContinueAndPopElseGoto) { spokeInstruction.Index = labels[spokeInstruction.elseGuy]; } } } StringBuilder sbw = new StringBuilder(); foreach (var spokeMethod in mets) { sbw.AppendLine("Method: " + spokeMethod.Class.Name + ":" + spokeMethod.MethodName); if (spokeMethod.Instructions == null) { continue; } //sbw.AppendLine("Variables: "); //foreach (var spokeType in spokeMethod.VariableRefs.allVariables) { // sbw.AppendLine(spokeType.Item1 + "(" + spokeType.Item2 + "): " + spokeType.Item3); //} //sbw.AppendLine(); for (int index = 0; index < spokeMethod.Instructions.Length; index++) { var spokeInstruction = spokeMethod.Instructions[index]; sbw.AppendLine(index + "\t\t\t" + spokeInstruction.ToString()); } } File.WriteAllText("C:\\spokeins.txt", sbw.ToString()); foreach (var spokeMethod in mets) { if (spokeMethod.Instructions != null) { doit(0, 0, spokeMethod.Instructions); } } var d = indexes.GroupBy(a => a.Type).Select(a => a.Key).ToArray(); }
private SpokeObject evaluateMethod(SpokeMethod fm, SpokeObject[] paras) { SpokeObject[] variables = new SpokeObject[fm.NumOfVars]; for (int i = 0; i < fm.Parameters.Length; i++) { variables[i] = paras[i]; } #if stacktrace dfss.AppendLine(fm.Class.Name + " : : " + fm.MethodName + " Start"); #endif SpokeObject lastStack; int stackIndex = 0; SpokeObject[] stack = new SpokeObject[3000]; for (int index = 0; index < fm.Instructions.Length; index++) { var ins = fm.Instructions[index]; #if stacktrace dfss.AppendLine(stackIndex + " :: " + ins.ToString()); #endif SpokeObject[] sps; SpokeObject bm; switch (ins.Type) { case SpokeInstructionType.CreateReference: stack[stackIndex++] = new SpokeObject(new SpokeObject[ins.Index]); break; case SpokeInstructionType.CreateArray: stack[stackIndex++] = new SpokeObject(new List <SpokeObject>(20)); break; case SpokeInstructionType.CreateMethod: stack[stackIndex++] = NULL; //new SpokeObject(ObjectType.Method) { AnonMethod = ins.anonMethod }; break; case SpokeInstructionType.Label: // throw new NotImplementedException(""); break; case SpokeInstructionType.Goto: index = ins.Index; break; case SpokeInstructionType.Comment: break; case SpokeInstructionType.CallMethod: sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } stack[stackIndex++] = evaluateMethod(Methods[ins.Index], sps); break; case SpokeInstructionType.CallMethodFunc: sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } stack[stackIndex++] = Methods[ins.Index].MethodFunc(sps); break; case SpokeInstructionType.CallInternal: sps = new SpokeObject[ins.Index3]; for (int i = ins.Index3 - 1; i >= 0; i--) { sps[i] = stack[--stackIndex]; } stack[stackIndex++] = InternalMethods[ins.Index](sps); break; case SpokeInstructionType.BreakpointInstruction: Console.WriteLine("BreakPoint"); break; case SpokeInstructionType.Return: #if stacktrace dfss.AppendLine(fm.Class.Name + " : : " + fm.MethodName + " End"); #endif return(stack[--stackIndex]); break; case SpokeInstructionType.IfTrueContinueElse: if (stack[--stackIndex].BoolVal) { continue; } index = ins.Index; break; case SpokeInstructionType.Or: stack[stackIndex - 2] = (stack[stackIndex - 2].BoolVal || stack[stackIndex - 1].BoolVal) ? TRUE : FALSE; stackIndex--; break; case SpokeInstructionType.And: stack[stackIndex - 2] = (stack[stackIndex - 2].BoolVal && stack[stackIndex - 1].BoolVal) ? TRUE : FALSE; stackIndex--; break; case SpokeInstructionType.StoreLocalInt: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.Int) { IntVal = lastStack.IntVal }; break; case SpokeInstructionType.StoreLocalFloat: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.Float) { FloatVal = lastStack.FloatVal }; break; case SpokeInstructionType.StoreLocalBool: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = lastStack.BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.StoreLocalString: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = new SpokeObject(ObjectType.String) { StringVal = lastStack.StringVal }; break; case SpokeInstructionType.StoreLocalMethod: case SpokeInstructionType.StoreLocalObject: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; variables[ins.Index] = lastStack; break; case SpokeInstructionType.StoreLocalRef: lastStack = stack[--stackIndex]; bm = variables[ins.Index]; bm.Variables = lastStack.Variables; bm.ArrayItems = lastStack.ArrayItems; bm.StringVal = lastStack.StringVal; bm.IntVal = lastStack.IntVal; bm.BoolVal = lastStack.BoolVal; bm.FloatVal = lastStack.FloatVal; break; case SpokeInstructionType.StoreFieldBool: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = stack[--stackIndex].BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.StoreFieldInt: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.Int) { IntVal = stack[--stackIndex].IntVal }; break; case SpokeInstructionType.StoreFieldFloat: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.Float) { FloatVal = stack[--stackIndex].FloatVal }; break; case SpokeInstructionType.StoreFieldString: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = new SpokeObject(ObjectType.String) { StringVal = stack[--stackIndex].StringVal }; break; case SpokeInstructionType.StoreFieldMethod: case SpokeInstructionType.StoreFieldObject: lastStack = stack[--stackIndex]; lastStack.Variables[ins.Index] = stack[--stackIndex]; break; case SpokeInstructionType.StoreToReference: lastStack = stack[--stackIndex]; stack[stackIndex - 1].Variables[ins.Index] = lastStack; break; case SpokeInstructionType.GetField: stack[stackIndex - 1] = stack[stackIndex - 1].Variables[ins.Index]; break; case SpokeInstructionType.GetLocal: stack[stackIndex++] = variables[ins.Index]; break; case SpokeInstructionType.PopStack: stackIndex--; break; case SpokeInstructionType.Not: stack[stackIndex - 1] = stack[stackIndex - 1].BoolVal ? FALSE : TRUE; break; case SpokeInstructionType.AddStringInt: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].IntVal }; stackIndex--; break; case SpokeInstructionType.AddIntString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].IntVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.IntConstant: stack[stackIndex++] = intCache(ins.Index); break; case SpokeInstructionType.BoolConstant: stack[stackIndex++] = ins.BoolVal ? TRUE : FALSE; break; case SpokeInstructionType.FloatConstant: stack[stackIndex++] = new SpokeObject(ObjectType.Float) { FloatVal = ins.FloatVal }; break; case SpokeInstructionType.StringConstant: stack[stackIndex++] = new SpokeObject(ObjectType.String) { StringVal = ins.StringVal }; break; case SpokeInstructionType.Null: stack[stackIndex++] = NULL; break; case SpokeInstructionType.AddIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal + stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.AddIntFloat: break; case SpokeInstructionType.AddFloatInt: break; case SpokeInstructionType.AddFloatFloat: break; case SpokeInstructionType.AddFloatString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].FloatVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.AddStringFloat: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].FloatVal }; stackIndex--; break; case SpokeInstructionType.AddStringString: stack[stackIndex - 2] = new SpokeObject(ObjectType.String) { StringVal = stack[stackIndex - 2].StringVal + stack[stackIndex - 1].StringVal }; stackIndex--; break; case SpokeInstructionType.SubtractIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal - stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.SubtractIntFloat: break; case SpokeInstructionType.SubtractFloatInt: break; case SpokeInstructionType.SubtractFloatFloat: break; case SpokeInstructionType.MultiplyIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal * stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.MultiplyIntFloat: break; case SpokeInstructionType.MultiplyFloatInt: break; case SpokeInstructionType.MultiplyFloatFloat: break; case SpokeInstructionType.DivideIntInt: stack[stackIndex - 2] = intCache(stack[stackIndex - 2].IntVal / stack[stackIndex - 1].IntVal); stackIndex--; break; case SpokeInstructionType.DivideIntFloat: break; case SpokeInstructionType.DivideFloatInt: break; case SpokeInstructionType.DivideFloatFloat: break; case SpokeInstructionType.GreaterIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal > stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal > stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal > stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal > stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal < stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal < stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal < stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal < stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal >= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal >= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal >= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.GreaterEqualFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal >= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualIntInt: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal <= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualIntFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].IntVal <= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualFloatInt: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal <= stack[stackIndex - 1].IntVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.LessEqualFloatFloat: stack[stackIndex - 2] = (stack[stackIndex - 2].FloatVal <= stack[stackIndex - 1].FloatVal) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.Equal: stack[stackIndex - 2] = SpokeObject.Compare(stack[stackIndex - 2], stack[stackIndex - 1]) ? TRUE : FALSE; stackIndex = stackIndex - 1; break; case SpokeInstructionType.InsertToArray: break; case SpokeInstructionType.RemoveToArray: break; case SpokeInstructionType.AddToArray: lastStack = stack[--stackIndex]; stack[stackIndex - 1].AddArray(lastStack); break; case SpokeInstructionType.AddRangeToArray: lastStack = stack[--stackIndex]; stack[stackIndex - 1].AddRangeArray(lastStack); break; case SpokeInstructionType.LengthOfArray: break; case SpokeInstructionType.ArrayElem: lastStack = stack[--stackIndex]; stack[stackIndex - 1] = stack[stackIndex - 1].ArrayItems[lastStack.IntVal]; break; case SpokeInstructionType.StoreArrayElem: var indexs = stack[--stackIndex]; var ars = stack[--stackIndex]; ars.ArrayItems[indexs.IntVal] = stack[--stackIndex]; break; default: throw new ArgumentOutOfRangeException(); } } #if stacktrace dfss.AppendLine(fm.Class.Name + " : : " + fm.MethodName + " End"); #endif return(null); }