// Copyright 2018 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.
// Code objects
package py
import (
"strings"
)
// Code object
//
// Freevars are variables declared in the namespace where the
// code object was defined, they are used when closures are
// used - these become Cellvars in the function with a closure.
//
// Cellvars are names of local variables referenced by functions with
// a closure.
type Code struct {
Argcount int32 // #arguments, except *args
Kwonlyargcount int32 // #keyword only arguments
Nlocals int32 // #local variables
Stacksize int32 // #entries needed for evaluation stack
Flags int32 // CO_..., see below
Code string // instruction opcodes
Consts Tuple // list (constants used)
Names []string // list of strings (names used)
Varnames []string // tuple of strings (local variable names)
Freevars []string // tuple of strings (free variable names)
Cellvars []string // tuple of strings (cell variable names)
// The rest doesn't count for hash or comparisons
Cell2arg []byte // Maps cell vars which are arguments.
Filename string // unicode (where it was loaded from)
Name string // unicode (name, for reference)
Firstlineno int32 // first source line number
Lnotab string // string (encoding addr<->lineno mapping) See Objects/lnotab_notes.txt for details.
Weakreflist *List // to support weakrefs to code objects
}
var CodeType = NewType("code", "code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring,\n constants, names, varnames, filename, name, firstlineno,\n lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart.")
// Type of this object
func (o *Code) Type() *Type {
return CodeType
}
// Make sure it satisfies the interface
var _ Object = (*Code)(nil)
const (
// Masks for flags above
CO_OPTIMIZED = 0x0001
CO_NEWLOCALS = 0x0002
CO_VARARGS = 0x0004
CO_VARKEYWORDS = 0x0008
CO_NESTED = 0x0010
CO_GENERATOR = 0x0020
// The CO_NOFREE flag is set if there are no free or cell
// variables. This information is redundant, but it allows a
// single flag test to determine whether there is any extra
// work to be done when the call frame it setup.
CO_NOFREE = 0x0040
CO_GENERATOR_ALLOWED = 0x1000
CO_FUTURE_DIVISION = 0x2000
CO_FUTURE_ABSOLUTE_IMPORT = 0x4000 // do absolute imports by default
CO_FUTURE_WITH_STATEMENT = 0x8000
CO_FUTURE_PRINT_FUNCTION = 0x10000
CO_FUTURE_UNICODE_LITERALS = 0x20000
CO_FUTURE_BARRY_AS_BDFL = 0x40000
CO_COMPILER_FLAGS_MASK = CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL
// This value is found in the cell2arg array when the
// associated cell variable does not correspond to an
// argument. The maximum number of arguments is 255 (indexed
// up to 254), so 255 work as a special flag.
CO_CELL_NOT_AN_ARG = 255
CO_MAXBLOCKS = 20 // Max static block nesting within a function
)
// Intern all the strings in the tuple
func intern_strings(tuple Tuple) {
for i, v_ := range tuple {
v := v_.(String)
tuple[i] = v.Intern()
}
}
const NAME_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
// all_name_chars(s): true iff all chars in s are valid NAME_CHARS
func all_name_chars(s String) bool {
for _, c := range s {
if strings.IndexRune(NAME_CHARS, c) < 0 {
return false
}
}
return true
}
// Make a new code object
func NewCode(argcount int32, kwonlyargcount int32,
nlocals int32, stacksize int32, flags int32,
code_ Object, consts_ Object, names_ Object,
varnames_ Object, freevars_ Object, cellvars_ Object,
filename_ Object, name_ Object, firstlineno int32,
lnotab_ Object) *Code {
var cell2arg []byte
// Type assert the objects
consts := consts_.(Tuple)
namesTuple := names_.(Tuple)
varnamesTuple := varnames_.(Tuple)
freevarsTuple := freevars_.(Tuple)
cellvarsTuple := cellvars_.(Tuple)
name := string(name_.(String))
filename := string(filename_.(String))
lnotab := string(lnotab_.(String))
code := string(code_.(String))
// Convert Tuples to native []string for speed
names := make([]string, len(namesTuple))
for i := range namesTuple {
names[i] = string(namesTuple[i].(String))
}
varnames := make([]string, len(varnamesTuple))
for i := range varnamesTuple {
varnames[i] = string(varnamesTuple[i].(String))
}
freevars := make([]string, len(freevarsTuple))
for i := range freevarsTuple {
freevars[i] = string(freevarsTuple[i].(String))
}
cellvars := make([]string, len(cellvarsTuple))
for i := range cellvarsTuple {
cellvars[i] = string(cellvarsTuple[i].(String))
}
// Check argument types
if argcount < 0 || kwonlyargcount < 0 || nlocals < 0 {
panic("Bad arguments to NewCode")
}
// Ensure that the filename is a ready Unicode string
// FIXME
// if PyUnicode_READY(filename) < 0 {
// return nil;
// }
n_cellvars := len(cellvars)
intern_strings(namesTuple)
intern_strings(varnamesTuple)
intern_strings(freevarsTuple)
intern_strings(cellvarsTuple)
/* Intern selected string constants */
for i := len(consts) - 1; i >= 0; i-- {
if v, ok := consts[i].(String); ok {
if all_name_chars(v) {
consts[i] = v.Intern()
}
}
}
/* Create mapping between cells and arguments if needed. */
if n_cellvars != 0 {
total_args := argcount + kwonlyargcount
if flags&CO_VARARGS != 0 {
total_args++
}
if flags&CO_VARKEYWORDS != 0 {
total_args++
}
used_cell2arg := false
cell2arg = make([]byte, n_cellvars)
for i := range cell2arg {
cell2arg[i] = CO_CELL_NOT_AN_ARG
}
// Find cells which are also arguments.
for i, cell := range cellvars {
for j := int32(0); j < total_args; j++ {
arg := varnames[j]
if cell == arg {
cell2arg[i] = byte(j)
used_cell2arg = true
break
}
}
}
if !used_cell2arg {
cell2arg = nil
}
}
return &Code{
Argcount: argcount,
Kwonlyargcount: kwonlyargcount,
Nlocals: nlocals,
Stacksize: stacksize,
Flags: flags,
Code: code,
Consts: consts,
Names: names,
Varnames: varnames,
Freevars: freevars,
Cellvars: cellvars,
Cell2arg: cell2arg,
Filename: filename,
Name: name,
Firstlineno: firstlineno,
Lnotab: lnotab,
Weakreflist: nil,
}
}
// Return number of free variables
func (co *Code) GetNumFree() int {
return len(co.Freevars)
}
// Use co_lnotab to compute the line number from a bytecode index,
// addrq. See lnotab_notes.txt for the details of the lnotab
// representation.
func (co *Code) Addr2Line(addrq int32) int32 {
line := co.Firstlineno
addr := int32(0)
for i := 0; i < len(co.Lnotab); i += 2 {
addr += int32(co.Lnotab[i])
if addr > addrq {
break
}
line += int32(co.Lnotab[i+1])
}
return line
}
// FIXME this should be the default?
func (co *Code) M__eq__(other Object) (Object, error) {
if otherCo, ok := other.(*Code); ok && co == otherCo {
return True, nil
}
return False, nil
}
// FIXME this should be the default?
func (co *Code) M__ne__(other Object) (Object, error) {
if otherCo, ok := other.(*Code); ok && co == otherCo {
return False, nil
}
return True, nil
}
// Check interface is satisfied
var _ I__eq__ = (*Code)(nil)
var _ I__ne__ = (*Code)(nil)