Пример #1
0
 static void HandlePrim(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     if (vm.GetCurrentCache () == null) {
         var udpName = (string)instruction.Arguments;
         vm.SetCurrentCache (Value.Make (GetUdpByName (vm, udpName)));
     }
     vm.stack.Push ((Value)vm.GetCurrentCache ());
     vm.IncrementTicks (1);
     vm.programCounter++;
 }
Пример #2
0
 static void HandleNot(Vm vm)
 {
     Prim0.LogicalNot (vm.api, ref vm.stack.Storage [vm.stack.Count - 1]);
     vm.programCounter++;
 }
Пример #3
0
 static void HandlePopBlock(Vm vm)
 {
     var returnValue = vm.stack.PopTop ();
     var namedBlock = vm.stack.PopTop ();
     if (namedBlock.Kind != Value.Kinds.NamedBlock) {
         vm.RaiseShovelError ("Invalid context for POP_BLOCK.");
     }
     vm.stack.Push (returnValue);
     vm.programCounter++;
 }
Пример #4
0
 static void HandleLte(Vm vm)
 {
     var start = vm.stack.Count - 2;
     Prim0.LessThanOrEqual (vm.api, ref vm.stack.Storage [start], ref vm.stack.Storage [start + 1]);
     vm.stack.Pop ();
     vm.programCounter++;
 }
Пример #5
0
 static void HandleNewFrame(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var args = (string[])instruction.Arguments;
     var frame = new VmEnvFrame () {
         VarNames = args,
         Values = new Value[args.Length],
         IntroducedAtProgramCounter = vm.programCounter
     };
     var newEnv = new VmEnvironment () {
         Frame = frame,
         Next = vm.currentEnvironment
     };
     vm.currentEnvironment = newEnv;
     vm.IncrementCells (args.Length * 3 + 5);
     vm.programCounter++;
 }
Пример #6
0
 static void HandleKeys(Vm vm)
 {
     Prim0.Keys (vm.api, ref vm.stack.Storage [vm.stack.Count - 1]);
     vm.programCounter++;
 }
Пример #7
0
 static void HandleLget(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var args = (int[])instruction.Arguments;
     vm.stack.Push (FindFrame (vm.currentEnvironment, args [0]).Values [args [1]]);
     vm.IncrementCells (1);
     vm.programCounter++;
 }
Пример #8
0
 static void HandleCallj(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var numArgs = (int)instruction.Arguments;
     Vm.HandleCallImpl (vm, numArgs, false);
 }
Пример #9
0
 static void HandleConst(Vm vm)
 {
     vm.stack.Push ((Value)vm.CurrentInstruction ().Arguments);
     vm.programCounter++;
     vm.IncrementCells (1);
 }
Пример #10
0
 static void HandleBlockReturn(Vm vm)
 {
     var returnValue = vm.stack.PopTop ();
     var name = vm.stack.PopTop ();
     if (name.Kind != Value.Kinds.String) {
         vm.RaiseShovelError ("The name of a block must be a string.");
     }
     var namedBlockIndex = vm.FindNamedBlock (name.stringValue);
     if (vm.stack.Count > namedBlockIndex + 1) {
         vm.stack.RemoveRange (namedBlockIndex + 1, vm.stack.Count - namedBlockIndex - 1);
     }
     var namedBlock = vm.stack.Top ().NamedBlockValue;
     vm.stack.Push (returnValue);
     vm.programCounter = namedBlock.BlockEnd;
     vm.currentEnvironment = namedBlock.Environment;
 }
Пример #11
0
 static void HandleCallImpl(Vm vm, int numArgs, bool saveReturnAddress, bool inApply = false)
 {
     var maybeCallable = vm.stack.Top ();
     if (maybeCallable.Kind != Value.Kinds.Callable) {
         vm.RaiseShovelError (String.Format (
             "Object [{0}] is not callable.", Prim0.ShovelStringRepresentation (vm.api, maybeCallable))
         );
     }
     var callable = maybeCallable.CallableValue;
     if (callable.ProgramCounter.HasValue) {
         vm.stack.Pop ();
         CallFunction (callable, vm, numArgs, saveReturnAddress, inApply);
         if (saveReturnAddress) {
             vm.IncrementCells (1);
         }
     } else {
         CallPrimitive (callable, vm, numArgs, saveReturnAddress, inApply);
     }
 }
Пример #12
0
 static void HandleBlock(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var blockEnd = (int)instruction.Arguments;
     var name = vm.stack.PopTop ();
     if (name.Kind != Value.Kinds.String) {
         vm.RaiseShovelError ("The name of a block must be a string.");
     }
     vm.stack.Push (Value.Make (new NamedBlock () {
         Name = name.stringValue,
         BlockEnd = blockEnd,
         Environment = vm.currentEnvironment
     }
     )
     );
     vm.IncrementCells (3);
     vm.programCounter++;
 }
Пример #13
0
 static void HandleArgs3(Vm vm)
 {
     if (vm.stack.TopIsReturnAddress ()) {
         vm.currentEnvironment.Frame.Values [0] = vm.stack.UnderTop (3);
         vm.currentEnvironment.Frame.Values [1] = vm.stack.UnderTop (2);
         vm.currentEnvironment.Frame.Values [2] = vm.stack.UnderTop (1);
         vm.stack.UnderPopAndCopyTop (3);
     } else {
         vm.currentEnvironment.Frame.Values [2] = vm.stack.PopTop ();
         vm.currentEnvironment.Frame.Values [1] = vm.stack.PopTop ();
         vm.currentEnvironment.Frame.Values [0] = vm.stack.PopTop ();
     }
     vm.programCounter++;
 }
Пример #14
0
 static void HandleArgs(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var argCount = (int)instruction.Arguments;
     if (argCount > 0) {
         Value? returnAddress = null;
         if (vm.stack.Top ().Kind == Value.Kinds.ReturnAddress) {
             returnAddress = vm.stack.PopTop ();
         }
         var values = vm.currentEnvironment.Frame.Values;
         Array.Copy (
             vm.stack.Storage, vm.stack.Count - argCount,
             values, 0, argCount);
         vm.stack.PopMany (argCount);
         if (returnAddress.HasValue) {
             vm.stack.Push (returnAddress.Value);
         }
     }
     vm.programCounter++;
 }
Пример #15
0
 public static Exception VmUserDefinedPrimitiveError(Shovel.Vm.Vm vm)
 {
     return(vm.UserDefinedPrimitiveError);
 }
Пример #16
0
 static void HandleContext(Vm vm)
 {
     var stackTraceSb = new StringBuilder ();
     vm.WriteStackTrace (stackTraceSb);
     var stackTrace = stackTraceSb.ToString ();
     var currentEnvironmentSb = new StringBuilder ();
     vm.WriteCurrentEnvironment (currentEnvironmentSb);
     var currentEnvironment = currentEnvironmentSb.ToString ();
     var result = new HashInstance ();
     result.Add (Value.Make ("stack"), Value.Make (stackTrace));
     result.Add (Value.Make ("environment"), Value.Make (currentEnvironment));
     vm.IncrementCells (6 + stackTrace.Length + currentEnvironment.Length);
     vm.stack.Push (Value.Make (result));
     vm.programCounter ++;
     return;
 }
Пример #17
0
 static void HandleJump(Vm vm)
 {
     vm.programCounter = (int)vm.CurrentInstruction ().Arguments;
 }
Пример #18
0
 static void HandleDelete(Vm vm)
 {
     var start = vm.stack.Count - 2;
     Prim0.DeleteDictionary (vm.api, ref vm.stack.Storage [start], ref vm.stack.Storage [start + 1]);
     vm.stack.Pop ();
     vm.programCounter++;
 }
Пример #19
0
 static void HandleLen(Vm vm)
 {
     Prim0.GetLength (vm.api, ref vm.stack.Storage [vm.stack.Count - 1]);
     vm.programCounter++;
 }
Пример #20
0
 static void HandleDropFrame(Vm vm)
 {
     vm.currentEnvironment = vm.currentEnvironment.Next;
     vm.programCounter++;
 }
Пример #21
0
 static void HandleLset(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var args = (int[])instruction.Arguments;
     SetInEnvironment (vm.currentEnvironment, args [0], args [1], vm.stack.Top ());
     vm.programCounter++;
 }
Пример #22
0
 static void HandleFjump(Vm vm)
 {
     var args = (int)vm.CurrentInstruction ().Arguments;
     //            vm.CheckBool ();
     if (!vm.stack.PopTop ().boolValue) {
         vm.programCounter = args;
     } else {
         vm.programCounter ++;
     }
 }
Пример #23
0
 static void HandleNeg(Vm vm)
 {
     Prim0.UnaryMinus (vm.api, ref vm.stack.Storage [vm.stack.Count - 1]);
     vm.programCounter++;
 }
Пример #24
0
 static void HandleFn(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     var args = (int[])instruction.Arguments;
     var arity = args[1];
     var hasCollectParameters = arity >= Callable.CollectParamsArityModifier;
     if (hasCollectParameters)
     {
         arity -= Callable.CollectParamsArityModifier;
     }
     var callable = new Callable () {
         ProgramCounter = args[0],
         Arity = arity,
         HasCollectParams = hasCollectParameters,
         Environment = vm.currentEnvironment
     };
     vm.stack.Push (Value.Make (callable));
     vm.IncrementCells (5);
     vm.programCounter++;
 }
Пример #25
0
 static void HandleNop(Vm vm)
 {
     vm.programCounter++;
 }
Пример #26
0
 static void HandleGrefDot(Vm vm)
 {
     var start = vm.stack.Count - 2;
     var callGetter = !Prim0.HashOrStructGetDot (vm, vm.api, ref vm.stack.Storage [start], ref vm.stack.Storage [start + 1]);
     if (callGetter)
     {
         var obj = vm.stack.Storage[start];
         if (obj.Kind == Value.Kinds.Hash) {
             vm.stack.Push(obj.hashValue.IndirectGet);
             HandleCallImpl(vm, 2, true);
         }
     } else {
         vm.stack.Pop ();
         vm.programCounter++;
     }
 }
Пример #27
0
 static void HandlePop(Vm vm)
 {
     vm.stack.Pop ();
     vm.programCounter++;
 }
Пример #28
0
 static void HandleIsStruct(Vm vm)
 {
     Prim0.IsStruct (vm.api, ref vm.stack.Storage [vm.stack.Count - 1]);
     vm.programCounter++;
 }
Пример #29
0
 static void HandlePow(Vm vm)
 {
     var start = vm.stack.Count - 2;
     Prim0.Pow (vm.api, ref vm.stack.Storage [start], ref vm.stack.Storage [start + 1]);
     vm.stack.Pop ();
     vm.programCounter++;
 }
Пример #30
0
 static void HandleIsStructInstance(Vm vm)
 {
     var start = vm.stack.Count - 2;
     Prim0.IsStructInstance (vm.api, ref vm.stack.Storage [start], ref vm.stack.Storage [start + 1]);
     vm.stack.Pop ();
     vm.programCounter++;
 }
Пример #31
0
 static void HandlePrim0(Vm vm)
 {
     var instruction = vm.CurrentInstruction ();
     if (vm.GetCurrentCache () == null) {
         var primName = (string)instruction.Arguments;
         if (!Vm.Prim0Hash.ContainsKey (primName)) {
             vm.RaiseShovelError (String.Format (
                 "Cannot take address of primitive '{0}' (implemented as instruction).",
                 primName)
             );
         }
         vm.SetCurrentCache (Value.Make (Vm.Prim0Hash [primName]));
     }
     vm.stack.Push ((Value)vm.GetCurrentCache ());
     vm.IncrementTicks (1);
     vm.programCounter++;
 }
Пример #32
0
 public static ShovelException VmProgrammingError(Shovel.Vm.Vm vm)
 {
     return(vm.ProgrammingError);
 }