should be last fixes before switching over paths and pulling from PR etc: added osfile example test, which uses pkg and imports os -- needed some fixes to get os package to parse, including fixing error conversion from string, and dealing with func literals with no arg names. osfile doesn't actually work b/c python import only working after install -- not worth doing install for test.

Author: Randall C. O'Reilly

SUPPORT_MATRIX.md

@@ -11,11 +11,12 @@ _examples/consts | yes | yes
 _examples/empty | yes | yes
 _examples/funcs | yes | yes
 _examples/gostrings | yes | yes
-_examples/hi | yes | yes
-_examples/iface | yes | yes
+_examples/hi | no | yes
+_examples/iface | no | yes
 _examples/lot | yes | yes
 _examples/maps | yes | yes
 _examples/named | yes | yes
+_examples/osfile | yes | yes
 _examples/pointers | yes | yes
 _examples/pyerrors | yes | yes
 _examples/rename | yes | yes

_examples/osfile/osfile.go

@@ -0,0 +1,30 @@
+// Copyright 2019 The go-python Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package osfile
+
+import (
+	"io"
+	"log"
+	"os"
+)
+
+// note: the real test is to access os.File, io.Writer etc directly
+// these funcs are just dummies to have something here to compile..
+
+func OpenFile(fname string) *os.File {
+	f, err := os.Create(fname)
+	if err != nil {
+		log.Println(err)
+		return nil
+	}
+	return f
+}
+
+func WriteToFile(w io.Writer, str string) {
+	_, err := w.Write([]byte(str))
+	if err != nil {
+		log.Println(err)
+	}
+}

_examples/osfile/test.py

@@ -0,0 +1,35 @@
+# Copyright 2019 The go-python Authors.  All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+## py2/py3 compat
+from __future__ import print_function
+
+# note: this doesn't work without actually doing "make install" in pkg build dir
+# and furthermore, os is also used in python, so probably not very practical
+# to include it in the first place -- need to use a wrapper solution.
+
+from osfile import osfile, os, go
+
+try:
+    f = os.Create("testfile.test")
+except Exception as err:
+    print("os.Create got an error: %s" % (err,))
+    pass
+
+    
+try:
+    f.Write("this is a test of python writing to a Go-opened file\n")
+except Exception as err:
+    print("file.Write got an error: %s" % (err,))
+    pass
+
+f.Close()
+
+try:
+    os.Remove("testfile.test")
+except Exception as err:
+    print("os.Remove got an error: %s" % (err,))
+    pass
+
+

bind/gen_func.go

@@ -207,8 +207,8 @@ func (g *pyGen) genFuncBody(sym *symbol, fsym *Func) {
 	}
 	if isMethod {
 		g.gofile.Printf(
-			`vifc, err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "%s")
-if err != nil {
+			`vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "%s")
+if __err != nil {
 `, symNm)
 		g.gofile.Indent()
 		if nres > 0 {
@@ -227,7 +227,7 @@ if err != nil {
 		g.gofile.Outdent()
 		g.gofile.Printf("}\n")
 	} else if rvIsErr {
-		g.gofile.Printf("var err error\n")
+		g.gofile.Printf("var __err error\n")
 	}
 
 	// pywrap output
@@ -288,9 +288,9 @@ if err != nil {
 		ret := res[0]
 		switch {
 		case rvIsErr:
-			g.gofile.Printf("err = ")
+			g.gofile.Printf("__err = ")
 		case nres == 2:
-			g.gofile.Printf("cret, err := ")
+			g.gofile.Printf("cret, __err := ")
 		case ret.sym.hasHandle() && !ret.sym.isPtrOrIface():
 			hasAddrOfTmp = true
 			g.gofile.Printf("cret := ")
@@ -340,9 +340,9 @@ if err != nil {
 
 	if rvIsErr || nres == 2 {
 		g.gofile.Printf("\n")
-		g.gofile.Printf("if err != nil {\n")
+		g.gofile.Printf("if __err != nil {\n")
 		g.gofile.Indent()
-		g.gofile.Printf("estr := C.CString(err.Error())\n")
+		g.gofile.Printf("estr := C.CString(__err.Error())\n")
 		g.gofile.Printf("C.PyErr_SetString(C.PyExc_RuntimeError, estr)\n")
 		if rvIsErr {
 			g.gofile.Printf("return estr\n") // NOTE: leaked string

bind/stdtypes.go

@@ -339,19 +339,20 @@ func stdBasicTypes() map[string]*symbol {
 		},
 
 		"error": {
-			gopkg:   look("error").Pkg(),
-			goobj:   look("error"),
-			gotyp:   look("error").Type(),
-			kind:    skType | skInterface,
-			goname:  "error",
-			id:      "error",
-			cpyname: "char*",
-			cgoname: "*C.char",
-			pysig:   "str",
-			go2py:   "C.CString",
-			py2go:   "C.GoString",
-			zval:    `""`,
-			pyfmt:   "O&",
+			gopkg:        look("error").Pkg(),
+			goobj:        look("error"),
+			gotyp:        look("error").Type(),
+			kind:         skType | skInterface,
+			goname:       "error",
+			id:           "error",
+			cpyname:      "char*",
+			cgoname:      "*C.char",
+			pysig:        "str",
+			go2py:        "C.CString",
+			py2go:        "errors.New(C.GoString",
+			py2goParenEx: ")",
+			zval:         `""`,
+			pyfmt:        "O&",
 		},
 	}
 

bind/symbols.go

@@ -658,7 +658,7 @@ func (sym *symtab) buildTuple(tuple *types.Tuple, varnm string, methvar string)
 	return bstr, nil
 }
 
-// pyObjectToGo returns code that will decodes a PyObject variable of name objnm into a basic go type
+// pyObjectToGo returns code that decodes a PyObject variable of name objnm into a basic go type
 func (sym *symtab) pyObjectToGo(typ types.Type, sy *symbol, objnm string) (string, error) {
 	bstr := ""
 	bt, isb := typ.Underlying().(*types.Basic)
@@ -687,6 +687,31 @@ func (sym *symtab) pyObjectToGo(typ types.Type, sy *symbol, objnm string) (strin
 	return bstr, nil
 }
 
+// ZeroToGo returns code for a zero of the given type, e.g., to synthesize a zero return value
+func (sym *symtab) ZeroToGo(typ types.Type, sy *symbol) (string, error) {
+	bstr := ""
+	bt, isb := typ.Underlying().(*types.Basic)
+	switch {
+	// case vsym.goname == "interface{}":
+	// 	bstr += fmt.Sprintf("C.PyTuple_SetItem(%s, %d, C.gopy_build_string(%s(%s)%s))\n", varnm, i, vsym.go2py, anm, vsym.go2pyParenEx)
+	// case vsym.hasHandle(): // note: assuming int64 handles
+	// 	bstr += fmt.Sprintf("C.PyTuple_SetItem(%s, %d, C.gopy_build_int64(C.int64_t(%s(%s)%s)))\n", varnm, i, vsym.go2py, anm, vsym.go2pyParenEx)
+	case isb:
+		bk := bt.Kind()
+		switch {
+		case types.Int <= bk && bk <= types.Float64:
+			bstr += fmt.Sprintf("%s(0)%s", sy.py2go, sy.py2goParenEx)
+		case bk == types.String:
+			bstr += `C.GoString(nil)`
+		case bk == types.Bool:
+			bstr += fmt.Sprintf("false")
+		}
+	default:
+		return "", fmt.Errorf("ZeroToGo: type not handled: %s", typ.String())
+	}
+	return bstr, nil
+}
+
 // typeNamePkg gets the goname and package for a given types.Type -- deals with
 // naming for types in other packages, and adds those packages to imports paths.
 // Falls back on sym.pkg if no other package info avail.
@@ -990,18 +1015,19 @@ func (sym *symtab) addSignatureType(pkg *types.Package, obj types.Object, t type
 	fn := sym.fullTypeString(t)
 	kind |= skSignature
 
-	nsig := typeGoName(t.Underlying())
-	py2g := fmt.Sprintf("%s { ", nsig)
-
 	sig := t.Underlying().(*types.Signature)
 	args := sig.Params()
+	nargs := args.Len()
 	rets := sig.Results()
+	nsig := typeGoName(t.Underlying())
+
 	if rets.Len() > 1 {
 		return fmt.Errorf("multiple return values not supported")
 	}
 	retstr := ""
 	var ret *types.Var
 	var rsym *symbol
+
 	if rets.Len() == 1 {
 		retstr = "_fcret := "
 		ret = rets.At(0)
@@ -1011,14 +1037,36 @@ func (sym *symtab) addSignatureType(pkg *types.Package, obj types.Object, t type
 		}
 	}
 
+	if nargs > 0 { // need to deal with unnamed args
+		nsig = "func ("
+		for i := 0; i < nargs; i++ {
+			v := args.At(i)
+			typ := v.Type()
+			anm := pySafeArg(v.Name(), i)
+			if i > 0 {
+				nsig += ", "
+			}
+			nsig += anm + " " + typeGoName(typ)
+		}
+		nsig += ")"
+		if rets.Len() == 1 {
+			nsig += " " + typeGoName(ret.Type())
+		}
+	}
+
+	py2g := fmt.Sprintf("%s { ", nsig)
+
 	// TODO: use strings.Builder
 	if rets.Len() == 0 {
 		py2g += "if C.PyCallable_Check(_fun_arg) == 0 { return }\n"
 	} else {
-		py2g += fmt.Sprintf("if C.PyCallable_Check(_fun_arg) == 0 { return %s(0)%s }\n", rsym.py2go, rsym.py2goParenEx)
+		zstr, err := sym.ZeroToGo(ret.Type(), rsym)
+		if err != nil {
+			return err
+		}
+		py2g += fmt.Sprintf("if C.PyCallable_Check(_fun_arg) == 0 { return %s }\n", zstr)
 	}
 	py2g += "_gstate := C.PyGILState_Ensure()\n"
-	nargs := args.Len()
 	if nargs > 0 {
 		bstr, err := sym.buildTuple(args, "_fcargs", "_fun_arg")
 		if err != nil {

cmd_exe.go

@@ -113,7 +113,13 @@ func gopyRunCmdExe(cmdr *commander.Command, args []string) error {
 	}
 
 	for _, path := range args {
-		rootdir, err := GoSrcDir(path)
+		var rootdir string
+		var err error
+		if strings.HasPrefix(path, "./") {
+			rootdir = path
+		} else {
+			rootdir, err = GoSrcDir(path)
+		}
 		if err != nil {
 			return err
 		}

cmd_pkg.go

@@ -111,7 +111,13 @@ func gopyRunCmdPkg(cmdr *commander.Command, args []string) error {
 	}
 
 	for _, path := range args {
-		rootdir, err := GoSrcDir(path)
+		var rootdir string
+		var err error
+		if strings.HasPrefix(path, "./") {
+			rootdir = path
+		} else {
+			rootdir, err = GoSrcDir(path)
+		}
 		if err != nil {
 			return err
 		}
@@ -125,7 +131,7 @@ func buildPkgRecurse(odir, path, rootdir, pathdir string, exmap map[string]struc
 	gofiles := GoFiles(pathdir)
 	// fmt.Printf("go files: %s\n", gofiles)
 	if len(gofiles) == 0 || (len(gofiles) == 1 && gofiles[0] == "doc.go") {
-		fmt.Printf("\tskipping dir with no go files or only doc.go file: %s\n", pathdir)
+		fmt.Printf("\tskipping dir with no go files or only doc.go file: %s -- %s\n", pathdir, gofiles)
 	} else {
 		if reldir == "" {
 			newPackage(path)

dirs.go

@@ -23,7 +23,7 @@ func GoSrcDir(dir string) (absDir string, err error) {
 			return absDir, nil
 		}
 	}
-	return "", fmt.Errorf("kit.GoSrcDir: unable to locate directory (%q) in GOPATH/src/ (%q) or GOROOT/src/pkg/ (%q)", dir, os.Getenv("GOPATH"), os.Getenv("GOROOT"))
+	return "", fmt.Errorf("GoSrcDir: unable to locate directory (%q) in GOPATH/src/ (%q) or GOROOT/src/pkg/ (%q)", dir, os.Getenv("GOPATH"), os.Getenv("GOROOT"))
 }
 
 // Dirs returns a slice of all the directories within a given directory

gopy.gide

@@ -28,7 +28,7 @@
     "Run Proj"
   ],
   "Find": {
-    "Find": "bool",
+    "Find": "Chdir",
     "Replace": "VarFromHandle",
     "IgnoreCase": false,
     "Langs": [
@@ -37,11 +37,17 @@
     ],
     "Loc": "FindLocAll",
     "FindHist": [
+      "Chdir",
+      "buildTuple",
+      "GoSrcDir",
+      "testPkg",
+      "run(",
+      "run",
+      ") run",
       "bool",
       "genMethod",
       "genFuncBody",
       "boolPyToGo",
-      "buildTuple",
       "could not find symbol",
       "newFuncFrom",
       "*ptrFromHandle",
@@ -54,7 +60,6 @@
       "C.free",
       "c.Free",
       "c.free",
-      "testPkg",
       "VarFmHandle",
       "sliceptr",
       "handle=",
@@ -81,12 +86,7 @@
       "Packages",
       "thePyGen",
       "todo",
-      "with go",
-      "for go",
-      "interface{}",
-      "types.New",
-      "C.Raise",
-      "mutex"
+      "with go"
     ],
     "ReplHist": [
       "VarFromHandle",
@@ -111,13 +111,16 @@
   },
   "OpenDirs": {
     "_examples": true,
+    "_examples/cgo": true,
+    "_examples/consts": true,
     "_examples/funcs": true,
     "_examples/hi": true,
     "_examples/hi/gen": false,
     "_examples/iface": true,
     "_examples/lot": true,
     "_examples/maps": true,
     "_examples/named": true,
+    "_examples/osfile": true,
     "_examples/pointers": true,
     "_examples/rename": true,
     "_examples/structs": true,