public T Call <T> (string name, params object[] args)
{
IodineObject[] arguments = new IodineObject[args.Length];
for (int i = 0; i < args.Length; i++)
{
arguments [i] = typeRegistry.ConvertToIodineObject(args [i]);
}
IodineObject ret = Context.Invoke(module.GetAttribute(name), arguments);
return((T)typeRegistry.ConvertToNativeObject(ret, typeof(T)));
}
/// <summary>
/// Calls an Iodine function in the current module
/// </summary>
/// <param name="name">Function name.</param>
/// <param name="args">Arguments.</param>
public dynamic Call(string name, params object[] args)
{
IodineObject[] arguments = new IodineObject[args.Length];
for (int i = 0; i < args.Length; i++)
{
arguments [i] = typeRegistry.ConvertToIodineObject(args [i]);
}
IodineObject ret = Context.Invoke(module.GetAttribute(name), arguments);
return(IodineDynamicObject.Create(ret, Context.VirtualMachine, typeRegistry));
}
public override bool IterMoveNext(VirtualMachine vm)
{
if (frame.AbortExecution)
{
return(false);
}
vm.NewFrame(frame);
value = vm.EvalCode(Target);
vm.EndFrame();
return(frame.Yielded);
}
private IodineObject readLine(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
StringBuilder accum = new StringBuilder();
int b = stream.ReadByte();
while (b != -1 && b != '\n')
{
accum.Append((char)b);
b = stream.ReadByte();
}
return(new IodineString(accum.ToString()));
}
private static IodineObject ColorPair(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineInteger index = args [0] as IodineInteger;
return(new AttributeWrapper(activeTerminal.ColorPair((int)index.Value)));
}
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
IodineObject[] arguments = new IodineObject[args.Length];
for (int i = 0; i < args.Length; i++)
{
arguments [i] = typeRegistry.ConvertToIodineObject(args [i]);
}
IodineObject returnVal = internalObject.Invoke(internalVm, arguments);
result = typeRegistry.ConvertToNativeObject(returnVal);
return(true);
}
public IodineObject querySql(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
var db = (IodineMySQLConnection)self;
var statement = (IodineString)args [0];
MySqlCommand cmd = new MySqlCommand(statement.Value, db.Connection);
var reader = cmd.ExecuteReader();
var table = new DataTable();
table.Load(reader);
reader.Dispose();
cmd.Dispose();
return(convertDataTable(table));
}
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 DownloadFile(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
ServicePointManager.ServerCertificateValidationCallback += (o, certificate, chain, errors) => true;
IodineString uri = args [0] as IodineString;
IodineString file = args [1] as IodineString;
try {
client.DownloadFile(uri.ToString(), file.ToString());
} catch (Exception e) {
vm.RaiseException(e.Message);
}
return(null);
}
private IodineObject listen(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineInteger backlogObj = args [0] as IodineInteger;
try {
int backlog = (int)backlogObj.Value;
Socket.Listen(backlog);
} catch {
vm.RaiseException("Could not listen to socket!");
return(null);
}
return(null);
}
private static IodineObject GetMaxYx(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(new IodineTuple(new IodineObject[] {
new IodineInteger(Console.WindowHeight),
new IodineInteger(Console.WindowWidth)
}));
}
private static IodineObject GetYx(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(new IodineTuple(new IodineObject[] {
new IodineInteger(Console.CursorTop),
new IodineInteger(Console.CursorLeft)
}));
}
private static IodineObject Print(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
string message = args [0].ToString();
activeTerminal.Print(message);
return(null);
}
private static object ConvertIodineObjectToObject(IodineObject obj)
{
if (obj is IodineInteger)
{
return((Int32)(((IodineInteger)obj).Value));
}
if (obj is IodineString)
{
return(((IodineString)obj).Value);
}
return(null);
}
private IodineObject DownloadRaw(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
ServicePointManager.ServerCertificateValidationCallback += (o, certificate, chain, errors) => true;
IodineString uri = args [0] as IodineString;
byte[] data;
try {
data = client.DownloadData(uri.ToString());
} catch (Exception e) {
vm.RaiseException(e.Message);
return(null);
}
return(new IodineBytes(data));
}
private void OptimizeObject(IodineObject obj)
{
foreach (IodineObject attr in obj.Attributes.Values)
{
if (attr is IodineMethod)
{
IodineMethod method = attr as IodineMethod;
foreach (IBytecodeOptimization opt in Optimizations)
{
opt.PerformOptimization(method);
}
}
}
}
public IodineObject Set(VirtualMachine vm, IodineObject value)
{
if (Setter is IodineMethod)
{
return(vm.InvokeMethod((IodineMethod)Setter, self, new IodineObject[] { value }));
}
if (Setter is IodineBoundMethod)
{
return(vm.InvokeMethod(((IodineBoundMethod)Setter).Method, self,
new IodineObject[] { value }));
}
return(Setter.Invoke(vm, new IodineObject[] { value }));
}
private IodineObject receive(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineInteger n = args [0] as IodineInteger;
StringBuilder accum = new StringBuilder();
for (int i = 0; i < n.Value; i++)
{
int b = stream.ReadByte();
if (b != -1)
{
accum.Append((char)b);
}
}
return(new IodineString(accum.ToString()));
}
private IodineObject UploadString(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
ServicePointManager.ServerCertificateValidationCallback += (o, certificate, chain, errors) => true;
IodineString uri = args [0] as IodineString;
IodineString str = args [1] as IodineString;
try {
string result = client.UploadString(uri.ToString(), "POST", str.ToString());
return(new IodineString(result));
} catch (Exception ex) {
Console.WriteLine(ex.Message);
Console.WriteLine(ex.InnerException);
}
return(new IodineString(""));
}
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 EmitContext(SymbolTable symbolTable,
ModuleBuilder module,
CodeBuilder method,
bool isInClass = false,
bool isInClassBody = false,
bool isPatternExpression = false,
IodineObject patternTempory = null)
{
SymbolTable = symbolTable;
CurrentMethod = method;
CurrentModule = module;
IsInClass = isInClass;
IsInClassBody = isInClassBody;
IsPatternExpression = isPatternExpression;
PatternTemporary = patternTempory;
}
private void WriteConstant(IodineObject obj)
{
var lookup = new Dictionary <Type, Action> ()
{
{ typeof(IodineNull), () => WriteNull() },
{ typeof(IodineBool), () => WriteBool(obj as IodineBool) },
{ typeof(IodineName), () => WriteName(obj as IodineName) },
{ typeof(IodineInteger), () => WriteInt(obj as IodineInteger) },
{ typeof(IodineFloat), () => WriteFloat(obj as IodineFloat) },
{ typeof(IodineBigInt), () => WriteBigInt(obj as IodineBigInt) },
{ typeof(IodineString), () => WriteString(obj as IodineString) },
{ typeof(CodeBuilder), () => WriteCodeObject(obj as CodeBuilder) },
};
lookup [obj.GetType()] ();
}
private IodineObject UploadValues(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
ServicePointManager.ServerCertificateValidationCallback += (o, certificate, chain, errors) => true;
IodineString uri = args [0] as IodineString;
IodineDictionary dict = args [1] as IodineDictionary;
NameValueCollection nv = new NameValueCollection();
foreach (IodineObject key in dict.Keys)
{
nv [key.ToString()] = dict.Get(key).ToString();
}
byte[] result = client.UploadValues(uri.ToString(), nv);
return(new IodineBytes(result));
}
private IodineObject setHost(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString hostObj = args [0] as IodineString;
if (hostObj == null)
{
vm.RaiseException(new IodineTypeException("Str"));
}
host = hostObj.ToString();
return(null);
}
private IodineList ConvertFromArray(ICollection collection)
{
var enumerator = collection.GetEnumerator();
IodineObject [] objects = new IodineObject [collection.Count];
var i = 0;
do
{
objects [i++] = ConvertToIodineObject(enumerator.Current);
if (i == collection.Count)
{
break;
}
} while (enumerator.MoveNext());
return(new IodineList(objects));
}
public object ConvertToNativeObject(IodineObject obj, Type expectedType)
{
if (obj == IodineNull.Instance || obj == null)
{
return(null);
}
IodineTypeDefinition key = obj.TypeDef;
TypeRegistryEntry entry = typeMappings.FirstOrDefault(p => p.IodineType == key && p.NativeType == expectedType);
if (entry != null)
{
return(entry.Mapping.ConvertFrom(this, obj));
}
return(null);
}
public void Run()
{
var version = typeof(IodineContext).Assembly.GetName().Version;
Console.WriteLine("Iodine v{0}-alpha", version.ToString(3));
Console.WriteLine("Fallback REPL. Enter expressions to have them be evaluated");
IodineContext context = new IodineContext();
context.ShouldOptimize = false;
context.Globals ["quit"] = new QuitObject();
while (true)
{
Console.Write(">>> ");
var source = Console.ReadLine().Trim();
try {
if (source.Length > 0)
{
SourceUnit unit = SourceUnit.CreateFromSource(source);
var result = unit.Compile(context);
IodineObject ret = context.Invoke(result, new IodineObject[] { });
if (!(ret is IodineNull))
{
Console.WriteLine(ret.Represent(context.VirtualMachine));
}
}
} catch (UnhandledIodineExceptionException ex) {
Console.Error.WriteLine("*** {0}", ex.OriginalException.GetAttribute("message"));
ex.PrintStack();
context.VirtualMachine.Top = null;
Console.Error.WriteLine();
} catch (ModuleNotFoundException ex) {
Console.Error.WriteLine(ex.ToString());
} catch (SyntaxException syntaxException) {
DisplayErrors(syntaxException.ErrorLog);
} catch (Exception ex) {
Console.Error.WriteLine("Fatal exception has occured!");
Console.Error.WriteLine(ex.Message);
Console.Error.WriteLine("Stack trace: \n{0}", ex.StackTrace);
//Console.Error.WriteLine ("\nIodine stack trace \n{0}", engine.VirtualMachine.GetStackTrace ());
}
}
}
public override IodineObject ConvertFrom(TypeRegistry registry, object obj)
{
var collection = (ICollection)obj;
var enumerator = collection.GetEnumerator();
IodineObject [] objects = new IodineObject [collection.Count];
var i = 0;
do
{
objects [i++] = registry.ConvertToIodineObject(enumerator.Current);
if (i == collection.Count)
{
break;
}
} while (enumerator.MoveNext());
return(new IodineList(objects));
}
private IodineObject send(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
foreach (IodineObject obj in args)
{
if (obj is IodineInteger)
{
stream.WriteByte((byte)((IodineInteger)obj).Value);
stream.Flush();
}
else if (obj is IodineString)
{
var buf = Encoding.UTF8.GetBytes(obj.ToString());
stream.Write(buf, 0, buf.Length);
stream.Flush();
}
}
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);
}
}
