public Instruction (SourceLocation location, Opcode opcode, int arg) : this () { OperationCode = opcode; Argument = arg; Location = location; }
public Tokenizer (ErrorLog errorLog, string source, string file = "") { this.errorLog = errorLog; this.source = source; this.file = file; position = 0; sourceLen = source.Length; location = new SourceLocation (0, 0, file); }
public void EmitInstruction (SourceLocation loc, Opcode opcode, int arg) { instructions.Add (new Instruction (loc, opcode, arg)); }
public Error (ErrorType etype, SourceLocation location, string text) { ErrorType = etype; Text = text; Location = location; }
public DebugResponse (SourceLocation location, StackFrame frame) { Location = location; Frame = frame; }
/// <summary> /// Initializes a new instance of the <see cref="Iodine.Compiler.Token"/> class. /// </summary> /// <param name="clazz">Token class.</param> /// <param name="value">Value.</param> /// <param name="location">Location.</param> public Token (TokenClass clazz, string value, SourceLocation location) { Class = clazz; Value = value; Location = location; }
public Statement (SourceLocation location) : base (location) { }
public void EmitInstruction(SourceLocation loc, Opcode opcode, IodineObject arg) { instructions.Add(new Instruction(loc, opcode, arg)); }
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.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.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 Error(ErrorType etype, SourceLocation location, string text) { ErrorType = etype; Text = text; Location = location; }
private void Trace (TraceType type, StackFrame frame, SourceLocation location) { pauseVirtualMachine.WaitOne (); if (traceCallback (type, this, frame, location)) { pauseVirtualMachine.Reset (); } }
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 void EmitInstruction(SourceLocation loc, Opcode opcode, Label label) { labelReferences [instructions.Count] = label; instructions.Add(new Instruction(loc, opcode, 0)); }
public void EmitInstruction (SourceLocation loc, Opcode opcode, IodineLabel label) { labelReferences [instructions.Count] = label; instructions.Add (new Instruction (loc, opcode, 0)); }
private int ReadChar () { if (position >= sourceLen) { return -1; } if (source [position] == '\n') { location = new SourceLocation (location.Line + 1, 0, this.file); } else { location = new SourceLocation (location.Line, location.Column + 1, this.file); } return source [position++]; }
private static AstNode ParseString(SourceLocation loc, string str) { int pos = 0; string accum = ""; List<string> vars = new List<string> (); while (pos < str.Length) { if (str [pos] == '#' && str.Length != pos + 1 && str [pos + 1] == '{') { string substr = str.Substring (pos + 2); if (substr.IndexOf ('}') == -1) return null; substr = substr.Substring (0, substr.IndexOf ('}')); pos += substr.Length + 3; vars.Add (substr); accum += "{}"; } else { accum += str [pos++]; } } StringExpression ret = new StringExpression (loc, accum); foreach (string name in vars) { ret.Add (new NameExpression (loc, name)); } return ret; }
public void EmitInstruction(SourceLocation loc, Opcode opcode) { instructions.Add(new Instruction(loc, opcode)); }