public IodineModule(string name)
: base(ModuleTypeDef)
{
Name = name;
Initializer = new IodineMethod (this, "__init__", false, 0, 0);
Attributes ["__init__"] = Initializer;
}
public void SetAttribute(string name, IodineObject value)
{
if (value is IodineMethod)
{
IodineMethod method = (IodineMethod)value;
Attributes [name] = new IodineBoundMethod(this, method);
}
else if (value is BuiltinMethodCallback)
{
BuiltinMethodCallback callback = (BuiltinMethodCallback)value;
callback.Self = this;
Attributes [name] = value;
}
else if (value is IodineBoundMethod)
{
IodineBoundMethod wrapper = (IodineBoundMethod)value;
Attributes [name] = new IodineBoundMethod(this, wrapper.Method);
}
else if (value is IodineProperty)
{
IodineProperty property = (IodineProperty)value;
Attributes [name] = new IodineProperty(property.Getter, property.Setter, this);
}
else
{
Attributes [name] = value;
}
}
private IodineObject GetBytecode(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineMethod method = args [0] as IodineMethod;
if (method == null && args [0] is IodineClosure)
{
method = ((IodineClosure)args [0]).Target;
}
if (method == null && args [0] is IodineBoundMethod)
{
method = ((IodineBoundMethod)args [0]).Method;
}
IodineList ret = new IodineList(new IodineObject[] { });
foreach (Instruction ins in method.Bytecode.Instructions)
{
ret.Add(new IodineInstruction(method, ins));
}
return(ret);
}
public IodineInstruction(IodineMethod method, Instruction instruction)
: base(TypeDefinition)
{
Instruction = instruction;
parentMethod = method;
SetAttribute("opcode", new IodineInteger((long)instruction.OperationCode));
SetAttribute("immediate", new IodineInteger(instruction.Argument));
if (instruction.Location != null)
{
SetAttribute("line", new IodineInteger(instruction.Location.Line));
SetAttribute("col", new IodineInteger(instruction.Location.Column));
SetAttribute("file", new IodineString(instruction.Location.File ?? ""));
}
else
{
SetAttribute("line", new IodineInteger(0));
SetAttribute("col", new IodineInteger(0));
SetAttribute("file", new IodineString(""));
}
switch (instruction.OperationCode)
{
case Opcode.LoadConst:
case Opcode.StoreGlobal:
case Opcode.LoadGlobal:
case Opcode.StoreAttribute:
case Opcode.LoadAttribute:
case Opcode.LoadAttributeOrNull:
SetAttribute("immediateref", method.Module.ConstantPool [instruction.Argument]);
break;
default:
SetAttribute("immediateref", IodineNull.Instance);
break;
}
}
private void NewFrame(IodineMethod method, IodineObject[] args, IodineObject self)
{
frameCount++;
stackSize++;
Top = new StackFrame(method.Module, method, args, Top, self);
frames.Push(Top);
}
private void NewFrame(IodineMethod method, IodineObject self, int localCount)
{
frameCount++;
stackSize++;
Top = new StackFrame(method, Top, self, localCount);
frames.Push(Top);
}
private void FindRegion (IodineMethod method, List<ReachableRegion> regions, int start)
{
if (IsReachable (regions, start)) {
return;
}
for (int i = start; i < method.Body.Count; i++) {
Instruction ins = method.Body [i];
if (ins.OperationCode == Opcode.Jump) {
regions.Add (new ReachableRegion (start, i));
FindRegion (method, regions, ins.Argument);
return;
} else if (ins.OperationCode == Opcode.JumpIfTrue ||
ins.OperationCode == Opcode.JumpIfFalse ||
ins.OperationCode == Opcode.PushExceptionHandler) {
regions.Add (new ReachableRegion (start, i));
FindRegion (method, regions, i + 1);
FindRegion (method, regions, ins.Argument);
return;
} else if (ins.OperationCode == Opcode.Return) {
regions.Add (new ReachableRegion (start, i));
return;
}
}
regions.Add (new ReachableRegion (start, method.Body.Count));
}
public IodineClass(string name, CodeObject initializer, IodineMethod constructor)
: base(name)
{
Constructor = constructor;
Initializer = initializer;
SetAttribute("__doc__", IodineString.Empty);
}
private int PerformMethodOptimization (IodineMethod method)
{
int removed = 0;
Instruction[] oldInstructions = method.Body.ToArray ();
Instruction[] newInstructions = new Instruction[method.Body.Count];
int next = 0;
Instruction last = new Instruction ();
for (int i = 0; i < method.Body.Count; i++) {
Instruction curr = oldInstructions [i];
if (i != 0 && curr.OperationCode == Opcode.Pop) {
if (last.OperationCode == Opcode.LoadLocal || last.OperationCode == Opcode.LoadGlobal
|| last.OperationCode == Opcode.LoadNull) {
oldInstructions [i] = new Instruction (curr.Location, Opcode.Nop, 0);
oldInstructions [i - 1] = new Instruction (curr.Location, Opcode.Nop, 0);
removed++;
}
} else if (curr.OperationCode == Opcode.Jump && curr.Argument == i + 1) {
oldInstructions [i] = new Instruction (curr.Location, Opcode.Nop, 0);
removed++;
}
last = curr;
}
for (int i = 0; i < oldInstructions.Length; i++) {
Instruction curr = oldInstructions [i];
if (curr.OperationCode == Opcode.Nop) {
ShiftLabels (next, newInstructions);
ShiftLabels (next, oldInstructions);
} else {
newInstructions [next++] = curr;
}
}
method.Body.Clear ();
method.Body.AddRange (newInstructions);
return removed;
}
public IodineModule(string name)
: base(ModuleTypeDef)
{
Name = name;
Initializer = new IodineMethod(this, "__init__", false, 0, 0);
Attributes ["__init__"] = Initializer;
}
public void SetAttribute(string name, IodineObject value)
{
if (value is IodineMethod)
{
IodineMethod method = (IodineMethod)value;
if (method.InstanceMethod)
{
Attributes [name] = new IodineInstanceMethodWrapper(this, method);
}
else
{
Attributes [name] = value;
}
}
else if (value is IodineInstanceMethodWrapper)
{
IodineInstanceMethodWrapper wrapper = (IodineInstanceMethodWrapper)value;
Attributes [name] = new IodineInstanceMethodWrapper(this, wrapper.Method);
}
else if (value is IodineProperty)
{
IodineProperty property = (IodineProperty)value;
Attributes [name] = new IodineProperty(property.Getter, property.Setter, this);
}
else
{
Attributes [name] = value;
}
}
public FunctionCompiler (SymbolTable symbolTable, IodineMethod methodBuilder,
Stack<IodineLabel> breakLabels, Stack<IodineLabel> continueLabels)
{
this.symbolTable = symbolTable;
this.methodBuilder = methodBuilder;
this.breakLabels = breakLabels;
this.continueLabels = continueLabels;
}
public IodineGenerator(StackFrame parentFrame, IodineInstanceMethodWrapper baseMethod,
IodineObject[] args)
: base(TypeDef)
{
arguments = args;
self = baseMethod.Self;
this.baseMethod = baseMethod.Method;
}
public IodineInstruction(IodineMethod method, Instruction instruction)
: base(TypeDefinition)
{
Instruction = instruction;
parentMethod = method;
SetAttribute("opcode", new IodineInteger((long)instruction.OperationCode));
SetAttribute("immediate", new IodineInteger(instruction.Argument));
}
public IodineGenerator(StackFrame parentFrame, IodineInstanceMethodWrapper baseMethod,
IodineObject[] args)
: base(TypeDefinition)
{
arguments = args;
self = baseMethod.Self;
this.baseMethod = baseMethod.Method;
}
public IodineInstruction (IodineMethod method, Instruction instruction)
: base (TypeDefinition)
{
Instruction = instruction;
parentMethod = method;
SetAttribute ("opcode", new IodineInteger ((long)instruction.OperationCode));
SetAttribute ("immediate", new IodineInteger (instruction.Argument));
}
public StackFrame (IodineMethod method, StackFrame parent, IodineObject self, int localCount,
IodineObject[] locals) : this (method, parent, self, localCount)
{
parentLocals = locals;
this.locals = new IodineObject[localCount];
for (int i = 0; i < localCount; i++) {
this.locals [i] = locals [i];
}
}
public StackFrame (IodineMethod method, StackFrame parent, IodineObject self, int localCount)
{
LocalCount = localCount;
locals = new IodineObject[localCount];
parentLocals = locals;
Method = method;
Self = self;
Parent = parent;
}
public StackFrame(IodineMethod method, StackFrame parent, IodineObject self, int localCount)
{
LocalCount = localCount;
locals = new IodineObject[localCount];
parentLocals = locals;
Method = method;
Self = self;
Parent = parent;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Iodine.Runtime.IodineBoundMethod"/> class.
/// </summary>
/// <param name="self">Self.</param>
/// <param name="method">Method.</param>
public IodineBoundMethod(IodineObject self, IodineMethod method)
: base(InstanceTypeDef)
{
Method = method;
SetAttribute("__name__", method.Attributes ["__name__"]);
SetAttribute("__doc__", method.Attributes ["__doc__"]);
SetAttribute("__invoke__", method.Attributes ["__invoke__"]);
Self = self;
}
public StackFrame(IodineMethod method, StackFrame parent, IodineObject self, int localCount,
IodineObject[] locals) : this(method, parent, self, localCount)
{
parentLocals = locals;
this.locals = new IodineObject[localCount];
for (int i = 0; i < localCount; i++)
{
this.locals [i] = locals [i];
}
}
public PatternCompiler (SymbolTable symbolTable,
IodineMethod methodBuilder,
int temporary,
IodineAstVisitor parent)
{
parentVisitor = parent;
this.methodBuilder = methodBuilder;
this.symbolTable = symbolTable;
this.temporary = temporary;
}
public StackFrame(
IodineModule module,
IodineMethod method,
IodineObject[] arguments,
StackFrame parent,
IodineObject self,
AttributeDictionary locals) : this(module, method, arguments, parent, self)
{
this.locals = locals;
}
StackFrame(
VirtualMachine vm,
IodineModule module,
IodineMethod method,
IodineObject [] arguments,
StackFrame parent,
IodineObject self,
AttributeDictionary locals,
AttributeDictionary parentLocals) : this(vm, module, method, arguments, parent, self)
{
this.parentLocals = parentLocals;
this.locals = locals;
}
/// <summary>
/// Executes an Iodine method
/// </summary>
/// <returns>Value evaluated on return (null if void).</returns>
/// <param name="method">Method.</param>
/// <param name="self">self pointer.</param>
/// <param name="arguments">Arguments.</param>
public IodineObject InvokeMethod(IodineMethod method, IodineObject self, IodineObject[] arguments)
{
int requiredArgs = method.AcceptsKeywordArgs ? method.ParameterCount - 1 : method.ParameterCount;
if ((method.Variadic && arguments.Length + 1 < requiredArgs) ||
(!method.Variadic && arguments.Length < requiredArgs))
{
RaiseException(new IodineArgumentException(method.ParameterCount));
return(null);
}
NewFrame(method, arguments, self);
return(Invoke(method, arguments));
}
public IodineGenerator(StackFrame frame,
IodineMethod baseMethod,
IodineObject[] args,
IodineObject initialValue)
: base(TypeDefinition)
{
arguments = args;
value = initialValue;
stackFrame = frame;
this.baseMethod = baseMethod;
SetAttribute("__iter__", new BuiltinMethodCallback((VirtualMachine vm, IodineObject self, IodineObject [] arguments) => {
return(GetIterator(vm));
}, this));
}
public StackFrame(
IodineModule module,
IodineMethod method,
IodineObject[] arguments,
StackFrame parent,
IodineObject self)
{
locals = new AttributeDictionary();
parentLocals = locals;
Method = method;
Module = module;
Self = self;
Arguments = arguments;
Parent = parent;
}
private IodineObject getBytecode(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineMethod method = args [0] as IodineMethod;
if (method == null && args [0] is IodineClosure)
{
method = ((IodineClosure)args [0]).Target;
}
IodineList ret = new IodineList(new IodineObject[] { });
foreach (Instruction ins in method.Body)
{
ret.Add(new IodineInstruction(method, ins));
}
return(ret);
}
/// <summary>
/// Determines whether an object has this trait
/// </summary>
/// <returns><c>true</c> if obj has trait; otherwise, <c>false</c>.</returns>
/// <param name="obj">Object.</param>
public bool HasTrait(IodineObject obj)
{
foreach (IodineMethod method in RequiredMethods)
{
if (obj.HasAttribute(method.Name))
{
IodineObject attr = obj.GetAttribute(method.Name);
IodineMethod objMethod = attr as IodineMethod;
if (objMethod == null)
{
// HACK: Make builtin methods work
if (attr is BuiltinMethodCallback)
{
continue;
}
if (attr is IodineBoundMethod)
{
objMethod = ((IodineBoundMethod)attr).Method;
}
else
{
return(false);
}
}
bool match = method.AcceptsKeywordArgs == objMethod.AcceptsKeywordArgs &&
method.Variadic == objMethod.Variadic &&
method.ParameterCount == objMethod.ParameterCount;
if (!match)
{
return(false);
}
}
else
{
return(false);
}
}
return(true);
}
public void PerformOptimization (IodineMethod method)
{
List <ReachableRegion> regions = new List<ReachableRegion> ();
int reachableSize = 0;
FindRegion (method, regions, 0);
foreach (ReachableRegion region in regions) {
reachableSize += region.Size + 1;
}
Instruction[] oldInstructions = method.Body.ToArray ();
Instruction[] newInstructions = new Instruction[method.Body.Count];
int next = 0;
for (int i = 0; i < method.Body.Count; i++) {
if (IsReachable (regions, i)) {
newInstructions [next++] = oldInstructions [i];
} else {
ShiftLabels (next, oldInstructions);
ShiftLabels (next, newInstructions);
}
}
method.Body.Clear ();
method.Body.AddRange (newInstructions);
}
void StoreNamedParameter(IodineMethod method,
IodineObject [] arguments,
IodineNamedParameter param,
int paramIndex)
{
if (param.Name == method.VarargsParameter)
{
// Variable list arguments
IodineObject [] tupleItems = new IodineObject [arguments.Length - paramIndex];
Array.Copy(arguments, paramIndex, tupleItems, 0, arguments.Length - paramIndex);
Top.StoreLocalExplicit(param.Name, new IodineTuple(tupleItems));
}
else if (param.Name == method.KwargsParameter)
{
/*
* At the moment, keyword arguments are passed to the function as an IodineHashMap,
*/
if (paramIndex < arguments.Length && arguments [paramIndex] is IodineDictionary)
{
Top.StoreLocalExplicit(param.Name, arguments [paramIndex]);
}
else
{
Top.StoreLocalExplicit(param.Name, new IodineDictionary());
}
}
else
{
if (arguments.Length <= paramIndex && method.HasDefaultValues)
{
Top.StoreLocalExplicit(param.Name, method.DefaultValues [paramIndex - method.DefaultValuesStartIndex]);
}
else
{
Top.StoreLocalExplicit(param.Name, arguments [paramIndex++]);
}
}
}
private IodineObject Invoke(IodineMethod method, IodineObject[] arguments)
{
if (method.Body.Count > 0)
{
currentLocation = method.Body [0].Location;
}
int insCount = method.Body.Count;
int prevStackSize = stackSize;
int i = 0;
foreach (string param in method.Parameters.Keys)
{
if (method.Variadic && (method.AcceptsKeywordArgs ? i == method.Parameters.Keys.Count - 2 :
i == method.Parameters.Keys.Count - 1))
{
IodineObject[] tupleItems = new IodineObject[arguments.Length - i];
Array.Copy(arguments, i, tupleItems, 0, arguments.Length - i);
Top.StoreLocal(method.Parameters [param], new IodineTuple(tupleItems));
}
else if (i == method.Parameters.Keys.Count - 1 && method.AcceptsKeywordArgs)
{
if (i < arguments.Length && arguments [i] is IodineHashMap)
{
Top.StoreLocal(method.Parameters [param], arguments [i]);
}
else
{
Top.StoreLocal(method.Parameters [param], new IodineHashMap());
}
}
else
{
Top.StoreLocal(method.Parameters [param], arguments [i++]);
}
}
StackFrame top = Top;
if (traceCallback != null)
{
Trace(TraceType.Function, top, currentLocation);
}
while (top.InstructionPointer < insCount && !top.AbortExecution && !Top.Yielded)
{
instruction = method.Body [Top.InstructionPointer++];
if (traceCallback != null && instruction.Location.Line != currentLocation.Line)
{
Trace(TraceType.Line, top, instruction.Location);
}
ExecuteInstruction();
top.Location = currentLocation;
}
IodineObject retVal = lastObject ?? IodineNull.Instance;
while (top.DisposableObjects.Count > 0)
{
top.DisposableObjects.Pop().Exit(this);
}
stackSize = prevStackSize;
if (top.AbortExecution)
{
return(IodineNull.Instance);
}
EndFrame();
return(retVal);
}
public IodineMethodBuilder(IodineMethod method)
: base(MethodBuilderTypeDef)
{
//this.internalValue = method;
}
public IodineClosure (StackFrame frame, IodineMethod target)
: base (TypeDefinition)
{
this.frame = frame;
Target = target;
}
private IodineMethod compileMethod(FunctionDeclaration funcDecl)
{
symbolTable.NextScope ();
IodineMethod methodBuilder = new IodineMethod (module, funcDecl.Name, funcDecl.InstanceMethod,
funcDecl.Parameters.Count,
symbolTable.CurrentScope.SymbolCount);
FunctionCompiler compiler = new FunctionCompiler (errorLog, symbolTable,
methodBuilder);
methodBuilder.Variadic = funcDecl.Variadic;
methodBuilder.AcceptsKeywordArgs = funcDecl.AcceptsKeywordArgs;
for (int i = 0; i < funcDecl.Parameters.Count; i++) {
methodBuilder.Parameters [funcDecl.Parameters [i]] = symbolTable.GetSymbol
(funcDecl.Parameters [i]).Index;
}
funcDecl.Children [0].Visit (compiler);
methodBuilder.EmitInstruction (Opcode.LoadNull);
methodBuilder.FinalizeLabels ();
symbolTable.LeaveScope ();
return methodBuilder;
}
public FunctionCompiler(ErrorLog errorLog, SymbolTable symbolTable, IodineMethod methodBuilder)
{
this.errorLog = errorLog;
this.symbolTable = symbolTable;
this.methodBuilder = methodBuilder;
}
public IodineObject InvokeMethod(IodineMethod method, StackFrame frame, IodineObject self,
IodineObject[] arguments)
{
int requiredArgs = method.AcceptsKeywordArgs ? method.ParameterCount - 1 :
method.ParameterCount;
if ((method.Variadic && arguments.Length + 1 < requiredArgs) ||
(!method.Variadic && arguments.Length < requiredArgs)) {
RaiseException (new IodineArgumentException (method.ParameterCount));
return null;
}
NewFrame (frame);
return Invoke (method, arguments);
}
public IodineClass(string name, IodineMethod initializer, IodineMethod constructor)
: base(name)
{
Constructor = constructor;
Initializer = initializer;
}
private void EvalInstruction()
{
if (instruction.Location != null)
{
currentLocation = instruction.Location;
}
switch (instruction.OperationCode)
{
case Opcode.Pop:
{
Pop();
break;
}
case Opcode.Dup:
{
IodineObject val = Pop();
Push(val);
Push(val);
break;
}
case Opcode.LoadConst:
{
Push(Top.Module.ConstantPool [instruction.Argument]);
break;
}
case Opcode.LoadNull:
{
Push(IodineNull.Instance);
break;
}
case Opcode.LoadSelf:
{
Push(Top.Self);
break;
}
case Opcode.LoadTrue:
{
Push(IodineBool.True);
break;
}
case Opcode.LoadException:
{
Push(lastException);
break;
}
case Opcode.LoadFalse:
{
Push(IodineBool.False);
break;
}
case Opcode.StoreLocal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
Top.StoreLocal(name, Pop());
break;
}
case Opcode.LoadLocal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
Push(Top.LoadLocal(name));
break;
}
case Opcode.StoreGlobal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
Top.Module.SetAttribute(this, name, Pop());
break;
}
case Opcode.LoadGlobal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (name == "_")
{
Push(Top.Module);
}
else if (Top.Module.Attributes.ContainsKey(name))
{
Push(Top.Module.GetAttribute(this, name));
}
else
{
RaiseException(new IodineAttributeNotFoundException(name));
}
break;
}
case Opcode.StoreAttribute:
{
IodineObject target = Pop();
IodineObject value = Pop();
string attribute = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (target.Attributes.ContainsKey(attribute) &&
target.Attributes [attribute] is IIodineProperty)
{
IIodineProperty property = (IIodineProperty)target.Attributes [attribute];
property.Set(this, value);
break;
}
target.SetAttribute(this, attribute, value);
break;
}
case Opcode.LoadAttribute:
{
IodineObject target = Pop();
string attribute = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (target.Attributes.ContainsKey(attribute) &&
target.Attributes [attribute] is IIodineProperty)
{
IIodineProperty property = (IIodineProperty)target.Attributes [attribute];
Push(property.Get(this));
break;
}
Push(target.GetAttribute(this, attribute));
break;
}
case Opcode.LoadAttributeOrNull:
{
IodineObject target = Pop();
string attribute = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (target.Attributes.ContainsKey(attribute))
{
Push(target.GetAttribute(this, attribute));
}
else
{
Push(IodineNull.Instance);
}
break;
}
case Opcode.StoreIndex:
{
IodineObject index = Pop();
IodineObject target = Pop();
IodineObject value = Pop();
target.SetIndex(this, index, value);
break;
}
case Opcode.LoadIndex:
{
IodineObject index = Pop();
IodineObject target = Pop();
Push(target.GetIndex(this, index));
break;
}
case Opcode.CastLocal:
{
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
IodineObject o = Top.LoadLocal(name);
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
if (o.InstanceOf(type))
{
Push(o);
}
else
{
RaiseException(new IodineTypeException(type.Name));
}
break;
}
case Opcode.BinOp:
{
IodineObject op2 = Pop();
IodineObject op1 = Pop();
Push(op1.PerformBinaryOperation(this,
(BinaryOperation)instruction.Argument,
op2
));
break;
}
case Opcode.UnaryOp:
{
Push(Pop().PerformUnaryOperation(this,
(UnaryOperation)instruction.Argument));
break;
}
case Opcode.Invoke:
{
IodineObject target = Pop();
IodineObject[] arguments = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
arguments [instruction.Argument - i] = Pop();
}
Push(target.Invoke(this, arguments));
break;
}
case Opcode.InvokeVar:
{
IodineObject target = Pop();
List <IodineObject> arguments = new List <IodineObject> ();
IodineTuple tuple = Pop() as IodineTuple;
if (tuple == null)
{
RaiseException(new IodineTypeException("Tuple"));
break;
}
for (int i = 0; i < instruction.Argument; i++)
{
arguments.Add(Pop());
}
arguments.AddRange(tuple.Objects);
Push(target.Invoke(this, arguments.ToArray()));
break;
}
case Opcode.InvokeSuper:
{
IodineTypeDefinition target = Pop() as IodineTypeDefinition;
IodineObject[] arguments = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
arguments [instruction.Argument - i] = Pop();
}
target.Inherit(this, Top.Self, arguments);
break;
}
case Opcode.Return:
{
Top.InstructionPointer = int.MaxValue;
break;
}
case Opcode.Yield:
{
Top.Yielded = true;
break;
}
case Opcode.JumpIfTrue:
{
if (Pop().IsTrue())
{
Top.InstructionPointer = instruction.Argument;
}
break;
}
case Opcode.JumpIfFalse:
{
if (!Pop().IsTrue())
{
Top.InstructionPointer = instruction.Argument;
}
break;
}
case Opcode.Jump:
{
Top.InstructionPointer = instruction.Argument;
break;
}
case Opcode.BuildClass:
{
IodineName name = Pop() as IodineName;
IodineString doc = Pop() as IodineString;
IodineMethod constructor = Pop() as IodineMethod;
//CodeObject initializer = Pop as CodeObject;
IodineTypeDefinition baseClass = Pop() as IodineTypeDefinition;
IodineTuple interfaces = Pop() as IodineTuple;
IodineClass clazz = new IodineClass(name.ToString(), new CodeObject(), constructor);
if (baseClass != null)
{
clazz.BaseClass = baseClass;
baseClass.BindAttributes(clazz);
}
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject val = Pop();
IodineObject key = Pop();
clazz.Attributes [val.ToString()] = key;
}
foreach (IodineObject obj in interfaces.Objects)
{
IodineContract contract = obj as IodineContract;
if (!contract.InstanceOf(clazz))
{
//RaiseException (new IodineTypeException (contract.Name));
break;
}
}
clazz.SetAttribute("__doc__", doc);
Push(clazz);
break;
}
case Opcode.BuildMixin:
{
IodineName name = Pop() as IodineName;
IodineMixin mixin = new IodineMixin(name.ToString());
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject val = Pop();
IodineObject key = Pop();
mixin.Attributes [val.ToString()] = key;
}
Push(mixin);
break;
}
case Opcode.BuildEnum:
{
IodineName name = Pop() as IodineName;
IodineEnum ienum = new IodineEnum(name.ToString());
for (int i = 0; i < instruction.Argument; i++)
{
IodineInteger val = Pop() as IodineInteger;
IodineName key = Pop() as IodineName;
ienum.AddItem(key.ToString(), (int)val.Value);
}
Push(ienum);
break;
}
case Opcode.BuildContract:
{
IodineName name = Pop() as IodineName;
IodineContract contract = new IodineContract(name.ToString());
for (int i = 0; i < instruction.Argument; i++)
{
IodineMethod val = Pop() as IodineMethod;
contract.AddMethod(val);
}
Push(contract);
break;
}
case Opcode.BuildTrait:
{
IodineName name = Pop() as IodineName;
IodineTrait trait = new IodineTrait(name.ToString());
for (int i = 0; i < instruction.Argument; i++)
{
IodineMethod val = Pop() as IodineMethod;
trait.AddMethod(val);
}
Push(trait);
break;
}
case Opcode.BuildHash:
{
IodineDictionary hash = new IodineDictionary();
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject val = Pop();
IodineObject key = Pop();
hash.Set(key, val);
}
Push(hash);
break;
}
case Opcode.BuildList:
{
IodineObject[] items = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
items [instruction.Argument - i] = Pop();
}
Push(new IodineList(items));
break;
}
case Opcode.BuildTuple:
{
IodineObject[] items = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
items [instruction.Argument - i] = Pop();
}
Push(new IodineTuple(items));
break;
}
case Opcode.BuildClosure:
{
IodineObject obj = Pop();
IodineMethod method = obj as IodineMethod;
Push(new IodineClosure(Top, method));
break;
}
case Opcode.BuildGenExpr:
{
CodeObject method = Pop() as CodeObject;
Push(new IodineGeneratorExpr(Top, method));
break;
}
case Opcode.Slice:
{
IodineObject target = Pop();
IodineInteger[] arguments = new IodineInteger[3];
for (int i = 0; i < 3; i++)
{
IodineObject obj = Pop();
arguments [i] = obj as IodineInteger;
if (obj != IodineNull.Instance && arguments [i] == null)
{
RaiseException(new IodineTypeException("Int"));
break;
}
}
IodineSlice slice = new IodineSlice(arguments [0], arguments [1], arguments [2]);
Push(target.Slice(this, slice));
break;
}
case Opcode.MatchPattern:
{
IodineObject collection = Pop().GetIterator(this);
IodineObject[] items = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
items [instruction.Argument - i] = Pop();
}
int index = 0;
collection.IterReset(this);
while (collection.IterMoveNext(this) && index < items.Length)
{
IodineObject o = collection.IterGetCurrent(this);
if (items [index] is IodineTypeDefinition)
{
if (!o.InstanceOf(items [index] as IodineTypeDefinition))
{
Push(IodineBool.False);
break;
}
}
else
{
if (!o.Equals(items [index]))
{
Push(IodineBool.False);
break;
}
}
index++;
}
Push(IodineBool.Create(index == items.Length));
break;
}
case Opcode.Unwrap:
{
IodineObject container = Pop();
IodineObject value = container.Unwrap(this);
if (instruction.Argument > 0)
{
IodineInteger len = value.Len(this) as IodineInteger;
if (len == null || len.Value != instruction.Argument)
{
Push(IodineBool.False);
break;
}
}
Push(value);
Push(IodineBool.True);
break;
}
case Opcode.Unpack:
{
IodineTuple tuple = Pop() as IodineTuple;
if (tuple == null)
{
RaiseException(new IodineTypeException("Tuple"));
break;
}
if (tuple.Objects.Length != instruction.Argument)
{
RaiseException(new IodineUnpackException(instruction.Argument));
break;
}
for (int i = tuple.Objects.Length - 1; i >= 0; i--)
{
Push(tuple.Objects [i]);
}
break;
}
case Opcode.GetIter:
{
Push(Pop().GetIterator(this));
break;
}
case Opcode.IterGetNext:
{
Push(Pop().IterGetCurrent(this));
break;
}
case Opcode.IterMoveNext:
{
Push(IodineBool.Create(Pop().IterMoveNext(this)));
break;
}
case Opcode.IterReset:
{
Pop().IterReset(this);
break;
}
case Opcode.PushExceptionHandler:
{
Top.ExceptionHandlers.Push(new IodineExceptionHandler(frameCount, instruction.Argument));
break;
}
case Opcode.PopExceptionHandler:
{
Top.ExceptionHandlers.Pop();
break;
}
case Opcode.InstanceOf:
{
IodineObject o = Pop();
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
Push(IodineBool.Create(o.InstanceOf(type)));
break;
}
case Opcode.DynamicCast:
{
IodineObject o = Pop();
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
if (o.InstanceOf(type))
{
Push(o);
}
else
{
Push(IodineNull.Instance);
}
break;
}
case Opcode.NullCoalesce:
{
IodineObject o1 = Pop();
IodineObject o2 = Pop();
if (o1 is IodineNull)
{
Push(o2);
}
else
{
Push(o1);
}
break;
}
case Opcode.BeginExcept:
{
bool rethrow = true;
for (int i = 1; i <= instruction.Argument; i++)
{
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
if (lastException.InstanceOf(type))
{
rethrow = false;
break;
}
}
if (rethrow)
{
RaiseException(lastException);
}
break;
}
case Opcode.Raise:
{
IodineObject e = Pop();
if (e.InstanceOf(IodineException.TypeDefinition))
{
RaiseException(e);
}
else
{
RaiseException(new IodineTypeException("Exception"));
}
break;
}
case Opcode.SwitchLookup:
{
Dictionary <int, IodineObject> lookup = new Dictionary <int, IodineObject> ();
int needle = Pop().GetHashCode();
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject value = Pop();
IodineObject key = Pop();
lookup [key.GetHashCode()] = value;
}
if (lookup.ContainsKey(needle))
{
lookup [needle].Invoke(this, new IodineObject[] { });
Push(IodineBool.True);
}
else
{
Push(IodineBool.False);
}
break;
}
case Opcode.BeginWith:
{
IodineObject obj = Pop();
obj.Enter(this);
Top.DisposableObjects.Push(obj);
break;
}
case Opcode.EndWith:
{
Top.DisposableObjects.Pop().Exit(this);
break;
}
case Opcode.IncludeMixin:
{
IodineObject obj = Pop();
IodineObject type = Pop();
foreach (KeyValuePair <string, IodineObject> attr in obj.Attributes)
{
type.SetAttribute(attr.Key, attr.Value);
}
break;
}
case Opcode.ApplyMixin:
{
IodineObject type = Pop();
IodineMixin mixin = Top.Module.ConstantPool [instruction.Argument] as IodineMixin;
foreach (KeyValuePair <string, IodineObject> attr in mixin.Attributes)
{
type.SetAttribute(attr.Key, attr.Value);
}
break;
}
case Opcode.BuildFunction:
{
MethodFlags flags = (MethodFlags)instruction.Argument;
IodineString name = Pop() as IodineString;
IodineString doc = Pop() as IodineString;
CodeObject bytecode = Pop() as CodeObject;
IodineTuple parameters = Pop() as IodineTuple;
IodineObject[] defaultValues = new IodineObject[] { };
int defaultValuesStart = 0;
if (flags.HasFlag(MethodFlags.HasDefaultParameters))
{
IodineTuple defaultValuesTuple = Pop() as IodineTuple;
IodineInteger startInt = Pop() as IodineInteger;
defaultValues = defaultValuesTuple.Objects;
defaultValuesStart = (int)startInt.Value;
}
IodineMethod method = new IodineMethod(
Top.Module,
name,
bytecode,
parameters,
flags,
defaultValues,
defaultValuesStart
);
method.SetAttribute("__doc__", doc);
Push(method);
break;
}
}
}
public void AddInstanceMethod(IodineMethod method)
{
SetAttribute(method.Name, method);
}
public FunctionCompiler (SymbolTable symbolTable, IodineMethod methodBuilder)
{
this.symbolTable = symbolTable;
this.methodBuilder = methodBuilder;
}
public void AddMethod(IodineMethod method)
{
Attributes [method.Name] = method;
}
public IodineClosure(StackFrame frame, IodineMethod target)
: base(TypeDefinition)
{
this.frame = frame;
Target = target;
}
public void AddInstanceMethod(IodineMethod method)
{
SetAttribute (method.Name, method);
}
public IodineClass(string name, IodineMethod initializer, IodineMethod constructor)
: base(name)
{
Constructor = constructor;
Initializer = initializer;
}
public void AddMethod(IodineMethod method)
{
RequiredMethods.Add(method);
}
/*
* Internal implementation of Invoke
*/
private IodineObject Invoke(IodineMethod method, IodineObject[] arguments)
{
if (method.Bytecode.Instructions.Length > 0)
{
currentLocation = method.Bytecode.Instructions [0].Location;
}
int insCount = method.Bytecode.Instructions.Length;
int prevStackSize = stackSize;
int i = 0;
lastObject = null;
/*
* Store function arguments into their respective local variable slots
*/
foreach (string param in method.Parameters)
{
if (param == method.VarargsParameter)
{
// Variable list arguments
IodineObject[] tupleItems = new IodineObject[arguments.Length - i];
Array.Copy(arguments, i, tupleItems, 0, arguments.Length - i);
Top.StoreLocalExplicit(param, new IodineTuple(tupleItems));
}
else if (param == method.KwargsParameter)
{
/*
* At the moment, keyword arguments are passed to the function as an IodineHashMap,
*/
if (i < arguments.Length && arguments [i] is IodineDictionary)
{
Top.StoreLocalExplicit(param, arguments [i]);
}
else
{
Top.StoreLocalExplicit(param, new IodineDictionary());
}
}
else
{
if (arguments.Length <= i && method.HasDefaultValues)
{
Top.StoreLocalExplicit(param, method.DefaultValues [i - method.DefaultValuesStartIndex]);
}
else
{
Top.StoreLocalExplicit(param, arguments [i++]);
}
}
}
StackFrame top = Top;
top.Module = method.Module;
if (traceCallback != null)
{
Trace(TraceType.Function, top, currentLocation);
}
IodineObject retVal = EvalCode(method.Bytecode);
if (top.Yielded)
{
top.Pop();
}
/*
* Calls __exit__ on any object used in a with statement
*/
while (!top.Yielded && top.DisposableObjects.Count > 0)
{
top.DisposableObjects.Pop().Exit(this);
}
stackSize = prevStackSize;
if (top.AbortExecution)
{
/*
* If AbortExecution was set, something went wrong and we most likely just
* raised an exception. We'll return right here and let what ever catches
* the exception clean up the stack
*/
return(retVal);
}
EndFrame();
return(retVal);
}
public override void Accept (FunctionDeclaration funcDecl)
{
symbolTable.NextScope ();
IodineMethod anonMethod = new IodineMethod (methodBuilder, methodBuilder.Module, null, funcDecl.InstanceMethod,
funcDecl.Parameters.Count, methodBuilder.LocalCount);
FunctionCompiler compiler = new FunctionCompiler (symbolTable, anonMethod);
for (int i = 0; i < funcDecl.Parameters.Count; i++) {
anonMethod.Parameters [funcDecl.Parameters [i]] = symbolTable.GetSymbol
(funcDecl.Parameters [i]).Index;
}
funcDecl.Children [0].Visit (compiler);
anonMethod.EmitInstruction (funcDecl.Location, Opcode.LoadNull);
anonMethod.Variadic = funcDecl.Variadic;
anonMethod.AcceptsKeywordArgs = funcDecl.AcceptsKeywordArgs;
anonMethod.FinalizeLabels ();
methodBuilder.EmitInstruction (funcDecl.Location, Opcode.LoadConst,
methodBuilder.Module.DefineConstant (anonMethod));
methodBuilder.EmitInstruction (funcDecl.Location, Opcode.BuildClosure);
methodBuilder.EmitInstruction (funcDecl.Location, Opcode.StoreLocal, symbolTable.GetSymbol (funcDecl.Name).Index);
symbolTable.LeaveScope ();
}
private void NewFrame(IodineMethod method, IodineObject self, int localCount)
{
frameCount++;
Top = new StackFrame (method, Top, self, localCount);
frames.Push (Top);
}
public override void Accept (LambdaExpression lambda)
{
symbolTable.NextScope ();
int locals = methodBuilder.LocalCount > 0 ? methodBuilder.LocalCount : symbolTable.CurrentScope.SymbolCount;
IodineMethod anonMethod = new IodineMethod (methodBuilder, methodBuilder.Module, null, lambda.InstanceMethod,
lambda.Parameters.Count, locals);
FunctionCompiler compiler = new FunctionCompiler (symbolTable, anonMethod);
for (int i = 0; i < lambda.Parameters.Count; i++) {
anonMethod.Parameters [lambda.Parameters [i]] = symbolTable.GetSymbol
(lambda.Parameters [i]).Index;
}
lambda.Children [0].Visit (compiler);
anonMethod.EmitInstruction (lambda.Location, Opcode.LoadNull);
anonMethod.Variadic = lambda.Variadic;
anonMethod.FinalizeLabels ();
methodBuilder.EmitInstruction (lambda.Location, Opcode.LoadConst,
methodBuilder.Module.DefineConstant (anonMethod));
if (methodBuilder.LocalCount > 0) {
methodBuilder.EmitInstruction (lambda.Location, Opcode.BuildClosure);
}
symbolTable.LeaveScope ();
}
private void ExecuteInstruction()
{
currentLocation = instruction.Location;
switch (instruction.OperationCode)
{
case Opcode.Pop:
{
Pop();
break;
}
case Opcode.Dup:
{
IodineObject val = Pop();
Push(val);
Push(val);
break;
}
case Opcode.LoadConst:
{
Push(Top.Module.ConstantPool [instruction.Argument]);
break;
}
case Opcode.LoadNull:
{
Push(IodineNull.Instance);
break;
}
case Opcode.LoadSelf:
{
Push(Top.Self);
break;
}
case Opcode.LoadTrue:
{
Push(IodineBool.True);
break;
}
case Opcode.LoadException:
{
Push(lastException);
break;
}
case Opcode.LoadFalse:
{
Push(IodineBool.False);
break;
}
case Opcode.StoreLocal:
{
Top.StoreLocal(instruction.Argument, Pop());
break;
}
case Opcode.LoadLocal:
{
Push(Top.LoadLocal(instruction.Argument));
break;
}
case Opcode.StoreGlobal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (Globals.ContainsKey(name))
{
Globals [name] = Pop();
}
else
{
Top.Module.SetAttribute(this, name, Pop());
}
break;
}
case Opcode.LoadGlobal:
{
string name = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (Top.Module.Attributes.ContainsKey(name))
{
Push(Top.Module.GetAttribute(this, name));
}
else if (Globals.ContainsKey(name))
{
Push(Globals [name]);
}
else
{
RaiseException(new IodineAttributeNotFoundException(name));
}
break;
}
case Opcode.StoreAttribute:
{
IodineObject target = Pop();
IodineObject value = Pop();
string attribute = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (target.Attributes.ContainsKey(attribute) &&
target.Attributes [attribute] is IIodineProperty)
{
IIodineProperty property = (IIodineProperty)target.Attributes [attribute];
property.Set(this, value);
break;
}
target.SetAttribute(this, attribute, value);
break;
}
case Opcode.LoadAttribute:
{
IodineObject target = Pop();
string attribute = ((IodineName)Top.Module.ConstantPool [instruction.Argument]).Value;
if (target.Attributes.ContainsKey(attribute) &&
target.Attributes [attribute] is IIodineProperty)
{
IIodineProperty property = (IIodineProperty)target.Attributes [attribute];
Push(property.Get(this));
break;
}
Push(target.GetAttribute(this, attribute));
break;
}
case Opcode.StoreIndex:
{
IodineObject index = Pop();
IodineObject target = Pop();
IodineObject value = Pop();
target.SetIndex(this, index, value);
break;
}
case Opcode.LoadIndex:
{
IodineObject index = Pop();
IodineObject target = Pop();
Push(target.GetIndex(this, index));
break;
}
case Opcode.BinOp:
{
IodineObject op2 = Pop();
IodineObject op1 = Pop();
Push(op1.PerformBinaryOperation(this,
(BinaryOperation)instruction.Argument,
op2));
break;
}
case Opcode.UnaryOp:
{
Push(Pop().PerformUnaryOperation(this,
(UnaryOperation)instruction.Argument));
break;
}
case Opcode.Invoke:
{
IodineObject target = Pop();
IodineObject[] arguments = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
arguments [instruction.Argument - i] = Pop();
}
Push(target.Invoke(this, arguments));
break;
}
case Opcode.InvokeVar:
{
IodineObject target = Pop();
List <IodineObject> arguments = new List <IodineObject> ();
IodineTuple tuple = Pop() as IodineTuple;
if (tuple == null)
{
RaiseException(new IodineTypeException("Tuple"));
break;
}
for (int i = 0; i < instruction.Argument; i++)
{
arguments.Add(Pop());
}
arguments.AddRange(tuple.Objects);
Push(target.Invoke(this, arguments.ToArray()));
break;
}
case Opcode.InvokeSuper:
{
IodineTypeDefinition target = (IodineTypeDefinition)Pop();
IodineObject[] arguments = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
arguments [instruction.Argument - i] = Pop();
}
target.Inherit(this, Top.Self, arguments);
break;
}
case Opcode.Return:
{
Top.InstructionPointer = int.MaxValue;
break;
}
case Opcode.Yield:
{
Top.Yielded = true;
break;
}
case Opcode.JumpIfTrue:
{
if (Pop().IsTrue())
{
Top.InstructionPointer = instruction.Argument;
}
break;
}
case Opcode.JumpIfFalse:
{
if (!Pop().IsTrue())
{
Top.InstructionPointer = instruction.Argument;
}
break;
}
case Opcode.Jump:
{
Top.InstructionPointer = instruction.Argument;
break;
}
case Opcode.BuildHash:
{
IodineHashMap hash = new IodineHashMap();
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject val = Pop();
IodineObject key = Pop();
hash.Set(key, val);
}
Push(hash);
break;
}
case Opcode.BuildList:
{
IodineObject[] items = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
items [instruction.Argument - i] = Pop();
}
Push(new IodineList(items));
break;
}
case Opcode.BuildTuple:
{
IodineObject[] items = new IodineObject[instruction.Argument];
for (int i = 1; i <= instruction.Argument; i++)
{
items [instruction.Argument - i] = Pop();
}
Push(new IodineTuple(items));
break;
}
case Opcode.BuildClosure:
{
IodineMethod method = Pop() as IodineMethod;
Push(new IodineClosure(Top, method));
break;
}
case Opcode.IterGetNext:
{
Push(Pop().IterGetCurrent(this));
break;
}
case Opcode.IterMoveNext:
{
Push(IodineBool.Create(Pop().IterMoveNext(this)));
break;
}
case Opcode.IterReset:
{
Pop().IterReset(this);
break;
}
case Opcode.PushExceptionHandler:
{
Top.ExceptionHandlers.Push(new IodineExceptionHandler(frameCount, instruction.Argument));
break;
}
case Opcode.PopExceptionHandler:
{
Top.ExceptionHandlers.Pop();
break;
}
case Opcode.InstanceOf:
{
IodineObject o = Pop();
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
Push(IodineBool.Create(o.InstanceOf(type)));
break;
}
case Opcode.DynamicCast:
{
IodineObject o = Pop();
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
if (o.InstanceOf(type))
{
Push(o);
}
else
{
Push(IodineNull.Instance);
}
break;
}
case Opcode.NullCoalesce:
{
IodineObject o1 = Pop();
IodineObject o2 = Pop();
if (o1 is IodineNull)
{
Push(o2);
}
else
{
Push(o1);
}
break;
}
case Opcode.BeginExcept:
{
bool rethrow = true;
for (int i = 1; i <= instruction.Argument; i++)
{
IodineTypeDefinition type = Pop() as IodineTypeDefinition;
if (type == null)
{
RaiseException(new IodineTypeException("TypeDef"));
break;
}
if (lastException.InstanceOf(type))
{
rethrow = false;
break;
}
}
if (rethrow)
{
RaiseException(lastException);
}
break;
}
case Opcode.Raise:
{
IodineObject e = Pop();
if (e.InstanceOf(IodineException.TypeDefinition))
{
RaiseException(e);
}
else
{
RaiseException(new IodineTypeException("Exception"));
}
break;
}
case Opcode.SwitchLookup:
{
Dictionary <int, IodineObject> lookup = new Dictionary <int, IodineObject> ();
int needle = Pop().GetHashCode();
for (int i = 0; i < instruction.Argument; i++)
{
IodineObject value = Pop();
IodineObject key = Pop();
lookup [key.GetHashCode()] = value;
}
if (lookup.ContainsKey(needle))
{
lookup [needle].Invoke(this, new IodineObject[] { });
Push(IodineBool.True);
}
else
{
Push(IodineBool.False);
}
break;
}
case Opcode.BeginWith:
{
IodineObject obj = Pop();
obj.Enter(this);
Top.DisposableObjects.Push(obj);
break;
}
case Opcode.EndWith:
{
Top.DisposableObjects.Pop().Exit(this);
break;
}
}
}
public IodineGenerator(StackFrame parentFrame, IodineMethod baseMethod, IodineObject[] args)
: base(TypeDef)
{
arguments = args;
this.baseMethod = baseMethod;
}
public IodineMethod (IodineMethod parent, IodineModule module, string name, bool isInstance, int parameterCount,
int localCount) : this (module, name, isInstance, parameterCount, localCount)
{
this.parent = parent;
}
private IodineObject Invoke(IodineMethod method, IodineObject[] arguments)
{
if (method.Body.Count > 0) {
currLoc = method.Body [0].Location;
}
int insCount = method.Body.Count;
int i = 0;
foreach (string param in method.Parameters.Keys) {
if (method.Variadic && (method.AcceptsKeywordArgs ? i == method.Parameters.Keys.Count - 2 :
i == method.Parameters.Keys.Count - 1)) {
IodineObject[] tupleItems = new IodineObject[arguments.Length - i];
Array.Copy (arguments, i, tupleItems, 0, arguments.Length - i);
Top.StoreLocal (method.Parameters [param], new IodineTuple (tupleItems));
} else if (i == method.Parameters.Keys.Count - 1 && method.AcceptsKeywordArgs) {
if (i < arguments.Length && arguments [i] is IodineHashMap) {
Top.StoreLocal (method.Parameters [param], arguments [i]);
} else {
Top.StoreLocal (method.Parameters [param], new IodineHashMap ());
}
} else {
Top.StoreLocal (method.Parameters [param], arguments [i++]);
}
}
StackFrame top = Top;
while (top.InstructionPointer < insCount && !top.AbortExecution && !Top.Yielded) {
instruction = method.Body [Top.InstructionPointer++];
ExecuteInstruction ();
top.Location = currLoc;
}
if (top.AbortExecution) {
while (top.DisposableObjects.Count > 0) {
top.DisposableObjects.Pop ().Exit (this);
}
return IodineNull.Instance;
}
IodineObject retVal = last ?? IodineNull.Instance;
EndFrame ();
while (top.DisposableObjects.Count > 0) {
top.DisposableObjects.Pop ().Exit (this);
}
return retVal;
}
public IodineInstanceMethodWrapper (IodineObject self, IodineMethod method)
: base (InstanceTypeDef)
{
Method = method;
Self = self;
}
public void PerformOptimization (IodineMethod method)
{
while (PerformMethodOptimization (method) > 0)
;
}
public IodineClass CompileClass(ClassDeclaration classDecl)
{
IodineMethod constructor = compileMethod (classDecl.Constructor);
if (classDecl.Constructor.Children [0].Children.Count == 0 ||
!(classDecl.Constructor.Children [0].Children [0] is SuperCallExpression)) {
if (classDecl.Base.Count > 0) {
foreach (string subclass in classDecl.Base) {
string[] contract = subclass.Split ('.');
constructor.EmitInstruction (classDecl.Location, Opcode.LoadGlobal,
constructor.Module.DefineConstant (new IodineName (contract [0])));
for (int j = 1; j < contract.Length; j++) {
constructor.EmitInstruction (classDecl.Location, Opcode.LoadAttribute,
constructor.Module.DefineConstant (new IodineName (contract [0])));
}
constructor.EmitInstruction (classDecl.Location, Opcode.InvokeSuper, 0);
}
}
}
IodineMethod initializer = new IodineMethod (module, "__init__", false, 0, 0);
IodineClass clazz = new IodineClass (classDecl.Name, initializer, constructor);
FunctionCompiler compiler = new FunctionCompiler (errorLog, symbolTable,
clazz.Initializer);
for (int i = 1; i < classDecl.Children.Count; i++) {
if (classDecl.Children [i] is FunctionDeclaration) {
FunctionDeclaration func = classDecl.Children [i] as FunctionDeclaration;
if (func.InstanceMethod)
clazz.AddInstanceMethod (compileMethod (func));
else {
clazz.SetAttribute (func.Name, compileMethod (func));
}
} else if (classDecl.Children [i] is ClassDeclaration) {
ClassDeclaration subclass = classDecl.Children [i] as ClassDeclaration;
clazz.SetAttribute (subclass.Name, CompileClass (subclass));
} else if (classDecl.Children [i] is EnumDeclaration) {
EnumDeclaration enumeration = classDecl.Children [i] as EnumDeclaration;
clazz.SetAttribute (enumeration.Name, CompileEnum (enumeration));
} else if (classDecl.Children [i] is BinaryExpression) {
BinaryExpression expr = classDecl.Children [i] as BinaryExpression;
NameExpression name = expr.Left as NameExpression;
expr.Right.Visit (compiler);
initializer.EmitInstruction (Opcode.LoadGlobal, module.DefineConstant (new
IodineName (classDecl.Name)));
initializer.EmitInstruction (Opcode.StoreAttribute, module.DefineConstant (new
IodineName (name.Value)));
} else {
classDecl.Children [i].Visit (compiler);
}
}
clazz.Initializer.FinalizeLabels ();
return clazz;
}
public void AddMethod (IodineMethod method)
{
RequiredMethods.Add (method);
}
public void AddMethod(IodineMethod method)
{
Attributes [method.Name] = method;
}
