Changeset 173 for trunk/minid

Timestamp:

05/27/07 16:59:34 (2 years ago)

Author:

JarrettBillingsley

Message:

--

Files:

• trunk/minid/arraylib.d (modified) (2 diffs)
• trunk/minid/baselib.d (modified) (8 diffs)
• trunk/minid/charlib.d (modified) (1 diff)
• trunk/minid/compiler.d (modified) (28 diffs)
• trunk/minid/iolib.d (modified) (1 diff)
• trunk/minid/mathlib.d (modified) (1 diff)
• trunk/minid/minid.d (modified) (7 diffs)
• trunk/minid/opcodes.d (modified) (8 diffs)
• trunk/minid/oslib.d (modified) (1 diff)
• trunk/minid/regexplib.d (modified) (1 diff)
• trunk/minid/stringlib.d (modified) (2 diffs)
• trunk/minid/tablelib.d (modified) (3 diffs)
• trunk/minid/types.d (modified) (28 diffs)
• trunk/minid/utils.d (modified) (1 diff)

trunk/minid/arraylib.d

@@ -54 +54 @@
-        );
-
-setGlobal("array"d,
+globals["array"d] =
-        (
-
+.ns
-            "new"d,      new MDClosure(namespace, &newArray, "array.new"),
-            "range"d,    new MDClosure(namespace, &range,    "array.range")
-)
+
-    }
-
@@ -446 +446 @@
-public void init()
-{
-
+.ns
-    new ArrayLib(namespace);
-    MDGlobalState().setMetatable(MDValue.Type.Array, namespace);

trunk/minid/baselib.d

@@ -574 +574 @@
-    {
-        s.push(makeNamespaceIterator(s.getContext!(MDNamespace)));
-
-        return 1;
-    }
@@ -581 +580 @@
-    {
-        if(s.isParam!("class")(0))
-makeNamespaceIterator(s.getParam!(MDClass)(0).fields)
+s.getParam!(MDClass)(0).fields
-        else if(s.isParam!("instance")(0))
-makeNamespaceIterator(s.getParam!(MDInstance)(0).fields)
+s.getParam!(MDInstance)(0).fields
-        else
-            s.throwRuntimeException("Expected class or instance, not '%s'", s.getParam(0u).typeString());
@@ -593 +592 @@
-    {
-        if(s.isParam!("class")(0))
-makeNamespaceIterator(s.getParam!(MDClass)(0).methods)
+s.getParam!(MDClass)(0).methods
-        else if(s.isParam!("instance")(0))
-makeNamespaceIterator(s.getParam!(MDInstance)(0).methods)
+s.getParam!(MDInstance)(0).methods
-        else
-            s.throwRuntimeException("Expected class or instance, not '%s'", s.getParam(0u).typeString());
@@ -704 +703 @@
-        s.push(new MDClosure(upvalues[0].as!(MDClosure).environment, &curryClosure, "curryClosure", upvalues));
-        return 1;
-    }
-    
-    int require(MDState s, uint numParams)
-    {
-        MDGlobalState().importModule(s.getParam!(dchar[])(0));
-        return 0;
-    }
-    
@@ -746 +739 @@
-        MDNamespace env = s.environment(1);
-        s.easyCall(new MDClosure(env, def), 1, MDValue(env));
+        return 1;
+    }
+    
+    int setModuleLoader(MDState s, uint numParams)
+    {
+        MDGlobalState().setModuleLoader(s.getParam!(dchar[])(0), s.getParam!(MDClosure)(1));
+        return 0;
+    }
+    
+    int functionEnvironment(MDState s, uint numParams)
+    {
+        MDClosure cl = s.getContext!(MDClosure);
+        
+        s.push(cl.environment);
+
+        if(numParams > 0)
+            cl.environment = s.getParam!(MDNamespace)(0);
+
-        return 1;
-    }
@@ -1178 +1189 @@
-        lib.stringBufferClass = new BaseLib.MDStringBufferClass();
-
-setGlobal("StringBuffer"d,  lib.stringBufferClass)
-setGlobal("assert"d,        newClosure(&lib.mdassert,              "assert")
-setGlobal("getTraceback"d,  newClosure(&lib.getTraceback,          "getTraceback")
-setGlobal("typeof"d,        newClosure(&lib.mdtypeof,              "typeof")
-setGlobal("fieldsOf"d,      newClosure(&lib.fieldsOf,              "fieldsOf")
-setGlobal("methodsOf"d,     newClosure(&lib.methodsOf,             "methodsOf")
-setGlobal("toString"d,      newClosure(&lib.mdtoString,            "toString")
-setGlobal("rawToString"d,   newClosure(&lib.rawToString,           "rawToString")
-setGlobal("toInt"d,         newClosure(&lib.toInt,                 "toInt")
-setGlobal("toFloat"d,       newClosure(&lib.toFloat,               "toFloat")
-setGlobal("toChar"d,        newClosure(&lib.toChar,                "toChar")
-setGlobal("format"d,        newClosure(&lib.mdformat,              "format")
-setGlobal("writefln"d,      newClosure(&lib.mdwritefln,            "writefln")
-setGlobal("writef"d,        newClosure(&lib.mdwritef,              "writef")
-setGlobal("writeln"d,       newClosure(&lib.writeln,               "writeln")
-setGlobal("write"d,         newClosure(&lib.write,                 "write")
-setGlobal("readf"d,         newClosure(&lib.readf,                 "readf")
-setGlobal("isNull"d,        newClosure(&lib.isParam!("null"),      "isNull")
-setGlobal("isBool"d,        newClosure(&lib.isParam!("bool"),      "isBool")
-setGlobal("isInt"d,         newClosure(&lib.isParam!("int"),       "isInt")
-setGlobal("isFloat"d,       newClosure(&lib.isParam!("float"),     "isFloat")
-setGlobal("isChar"d,        newClosure(&lib.isParam!("char"),      "isChar")
-setGlobal("isString"d,      newClosure(&lib.isParam!("string"),    "isString")
-setGlobal("isTable"d,       newClosure(&lib.isParam!("table"),     "isTable")
-setGlobal("isArray"d,       newClosure(&lib.isParam!("array"),     "isArray")
-setGlobal("isFunction"d,    newClosure(&lib.isParam!("function"),  "isFunction")
-setGlobal("isClass"d,       newClosure(&lib.isParam!("class"),     "isClass")
-setGlobal("isInstance"d,    newClosure(&lib.isParam!("instance"),  "isInstance")
-setGlobal("isNamespace"d,   newClosure(&lib.isParam!("namespace"), "isNamespace")
-setGlobal("isThread"d,      newClosure(&lib.isParam!("thread"),    "isThread")
-setGlobal("currentThread"d, newClosure(&lib.currentThread,         "currentThread")
-setGlobal("curry"d,         newClosure(&lib.curry,                 "curry")
-setGlobal("require"d,       newClosure(&lib.require,               "require")
-setGlobal("loadString"d,    newClosure(&lib.loadString,            "loadString")
-setGlobal("eval"d,          newClosure(&lib.eval,                  "eval")
-setGlobal("loadJSON"d,      newClosure(&lib.loadJSON,              "loadJSON")
+globals["StringBuffer"d] =    lib.stringBufferClass
+globals["assert"d] =          newClosure(&lib.mdassert,              "assert"
+globals["getTraceback"d] =    newClosure(&lib.getTraceback,          "getTraceback"
+globals["typeof"d] =          newClosure(&lib.mdtypeof,              "typeof"
+globals["fieldsOf"d] =        newClosure(&lib.fieldsOf,              "fieldsOf"
+globals["methodsOf"d] =       newClosure(&lib.methodsOf,             "methodsOf"
+globals["toString"d] =        newClosure(&lib.mdtoString,            "toString"
+globals["rawToString"d] =     newClosure(&lib.rawToString,           "rawToString"
+globals["toInt"d] =           newClosure(&lib.toInt,                 "toInt"
+globals["toFloat"d] =         newClosure(&lib.toFloat,               "toFloat"
+globals["toChar"d] =          newClosure(&lib.toChar,                "toChar"
+globals["format"d] =          newClosure(&lib.mdformat,              "format"
+globals["writefln"d] =        newClosure(&lib.mdwritefln,            "writefln"
+globals["writef"d] =          newClosure(&lib.mdwritef,              "writef"
+globals["writeln"d] =         newClosure(&lib.writeln,               "writeln"
+globals["write"d] =           newClosure(&lib.write,                 "write"
+globals["readf"d] =           newClosure(&lib.readf,                 "readf"
+globals["isNull"d] =          newClosure(&lib.isParam!("null"),      "isNull"
+globals["isBool"d] =          newClosure(&lib.isParam!("bool"),      "isBool"
+globals["isInt"d] =           newClosure(&lib.isParam!("int"),       "isInt"
+globals["isFloat"d] =         newClosure(&lib.isParam!("float"),     "isFloat"
+globals["isChar"d] =          newClosure(&lib.isParam!("char"),      "isChar"
+globals["isString"d] =        newClosure(&lib.isParam!("string"),    "isString"
+globals["isTable"d] =         newClosure(&lib.isParam!("table"),     "isTable"
+globals["isArray"d] =         newClosure(&lib.isParam!("array"),     "isArray"
+globals["isFunction"d] =      newClosure(&lib.isParam!("function"),  "isFunction"
+globals["isClass"d] =         newClosure(&lib.isParam!("class"),     "isClass"
+globals["isInstance"d] =      newClosure(&lib.isParam!("instance"),  "isInstance"
+globals["isNamespace"d] =     newClosure(&lib.isParam!("namespace"), "isNamespace"
+globals["isThread"d] =        newClosure(&lib.isParam!("thread"),    "isThread"
+globals["currentThread"d] =   newClosure(&lib.currentThread,         "currentThread"
+globals["curry"d] =           newClosure(&lib.curry,                 "curry"
+globals["loadString"d] =      newClosure(&lib.loadString,            "loadString"
+globals["eval"d] =            newClosure(&lib.eval,                  "eval"
+globals["loadJSON"d] =        newClosure(&lib.loadJSON,              "loadJSON"
+globals["setModuleLoader"d] = newClosure(&lib.setModuleLoader,       "setModuleLoader"
-
-        MDNamespace namespace = MDNamespace.create
-        (
-
+.ns
-            "opApply"d,             newClosure(&lib.namespaceApply,        "namespace.opApply")
-        );
@@ -1225 +1236 @@
-        MDNamespace thread = MDNamespace.create
-        (
-
+.ns
-            "state"d,               newClosure(&lib.threadState,           "thread.state"),
-            "isInitial"d,           newClosure(&lib.isInitial,             "thread.isInitial"),
@@ -1238 +1249 @@
-
-        setMetatable(MDValue.Type.Thread, thread);
+        
+        MDNamespace func = MDNamespace.create
+        (
+            "function"d, globals.ns,
+            "environment"d,         newClosure(&lib.functionEnvironment,   "function.environment")
+        );
+        
+        setMetatable(MDValue.Type.Function, func);
-    }
-}

trunk/minid/charlib.d

@@ -126 +126 @@
-public void init()
-{
-
+.ns
-    new CharLib(namespace);
-    MDGlobalState().setMetatable(MDValue.Type.Char, namespace);

trunk/minid/compiler.d

@@ -140 +140 @@
-        Local,
-        Module,
+        Namespace,
-        Null,
-        Return,
@@ -237 +238 @@
-        Type.Local: "local",
-        Type.Module: "module",
+        Type.Namespace: "namespace",
-        Type.Null: "null",
-        Type.Return: "return",
@@ -336 +338 @@
-        stringToType["local"] = Type.Local;
-        stringToType["module"] = Type.Module;
+        stringToType["namespace"] = Type.Namespace;
-        stringToType["null"] = Type.Null;
-        stringToType["return"] = Type.Return;
@@ -462 +465 @@
-
-            mEncoding = Encoding.UTF8;
-            //mCharacter = firstChar;
-            //mCharacter = 0;
-        }
-        else
@@ -815 +816 @@
-                switch(mCharacter)
-                {
-
+, 'B'
-                        nextChar();
-
-
+ && mCharacter != '_'
-                            throw new MDCompileException(mLoc, "Binary digit expected, not '%s'", mCharacter);
-
@@ -845 +846 @@
-                        return true;
-
-
+, 'C'
-                        nextChar();
-
-
+ && mCharacter != '_'
-                            throw new MDCompileException(mLoc, "Octal digit expected, not '%s'", mCharacter);
-
@@ -875 +876 @@
-                        return true;
-
-
+, 'X'
-                        nextChar();
-
@@ -3550 +3551 @@
-}
-
+class NamespaceDef
+{
+    protected Location mLocation;
+    protected Location mEndLocation;
+    protected Identifier mName;
+    protected Expression mParent;
+    
+    struct Field
+    {
+        dchar[] name;
+        Expression initializer;
+    }
+
+    protected Field[] mFields;
+
+    public this(Location location, Location endLocation, Identifier name, Expression parent, Field[] fields)
+    {
+        mLocation = location;
+        mEndLocation = endLocation;
+        mName = name;
+        mParent = parent;
+        mFields = fields;
+    }
+
+    public static NamespaceDef parse(ref Token* t)
+    {
+        Location location = t.location;
+        t = t.expect(Token.Type.Namespace);
+
+        Identifier name = Identifier.parse(t);
+        Expression parent;
+
+        if(t.type == Token.Type.Colon)
+        {
+            t = t.nextToken;
+            parent = Expression.parse(t);
+        }
+        else
+            parent = new NullExp(t.location);
+
+        t = t.expect(Token.Type.LBrace);
+        
+        Expression[dchar[]] fields;
+
+        void addField(Identifier name, Expression v)
+        {
+            if(name.mName in fields)
+                throw new MDCompileException(name.mLocation, "Redeclaration of member '%s'", name.mName);
+
+            fields[name.mName] = v;
+        }
+        
+        while(t.type != Token.Type.RBrace)
+        {
+            switch(t.type)
+            {
+                case Token.Type.Function:
+                    FuncDef fd = FuncDef.parseSimple(t);
+                    addField(fd.mName, new FuncLiteralExp(fd.mLocation, fd.mEndLocation, fd));
+                    break;
+
+                case Token.Type.Ident:
+                    Identifier id = Identifier.parse(t);
+
+                    Expression v;
+
+                    if(t.type == Token.Type.Assign)
+                    {
+                        t = t.nextToken;
+                        v = Expression.parse(t);
+                    }
+                    else
+                        v = new NullExp(id.mLocation);
+
+                    t = t.expect(Token.Type.Semicolon);
+                    addField(id, v);
+                    break;
+
+                case Token.Type.EOF:
+                    throw new MDCompileException(t.location, "Namespace at ", location.toString(), " is missing its closing brace");
+
+                default:
+                    throw new MDCompileException(t.location, "Namespace member expected, not '%s'", t.toString());
+            }
+        }
+
+        Field[] fieldsArray = new Field[fields.length];
+
+        uint i = 0;
+
+        foreach(name, initializer; fields)
+        {
+            fieldsArray[i].name = name;
+            fieldsArray[i].initializer = initializer;
+            i++;
+        }
+
+        t.expect(Token.Type.RBrace);
+        Location endLocation = t.location;
+        t = t.nextToken;
+        
+        return new NamespaceDef(location, endLocation, name, parent, fieldsArray);
+    }
+
+    public void codeGen(FuncState s)
+    {
+        mParent.codeGen(s);
+        Exp parent;
+        s.popSource(mLocation.line, parent);
+        s.freeExpTempRegs(&parent);
+
+        uint destReg = s.pushRegister();
+        uint nameConst = s.tagConst(s.codeStringConst(mName.mName));
+        s.codeR(mLocation.line, Op.Namespace, destReg, nameConst, parent.index);
+
+        foreach(field; mFields)
+        {
+            uint index = s.tagConst(s.codeStringConst(field.name));
+
+            field.initializer.codeGen(s);
+            Exp val;
+            s.popSource(field.initializer.mEndLocation.line, val);
+            s.codeR(field.initializer.mEndLocation.line, Op.IndexAssign, destReg, index, val.index);
+            s.freeExpTempRegs(&val);
+        }
+
+        s.pushTempReg(destReg);
+    }
+
+    public NamespaceDef fold()
+    {
+        foreach(ref field; mFields)
+            field.initializer = field.initializer.fold();
+
+        return this;
+    }
+}
+
-class Module
-{
@@ -3555 +3694 @@
-    protected Location mEndLocation;
-    protected ModuleDeclaration mModDecl;
-    protected dchar[][] mImports;
-    protected Statement[] mStatements;
-
-dchar[][] imports, 
+
-    {
-        mLocation = location;
-        mEndLocation = endLocation;
-        mModDecl = modDecl;
-        mImports = imports;
-        mStatements = statements;
-    }
@@ -3571 +3708 @@
-        Location location = t.location;
-        ModuleDeclaration modDecl = ModuleDeclaration.parse(t);
-
+
-        List!(Statement) statements;
-
-        bool[dchar[]] imports;
-
-        void addImport(ImportStatement imp)
-        {
-            imports[Identifier.toLongString(imp.mNames)] = true;
-            statements.add(imp);
-        }
-
-        while(t.type != Token.Type.EOF)
-
-
-
-
-
-
+
-
-        t.expect(Token.Type.EOF);
-
-imports.keys.sort, 
+
-    }
-
@@ -3598 +3722 @@
-    {
-        MDModuleDef def = new MDModuleDef();
-
+
-        def.mName = Identifier.toLongString(mModDecl.mNames);
-
-
-
+
+
-        fs.mIsVararg = true;
-
@@ -3631 +3754 @@
-    {
-        writefln("module %s", Identifier.toLongString(mModDecl.mNames));
-
-        foreach(name; mImports)
-            writefln("import %s", name);
-    }
-}
@@ -3693 +3813 @@
-                return ExpressionStatement.parse(t);
-
-
+, Token.Type.Namespace
-                return DeclarationStatement.parse(t);
+                
+            case Token.Type.Import:
+                return ImportStatement.parse(t);
-
-            case Token.Type.LBrace:
@@ -3721 +3844 @@
-            case Token.Type.Switch:
-                return SwitchStatement.parse(t);
-                
-            //case Token.Type.Case:
-            //  return CaseStatement.parse(t);
-
-            //case Token.Type.Default:
-            //  return DefaultStatement.parse(t);
-
-            case Token.Type.Continue:
@@ -3764 +3881 @@
-class ImportStatement : Statement
-{
-Identifier[] mNames
+Expression mExpr
-    protected Identifier[] mSymbols;
-
-Identifier[] names
+Expression expr
-    {
-        super(location, endLocation);
-
-Names = names
+
+Expr = expr
-        mSymbols = symbols;
-    }
@@ -3780 +3897 @@
-
-        t = t.expect(Token.Type.Import);
-
-
-
-
-
+
+
+
+
-        {
-            t = t.nextToken;
+            expr = Expression.parse(t);
+            t = t.expect(Token.Type.RParen);
+        }
+        else
+        {
+            Identifier[] names;
-            names ~= Identifier.parse(t);
-
-
+
+
+
+
+
+
+
+
+
+
-        Identifier[] symbols;
-
@@ -3808 +3938 @@
-        t = t.nextToken;
-
-
-
-
-
-
-
+
-    }
-
-    public override void codeGen(FuncState s)
-    {
-        if(mSymbols.length == 0)
-            return;
-
-        foreach(i, sym; mSymbols)
-        {
@@ -3832 +3954 @@
-            }
-        }
-
+
+
+
-        foreach(sym; mSymbols)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-            s.pushVar(mNames[0]);
-
+
-            foreach(name; mNames[1 .. $])
-            {
@@ -3848 +3990 @@
-            s.popField(mLocation.line, sym);
-
-
+*/
-            s.insertLocal(sym);
-        }
@@ -3985 +4127 @@
-            else if(t.nextToken.type == Token.Type.Class)
-                return ClassDecl.parse(t);
+            else if(t.nextToken.type == Token.Type.Namespace)
+                return NamespaceDecl.parse(t);
-            else
-                throw new MDCompileException(location, "Illegal token '%s' after '%s'", t.nextToken.toString(), t.toString());
@@ -3992 +4136 @@
-        else if(t.type == Token.Type.Class)
-            return ClassDecl.parse(t);
+        else if(t.type == Token.Type.Namespace)
+            return NamespaceDecl.parse(t);
-        else
-            throw new MDCompileException(location, "Declaration expected, not '%s'", t.toString());
@@ -4251 +4397 @@
-    }
-
+    public override void codeGen(FuncState s)
+    {
+        if(mProtection == Protection.Local)
+        {
+            s.insertLocal(mDef.mName);
+            s.activateLocals(1);
+            s.pushVar(mDef.mName);
+        }
+        else
+        {
+            assert(mProtection == Protection.Global);
+            s.pushNewGlobal(mDef.mName);
+        }
+
+        mDef.codeGen(s);
+        s.popAssign(mEndLocation.line);
+    }
+    
+    public override Declaration fold()
+    {
+        mDef = mDef.fold();
+        return this;
+    }
+}
+
+class NamespaceDecl : Declaration
+{
+    protected NamespaceDef mDef;
+
+    public this(Location location, Protection protection, NamespaceDef def)
+    {
+        super(location, def.mEndLocation, protection);
+
+        mDef = def;
+    }
+
+    public static NamespaceDecl parse(ref Token* t)
+    {
+        Location location = t.location;
+        Protection protection = Protection.Local;
+        
+        if(t.type == Token.Type.Global)
+        {
+            protection = Protection.Global;
+            t = t.nextToken;
+        }
+        else if(t.type == Token.Type.Local)
+            t = t.nextToken;
+
+        NamespaceDef def = NamespaceDef.parse(t);
+
+        return new NamespaceDecl(location, protection, def);
+    }
+    
-    public override void codeGen(FuncState s)
-    {
@@ -6050 +6250 @@
-            _commonParse:
-                t = t.nextToken;
-OrOrExp
+Expression
-                exp1 = new OpEqExp(location, exp2.mEndLocation, type, exp1, exp2);
-                break;
@@ -6056 +6256 @@
-            case Token.Type.CatEq:
-                t = t.nextToken;
-OrOrExp
+Expression
-                exp1 = new CatEqExp(location, exp2.mEndLocation, exp1, exp2);
-                break;
@@ -7689 +7889 @@
-            s.freeExpTempRegs(&src);
-            assert(s.nextRegister() == funcReg);
-            //assert(src.index < funcReg + 2);
-
-            s.pushRegister();
@@ -7933 +8132 @@
-                break;
-                
+            case Token.Type.Namespace:
+                exp = NamespaceCtorExp.parse(t);
+                break;
+                
-            case Token.Type.Yield:
-                exp = YieldExp.parse(t);
@@ -8527 +8730 @@
-    {
-        super(location, endLocation);
-
+
-        if(fields.length > 0)
-            mEndLocation = fields[$ - 1][1].mEndLocation;
@@ -8832 +9035 @@
-}
-
+class NamespaceCtorExp : PrimaryExp
+{
+    protected NamespaceDef mDef;
+
+    public this(Location location, Location endLocation, NamespaceDef def)
+    {
+        super(location, endLocation);
+        
+        mDef = def;
+    }
+
+    public static NamespaceCtorExp parse(ref Token* t)
+    {
+        Location location = t.location;
+        NamespaceDef def = NamespaceDef.parse(t);
+
+        return new NamespaceCtorExp(location, def.mEndLocation, def);
+    }
+    
+    public override void codeGen(FuncState s)
+    {
+        mDef.codeGen(s);
+    }
+    
+    public InstRef* codeCondition(FuncState s)
+    {
+        throw new MDCompileException(mLocation, "Cannot use namespace constructor as a condition");
+    }
+
+    public override Expression fold()
+    {
+        mDef = mDef.fold();
+        return this;
+    }
+}
+
-class YieldExp : PrimaryExp
-{

trunk/minid/iolib.d

@@ -557 +557 @@
-public void init()
-{
-
+.ns
-    new IOLib(namespace);
-setGlobal("io"d, namespace)
+globals["io"d] = namespace
-}

trunk/minid/mathlib.d

@@ -289 +289 @@
-public void init()
-{
-
+.ns
-    new MathLib(namespace);
-setGlobal("math"d, namespace)
+globals["math"d] = namespace
-}

trunk/minid/minid.d

@@ -24 +24 @@
-module minid.minid;
-
+public import minid.compiler;
-public import minid.types;
-public import minid.compiler;
-public import minid.utils;
-
+import arraylib = minid.arraylib;
-import baselib = minid.baselib;
-import stringlib = minid.stringlib;
-import arraylib = minid.arraylib;
-import tablelib = minid.tablelib;
-import mathlib = minid.mathlib;
-import charlib = minid.charlib;
-import iolib = minid.iolib;
+import mathlib = minid.mathlib;
-import oslib = minid.oslib;
-import regexplib = minid.regexplib;
-
+
+
+
+
-import path = std.path;
-file = std.file
+std.string
-import utf = std.utf;
-import std.string;
-
-/**
@@ -95 +95 @@
-    libs = An ORing together of any standard libraries you want to load (see the MDStdlib enum).
-    Defaults to MDStdlib.All.
-
+
-Returns:
-    The main thread state associated with the global state.
@@ -104 +104 @@
-    {
-        MDGlobalState();
+        MDGlobalState().tryPath = &tryPath;
+        version(MDNoDynLibs){}else MDGlobalState().tryDynLibPath = &tryDynLibPath;
-
-        baselib.init();
@@ -118 +120 @@
-        if(libs & MDStdlib.Math)
-            mathlib.init();
+            
+        if(libs & MDStdlib.OS)
+            oslib.init();
+            
+        if(libs & MDStdlib.Regexp)
+            regexplib.init();
-
-        if(libs & MDStdlib.String)
@@ -124 +132 @@
-        if(libs & MDStdlib.Table)
-            tablelib.init();
-            
-        if(libs & MDStdlib.OS)
-            oslib.init();
-            
-        if(libs & MDStdlib.Regexp)
-            regexplib.init();
-
-        MDGlobalState().registerModuleLoader(&MDFileLoader().load);
-    }
-
@@ -137 +137 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-