public IodineModule (string name) : base (ModuleTypeDef) { Name = name; Initializer = new IodineMethod (this, "__init__", false, 0, 0); Attributes ["__init__"] = Initializer; Attributes ["__name__"] = new IodineString (name); }
public IodineHostEntry (IPHostEntry host) : base (HostEntryTypeDef) { this.Entry = host; IodineObject[] addresses = new IodineObject[Entry.AddressList.Length]; int i = 0; foreach (IPAddress ip in Entry.AddressList) { addresses [i++] = new IodineString (ip.ToString ()); } SetAttribute ("addressList", new IodineTuple (addresses)); }
private IodineObject Popen(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString command = args [0] as IodineString; IodineString mode = args [1] as IodineString; if (command == null || mode == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } bool read = false; bool write = false; foreach (char c in mode.Value) { switch (c) { case 'r': read = true; break; case 'w': write = true; break; } } bool isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32S || Environment.OSVersion.Platform == PlatformID.Win32Windows || Environment.OSVersion.Platform == PlatformID.WinCE || Environment.OSVersion.Platform == PlatformID.Xbox; if (isWindows) { return(new IodineSubprocess(Popen_Win32(command.Value, read, write), read, write)); } else { Process proc = Popen_Unix(command.Value, read, write); proc.Start(); return(new IodineSubprocess(proc, read, write)); } }
public override IodineObject Invoke(VirtualMachine vm, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); } if (args [0].HasAttribute("_toStr")) { IodineString ret = args [0].GetAttribute("_toStr").Invoke(vm, new IodineObject[] { }) as IodineString; return(ret); } return(new IodineString(args [0].ToString())); }
private IodineObject spawn(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); } IodineString str = args [0] as IodineString; string cmdArgs = ""; bool wait = true; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } if (args.Length >= 2) { IodineString cmdArgsObj = args [1] as IodineString; if (cmdArgsObj == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } cmdArgs = cmdArgsObj.Value; } if (args.Length >= 3) { IodineBool waitObj = args [2] as IodineBool; if (waitObj == null) { vm.RaiseException(new IodineTypeException("Bool")); return(null); } wait = waitObj.Value; } ProcessStartInfo info = new ProcessStartInfo(str.Value, cmdArgs); info.UseShellExecute = false; Process proc = Process.Start(info); if (wait) { proc.WaitForExit(); } return(new IodineInteger(proc.ExitCode)); }
private IodineObject IsSymbol(VirtualMachine vm, IodineObject self, IodineObject[] args) { IodineString thisObj = self as IodineString; bool result = thisObj.Value.Length == 0 ? false : true; for (int i = 0; i < thisObj.Value.Length; i++) { if (!char.IsSymbol(thisObj.Value [i])) { return(IodineBool.False); } } return(IodineBool.Create(result)); }
private IodineObject LoadModule(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(1)); return(IodineNull.Instance); } IodineString source = args [0] as IodineString; try { return(vm.LoadModule(source.ToString())); } catch (ModuleNotFoundException ex) { vm.RaiseException(new IodineModuleNotFoundException(ex.Name)); return(null); } }
public IodineSyntaxException(ErrorLog errorLog) : base(TypeDefinition, "Syntax error") { Base = new IodineException(); IodineObject[] errors = new IodineObject[errorLog.ErrorCount]; int i = 0; foreach (Error error in errorLog.Errors) { SourceLocation loc = error.Location; string text = String.Format("{0} ({1}:{2}) error: {3}", Path.GetFileName(loc.File), loc.Line, loc.Column, error.Text); errors [i++] = new IodineString(text); } SetAttribute("errors", new IodineTuple(errors)); }
private IodineObject getSize(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString format = args [0] as IodineString; int ret = 0; int i = 0; while (i < format.Value.Length) { int arg = 1; if (i < format.Value.Length && char.IsDigit(format.Value [i])) { StringBuilder accum = new StringBuilder(); do { accum.Append(format.Value [i++]); } while (i < format.Value.Length && char.IsDigit(format.Value [i])); arg = Int32.Parse(accum.ToString()); } if (i < format.Value.Length) { char specifier = format.Value [i++]; if (i < format.Value.Length && char.IsDigit(format.Value [i])) { StringBuilder accum = new StringBuilder(); do { accum.Append(format.Value [i++]); } while (i < format.Value.Length && char.IsDigit(format.Value [i])); arg = Int32.Parse(accum.ToString()); } if (specifier == 'x') { ret += arg; } else { ret += getSize(specifier, arg); } } } return(new IodineInteger(ret)); }
private IodineObject isMatch(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString expr = args [0] as IodineString; if (expr == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(IodineBool.Create(Value.IsMatch(expr.ToString()))); }
private IodineObject compile(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString expr = args [0] as IodineString; if (expr == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(new IodineRegex(new Regex(expr.ToString()))); }
private IodineObject replace(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString arg1 = args [0] as IodineString; IodineString arg2 = args [1] as IodineString; if (arg1 == null || arg2 == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(new IodineString(Value.Replace(arg1.Value, arg2.Value))); }
private IodineObject ord(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString str = args [0] as IodineString; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(new IodineInteger((int)str.Value [0])); }
private IodineObject Compile(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(1)); return(IodineNull.Instance); } IodineString source = args [0] as IodineString; SourceUnit unit = SourceUnit.CreateFromSource(source.Value); try { return(unit.Compile(vm.Context)); } catch (SyntaxException ex) { vm.RaiseException(new IodineSyntaxException(ex.ErrorLog)); return(IodineNull.Instance); } }
public IodineMethod( IodineModule module, IodineString name, CodeObject bytecode, IodineTuple parameters, MethodFlags flags, IodineObject[] defaultValues, int defaultStart = 0 ) : base(MethodTypeDef) { Module = module; Bytecode = bytecode; ParameterCount = Parameters.Count; Variadic = (flags & MethodFlags.AcceptsVarArgs) != 0; AcceptsKeywordArgs = (flags & MethodFlags.AcceptsKwargs) != 0; HasDefaultValues = (flags & MethodFlags.HasDefaultParameters) != 0; DefaultValuesStartIndex = defaultStart; DefaultValues = defaultValues; SetParameters(Parameters, parameters); Name = name.ToString(); SetAttribute("__doc__", IodineString.Empty); SetAttribute("__invoke__", new BuiltinMethodCallback(invoke, this)); if (AcceptsKeywordArgs) { var lastParameter = Parameters.Last() as IodineNamedParameter; KwargsParameter = lastParameter.Name; if (Variadic) { var secondToLastParameter = Parameters [Parameters.Count - 2] as IodineNamedParameter; VarargsParameter = secondToLastParameter.Name; } } else if (Variadic) { var lastParameter = Parameters.Last() as IodineNamedParameter; VarargsParameter = lastParameter.Name; } }
private IodineObject hasAttribute(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineObject o1 = args [0]; IodineString str = args [1] as IodineString; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(IodineBool.Create(o1.HasAttribute(str.Value))); }
public override IodineObject Invoke(VirtualMachine vm, IodineObject[] args) { if (args.Length == 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString name = args [0] as IodineString; if (name == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } IodineTypeDefinition baseType = IodineObject.ObjectTypeDef; if (args.Length > 1) { baseType = args [1] as IodineTypeDefinition; if (baseType == null) { vm.RaiseException(new IodineTypeException("TypeDef")); return(null); } } IodineTypeDefinition clazz = new IodineTypeDefinition(name.Value); clazz.Base = baseType; if (args.Length > 2) { IodineDictionary map = args [2] as IodineDictionary; foreach (IodineObject key in map.Keys) { clazz.SetAttribute(key.ToString(), map.Get(key)); } } return(clazz); }
private IodineObject setAttribute(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 3) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineObject o1 = args [0]; IodineString str = args [1] as IodineString; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } o1.SetAttribute(str.Value, args [2]); return(null); }
private IodineObject isMatch(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 1) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString data = args [0] as IodineString; IodineString pattern = args [1] as IodineString; if (pattern == null || data == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(IodineBool.Create(Regex.IsMatch(data.ToString(), pattern.ToString()))); }
private IodineObject IsFile(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString path = args [0] as IodineString; if (path == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } return(IodineBool.Create(File.Exists(path.Value))); }
private IodineObject SetEnv(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); } IodineString str = args [0] as IodineString; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } Environment.SetEnvironmentVariable(str.Value, args [1].ToString(), EnvironmentVariableTarget.User); return(null); }
private IodineObject replace(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 1) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString input = args [0] as IodineString; IodineString val = args [0] as IodineString; if (input == null || val == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } Value.Replace(args [0].ToString(), args [1].ToString()); return(null); }
private IodineObject setCwd(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString cwd = args [0] as IodineString; if (cwd == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } Environment.CurrentDirectory = args [0].ToString(); return(null); }
public IodineModule(string name, string location = null) : base(ModuleTypeDef) { if (name == "__init__") { /* * The name __init__ is reserved for packages */ Name = Path.GetFileName(Path.GetDirectoryName(location)); } else { Name = name; } Location = location; SetAttribute("__doc__", IodineString.Empty); Attributes ["__name__"] = new IodineString(Name); }
static IodineObject Captures(VirtualMachine vm, IodineObject self, IodineObject [] args) { var match = self as IodineMatch; if (match == null) { vm.RaiseException(new IodineFunctionInvocationException()); return(null); } var strObjects = new IodineString [match.Value.Captures.Count]; for (int i = 0; i < match.Value.Captures.Count; i++) { strObjects [i] = new IodineString(match.Value.Captures [i].Value); } return(new IodineTuple(strObjects)); }
private IodineObject getEnv(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length <= 0) { vm.RaiseException(new IodineArgumentException(1)); } IodineString str = args [0] as IodineString; if (str == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } if (Environment.GetEnvironmentVariable(str.Value) != null) { return(new IodineString(Environment.GetEnvironmentVariable(str.Value))); } return(null); }
private IodineObject Join(VirtualMachine vm, IodineObject self, IodineObject[] args) { IodineString thisObj = self as IodineString; StringBuilder accum = new StringBuilder(); IodineObject collection = args [0].GetIterator(vm); collection.IterReset(vm); string last = ""; string sep = ""; while (collection.IterMoveNext(vm)) { IodineObject o = collection.IterGetCurrent(vm); accum.AppendFormat("{0}{1}", last, sep); last = o.ToString(vm).ToString(); sep = thisObj.Value; } accum.Append(last); return(new IodineString(accum.ToString())); }
private IodineObject indexOf(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString ch = args [0] as IodineString; char val; if (ch == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } val = ch.Value [0]; return(new IodineInteger(Value.IndexOf(val))); }
private IodineObject System(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(1)); return(null); } IodineString command = args [0] as IodineString; if (command == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } bool isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32S || Environment.OSVersion.Platform == PlatformID.Win32Windows || Environment.OSVersion.Platform == PlatformID.WinCE || Environment.OSVersion.Platform == PlatformID.Xbox; Process proc = null; if (isWindows) { proc = Popen_Win32(command.Value, false, false); } else { proc = Popen_Unix(command.Value, false, false); } proc.Start(); proc.WaitForExit(); return(new IodineInteger(proc.ExitCode)); }
private IodineObject Substring(VirtualMachine vm, IodineObject self, IodineObject[] args) { IodineString thisObj = self as IodineString; if (args.Length < 1) { vm.RaiseException(new IodineArgumentException(1)); return(null); } int start = 0; int len = 0; IodineInteger startObj = args [0] as IodineInteger; if (startObj == null) { vm.RaiseException(new IodineTypeException("Int")); return(null); } start = (int)startObj.Value; if (args.Length == 1) { len = thisObj.Value.Length; } else { IodineInteger endObj = args [1] as IodineInteger; if (endObj == null) { vm.RaiseException(new IodineTypeException("Int")); return(null); } len = (int)endObj.Value; } if (start < thisObj.Value.Length && len <= thisObj.Value.Length) { return(new IodineString(thisObj.Value.Substring(start, len - start))); } vm.RaiseException(new IodineIndexException()); return(null); }
private IodineObject on(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString e = args [0] as IodineString; if (e == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } if (!listeners.ContainsKey(e.Value)) { listeners.Add(e.Value, new List <IodineObject> ()); } listeners [e.Value].Add(args [1]); return(null); }
private IodineObject Copytree(VirtualMachine vm, IodineObject self, IodineObject[] args) { if (args.Length < 2) { vm.RaiseException(new IodineArgumentException(2)); return(null); } IodineString src = args [0] as IodineString; IodineString dest = args [1] as IodineString; if (dest == null || src == null) { vm.RaiseException(new IodineTypeException("Str")); return(null); } CopyDir(src.Value, dest.Value, true); return(null); }
public override void Accept (UseStatement useStmt) { string import = !useStmt.Relative ? useStmt.Module : Path.Combine ( Path.GetDirectoryName (useStmt.Location.File), useStmt.Module); /* * Implementation detail: The use statement in all reality is simply an * alias for the function require (); Here we translate the use statement * into a call to the require function */ if (useStmt.Wildcard) { module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst, module.DefineConstant (new IodineString (import))); module.Initializer.EmitInstruction (useStmt.Location, Opcode.BuildTuple, 0); module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadGlobal, module.DefineConstant (new IodineName ("require"))); module.Initializer.EmitInstruction (useStmt.Location, Opcode.Invoke, 2); module.Initializer.EmitInstruction (useStmt.Location, Opcode.Pop); } else { IodineObject[] items = new IodineObject [useStmt.Imports.Count]; module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst, module.DefineConstant (new IodineString (import))); if (items.Length > 0) { for (int i = 0; i < items.Length; i++) { items [i] = new IodineString (useStmt.Imports [i]); module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst, module.DefineConstant (new IodineString (useStmt.Imports [i]))); } module.Initializer.EmitInstruction (useStmt.Location, Opcode.BuildTuple, items.Length); } module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadGlobal, module.DefineConstant (new IodineName ("require"))); module.Initializer.EmitInstruction (useStmt.Location, Opcode.Invoke, items.Length == 0 ? 1 : 2); module.Initializer.EmitInstruction (useStmt.Location, Opcode.Pop); } }
public static IodineOptions Parse (string[] args) { IodineOptions ret = new IodineOptions (); int i; for (i = 0; i < args.Length; i++) { if (args [i].StartsWith ("-")) { ret.Options.Add (args [i].Substring (1)); } else { ret.FileName = args [i++]; if (!File.Exists (ret.FileName)) { Panic ("Could not find file {0}!", ret.FileName); } break; } } IodineObject[] arguments = new IodineObject [args.Length - i]; int start = i; for (; i < args.Length; i++) { arguments [i - start] = new IodineString (args [i]); } ret.IodineArguments = new IodineList (arguments); return ret; }
public bool TryToConvertFromPrimative(object obj, out IodineObject result) { result = new IodineString (obj.ToString ()); return true; }
public static IodineOptions Parse(string[] args) { IodineOptions ret = new IodineOptions (); int i; for (i = 0; i < args.Length; i++) { if (args [i].StartsWith ("-")) { switch (args [i]) { case "version": case "v": ret.ShowVersion = true; break; default: Panic ("Unknown command line argument '{0}'", args [i]); break; } } else { ret.FileName = args [i++]; if (!System.IO.File.Exists (ret.FileName)) { Panic ("Could not find file {0}!", ret.FileName); } break; } } IodineObject[] arguments = new IodineObject [args.Length - i]; int start = i; for (; i < args.Length; i++) { arguments [i - start] = new IodineString (args [i]); } ret.Arguments = new IodineList (arguments); return ret; }
public IodineTypeDefinition(string name) : base(TypeDefTypeDef) { Name = name; attributes ["__name__"] = new IodineString (name); }
public IodineSyntaxException(ErrorLog errorLog) : base(TypeDefinition, "Syntax error") { Base = new IodineException (); IodineObject[] errors = new IodineObject[errorLog.ErrorCount]; int i = 0; foreach (Error error in errorLog.Errors) { Location loc = error.Location; string text = String.Format ("{0} ({1}:{2}) error: {3}", Path.GetFileName (loc.File), loc.Line, loc.Column, error.Text); errors [i++] = new IodineString (text); } SetAttribute ("errors", new IodineTuple (errors)); }
public void Accept(UseStatement useStmt) { module.Imports.Add (useStmt.Module); string import = !useStmt.Relative ? useStmt.Module : Path.Combine ( Path.GetDirectoryName (useStmt.Location.File), useStmt.Module); if (useStmt.Wildcard) { module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant ( new IodineString (import))); module.Initializer.EmitInstruction (Opcode.BuildTuple, 0); module.Initializer.EmitInstruction (Opcode.LoadGlobal, module.DefineConstant ( new IodineName ("require"))); module.Initializer.EmitInstruction (Opcode.Invoke, 2); module.Initializer.EmitInstruction (Opcode.Pop); } else { IodineObject[] items = new IodineObject [useStmt.Imports.Count]; module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant ( new IodineString (import))); if (items.Length > 0) { for (int i = 0; i < items.Length; i++) { items [i] = new IodineString (useStmt.Imports [i]); module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant ( new IodineString (useStmt.Imports [i]))); } module.Initializer.EmitInstruction (Opcode.BuildTuple, items.Length); } module.Initializer.EmitInstruction (Opcode.LoadGlobal, module.DefineConstant ( new IodineName ("require"))); module.Initializer.EmitInstruction (Opcode.Invoke, items.Length == 0 ? 1 : 2); module.Initializer.EmitInstruction (Opcode.Pop); } }