static BuiltInModules()
{
var modules = Assembly.GetExecutingAssembly().GetTypes()
.Where(p => p.IsSubclassOf(typeof(IodineModule)));
foreach (Type type in modules)
{
if (type.IsDefined(typeof(IodineBuiltinModule), false))
{
IodineBuiltinModule attr = (IodineBuiltinModule)type.GetCustomAttributes(
typeof(IodineBuiltinModule),
false
).First();
IodineModule module = (IodineModule)Activator.CreateInstance(type);
BuiltinDocString docstr = type.GetCustomAttribute <BuiltinDocString> ();
if (docstr != null)
{
module.SetAttribute("__doc__", new IodineString(docstr.DocumentationString));
}
Modules.Add(attr.Name, module);
}
}
}
private IodineObject Eval(VirtualMachine host, string source, IodineDictionary dict)
{
VirtualMachine vm = host;
IodineContext context = host.Context;
if (dict != null)
{
context = new IodineContext();
context.Globals.Clear();
vm = new VirtualMachine(host.Context);
foreach (IodineObject key in dict.Keys)
{
context.Globals [key.ToString()] = dict.Get(key);
}
}
SourceUnit code = SourceUnit.CreateFromSource(source);
IodineModule module = null;
try {
module = code.Compile(context);
} catch (SyntaxException ex) {
vm.RaiseException(new IodineSyntaxException(ex.ErrorLog));
return(IodineNull.Instance);
}
return(module.Invoke(vm, new IodineObject[] { }));
}
private IodineObject eval(VirtualMachine host, string source, IodineHashMap dict)
{
VirtualMachine vm = host;
if (dict != null)
{
vm = new VirtualMachine(host.Context, new Dictionary <string, IodineObject> ());
foreach (string glob in host.Globals.Keys)
{
vm.Globals [glob] = host.Globals [glob];
}
foreach (IodineObject key in dict.Keys.Values)
{
vm.Globals [key.ToString()] = dict.Dict [key.GetHashCode()];
}
}
IodineContext context = new IodineContext();
SourceUnit code = SourceUnit.CreateFromSource(source);
IodineModule module = null;
try {
module = code.Compile(context);
} catch (SyntaxException ex) {
vm.RaiseException(new IodineSyntaxException(ex.ErrorLog));
return(null);
}
return(vm.InvokeMethod(module.Initializer, null, new IodineObject[] { }));
}
public ModuleCompiler(ErrorLog errorLog, SymbolTable symbolTable, IodineModule module)
{
this.errorLog = errorLog;
this.symbolTable = symbolTable;
this.module = module;
functionCompiler = new FunctionCompiler (errorLog, symbolTable, module.Initializer);
}
public IodineModule CompileAst(IodineModule module, AstRoot ast)
{
ModuleCompiler compiler = new ModuleCompiler (errorLog, symbolTable, module);
ast.Visit (compiler);
module.Initializer.FinalizeLabels ();
optimizeObject (module);
return module;
}
private IodineObject loadModule(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineString pathStr = args [0] as IodineString;
IodineModule module = vm.Context.LoadModule(pathStr.Value);
module.Initializer.Invoke(vm, new IodineObject[] { });
return(module);
}
public IodineMethod(IodineModule module, string name, bool isInstance, int parameterCount,
int localCount) : base(MethodTypeDef)
{
Name = name;
ParameterCount = parameterCount;
Module = module;
LocalCount = localCount;
InstanceMethod = isInstance;
Parameters = new Dictionary <string, int> ();
}
public IodineModule LoadModule(string name, bool useCache = true)
{
IodineModule module = Context.LoadModule(name, useCache);
if (module == null)
{
throw new ModuleNotFoundException(name, Context.SearchPath);
}
return(module);
}
public StackFrame(
IodineModule module,
IodineMethod method,
IodineObject[] arguments,
StackFrame parent,
IodineObject self,
AttributeDictionary locals) : this(module, method, arguments, parent, self)
{
this.locals = locals;
}
public IodineModule LoadModule(string name)
{
IodineModule module = Context.LoadModule(name);
if (module == null)
{
throw new Exception("Could not find module " + name +
"\n Searched in: " + String.Join("\n", Context.SearchPath));
}
return(module);
}
public IodineModule Compile (string moduleName)
{
IodineModule module = new IodineModule (moduleName);
ModuleCompiler compiler = new ModuleCompiler (symbolTable, module);
root.Visit (compiler);
module.Initializer.FinalizeLabels ();
if (context.ShouldOptimize) {
OptimizeObject (module);
}
return module;
}
private IodineObject LoadModule(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString pathStr = args [0] as IodineString;
IodineModule module = vm.Context.LoadModule(pathStr.Value);
module.Invoke(vm, new IodineObject[] { });
return(module);
}
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;
}
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;
}
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 Reload(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(IodineNull.Instance);
}
IodineModule module = args [0] as IodineModule;
if (module == null)
{
vm.RaiseException(new IodineTypeException("Module"));
return(IodineNull.Instance);
}
return(vm.LoadModule(module.Location, false));
}
IodineObject Require(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(IodineNull.Instance);
}
var path = args [0] as IodineString;
if (path == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(IodineNull.Instance);
}
string name = path.Value;
var fullPath = Path.GetFullPath(name);
if (args.Length == 1)
{
// use <module>
if (VirtualMachine.ModuleCache.ContainsKey(fullPath))
{
IodineModule module = VirtualMachine.ModuleCache [fullPath];
vm.Top.StoreLocal(Path.GetFileNameWithoutExtension(fullPath), module);
}
else
{
var module = vm.LoadModule(name);
vm.Top.StoreLocal(Path.GetFileNameWithoutExtension(fullPath), module);
VirtualMachine.ModuleCache [fullPath] = module;
if (module.Initializer != null)
{
module.Invoke(vm, new IodineObject [] { });
}
}
}
else
{
// use <types> from <module>
var names = args [1] as IodineTuple;
if (names == null)
{
vm.RaiseException(new IodineTypeCastException("Tuple"));
return(IodineNull.Instance);
}
IodineModule module = null;
if (VirtualMachine.ModuleCache.ContainsKey(fullPath))
{
module = VirtualMachine.ModuleCache [fullPath];
}
else
{
module = vm.LoadModule(name);
VirtualMachine.ModuleCache [fullPath] = module;
if (module.Initializer != null)
{
module.Invoke(vm, new IodineObject [] { });
}
}
vm.Top.StoreLocal(Path.GetFileNameWithoutExtension(fullPath), module);
if (names.Objects.Length > 0)
{
foreach (IodineObject item in names.Objects)
{
vm.Top.StoreLocal(
item.ToString(),
module.GetAttribute(item.ToString())
);
}
}
else
{
foreach (KeyValuePair <string, IodineObject> kv in module.Attributes)
{
vm.Top.StoreLocal(kv.Key, kv.Value);
}
}
}
return(IodineNull.Instance);
}
public IodineMethod(IodineMethod parent, IodineModule module, string name, bool isInstance, int parameterCount,
int localCount) : this(module, name, isInstance, parameterCount, localCount)
{
this.parent = parent;
}
public IodineMethod (IodineMethod parent, IodineModule module, string name, bool isInstance, int parameterCount,
int localCount) : this (module, name, isInstance, parameterCount, localCount)
{
this.parent = parent;
}
public IodineMethod (IodineModule module, string name, bool isInstance, int parameterCount,
int localCount) : base (MethodTypeDef)
{
Name = name;
ParameterCount = parameterCount;
Module = module;
LocalCount = localCount;
InstanceMethod = isInstance;
Parameters = new Dictionary<string, int> ();
SetAttribute ("__module__", module);
}
public static IodineModule CompileModule(ErrorLog errorLog, string file)
{
if (FindModule (file) != null) {
Tokenizer lexer = new Tokenizer (errorLog, File.ReadAllText (FindModule (file)), file);
TokenStream tokenStream = lexer.Scan ();
if (errorLog.ErrorCount > 0)
return null;
Parser parser = new Parser (tokenStream);
AstRoot root = parser.Parse ();
if (errorLog.ErrorCount > 0)
return null;
SemanticAnalyser analyser = new SemanticAnalyser (errorLog);
SymbolTable symbolTable = analyser.Analyse (root);
if (errorLog.ErrorCount > 0)
return null;
IodineCompiler compiler = new IodineCompiler (errorLog, symbolTable, Path.GetFullPath (file));
IodineModule module = new IodineModule (Path.GetFileNameWithoutExtension (file));
compiler.CompileAst (module, root);
if (errorLog.ErrorCount > 0)
return null;
return module;
} else {
errorLog.AddError (ErrorType.ParserError, new Location (0, 0, file),
"Could not find module {0}", file);
return null;
}
}
public static IodineModule CompileModuleFromSource(ErrorLog errorLog, string source)
{
Tokenizer lexer = new Tokenizer (errorLog, source);
TokenStream tokenStream = lexer.Scan ();
if (errorLog.ErrorCount > 0)
return null;
Parser parser = new Parser (tokenStream);
AstRoot root = parser.Parse ();
if (errorLog.ErrorCount > 0)
return null;
SemanticAnalyser analyser = new SemanticAnalyser (errorLog);
SymbolTable symbolTable = analyser.Analyse (root);
if (errorLog.ErrorCount > 0)
return null;
IodineCompiler compiler = new IodineCompiler (errorLog, symbolTable, "");
IodineModule module = new IodineModule ("");
compiler.CompileAst (module, root);
if (errorLog.ErrorCount > 0)
return null;
return module;
}
private IodineObject require(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString path = args [0] as IodineString;
if (path == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
string name = path.Value;
string fullPath = Path.GetFullPath(name);
if (args.Length == 1)
{
if (VirtualMachine.ModuleCache.ContainsKey(fullPath))
{
IodineModule module = VirtualMachine.ModuleCache [fullPath];
vm.Top.Module.SetAttribute(vm, Path.GetFileNameWithoutExtension(fullPath),
module);
}
else
{
IodineModule module = vm.LoadModule(name);
vm.Top.Module.SetAttribute(vm, Path.GetFileNameWithoutExtension(
fullPath), module);
VirtualMachine.ModuleCache [fullPath] = module;
module.Initializer.Invoke(vm, new IodineObject[] { });
}
}
else
{
IodineTuple names = args [1] as IodineTuple;
if (names == null)
{
vm.RaiseException(new IodineTypeCastException("Tuple"));
return(null);
}
IodineModule module = null;
if (VirtualMachine.ModuleCache.ContainsKey(fullPath))
{
module = VirtualMachine.ModuleCache [fullPath];
}
else
{
module = vm.LoadModule(name);
VirtualMachine.ModuleCache [fullPath] = module;
module.Initializer.Invoke(vm, new IodineObject[] { });
}
vm.Top.Module.SetAttribute(vm, Path.GetFileNameWithoutExtension(fullPath),
module);
if (names.Objects.Length > 0)
{
foreach (IodineObject item in names.Objects)
{
vm.Top.Module.SetAttribute(vm, item.ToString(),
module.GetAttribute(item.ToString()));
}
}
else
{
foreach (KeyValuePair <string, IodineObject> kv in module.Attributes)
{
vm.Top.Module.SetAttribute(vm, kv.Key, kv.Value);
}
}
}
return(null);
}
public ModuleCompiler (SymbolTable symbolTable, IodineModule module)
{
this.symbolTable = symbolTable;
this.module = module;
functionCompiler = new FunctionCompiler (symbolTable, module.Initializer);
}
public IodineModuleBuilder(IodineModule module)
{
}
