renamed py.Ctx to py.Context

go-python · drew-512 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021
commit 8033615317b96cab0fe92cb15a2c394d09f047cf
diff --git a/builtin/builtin.go b/builtin/builtin.go
@@ -172,7 +172,7 @@ func init() {
 		Methods: methods,
 		Globals: globals,
 	})
-	
+
 }
 
 const print_doc = `print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
@@ -190,7 +190,7 @@ func builtin_print(self py.Object, args py.Tuple, kwargs py.StringDict) (py.Obje
 		endObj py.Object = py.String("\n")
 		flush  py.Object
 	)
-	sysModule, err := self.(*py.Module).Ctx.GetModule("sys")
+	sysModule, err := self.(*py.Module).Context.GetModule("sys")
 	if err != nil {
 		return nil, err
 	}
@@ -463,7 +463,7 @@ func builtin___build_class__(self py.Object, args py.Tuple, kwargs py.StringDict
 	}
 	// fmt.Printf("Calling %v with %v and %v\n", fn.Name, fn.Globals, ns)
 	// fmt.Printf("Code = %#v\n", fn.Code)
-	cell, err = fn.Ctx.RunCode(fn.Code, fn.Globals, ns, fn.Closure)
+	cell, err = fn.Context.RunCode(fn.Code, fn.Globals, ns, fn.Closure)
 	if err != nil {
 		return nil, err
 	}

diff --git a/examples/multi-ctx/main.go b/examples/multi-ctx/main.go
@@ -24,7 +24,7 @@ import (
 func main() {
 
 	// The total job count implies a fixed amount of work.
-	// The number of workers is how many py.Ctx (in concurrent goroutines) to pull jobs off the queue.
+	// The number of workers is how many py.Context (in concurrent goroutines) to pull jobs off the queue.
 	// One worker does all the work serially while N number of workers will (ideally) divides up.
 	totalJobs := 20
 
@@ -55,7 +55,7 @@ print("%s ready!" % (WORKER_ID))
 
 type worker struct {
 	name string
-	ctx  py.Ctx
+	ctx  py.Context
 	main *py.Module
 	job  *py.Code
 }
@@ -96,14 +96,14 @@ func RunMultiPi(numWorkers, numTimes int) time.Duration {
 	workers := make([]worker, numWorkers)
 	for i := 0; i < numWorkers; i++ {
 
-		opts := py.DefaultCtxOpts()
+		opts := py.DefaultContextOpts()
 
 		// Make sure our import statement will find pi_chudnovsky_bs
 		opts.SysPaths = append(opts.SysPaths, "..")
 
 		workers[i] = worker{
 			name: fmt.Sprintf("Worker #%d", i+1),
-			ctx:  py.NewCtx(opts),
+			ctx:  py.NewContext(opts),
 			job:  jobCode,
 		}
 
@@ -116,7 +116,7 @@ func RunMultiPi(numWorkers, numTimes int) time.Duration {
 		w := workers[i]
 		go func() {
 
-			// Compiling can be concurrent since there is no associated py.Ctx
+			// Compiling can be concurrent since there is no associated py.Context
 			w.compileTemplate(jobSrcTemplate)
 
 			for jobID := range jobPipe {

diff --git a/main.go b/main.go
@@ -43,11 +43,11 @@ func main() {
 	flag.Usage = syntaxError
 	flag.Parse()
 	args := flag.Args()
-	
-	opts := py.DefaultCtxOpts()
+
+	opts := py.DefaultContextOpts()
 	opts.SysArgs = flag.Args()
-	ctx := py.NewCtx(opts)
-	
+	ctx := py.NewContext(opts)
+
 	if *cpuprofile != "" {
 		f, err := os.Create(*cpuprofile)
 		if err != nil {
@@ -59,7 +59,7 @@ func main() {
 		}
 		defer pprof.StopCPUProfile()
 	}
-	
+
 	// IF no args, enter REPL mode
 	if len(args) == 0 {
 
@@ -70,7 +70,7 @@ func main() {
 
 		replCtx := repl.New(ctx)
 		cli.RunREPL(replCtx)
-		
+
 	} else {
 		_, err := py.RunFile(ctx, args[0], py.CompileOpts{}, nil)
 		if err != nil {

diff --git a/modules/runtime.go b/modules/runtime.go
@@ -23,19 +23,19 @@ import (
 )
 
 func init() {
-	// Assign the base-level py.Ctx creation function while also preventing an import cycle.
-	py.NewCtx = NewCtx
+	// Assign the base-level py.Context creation function while also preventing an import cycle.
+	py.NewContext = NewContext
 }
 
-// ctx implements py.Ctx
-type ctx struct {
+// context implements py.Context
+type context struct {
 	store *py.ModuleStore
-	opts  py.CtxOpts
+	opts  py.ContextOpts
 }
 
-// See py.Ctx interface
-func NewCtx(opts py.CtxOpts) py.Ctx {
-	ctx := &ctx{
+// See py.Context interface
+func NewContext(opts py.ContextOpts) py.Context {
+	ctx := &context{
 		opts: opts,
 	}
 
@@ -50,7 +50,7 @@ func NewCtx(opts py.CtxOpts) py.Ctx {
 	return ctx
 }
 
-func (ctx *ctx) ModuleInit(impl *py.ModuleImpl) (*py.Module, error) {
+func (ctx *context) ModuleInit(impl *py.ModuleImpl) (*py.Module, error) {
 	var err error
 
 	if impl.Code == nil && len(impl.CodeSrc) > 0 {
@@ -87,7 +87,7 @@ func (ctx *ctx) ModuleInit(impl *py.ModuleImpl) (*py.Module, error) {
 	return module, nil
 }
 
-func (ctx *ctx) ResolveAndCompile(pathname string, opts py.CompileOpts) (py.CompileOut, error) {
+func (ctx *context) ResolveAndCompile(pathname string, opts py.CompileOpts) (py.CompileOut, error) {
 	tryPaths := defaultPaths
 	if opts.UseSysPaths {
 		tryPaths = ctx.Store().MustGetModule("sys").Globals["path"].(*py.List).Items
@@ -215,14 +215,14 @@ func resolveRunPath(runPath string, opts py.CompileOpts, pathObjs []py.Object, t
 	return err
 }
 
-func (ctx *ctx) RunCode(code *py.Code, globals, locals py.StringDict, closure py.Tuple) (py.Object, error) {
+func (ctx *context) RunCode(code *py.Code, globals, locals py.StringDict, closure py.Tuple) (py.Object, error) {
 	return vm.EvalCode(ctx, code, globals, locals, nil, nil, nil, nil, closure)
 }
 
-func (ctx *ctx) GetModule(moduleName string) (*py.Module, error) {
+func (ctx *context) GetModule(moduleName string) (*py.Module, error) {
 	return ctx.store.GetModule(moduleName)
 }
 
-func (ctx *ctx) Store() *py.ModuleStore {
+func (ctx *context) Store() *py.ModuleStore {
 	return ctx.store
 }
diff --git a/py/frame.go b/py/frame.go
@@ -26,7 +26,7 @@ type TryBlock struct {
 // A python Frame object
 type Frame struct {
 	// Back       *Frame        // previous frame, or nil
-	Ctx             Ctx        // host module (state) context 
+	Context         Context    // host module (state) context
 	Code            *Code      // code segment
 	Builtins        StringDict // builtin symbol table
 	Globals         StringDict // global symbol table
@@ -78,7 +78,7 @@ func (o *Frame) Type() *Type {
 }
 
 // Make a new frame for a code object
-func NewFrame(ctx Ctx, globals, locals StringDict, code *Code, closure Tuple) *Frame {
+func NewFrame(ctx Context, globals, locals StringDict, code *Code, closure Tuple) *Frame {
 	nlocals := int(code.Nlocals)
 	ncells := len(code.Cellvars)
 	nfrees := len(code.Freevars)
@@ -91,7 +91,7 @@ func NewFrame(ctx Ctx, globals, locals StringDict, code *Code, closure Tuple) *F
 	cellAndFreeVars := allocation[nlocals:varsize]
 
 	return &Frame{
-		Ctx:             ctx,
+		Context:         ctx,
 		Globals:         globals,
 		Locals:          locals,
 		Code:            code,

diff --git a/py/function.go b/py/function.go
@@ -18,7 +18,7 @@ package py
 // A python Function object
 type Function struct {
 	Code        *Code      // A code object, the __code__ attribute
-	Ctx         Ctx        // Host VM context
+	Context     Context    // Host VM context
 	Globals     StringDict // A dictionary (other mappings won't do)
 	Defaults    Tuple      // NULL or a tuple
 	KwDefaults  StringDict // NULL or a dict
@@ -56,7 +56,7 @@ func (f *Function) GetDict() StringDict {
 // attribute. qualname should be a unicode object or ""; if "", the
 // __qualname__ attribute is set to the same value as its __name__
 // attribute.
-func NewFunction(ctx Ctx, code *Code, globals StringDict, qualname string) *Function {
+func NewFunction(ctx Context, code *Code, globals StringDict, qualname string) *Function {
 	var doc Object
 	if len(code.Consts) >= 1 {
 		doc = code.Consts[0]
@@ -73,7 +73,7 @@ func NewFunction(ctx Ctx, code *Code, globals StringDict, qualname string) *Func
 
 	return &Function{
 		Code:     code,
-		Ctx:      ctx,
+		Context:  ctx,
 		Qualname: qualname,
 		Globals:  globals,
 		Name:     code.Name,
@@ -84,7 +84,7 @@ func NewFunction(ctx Ctx, code *Code, globals StringDict, qualname string) *Func
 
 // Call a function
 func (f *Function) M__call__(args Tuple, kwargs StringDict) (Object, error) {
-	result, err := VmEvalCode(f.Ctx, f.Code, f.Globals, NewStringDict(), args, kwargs, f.Defaults, f.KwDefaults, f.Closure)
+	result, err := VmEvalCode(f.Context, f.Code, f.Globals, NewStringDict(), args, kwargs, f.Defaults, f.KwDefaults, f.Closure)
 	if err != nil {
 		return nil, err
 	}

diff --git a/py/import.go b/py/import.go
@@ -11,7 +11,7 @@ import (
 	"strings"
 )
 
-func Import(ctx Ctx, names ...string) error {
+func Import(ctx Context, names ...string) error {
 	for _, name := range names {
 		_, err := ImportModuleLevelObject(ctx, name, nil, nil, nil, 0)
 		if err != nil {
@@ -80,7 +80,7 @@ func Import(ctx Ctx, names ...string) error {
 //
 // Changed in version 3.3: Negative values for level are no longer
 // supported (which also changes the default value to 0).
-func ImportModuleLevelObject(ctx Ctx, name string, globals, locals StringDict, fromlist Tuple, level int) (Object, error) {
+func ImportModuleLevelObject(ctx Context, name string, globals, locals StringDict, fromlist Tuple, level int) (Object, error) {
 	// Module already loaded - return that
 	if module, err := ctx.GetModule(name); err == nil {
 		return module, nil
@@ -124,7 +124,7 @@ func ImportModuleLevelObject(ctx Ctx, name string, globals, locals StringDict, f
 // This calls functins from _bootstrap.py which is a frozen module
 //
 // Too much functionality for the moment
-func XImportModuleLevelObject(ctx Ctx, nameObj, given_globals, locals, given_fromlist Object, level int) (Object, error) {
+func XImportModuleLevelObject(ctx Context, nameObj, given_globals, locals, given_fromlist Object, level int) (Object, error) {
 	var abs_name string
 	var builtins_import Object
 	var final_mod Object
@@ -338,7 +338,7 @@ error:
 }
 
 // The actual import code
-func BuiltinImport(ctx Ctx, self Object, args Tuple, kwargs StringDict, currentGlobal StringDict) (Object, error) {
+func BuiltinImport(ctx Context, self Object, args Tuple, kwargs StringDict, currentGlobal StringDict) (Object, error) {
 	kwlist := []string{"name", "globals", "locals", "fromlist", "level"}
 	var name Object
 	var globals Object = currentGlobal

diff --git a/py/module.go b/py/module.go
@@ -14,23 +14,23 @@ import (
 type ModuleFlags int32
 
 const (
-	// Set for modules that are threadsafe, stateless, and/or can be shared across multiple py.Ctx instances (for efficiency).
-	// Otherwise, a separate module instance is created for each py.Ctx that imports it.
+	// Set for modules that are threadsafe, stateless, and/or can be shared across multiple py.Context instances (for efficiency).
+	// Otherwise, a separate module instance is created for each py.Context that imports it.
 	ShareModule ModuleFlags = 0x01 // @@TODO
 
 	MainModuleName = "__main__"
 )
 
-// ModuleInfo contains info and about a module and can specify flags that affect how it is imported into a py.Ctx
+// ModuleInfo contains info and about a module and can specify flags that affect how it is imported into a py.Context
 type ModuleInfo struct {
 	Name     string // __name__ (if nil, "__main__" is used)
 	Doc      string // __doc__
 	FileDesc string // __file__
 	Flags    ModuleFlags
 }
 
-// ModuleImpl is used for modules that are ready to be imported into a py.Ctx.
-// If a module is threadsafe and stateless it can be shared across multiple py.Ctx instances (for efficiency).
+// ModuleImpl is used for modules that are ready to be imported into a py.Context.
+// If a module is threadsafe and stateless it can be shared across multiple py.Context instances (for efficiency).
 // By convention, .Code is executed when a module instance is initialized.
 // If .Code == nil, then .CodeBuf or .CodeSrc will be auto-compiled to set .Code.
 type ModuleImpl struct {
@@ -42,7 +42,7 @@ type ModuleImpl struct {
 	Code    *Code  // Module code body
 }
 
-// ModuleStore is a container of Module imported into an owning py.Ctx.
+// ModuleStore is a container of Module imported into an owning py.Context.
 type ModuleStore struct {
 	// Registry of installed modules
 	modules map[string]*Module
@@ -85,12 +85,12 @@ func NewModuleStore() *ModuleStore {
 	}
 }
 
-// Module is a runtime instance of a ModuleImpl bound to the py.Ctx that imported it.
+// Module is a runtime instance of a ModuleImpl bound to the py.Context that imported it.
 type Module struct {
 	ModuleInfo
 
 	Globals StringDict
-	Ctx     Ctx
+	Context Context
 }
 
 var ModuleType = NewType("module", "module object")
@@ -112,17 +112,17 @@ func (m *Module) GetDict() StringDict {
 // NewModule adds a new Module instance to this ModuleStore.
 // Each given Method prototype is used to create a new "live" Method bound this the newly created Module.
 // This func also sets appropriate module global attribs based on the given ModuleInfo (e.g. __name__).
-func (store *ModuleStore) NewModule(ctx Ctx, info ModuleInfo, methods []*Method, globals StringDict) (*Module, error) {
+func (store *ModuleStore) NewModule(ctx Context, info ModuleInfo, methods []*Method, globals StringDict) (*Module, error) {
 	if info.Name == "" {
 		info.Name = MainModuleName
 	}
 	m := &Module{
 		ModuleInfo: info,
 		Globals:    globals.Copy(),
-		Ctx:        ctx,
+		Context:    ctx,
 	}
 	// Insert the methods into the module dictionary
-	// Copy each method an insert each "live" with a ptr back to the module (which can also lead us to the host Ctx)
+	// Copy each method an insert each "live" with a ptr back to the module (which can also lead us to the host Context)
 	for _, method := range methods {
 		methodInst := new(Method)
 		*methodInst = *method

diff --git a/py/py.go b/py/py.go
@@ -26,7 +26,7 @@ type IGoInt64 interface {
 
 var (
 	// Set in vm/eval.go - to avoid circular import
-	VmEvalCode func(ctx Ctx, code *Code, globals, locals StringDict, args []Object, kws StringDict, defs []Object, kwdefs StringDict, closure Tuple) (retval Object, err error)
+	VmEvalCode func(ctx Context, code *Code, globals, locals StringDict, args []Object, kws StringDict, defs []Object, kwdefs StringDict, closure Tuple) (retval Object, err error)
 	VmRunFrame func(frame *Frame) (res Object, err error)
 )