Redo import

Author: ncw

builtin/builtin.go

@@ -345,11 +345,17 @@ is the number of parent directories to search relative to the current module.`
 
 func builtin___import__(self py.Object, args py.Tuple, kwargs py.StringDict) py.Object {
 	kwlist := []string{"name", "globals", "locals", "fromlist", "level"}
-	var name, globals, locals, fromlist py.Object
+	var name py.Object
+	var globals py.Object = py.NewStringDict()
+	var locals py.Object = py.NewStringDict()
+	var fromlist py.Object = py.Tuple{}
 	var level py.Object = py.Int(0)
 
 	py.ParseTupleAndKeywords(args, kwargs, "U|OOOi:__import__", kwlist, &name, &globals, &locals, &fromlist, &level)
-	return py.ImportModuleLevelObject(name, globals, locals, fromlist, int(level.(py.Int)))
+	if fromlist == py.None {
+		fromlist = py.Tuple{}
+	}
+	return py.ImportModuleLevelObject(string(name.(py.String)), globals.(py.StringDict), locals.(py.StringDict), fromlist.(py.Tuple), int(level.(py.Int)))
 }
 
 const ord_doc = `ord(c) -> integer

compile/compile.go

@@ -68,3 +68,8 @@ sys.stdout.close()`,
 	}
 	return obj
 }
+
+// Set in py to avoid circular import
+func init() {
+	py.Compile = Compile
+}

py/import.go

@@ -3,11 +3,148 @@
 package py
 
 import (
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
 	"strings"
 )
 
+var (
+	// This will become sys.path one day ;-)
+	modulePath = []string{"", "/usr/lib/python3.3", "/usr/local/lib/python3.3/dist-packages", "/usr/lib/python3/dist-packages"}
+)
+
 // The workings of __import__
-func ImportModuleLevelObject(nameObj, given_globals, locals, given_fromlist Object, level int) Object {
+//
+// __import__(name, globals=None, locals=None, fromlist=(), level=0)
+//
+// This function is invoked by the import statement. It can be
+// replaced (by importing the builtins module and assigning to
+// builtins.__import__) in order to change semantics of the import
+// statement, but doing so is strongly discouraged as it is usually
+// simpler to use import hooks (see PEP 302) to attain the same goals
+// and does not cause issues with code which assumes the default
+// import implementation is in use. Direct use of __import__() is also
+// discouraged in favor of importlib.import_module().
+//
+// The function imports the module name, potentially using the given
+// globals and locals to determine how to interpret the name in a
+// package context. The fromlist gives the names of objects or
+// submodules that should be imported from the module given by
+// name. The standard implementation does not use its locals argument
+// at all, and uses its globals only to determine the package context
+// of the import statement.
+//
+// level specifies whether to use absolute or relative imports. 0 (the
+// default) means only perform absolute imports. Positive values for
+// level indicate the number of parent directories to search relative
+// to the directory of the module calling __import__() (see PEP 328
+// for the details).
+//
+// When the name variable is of the form package.module, normally, the
+// top-level package (the name up till the first dot) is returned, not
+// the module named by name. However, when a non-empty fromlist
+// argument is given, the module named by name is returned.
+//
+// For example, the statement import spam results in bytecode
+// resembling the following code:
+//
+// spam = __import__('spam', globals(), locals(), [], 0)
+// The statement import spam.ham results in this call:
+//
+// spam = __import__('spam.ham', globals(), locals(), [], 0)
+//
+// Note how __import__() returns the toplevel module here because this
+// is the object that is bound to a name by the import statement.
+//
+// On the other hand, the statement from spam.ham import eggs, sausage
+// as saus results in
+//
+// _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
+// eggs = _temp.eggs
+// saus = _temp.sausage
+//
+// Here, the spam.ham module is returned from __import__(). From this
+// object, the names to import are retrieved and assigned to their
+// respective names.
+//
+// If you simply want to import a module (potentially within a
+// package) by name, use importlib.import_module().
+//
+// Changed in version 3.3: Negative values for level are no longer
+// supported (which also changes the default value to 0).
+func ImportModuleLevelObject(name string, globals, locals StringDict, fromlist Tuple, level int) Object {
+	// Module already loaded - return that
+	if module, ok := modules[name]; ok {
+		return module
+	}
+
+	if level != 0 {
+		panic("Relative import not supported yet")
+	}
+
+	parts := strings.Split(name, ".")
+	pathParts := path.Join(parts...)
+
+	for _, mpath := range modulePath {
+		if mpath == "" {
+			mpathObj, ok := globals["__file__"]
+			if !ok {
+				panic(ExceptionNewf(SystemError, "Couldn't find __file__ in globals"))
+			}
+			mpath = string(mpathObj.(String))
+		}
+		fullPath := path.Join(mpath, pathParts)
+		// FIXME Read pyc/pyo too
+		fullPath, err := filepath.Abs(fullPath + ".py")
+		if err != nil {
+			continue
+		}
+		// Check if file exists
+		if _, err := os.Stat(fullPath); err == nil {
+			str, err := ioutil.ReadFile(fullPath)
+			if err != nil {
+				panic(ExceptionNewf(OSError, "Couldn't read %q: %v", fullPath, err))
+			}
+			codeObj := Compile(string(str), fullPath, "exec", 0, true)
+			code, ok := codeObj.(*Code)
+			if !ok {
+				panic(ExceptionNewf(ImportError, "Compile didn't return code object"))
+			}
+			module := NewModule(name, "", nil, nil)
+			_, err = Run(module.Globals, module.Globals, code, nil)
+			if err != nil {
+				panic(err)
+			}
+			return module
+		}
+	}
+	panic(ExceptionNewf(ImportError, "No module named '%s'", name))
+
+	// Convert to absolute path if relative
+	// Use __file__ from globals to work out what we are relative to
+
+	// '' in path seems to mean use the current __file__
+
+	// Find a valid path which we need to check for the correct __init__.py in subdirectories etc
+
+	// Look for .py and .pyc files
+
+	// Make absolute module path too if we can for sys.modules
+
+	//How do we uniquely identify modules?
+
+	// SystemError: Parent module '' not loaded, cannot perform relative import
+
+}
+
+// Straight port of the python code
+//
+// This calls functins from _bootstrap.py which is a frozen module
+//
+// Too much functionality for the moment
+func XImportModuleLevelObject(nameObj, given_globals, locals, given_fromlist Object, level int) Object {
 	var abs_name string
 	var builtins_import Object
 	var final_mod Object

py/py.go

@@ -17,6 +17,8 @@ var (
 	// See vm/eval.go - set to avoid circular import
 	Run      func(globals, locals StringDict, code *Code, closure Tuple) (res Object, err error)
 	RunFrame func(frame *Frame) (res Object, err error)
+	// See compile/compile.go - set to avoid circular import
+	Compile func(str, filename, mode string, flags int, dont_inherit bool) Object
 )
 
 // Called to create a new instance of class cls. __new__() is a static method (special-cased so you need not declare it as such) that takes the class of which an instance was requested as its first argument. The remaining arguments are those passed to the object constructor expression (the call to the class). The return value of __new__() should be the new object instance (usually an instance of cls).