added py.CompileMode instead of string

go-python · sbinet · Feb 7, 2022 · Feb 3, 2022 · Feb 3, 2022 · Feb 3, 2022
commit fc528c7da59f94df4ec9fcf45c9c9100c07ce7b2
diff --git a/compile/compile.go b/compile/compile.go
@@ -89,33 +89,36 @@ func init() {
 	py.Compile = Compile
 }
 
-// Compile(source, filename, mode, flags, dont_inherit) -> code object
+// Compile(src, srcDesc, compileMode, flags, dont_inherit) -> code object
 //
 // Compile the source string (a Python module, statement or expression)
-// into a code object that can be executed by exec() or eval().
-// The filename will be used for run-time error messages.
-// The mode must be 'exec' to compile a module, 'single' to compile a
-// single (interactive) statement, or 'eval' to compile an expression.
+// into a code object that can be executed.
+//
+// srcDesc is used for run-time error messages and is typically a file system pathname,
+//
+// See py.CompileMode for compile mode options.
+//
 // The flags argument, if present, controls which future statements influence
 // the compilation of the code.
+//
 // The dont_inherit argument, if non-zero, stops the compilation inheriting
 // the effects of any future statements in effect in the code calling
 // compile; if absent or zero these statements do influence the compilation,
 // in addition to any features explicitly specified.
-func Compile(str, filename, mode string, futureFlags int, dont_inherit bool) (py.Object, error) {
+func Compile(src, srcDesc string, mode py.CompileMode, futureFlags int, dont_inherit bool) (*py.Code, error) {
 	// Parse Ast
-	Ast, err := parser.ParseString(str, mode)
+	Ast, err := parser.ParseString(src, mode)
 	if err != nil {
 		return nil, err
 	}
 	// Make symbol table
-	SymTable, err := symtable.NewSymTable(Ast, filename)
+	SymTable, err := symtable.NewSymTable(Ast, srcDesc)
 	if err != nil {
 		return nil, err
 	}
 	c := newCompiler(nil, compilerScopeModule)
-	c.Filename = filename
-	err = c.compileAst(Ast, filename, futureFlags, dont_inherit, SymTable)
+	c.Filename = srcDesc
+	err = c.compileAst(Ast, srcDesc, futureFlags, dont_inherit, SymTable)
 	if err != nil {
 		return nil, err
 	}

diff --git a/compile/compile_data_test.go b/compile/compile_data_test.go
@@ -12,7 +12,7 @@ import (
 
 var compileTestData = []struct {
 	in            string
-	mode          string // exec, eval or single
+	mode          py.CompileMode
 	out           *py.Code
 	exceptionType *py.Type
 	errString     string

diff --git a/parser/grammar_test.go b/parser/grammar_test.go
@@ -21,7 +21,7 @@ var debugLevel = flag.Int("debugLevel", 0, "Debug level 0-4")
 func TestGrammar(t *testing.T) {
 	SetDebug(*debugLevel)
 	for _, test := range grammarTestData {
-		Ast, err := ParseString(test.in, test.mode)
+		Ast, err := ParseString(test.in, py.CompileMode(test.mode))
 		if err != nil {
 			if test.exceptionType == nil {
 				t.Errorf("%s: Got exception %v when not expecting one", test.in, err)

diff --git a/parser/lexer.go b/parser/lexer.go
@@ -62,20 +62,20 @@ type yyLex struct {
 // can be 'exec' if source consists of a sequence of statements,
 // 'eval' if it consists of a single expression, or 'single' if it
 // consists of a single interactive statement
-func NewLex(r io.Reader, filename string, mode string) (*yyLex, error) {
+func NewLex(r io.Reader, filename string, mode py.CompileMode) (*yyLex, error) {
 	x := &yyLex{
 		reader:      bufio.NewReader(r),
 		filename:    filename,
 		indentStack: []int{0},
 		state:       readString,
 	}
 	switch mode {
-	case "exec":
+	case py.ExecMode:
 		x.queue(FILE_INPUT)
 		x.exec = true
-	case "eval":
+	case py.EvalMode:
 		x.queue(EVAL_INPUT)
-	case "single":
+	case py.SingleMode:
 		x.queue(SINGLE_INPUT)
 		x.interactive = true
 	default:
@@ -933,7 +933,7 @@ func SetDebug(level int) {
 }
 
 // Parse a file
-func Parse(in io.Reader, filename string, mode string) (mod ast.Mod, err error) {
+func Parse(in io.Reader, filename string, mode py.CompileMode) (mod ast.Mod, err error) {
 	lex, err := NewLex(in, filename, mode)
 	if err != nil {
 		return nil, err
@@ -952,12 +952,12 @@ func Parse(in io.Reader, filename string, mode string) (mod ast.Mod, err error)
 }
 
 // Parse a string
-func ParseString(in string, mode string) (ast.Ast, error) {
+func ParseString(in string, mode py.CompileMode) (ast.Ast, error) {
 	return Parse(bytes.NewBufferString(in), "<string>", mode)
 }
 
 // Lex a file only, returning a sequence of tokens
-func Lex(in io.Reader, filename string, mode string) (lts LexTokens, err error) {
+func Lex(in io.Reader, filename string, mode py.CompileMode) (lts LexTokens, err error) {
 	lex, err := NewLex(in, filename, mode)
 	if err != nil {
 		return nil, err
@@ -984,6 +984,6 @@ func Lex(in io.Reader, filename string, mode string) (lts LexTokens, err error)
 }
 
 // Lex a string
-func LexString(in string, mode string) (lts LexTokens, err error) {
+func LexString(in string, mode py.CompileMode) (lts LexTokens, err error) {
 	return Lex(bytes.NewBufferString(in), "<string>", mode)
 }
diff --git a/parser/lexer_test.go b/parser/lexer_test.go
@@ -196,7 +196,7 @@ func TestLex(t *testing.T) {
 	for _, test := range []struct {
 		in        string
 		errString string
-		mode      string
+		mode      py.CompileMode
 		lts       LexTokens
 	}{
 		{"", "", "exec", LexTokens{

diff --git a/symtable/symtable_data_test.go b/symtable/symtable_data_test.go
@@ -12,7 +12,7 @@ import (
 
 var symtableTestData = []struct {
 	in            string
-	mode          string // exec, eval or single
+	mode          py.CompileMode
 	out           *SymTable
 	exceptionType *py.Type
 	errString     string