// Creates a new instance of the given [classObj]. public ObjInstance(ObjClass classObj) { Fields = new Value[classObj.NumFields]; // Initialize fields to null. for (int i = 0; i < classObj.NumFields; i++) { Fields[i] = Value.Null; } ClassObj = classObj; }
// Makes [superclass] the superclass of [subclass], and causes subclass to // inherit its methods. This should be called before any methods are defined // on subclass. public void BindSuperclass(ObjClass sc) { if (sc == null) { throw new Exception("Must have superclass."); } Superclass = sc; // Include the superclass in the total number of fields. NumFields += sc.NumFields; // Inherit methods from its superclass. Methods = new Method[sc.Methods.Length]; sc.Methods.CopyTo(Methods, 0); }
// Makes [superclass] the superclass of [subclass], and causes subclass to // inherit its methods. This should be called before any methods are defined // on subclass. public void BindSuperclass(ObjClass sc) { if (sc == null) { throw new Exception("Must have superclass."); } Superclass = sc; // Include the superclass in the total number of fields. NumFields += sc.NumFields; // Inherit methods from its superclass. Methods = new Method[sc.Methods.Length]; sc.Methods.CopyTo(Methods, 0); }
// Defines [methodValue] as a method on [classObj]. private static Value BindMethod(MethodType methodType, int symbol, ObjClass classObj, Value methodContainer) { ObjFn methodFn = methodContainer.Obj as ObjFn ?? ((ObjClosure)methodContainer.Obj).Function; // Methods are always bound against the class, and not the metaclass, even // for static methods, because static methods don't have instance fields // anyway. Compiler.BindMethodCode(classObj, methodFn); Method method = new Method { mType = MethodType.Block, obj = methodContainer.Obj }; if (methodType == MethodType.Static) classObj = classObj.ClassObj; //classObj.Methods[symbol] = method; classObj.BindMethod(symbol, method); return new Value (ValueType.Null); }
// Creates a new class object as well as its associated metaclass. public ObjClass(ObjClass superclass, int numFields, ObjString name) { Methods = new Method[InitialMethodSize]; Superclass = superclass; NumFields = numFields; Name = name; // Create the metaclass. ObjString metaclassName = new ObjString(name + " metaclass"); ObjClass metaclass = new ObjClass(0, metaclassName) { ClassObj = ClassClass }; // Metaclasses always inherit Class and do not parallel the non-metaclass // hierarchy. metaclass.BindSuperclass(ClassClass); ClassObj = metaclass; BindSuperclass(superclass); }
// Makes [superclass] the superclass of [subclass], and causes subclass to // inherit its methods. This should be called before any methods are defined // on subclass. public void BindSuperclass(ObjClass sc) { if (sc == null) { throw new Exception("Must have superclass."); } Superclass = sc; // Include the superclass in the total number of fields. NumFields += sc.NumFields; // Inherit methods from its superclass. //foreach (KeyValuePair<int, Method> m in sc.Methods) //{ // BindMethod(m.Key, m.Value); //} Methods = new Method[sc.Methods.Length]; sc.Methods.CopyTo(Methods,0); }
// Creates a new class object as well as its associated metaclass. public ObjClass(ObjClass superclass, int numFields, ObjString name) { Methods = new Method[InitialMethodSize]; Superclass = superclass; NumFields = numFields; Name = name; // Create the metaclass. ObjString metaclassName = new ObjString(name + " metaclass"); ObjClass metaclass = new ObjClass(0, metaclassName) { ClassObj = ClassClass }; // Metaclasses always inherit Class and do not parallel the non-metaclass // hierarchy. metaclass.BindSuperclass(ClassClass); ClassObj = metaclass; BindSuperclass(superclass); }
public void Primitive(ObjClass objClass, string s, Primitive func) { if (!MethodNames.Contains(s)) { MethodNames.Add(s); } int symbol = MethodNames.IndexOf(s); objClass.BindMethod(symbol, new Method { Primitive = func, MType = MethodType.Primitive }); }
// Defines [methodValue] as a method on [classObj]. private static bool BindMethod(bool isStatic, int symbol, ObjClass classObj, Obj methodContainer) { // If we are binding a foreign method, just return, as this will be handled later if (methodContainer is ObjString) return true; ObjFn methodFn = methodContainer as ObjFn ?? ((ObjClosure)methodContainer).Function; Method method = new Method { MType = MethodType.Block, Obj = methodContainer }; if (isStatic) classObj = classObj.ClassObj; // Methods are always bound against the class, and not the metaclass, even // for static methods, because static methods don't have instance fields // anyway. Compiler.BindMethodCode(classObj, methodFn); classObj.BindMethod(symbol, method); return true; }
// The main bytecode interpreter loop. This is where the magic happens. It is // also, as you can imagine, highly performance critical. Returns `true` if the // fiber completed without error. private bool RunInterpreter() { /* Load Frame */ CallFrame frame = Fiber.Frames[Fiber.NumFrames - 1]; int ip = frame.Ip; int stackStart = frame.StackStart; Obj[] stack = Fiber.Stack; ObjFn fn = frame.Fn as ObjFn ?? ((ObjClosure)frame.Fn).Function; byte[] bytecode = fn.Bytecode; while (true) { Instruction instruction = (Instruction)bytecode[ip++]; int index; switch (instruction) { case Instruction.LOAD_LOCAL_0: case Instruction.LOAD_LOCAL_1: case Instruction.LOAD_LOCAL_2: case Instruction.LOAD_LOCAL_3: case Instruction.LOAD_LOCAL_4: case Instruction.LOAD_LOCAL_5: case Instruction.LOAD_LOCAL_6: case Instruction.LOAD_LOCAL_7: case Instruction.LOAD_LOCAL_8: { index = stackStart + instruction - Instruction.LOAD_LOCAL_0; if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = stack[index]; break; } case Instruction.LOAD_LOCAL: { index = stackStart + bytecode[ip++]; if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = stack[index]; break; } case Instruction.LOAD_FIELD_THIS: { byte field = bytecode[ip++]; ObjInstance instance = (ObjInstance)stack[stackStart]; if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = instance.Fields[field]; break; } case Instruction.POP: { Fiber.StackTop--; break; } case Instruction.DUP: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop] = stack[Fiber.StackTop - 1]; Fiber.StackTop++; break; } case Instruction.NULL: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = Obj.Null; break; } case Instruction.FALSE: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = Obj.False; break; } case Instruction.TRUE: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = Obj.True; break; } case Instruction.CALL_0: case Instruction.CALL_1: case Instruction.CALL_2: case Instruction.CALL_3: case Instruction.CALL_4: case Instruction.CALL_5: case Instruction.CALL_6: case Instruction.CALL_7: case Instruction.CALL_8: case Instruction.CALL_9: case Instruction.CALL_10: case Instruction.CALL_11: case Instruction.CALL_12: case Instruction.CALL_13: case Instruction.CALL_14: case Instruction.CALL_15: case Instruction.CALL_16: // Handle Super calls case Instruction.SUPER_0: case Instruction.SUPER_1: case Instruction.SUPER_2: case Instruction.SUPER_3: case Instruction.SUPER_4: case Instruction.SUPER_5: case Instruction.SUPER_6: case Instruction.SUPER_7: case Instruction.SUPER_8: case Instruction.SUPER_9: case Instruction.SUPER_10: case Instruction.SUPER_11: case Instruction.SUPER_12: case Instruction.SUPER_13: case Instruction.SUPER_14: case Instruction.SUPER_15: case Instruction.SUPER_16: { int numArgs = instruction - (instruction >= Instruction.SUPER_0 ? Instruction.SUPER_0 : Instruction.CALL_0) + 1; int symbol = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += 2; // The receiver is the first argument. int argStart = Fiber.StackTop - numArgs; Obj receiver = stack[argStart]; ObjClass classObj; if (instruction < Instruction.SUPER_0) { if (receiver.Type == ObjType.Obj) classObj = receiver.ClassObj; else if (receiver.Type == ObjType.Num) classObj = NumClass; else if (receiver == Obj.True || receiver == Obj.False) classObj = BoolClass; else classObj = NullClass; } else { // The superclass is stored in a constant. classObj = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]] as ObjClass; ip += 2; } // If the class's method table doesn't include the symbol, bail. Method method = symbol < classObj.Methods.Length ? classObj.Methods[symbol] : null; if (method == null) { /* Method not found */ frame.Ip = ip; MethodNotFound(this, classObj, symbol); if (!HandleRuntimeError()) return false; frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } if (method.MType == MethodType.Primitive) { // After calling this, the result will be in the first arg slot. if (method.Primitive(this, stack, argStart)) { Fiber.StackTop = argStart + 1; } else { frame.Ip = ip; if (Fiber.Error != null && Fiber.Error != Obj.Null) { if (!HandleRuntimeError()) return false; } else { // If we don't have a fiber to switch to, stop interpreting. if (stack[argStart] == Obj.Null) return true; Fiber = stack[argStart] as ObjFiber; if (Fiber == null) return false; } /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; } break; } frame.Ip = ip; if (method.MType == MethodType.Block) { receiver = method.Obj; } else if (!CheckArity(stack, numArgs, argStart)) { if (!HandleRuntimeError()) return false; frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } Fiber.Frames.Add(frame = new CallFrame { Fn = receiver, StackStart = argStart, Ip = 0 }); Fiber.NumFrames++; /* Load Frame */ ip = 0; stackStart = argStart; fn = (receiver as ObjFn) ?? (receiver as ObjClosure).Function; bytecode = fn.Bytecode; break; } case Instruction.STORE_LOCAL: { index = stackStart + bytecode[ip++]; stack[index] = stack[Fiber.StackTop - 1]; break; } case Instruction.CONSTANT: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]]; ip += 2; break; } case Instruction.LOAD_UPVALUE: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = ((ObjClosure)frame.Fn).Upvalues[bytecode[ip++]].Container; break; } case Instruction.STORE_UPVALUE: { ObjUpvalue[] upvalues = ((ObjClosure)frame.Fn).Upvalues; upvalues[bytecode[ip++]].Container = stack[Fiber.StackTop - 1]; break; } case Instruction.LOAD_MODULE_VAR: { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = fn.Module.Variables[(bytecode[ip] << 8) + bytecode[ip + 1]].Container; ip += 2; break; } case Instruction.STORE_MODULE_VAR: { fn.Module.Variables[(bytecode[ip] << 8) + bytecode[ip + 1]].Container = stack[Fiber.StackTop - 1]; ip += 2; break; } case Instruction.STORE_FIELD_THIS: { byte field = bytecode[ip++]; ObjInstance instance = (ObjInstance)stack[stackStart]; instance.Fields[field] = stack[Fiber.StackTop - 1]; break; } case Instruction.LOAD_FIELD: { byte field = bytecode[ip++]; ObjInstance instance = (ObjInstance)stack[--Fiber.StackTop]; if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = instance.Fields[field]; break; } case Instruction.STORE_FIELD: { byte field = bytecode[ip++]; ObjInstance instance = (ObjInstance)stack[--Fiber.StackTop]; instance.Fields[field] = stack[Fiber.StackTop - 1]; break; } case Instruction.JUMP: { int offset = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += offset + 2; break; } case Instruction.LOOP: { // Jump back to the top of the loop. int offset = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += 2; ip -= offset; break; } case Instruction.JUMP_IF: { int offset = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += 2; Obj condition = stack[--Fiber.StackTop]; if (condition == Obj.False || condition == Obj.Null) ip += offset; break; } case Instruction.AND: case Instruction.OR: { int offset = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += 2; Obj condition = stack[Fiber.StackTop - 1]; if ((condition == Obj.Null || condition == Obj.False) ^ instruction == Instruction.OR) ip += offset; else Fiber.StackTop--; break; } case Instruction.CLOSE_UPVALUE: { Fiber.CloseUpvalue(); Fiber.StackTop--; break; } case Instruction.RETURN: { Fiber.Frames.RemoveAt(--Fiber.NumFrames); Obj result = stack[--Fiber.StackTop]; // Close any upvalues still in scope. if (Fiber.StackTop > stackStart) { while (Fiber.OpenUpvalues != null && Fiber.OpenUpvalues.Index >= stackStart) { Fiber.CloseUpvalue(); } } // If the fiber is complete, end it. if (Fiber.NumFrames == 0) { // If this is the main fiber, we're done. if (Fiber.Caller == null) return true; // We have a calling fiber to resume. Fiber = Fiber.Caller; stack = Fiber.Stack; // Store the result in the resuming fiber. stack[Fiber.StackTop - 1] = result; } else { // Discard the stack slots for the call frame (leaving one slot for the result). Fiber.StackTop = stackStart + 1; // Store the result of the block in the first slot, which is where the // caller expects it. stack[stackStart] = result; } /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; fn = frame.Fn as ObjFn ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } case Instruction.CLOSURE: { ObjFn prototype = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]] as ObjFn; ip += 2; // Create the closure and push it on the stack before creating upvalues // so that it doesn't get collected. ObjClosure closure = new ObjClosure(prototype); if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = closure; // Capture upvalues. for (int i = 0; i < prototype.NumUpvalues; i++) { byte isLocal = bytecode[ip++]; index = bytecode[ip++]; if (isLocal > 0) { // Make an new upvalue to close over the parent's local variable. closure.Upvalues[i] = Fiber.CaptureUpvalue(stackStart + index); } else { // Use the same upvalue as the current call frame. closure.Upvalues[i] = ((ObjClosure)frame.Fn).Upvalues[index]; } } break; } case Instruction.CLASS: { Obj name = stack[Fiber.StackTop - 2]; ObjClass superclass = stack[Fiber.StackTop - 1] as ObjClass; Obj error = ValidateSuperclass(name, stack[Fiber.StackTop - 1]); if (error != null) { Fiber.Error = error; frame.Ip = ip; if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } int numFields = bytecode[ip++]; Obj classObj = new ObjClass(superclass, numFields, name as ObjString); // Don't pop the superclass and name off the stack until the subclass is // done being created, to make sure it doesn't get collected. Fiber.StackTop -= 2; // Now that we know the total number of fields, make sure we don't overflow. if (superclass.NumFields + numFields <= Compiler.MaxFields) { stack[Fiber.StackTop++] = classObj; break; } // Overflow handling frame.Ip = ip; Fiber.Error = Obj.MakeString(string.Format("Class '{0}' may not have more than 255 fields, including inherited ones.", name)); if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } case Instruction.METHOD_INSTANCE: case Instruction.METHOD_STATIC: { int symbol = (bytecode[ip] << 8) + bytecode[ip + 1]; ip += 2; ObjClass classObj = stack[Fiber.StackTop - 1] as ObjClass; Obj method = stack[Fiber.StackTop - 2]; bool isStatic = instruction == Instruction.METHOD_STATIC; if (!BindMethod(isStatic, symbol, classObj, method)) { frame.Ip = ip; Fiber.Error = Obj.MakeString("Error while binding method"); if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } Fiber.StackTop -= 2; break; } case Instruction.LOAD_MODULE: { Obj name = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]]; ip += 2; Obj result = ImportModule(name); // If it returned a string, it was an error message. if ((result is ObjString)) { frame.Ip = ip; Fiber.Error = result; if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } // Make a slot that the module's fiber can use to store its result in. // It ends up getting discarded, but CODE_RETURN expects to be able to // place a value there. if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = Obj.Null; // If it returned a fiber to execute the module body, switch to it. if (result is ObjFiber) { // Return to this module when that one is done. (result as ObjFiber).Caller = Fiber; frame.Ip = ip; Fiber = (result as ObjFiber); /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; } break; } case Instruction.IMPORT_VARIABLE: { Obj module = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]]; ip += 2; Obj variable = fn.Constants[(bytecode[ip] << 8) + bytecode[ip + 1]]; ip += 2; Obj result; if (ImportVariable(module, variable, out result)) { if (Fiber.StackTop >= Fiber.Capacity) stack = Fiber.IncreaseStack(); stack[Fiber.StackTop++] = result; } else { frame.Ip = ip; Fiber.Error = result; if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; } break; } case Instruction.CONSTRUCT: { int stackPosition = Fiber.StackTop - 1 + (Instruction.CALL_0 - (Instruction)bytecode[ip]); ObjClass v = stack[stackPosition] as ObjClass; if (v == null) { Fiber.Error = Obj.MakeString("'this' should be a class."); if (!HandleRuntimeError()) return false; /* Load Frame */ frame = Fiber.Frames[Fiber.NumFrames - 1]; ip = frame.Ip; stackStart = frame.StackStart; stack = Fiber.Stack; fn = (frame.Fn as ObjFn) ?? (frame.Fn as ObjClosure).Function; bytecode = fn.Bytecode; break; } stack[stackPosition] = new ObjInstance(v); } break; case Instruction.FOREIGN_CLASS: // Not yet implemented break; case Instruction.FOREIGN_CONSTRUCT: // Not yet implemented break; case Instruction.END: // A CODE_END should always be preceded by a CODE_RETURN. If we get here, // the compiler generated wrong code. return false; } } // We should only exit this function from an explicit return from CODE_RETURN // or a runtime error. }
// Creates a string containing an appropriate method not found error for a // method with [symbol] on [classObj]. static void MethodNotFound(WrenVM vm, ObjClass classObj, int symbol) { vm.Fiber.Error = Obj.MakeString(string.Format("{0} does not implement '{1}'.", classObj.Name, vm.MethodNames[symbol])); }
public void Call(ObjClass objClass, string s) { if (!MethodNames.Contains(s)) { MethodNames.Add(s); } int symbol = MethodNames.IndexOf(s); objClass.BindMethod(symbol, new Method { MType = MethodType.Call }); }
// Creates either the Object or Class class in the core library with [name]. static ObjClass DefineClass(WrenVM vm, string name) { ObjString nameString = new ObjString(name); ObjClass classObj = new ObjClass(0, nameString); vm.DefineVariable(null, name, classObj); return classObj; }
public static void BindMethodCode(ObjClass classObj, ObjFn fn) { int ip = 0; for (; ; ) { Instruction instruction = (Instruction)fn.Bytecode[ip++]; switch (instruction) { case Instruction.LOAD_FIELD: case Instruction.STORE_FIELD: case Instruction.LOAD_FIELD_THIS: case Instruction.STORE_FIELD_THIS: // Shift this class's fields down past the inherited ones. We don't // check for overflow here because we'll see if the number of fields // overflows when the subclass is created. fn.Bytecode[ip++] += (byte)classObj.Superclass.NumFields; break; case Instruction.SUPER_0: case Instruction.SUPER_1: case Instruction.SUPER_2: case Instruction.SUPER_3: case Instruction.SUPER_4: case Instruction.SUPER_5: case Instruction.SUPER_6: case Instruction.SUPER_7: case Instruction.SUPER_8: case Instruction.SUPER_9: case Instruction.SUPER_10: case Instruction.SUPER_11: case Instruction.SUPER_12: case Instruction.SUPER_13: case Instruction.SUPER_14: case Instruction.SUPER_15: case Instruction.SUPER_16: { // Skip over the symbol. ip += 2; // Fill in the constant slot with a reference to the superclass. int constant = (fn.Bytecode[ip] << 8) | fn.Bytecode[ip + 1]; fn.Constants[constant] = classObj.Superclass; break; } case Instruction.CLOSURE: { // Bind the nested closure too. int constant = (fn.Bytecode[ip] << 8) | fn.Bytecode[ip + 1]; BindMethodCode(classObj, fn.Constants[constant] as ObjFn); ip += GetNumArguments(fn.Bytecode, new List<Obj>(fn.Constants), ip - 1); break; } case Instruction.END: return; default: // Other instructions are unaffected, so just skip over them. ip += GetNumArguments(fn.Bytecode, new List<Obj>(fn.Constants), ip - 1); break; } } }
// Creates a string containing an appropriate method not found error for a // method with [symbol] on [classObj]. static Value MethodNotFound(WrenVM vm, ObjClass classObj, int symbol) { return new Value(string.Format("{0} does not implement '{1}'.", classObj.Name, vm.MethodNames[symbol])); }