// Copyright 2009 The Go 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 eval
import (
"big"
"fmt"
"go/ast"
"go/token"
"log"
"strconv"
"strings"
"os"
)
var (
idealZero = big.NewInt(0)
idealOne = big.NewInt(1)
)
// An expr is the result of compiling an expression. It stores the
// type of the expression and its evaluator function.
type expr struct {
*exprInfo
t Type
// Evaluate this node as the given type.
eval interface{}
// Map index expressions permit special forms of assignment,
// for which we need to know the Map and key.
evalMapValue func(t *Thread) (Map, interface{})
// Evaluate to the "address of" this value; that is, the
// settable Value object. nil for expressions whose address
// cannot be taken.
evalAddr func(t *Thread) Value
// Execute this expression as a statement. Only expressions
// that are valid expression statements should set this.
exec func(t *Thread)
// If this expression is a type, this is its compiled type.
// This is only permitted in the function position of a call
// expression. In this case, t should be nil.
valType Type
// A short string describing this expression for error
// messages.
desc string
}
// exprInfo stores information needed to compile any expression node.
// Each expr also stores its exprInfo so further expressions can be
// compiled from it.
type exprInfo struct {
*compiler
pos token.Pos
}
func (a *exprInfo) newExpr(t Type, desc string) *expr {
return &expr{exprInfo: a, t: t, desc: desc}
}
func (a *exprInfo) diag(format string, args ...interface{}) {
a.diagAt(a.pos, format, args...)
}
func (a *exprInfo) diagOpType(op token.Token, vt Type) {
a.diag("illegal operand type for '%v' operator\n\t%v", op, vt)
}
func (a *exprInfo) diagOpTypes(op token.Token, lt Type, rt Type) {
a.diag("illegal operand types for '%v' operator\n\t%v\n\t%v", op, lt, rt)
}
/*
* Common expression manipulations
*/
// a.convertTo(t) converts the value of the analyzed expression a,
// which must be a constant, ideal number, to a new analyzed
// expression with a constant value of type t.
//
// TODO(austin) Rename to resolveIdeal or something?
func (a *expr) convertTo(t Type) *expr {
if !a.t.isIdeal() {
log.Panicf("attempted to convert from %v, expected ideal", a.t)
}
var rat *big.Rat
// XXX(Spec) The spec says "It is erroneous".
//
// It is an error to assign a value with a non-zero fractional
// part to an integer, or if the assignment would overflow or
// underflow, or in general if the value cannot be represented
// by the type of the variable.
switch a.t {
case IdealFloatType:
rat = a.asIdealFloat()()
if t.isInteger() && !rat.IsInt() {
a.diag("constant %v truncated to integer", rat.FloatString(6))
return nil
}
case IdealIntType:
i := a.asIdealInt()()
rat = new(big.Rat).SetInt(i)
default:
log.Panicf("unexpected ideal type %v", a.t)
}
// Check bounds
if t, ok := t.lit().(BoundedType); ok {
if rat.Cmp(t.minVal()) < 0 {
a.diag("constant %v underflows %v", rat.FloatString(6), t)
return nil
}
if rat.Cmp(t.maxVal()) > 0 {
a.diag("constant %v overflows %v", rat.FloatString(6), t)
return nil
}
}
// Convert rat to type t.
res := a.newExpr(t, a.desc)
switch t := t.lit().(type) {
case *uintType:
n, d := rat.Num(), rat.Denom()
f := new(big.Int).Quo(n, d)
f = f.Abs(f)
v := uint64(f.Int64())
res.eval = func(*Thread) uint64 { return v }
case *intType:
n, d := rat.Num(), rat.Denom()
f := new(big.Int).Quo(n, d)
v := f.Int64()
res.eval = func(*Thread) int64 { return v }
case *idealIntType:
n, d := rat.Num(), rat.Denom()
f := new(big.Int).Quo(n, d)
res.eval = func() *big.Int { return f }
case *floatType:
n, d := rat.Num(), rat.Denom()
v := float64(n.Int64()) / float64(d.Int64())
res.eval = func(*Thread) float64 { return v }
case *idealFloatType:
res.eval = func() *big.Rat { return rat }
default:
log.Panicf("cannot convert to type %T", t)
}
return res
}
// convertToInt converts this expression to an integer, if possible,
// or produces an error if not. This accepts ideal ints, uints, and
// ints. If max is not -1, produces an error if possible if the value
// exceeds max. If negErr is not "", produces an error if possible if
// the value is negative.
func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr {
switch a.t.lit().(type) {
case *idealIntType:
val := a.asIdealInt()()
if negErr != "" && val.Sign() < 0 {
a.diag("negative %s: %s", negErr, val)
return nil
}
bound := max
if negErr == "slice" {
bound++
}
if max != -1 && val.Cmp(big.NewInt(bound)) >= 0 {
a.diag("index %s exceeds length %d", val, max)
return nil
}
return a.convertTo(IntType)
case *uintType:
// Convert to int
na := a.newExpr(IntType, a.desc)
af := a.asUint()
na.eval = func(t *Thread) int64 { return int64(af(t)) }
return na
case *intType:
// Good as is
return a
}
a.diag("illegal operand type for %s\n\t%v", errOp, a.t)
return nil
}
// derefArray returns an expression of array type if the given
// expression is a *array type. Otherwise, returns the given
// expression.
func (a *expr) derefArray() *expr {
if pt, ok := a.t.lit().(*PtrType); ok {
if _, ok := pt.Elem.lit().(*ArrayType); ok {
deref := a.compileStarExpr(a)
if deref == nil {
log.Panicf("failed to dereference *array")
}
return deref
}
}
return a
}
/*
* Assignments
*/
// An assignCompiler compiles assignment operations. Anything other
// than short declarations should use the compileAssign wrapper.
//
// There are three valid types of assignment:
// 1) T = T
// Assigning a single expression with single-valued type to a
// single-valued type.
// 2) MT = T, T, ...
// Assigning multiple expressions with single-valued types to a
// multi-valued type.
// 3) MT = MT
// Assigning a single expression with multi-valued type to a
// multi-valued type.
type assignCompiler struct {
*compiler
pos token.Pos
// The RHS expressions. This may include nil's for
// expressions that failed to compile.
rs []*expr
// The (possibly unary) MultiType of the RHS.
rmt *MultiType
// Whether this is an unpack assignment (case 3).
isUnpack bool
// Whether map special assignment forms are allowed.
allowMap bool
// Whether this is a "r, ok = a[x]" assignment.
isMapUnpack bool
// The operation name to use in error messages, such as
// "assignment" or "function call".
errOp string
// The name to use for positions in error messages, such as
// "argument".
errPosName string
}
// Type check the RHS of an assignment, returning a new assignCompiler
// and indicating if the type check succeeded. This always returns an
// assignCompiler with rmt set, but if type checking fails, slots in
// the MultiType may be nil. If rs contains nil's, type checking will
// fail and these expressions given a nil type.
func (a *compiler) checkAssign(pos token.Pos, rs []*expr, errOp, errPosName string) (*assignCompiler, bool) {
c := &assignCompiler{
compiler: a,
pos: pos,
rs: rs,
errOp: errOp,
errPosName: errPosName,
}
// Is this an unpack?
if len(rs) == 1 && rs[0] != nil {
if rmt, isUnpack := rs[0].t.(*MultiType); isUnpack {
c.rmt = rmt
c.isUnpack = true
return c, true
}
}
// Create MultiType for RHS and check that all RHS expressions
// are single-valued.
rts := make([]Type, len(rs))
ok := true
for i, r := range rs {
if r == nil {
ok = false
continue
}
if _, isMT := r.t.(*MultiType); isMT {
r.diag("multi-valued expression not allowed in %s", errOp)
ok = false
continue
}
rts[i] = r.t
}
c.rmt = NewMultiType(rts)
return c, ok
}
func (a *assignCompiler) allowMapForms(nls int) {
a.allowMap = true
// Update unpacking info if this is r, ok = a[x]
if nls == 2 && len(a.rs) == 1 && a.rs[0] != nil && a.rs[0].evalMapValue != nil {
a.isUnpack = true
a.rmt = NewMultiType([]Type{a.rs[0].t, BoolType})
a.isMapUnpack = true
}
}
// compile type checks and compiles an assignment operation, returning
// a function that expects an l-value and the frame in which to
// evaluate the RHS expressions. The l-value must have exactly the
// type given by lt. Returns nil if type checking fails.
func (a *assignCompiler) compile(b *block, lt Type) func(Value, *Thread) {
lmt, isMT := lt.(*MultiType)
rmt, isUnpack := a.rmt, a.isUnpack
// Create unary MultiType for single LHS
if !isMT {
lmt = NewMultiType([]Type{lt})
}
// Check that the assignment count matches
lcount := len(lmt.Elems)
rcount := len(rmt.Elems)
if lcount != rcount {
msg := "not enough"
pos := a.pos
if rcount > lcount {
msg = "too many"
if lcount > 0 {
pos = a.rs[lcount-1].pos
}
}
a.diagAt(pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt)
return nil
}
bad := false
// If this is an unpack, create a temporary to store the
// multi-value and replace the RHS with expressions to pull
// out values from the temporary. Technically, this is only
// necessary when we need to perform assignment conversions.
var effect func(*Thread)
if isUnpack {
// This leaks a slot, but is definitely safe.
temp := b.DefineTemp(a.rmt)
tempIdx := temp.Index
if tempIdx < 0 {
panic(fmt.Sprintln("tempidx", tempIdx))
}
if a.isMapUnpack {
rf := a.rs[0].evalMapValue
vt := a.rmt.Elems[0]
effect = func(t *Thread) {
m, k := rf(t)
v := m.Elem(t, k)
found := boolV(true)
if v == nil {
found = boolV(false)
v = vt.Zero()
}
t.f.Vars[tempIdx] = multiV([]Value{v, &found})
}
} else {
rf := a.rs[0].asMulti()
effect = func(t *Thread) { t.f.Vars[tempIdx] = multiV(rf(t)) }
}
orig := a.rs[0]
a.rs = make([]*expr, len(a.rmt.Elems))
for i, t := range a.rmt.Elems {
if t.isIdeal() {
log.Panicf("Right side of unpack contains ideal: %s", rmt)
}
a.rs[i] = orig.newExpr(t, orig.desc)
index := i
a.rs[i].genValue(func(t *Thread) Value { return t.f.Vars[tempIdx].(multiV)[index] })
}
}
// Now len(a.rs) == len(a.rmt) and we've reduced any unpacking
// to multi-assignment.
// TODO(austin) Deal with assignment special cases.
// Values of any type may always be assigned to variables of
// compatible static type.
for i, lt := range lmt.Elems {
rt := rmt.Elems[i]
// When [an ideal is] (used in an expression) assigned
// to a variable or typed constant, the destination
// must be able to represent the assigned value.
if rt.isIdeal() {
a.rs[i] = a.rs[i].convertTo(lmt.Elems[i])
if a.rs[i] == nil {
bad = true
continue
}
rt = a.rs[i].t
}
// A pointer p to an array can be assigned to a slice
// variable v with compatible element type if the type
// of p or v is unnamed.
if rpt, ok := rt.lit().(*PtrType); ok {
if at, ok := rpt.Elem.lit().(*ArrayType); ok {
if lst, ok := lt.lit().(*SliceType); ok {
if lst.Elem.compat(at.Elem, false) && (rt.lit() == Type(rt) || lt.lit() == Type(lt)) {
rf := a.rs[i].asPtr()
a.rs[i] = a.rs[i].newExpr(lt, a.rs[i].desc)
len := at.Len
a.rs[i].eval = func(t *Thread) Slice { return Slice{rf(t).(ArrayValue), len, len} }
rt = a.rs[i].t
}
}
}
}
if !lt.compat(rt, false) {
if len(a.rs) == 1 {
a.rs[0].diag("illegal operand types for %s\n\t%v\n\t%v", a.errOp, lt, rt)
} else {
a.rs[i].diag("illegal operand types in %s %d of %s\n\t%v\n\t%v", a.errPosName, i+1, a.errOp, lt, rt)
}
bad = true
}
}
if bad {
return nil
}
// Compile
if !isMT {
// Case 1
return genAssign(lt, a.rs[0])
}
// Case 2 or 3
as := make([]func(lv Value, t *Thread), len(a.rs))
for i, r := range a.rs {
as[i] = genAssign(lmt.Elems[i], r)
}
return func(lv Value, t *Thread) {
if effect != nil {
effect(t)
}
lmv := lv.(multiV)
for i, a := range as {
a(lmv[i], t)
}
}
}
// compileAssign compiles an assignment operation without the full
// generality of an assignCompiler. See assignCompiler for a
// description of the arguments.
func (a *compiler) compileAssign(pos token.Pos, b *block, lt Type, rs []*expr, errOp, errPosName string) func(Value, *Thread) {
ac, ok := a.checkAssign(pos, rs, errOp, errPosName)
if !ok {
return nil
}
return ac.compile(b, lt)
}
/*
* Expression compiler
*/
// An exprCompiler stores information used throughout the compilation
// of a single expression. It does not embed funcCompiler because
// expressions can appear at top level.
type exprCompiler struct {
*compiler
// The block this expression is being compiled in.
block *block
// Whether this expression is used in a constant context.
constant bool
}
// compile compiles an expression AST. callCtx should be true if this
// AST is in the function position of a function call node; it allows
// the returned expression to be a type or a built-in function (which
// otherwise result in errors).
func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr {
ei := &exprInfo{a.compiler, x.Pos()}
switch x := x.(type) {
// Literals
case *ast.BasicLit:
switch x.Kind {
case token.INT:
return ei.compileIntLit(string(x.Value))
case token.FLOAT:
return ei.compileFloatLit(string(x.Value))
case token.CHAR:
return ei.compileCharLit(string(x.Value))
case token.STRING:
return ei.compileStringLit(string(x.Value))
default:
log.Panicf("unexpected basic literal type %v", x.Kind)
}
case *ast.CompositeLit:
goto notimpl
case *ast.FuncLit:
decl := ei.compileFuncType(a.block, x.Type)
if decl == nil {
// TODO(austin) Try compiling the body,
// perhaps with dummy argument definitions
return nil
}
fn := ei.compileFunc(a.block, decl, x.Body)
if fn == nil {
return nil
}
if a.constant {
a.diagAt(x.Pos(), "function literal used in constant expression")
return nil
}
return ei.compileFuncLit(decl, fn)
// Types
case *ast.ArrayType:
// TODO(austin) Use a multi-type case
goto typeexpr
case *ast.ChanType:
goto typeexpr
case *ast.Ellipsis:
goto typeexpr
case *ast.FuncType:
goto typeexpr
case *ast.InterfaceType:
goto typeexpr
case *ast.MapType:
goto typeexpr
// Remaining expressions
case *ast.BadExpr:
// Error already reported by parser
a.silentErrors++
return nil
case *ast.BinaryExpr:
l, r := a.compile(x.X, false), a.compile(x.Y, false)
if l == nil || r == nil {
return nil
}
return ei.compileBinaryExpr(x.Op, l, r)
case *ast.CallExpr:
l := a.compile(x.Fun, true)
args := make([]*expr, len(x.Args))
bad := false
for i, arg := range x.Args {
if i == 0 && l != nil && (l.t == Type(makeType) || l.t == Type(newType)) {
argei := &exprInfo{a.compiler, arg.Pos()}
args[i] = argei.exprFromType(a.compileType(a.block, arg))
} else {
args[i] = a.compile(arg, false)
}
if args[i] == nil {
bad = true
}
}
if bad || l == nil {
return nil
}
if a.constant {
a.diagAt(x.Pos(), "function call in constant context")
return nil
}
if l.valType != nil {
a.diagAt(x.Pos(), "type conversions not implemented")
return nil
} else if ft, ok := l.t.(*FuncType); ok && ft.builtin != "" {
return ei.compileBuiltinCallExpr(a.block, ft, args)
} else {
return ei.compileCallExpr(a.block, l, args)
}
case *ast.Ident:
return ei.compileIdent(a.block, a.constant, callCtx, x.Name)
case *ast.IndexExpr:
l, r := a.compile(x.X, false), a.compile(x.Index, false)
if l == nil || r == nil {
return nil
}
return ei.compileIndexExpr(l, r)
case *ast.SliceExpr:
var lo, hi *expr
arr := a.compile(x.X, false)
if x.Low == nil {
// beginning was omitted, so we need to provide it
ei := &exprInfo{a.compiler, x.Pos()}
lo = ei.compileIntLit("0")
} else {
lo = a.compile(x.Low, false)
}
if x.High == nil {
// End was omitted, so we need to compute len(x.X)
ei := &exprInfo{a.compiler, x.Pos()}
hi = ei.compileBuiltinCallExpr(a.block, lenType, []*expr{arr})
} else {
hi = a.compile(x.High, false)
}
if arr == nil || lo == nil || hi == nil {
return nil
}
return ei.compileSliceExpr(arr, lo, hi)
case *ast.KeyValueExpr:
goto notimpl
case *ast.ParenExpr:
return a.compile(x.X, callCtx)
case *ast.SelectorExpr:
v := a.compile(x.X, false)
if v == nil {
return nil
}
return ei.compileSelectorExpr(v, x.Sel.Name)
case *ast.StarExpr:
// We pass down our call context because this could be
// a pointer type (and thus a type conversion)
v := a.compile(x.X, callCtx)
if v == nil {
return nil
}
if v.valType != nil {
// Turns out this was a pointer type, not a dereference
return ei.exprFromType(NewPtrType(v.valType))
}
return ei.compileStarExpr(v)
case *ast.StructType:
goto notimpl
case *ast.TypeAssertExpr:
goto notimpl
case *ast.UnaryExpr:
v := a.compile(x.X, false)
if v == nil {
return nil
}
return ei.compileUnaryExpr(x.Op, v)
}
log.Panicf("unexpected ast node type %T", x)
panic("unreachable")
typeexpr:
if !callCtx {
a.diagAt(x.Pos(), "type used as expression")
return nil
}
return ei.exprFromType(a.compileType(a.block, x))
notimpl:
a.diagAt(x.Pos(), "%T expression node not implemented", x)
return nil
}
func (a *exprInfo) exprFromType(t Type) *expr {
if t == nil {
return nil
}
expr := a.newExpr(nil, "type")
expr.valType = t
return expr
}
func (a *exprInfo) compileIdent(b *block, constant bool, callCtx bool, name string) *expr {
bl, level, def := b.Lookup(name)
if def == nil {
a.diag("%s: undefined", name)
return nil
}
switch def := def.(type) {
case *Constant:
expr := a.newExpr(def.Type, "constant")
if ft, ok := def.Type.(*FuncType); ok && ft.builtin != "" {
// XXX(Spec) I don't think anything says that
// built-in functions can't be used as values.
if !callCtx {
a.diag("built-in function %s cannot be used as a value", ft.builtin)
return nil
}
// Otherwise, we leave the evaluators empty
// because this is handled specially
} else {
expr.genConstant(def.Value)
}
return expr
case *Variable:
if constant {
a.diag("variable %s used in constant expression", name)
return nil
}
if bl.global {
return a.compileGlobalVariable(def)
}
return a.compileVariable(level, def)
case Type:
if callCtx {
return a.exprFromType(def)
}
a.diag("type %v used as expression", name)
return nil
}
log.Panicf("name %s has unknown type %T", name, def)
panic("unreachable")
}
func (a *exprInfo) compileVariable(level int, v *Variable) *expr {
if v.Type == nil {
// Placeholder definition from an earlier error
a.silentErrors++
return nil
}
expr := a.newExpr(v.Type, "variable")
expr.genIdentOp(level, v.Index)
return expr
}
func (a *exprInfo) compileGlobalVariable(v *Variable) *expr {
if v.Type == nil {
// Placeholder definition from an earlier error
a.silentErrors++
return nil
}
if v.Init == nil {
v.Init = v.Type.Zero()
}
expr := a.newExpr(v.Type, "variable")
val := v.Init
expr.genValue(func(t *Thread) Value { return val })
return expr
}
func (a *exprInfo) compileIdealInt(i *big.Int, desc string) *expr {
expr := a.newExpr(IdealIntType, desc)
expr.eval = func() *big.Int { return i }
return expr
}
func (a *exprInfo) compileIntLit(lit string) *expr {
i, _ := new(big.Int).SetString(lit, 0)
return a.compileIdealInt(i, "integer literal")
}
func (a *exprInfo) compileCharLit(lit string) *expr {
if lit[0] != '\'' {
// Caught by parser
a.silentErrors++
return nil
}
v, _, tail, err := strconv.UnquoteChar(lit[1:], '\'')
if err != nil || tail != "'" {
// Caught by parser
a.silentErrors++
return nil
}
return a.compileIdealInt(big.NewInt(int64(v)), "character literal")
}
func (a *exprInfo) compileFloatLit(lit string) *expr {
f, ok := new(big.Rat).SetString(lit)
if !ok {
log.Panicf("malformed float literal %s at %v passed parser", lit, a.pos)
}
expr := a.newExpr(IdealFloatType, "float literal")
expr.eval = func() *big.Rat { return f }
return expr
}
func (a *exprInfo) compileString(s string) *expr {
// Ideal strings don't have a named type but they are
// compatible with type string.
// TODO(austin) Use unnamed string type.
expr := a.newExpr(StringType, "string literal")
expr.eval = func(*Thread) string { return s }
return expr
}
func (a *exprInfo) compileStringLit(lit string) *expr {
s, err := strconv.Unquote(lit)
if err != nil {
a.diag("illegal string literal, %v", err)
return nil
}
return a.compileString(s)
}
func (a *exprInfo) compileStringList(list []*expr) *expr {
ss := make([]string, len(list))
for i, s := range list {
ss[i] = s.asString()(nil)
}
return a.compileString(strings.Join(ss, ""))
}
func (a *exprInfo) compileFuncLit(decl *FuncDecl, fn func(*Thread) Func) *expr {
expr := a.newExpr(decl.Type, "function literal")
expr.eval = fn
return expr
}
func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr {
// mark marks a field that matches the selector name. It
// tracks the best depth found so far and whether more than
// one field has been found at that depth.
bestDepth := -1
ambig := false
amberr := ""
mark := func(depth int, pathName string) {
switch {
case bestDepth == -1 || depth < bestDepth:
bestDepth = depth
ambig = false
amberr = ""
case depth == bestDepth:
ambig = true
default:
log.Panicf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth)
}
amberr += "\n\t" + pathName[1:]
}
visited := make(map[Type]bool)
// find recursively searches for the named field, starting at
// type t. If it finds the named field, it returns a function
// which takes an expr that represents a value of type 't' and
// returns an expr that retrieves the named field. We delay
// expr construction to avoid producing lots of useless expr's
// as we search.
//
// TODO(austin) Now that the expression compiler works on
// semantic values instead of AST's, there should be a much
// better way of doing this.
var find func(Type, int, string) func(*expr) *expr
find = func(t Type, depth int, pathName string) func(*expr) *expr {
// Don't bother looking if we've found something shallower
if bestDepth != -1 && bestDepth < depth {
return nil
}
// Don't check the same type twice and avoid loops
if visited[t] {
return nil
}
visited[t] = true
// Implicit dereference
deref := false
if ti, ok := t.(*PtrType); ok {
deref = true
t = ti.Elem
}
// If it's a named type, look for methods
if ti, ok := t.(*NamedType); ok {
_, ok := ti.methods[name]
if ok {
mark(depth, pathName+"."+name)
log.Panic("Methods not implemented")
}
t = ti.Def
}
// If it's a struct type, check fields and embedded types
var builder func(*expr) *expr
if t, ok := t.(*StructType); ok {
for i, f := range t.Elems {
var sub func(*expr) *expr
switch {
case f.Name == name:
mark(depth, pathName+"."+name)
sub = func(e *expr) *expr { return e }
case f.Anonymous:
sub = find(f.Type, depth+1, pathName+"."+f.Name)
if sub == nil {
continue
}
default:
continue
}
// We found something. Create a
// builder for accessing this field.
ft := f.Type
index := i
builder = func(parent *expr) *expr {
if deref {
parent = a.compileStarExpr(parent)
}
expr := a.newExpr(ft, "selector expression")
pf := parent.asStruct()
evalAddr := func(t *Thread) Value { return pf(t).Field(t, index) }
expr.genValue(evalAddr)
return sub(expr)
}
}
}
return builder
}
builder := find(v.t, 0, "")
if builder == nil {
a.diag("type %v has no field or method %s", v.t, name)
return nil
}
if ambig {
a.diag("field %s is ambiguous in type %v%s", name, v.t, amberr)
return nil
}
return builder(v)
}
func (a *exprInfo) compileSliceExpr(arr, lo, hi *expr) *expr {
// Type check object
arr = arr.derefArray()
var at Type
var maxIndex int64 = -1
switch lt := arr.t.lit().(type) {
case *ArrayType:
at = NewSliceType(lt.Elem)
maxIndex = lt.Len
case *SliceType:
at = lt
case *stringType:
at = lt
default:
a.diag("cannot slice %v", arr.t)
return nil
}
// Type check index and convert to int
// XXX(Spec) It's unclear if ideal floats with no
// fractional part are allowed here. 6g allows it. I
// believe that's wrong.
lo = lo.convertToInt(maxIndex, "slice", "slice")
hi = hi.convertToInt(maxIndex, "slice", "slice")
if lo == nil || hi == nil {
return nil
}
expr := a.newExpr(at, "slice expression")
// Compile
lof := lo.asInt()
hif := hi.asInt()
switch lt := arr.t.lit().(type) {
case *ArrayType:
arrf := arr.asArray()
bound := lt.Len
expr.eval = func(t *Thread) Slice {
arr, lo, hi := arrf(t), lof(t), hif(t)
if lo > hi || hi > bound || lo < 0 {
t.Abort(SliceError{lo, hi, bound})
}
return Slice{arr.Sub(lo, bound-lo), hi - lo, bound - lo}
}
case *SliceType:
arrf := arr.asSlice()
expr.eval = func(t *Thread) Slice {
arr, lo, hi := arrf(t), lof(t), hif(t)
if lo > hi || hi > arr.Cap || lo < 0 {
t.Abort(SliceError{lo, hi, arr.Cap})
}
return Slice{arr.Base.Sub(lo, arr.Cap-lo), hi - lo, arr.Cap - lo}
}
case *stringType:
arrf := arr.asString()
// TODO(austin) This pulls over the whole string in a
// remote setting, instead of creating a substring backed
// by remote memory.
expr.eval = func(t *Thread) string {
arr, lo, hi := arrf(t), lof(t), hif(t)
if lo > hi || hi > int64(len(arr)) || lo < 0 {
t.Abort(SliceError{lo, hi, int64(len(arr))})
}
return arr[lo:hi]
}
default:
log.Panicf("unexpected left operand type %T", arr.t.lit())
}
return expr
}
func (a *exprInfo) compileIndexExpr(l, r *expr) *expr {
// Type check object
l = l.derefArray()
var at Type
intIndex := false
var maxIndex int64 = -1
switch lt := l.t.lit().(type) {
case *ArrayType:
at = lt.Elem
intIndex = true
maxIndex = lt.Len
case *SliceType:
at = lt.Elem
intIndex = true
case *stringType:
at = Uint8Type
intIndex = true
case *MapType:
at = lt.Elem
if r.t.isIdeal() {
r = r.convertTo(lt.Key)
if r == nil {
return nil
}
}
if !lt.Key.compat(r.t, false) {
a.diag("cannot use %s as index into %s", r.t, lt)
return nil
}
default:
a.diag("cannot index into %v", l.t)
return nil
}
// Type check index and convert to int if necessary
if intIndex {
// XXX(Spec) It's unclear if ideal floats with no
// fractional part are allowed here. 6g allows it. I
// believe that's wrong.
r = r.convertToInt(maxIndex, "index", "index")
if r == nil {
return nil
}
}
expr := a.newExpr(at, "index expression")
// Compile
switch lt := l.t.lit().(type) {
case *ArrayType:
lf := l.asArray()
rf := r.asInt()
bound := lt.Len
expr.genValue(func(t *Thread) Value {
l, r := lf(t), rf(t)
if r < 0 || r >= bound {
t.Abort(IndexError{r, bound})
}
return l.Elem(t, r)
})
case *SliceType:
lf := l.asSlice()
rf := r.asInt()
expr.genValue(func(t *Thread) Value {
l, r := lf(t), rf(t)
if l.Base == nil {
t.Abort(NilPointerError{})
}
if r < 0 || r >= l.Len {
t.Abort(IndexError{r, l.Len})
}
return l.Base.Elem(t, r)
})
case *stringType:
lf := l.asString()
rf := r.asInt()
// TODO(austin) This pulls over the whole string in a
// remote setting, instead of just the one character.
expr.eval = func(t *Thread) uint64 {
l, r := lf(t), rf(t)
if r < 0 || r >= int64(len(l)) {
t.Abort(IndexError{r, int64(len(l))})
}
return uint64(l[r])
}
case *MapType:
lf := l.asMap()
rf := r.asInterface()
expr.genValue(func(t *Thread) Value {
m := lf(t)
k := rf(t)
if m == nil {
t.Abort(NilPointerError{})
}
e := m.Elem(t, k)
if e == nil {
t.Abort(KeyError{k})
}
return e
})
// genValue makes things addressable, but map values
// aren't addressable.
expr.evalAddr = nil
expr.evalMapValue = func(t *Thread) (Map, interface{}) {
// TODO(austin) Key check? nil check?
return lf(t), rf(t)
}
default:
log.Panicf("unexpected left operand type %T", l.t.lit())
}
return expr
}
func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr {
// TODO(austin) Variadic functions.
// Type check
// XXX(Spec) Calling a named function type is okay. I really
// think there needs to be a general discussion of named
// types. A named type creates a new, distinct type, but the
// type of that type is still whatever it's defined to. Thus,
// in "type Foo int", Foo is still an integer type and in
// "type Foo func()", Foo is a function type.
lt, ok := l.t.lit().(*FuncType)
if !ok {
a.diag("cannot call non-function type %v", l.t)
return nil
}
// The arguments must be single-valued expressions assignment
// compatible with the parameters of F.
//
// XXX(Spec) The spec is wrong. It can also be a single
// multi-valued expression.
nin := len(lt.In)
assign := a.compileAssign(a.pos, b, NewMultiType(lt.In), as, "function call", "argument")
if assign == nil {
return nil
}
var t Type
nout := len(lt.Out)
switch nout {
case 0:
t = EmptyType
case 1:
t = lt.Out[0]
default:
t = NewMultiType(lt.Out)
}
expr := a.newExpr(t, "function call")
// Gather argument and out types to initialize frame variables
vts := make([]Type, nin+nout)
copy(vts, lt.In)
copy(vts[nin:], lt.Out)
// Compile
lf := l.asFunc()
call := func(t *Thread) []Value {
fun := lf(t)
fr := fun.NewFrame()
for i, t := range vts {
fr.Vars[i] = t.Zero()
}
assign(multiV(fr.Vars[0:nin]), t)
oldf := t.f
t.f = fr
fun.Call(t)
t.f = oldf
return fr.Vars[nin : nin+nout]
}
expr.genFuncCall(call)
return expr
}
func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *expr {
checkCount := func(min, max int) bool {
if len(as) < min {
a.diag("not enough arguments to %s", ft.builtin)
return false
} else if len(as) > max {
a.diag("too many arguments to %s", ft.builtin)
return false
}
return true
}
switch ft {
case capType:
if !checkCount(1, 1) {
return nil
}
arg := as[0].derefArray()
expr := a.newExpr(IntType, "function call")
switch t := arg.t.lit().(type) {
case *ArrayType:
// TODO(austin) It would be nice if this could
// be a constant int.
v := t.Len
expr.eval = func(t *Thread) int64 { return v }
case *SliceType:
vf := arg.asSlice()
expr.eval = func(t *Thread) int64 { return vf(t).Cap }
//case *ChanType:
default:
a.diag("illegal argument type for cap function\n\t%v", arg.t)
return nil
}
return expr
case copyType:
if !checkCount(2, 2) {
return nil
}
src := as[1]
dst := as[0]
if src.t != dst.t {
a.diag("arguments to built-in function 'copy' must have same type\nsrc: %s\ndst: %s\n", src.t, dst.t)
return nil
}
if _, ok := src.t.lit().(*SliceType); !ok {
a.diag("src argument to 'copy' must be a slice (got: %s)", src.t)
return nil
}
if _, ok := dst.t.lit().(*SliceType); !ok {
a.diag("dst argument to 'copy' must be a slice (got: %s)", dst.t)
return nil
}
expr := a.newExpr(IntType, "function call")
srcf := src.asSlice()
dstf := dst.asSlice()
expr.eval = func(t *Thread) int64 {
src, dst := srcf(t), dstf(t)
nelems := src.Len
if nelems > dst.Len {
nelems = dst.Len
}
dst.Base.Sub(0, nelems).Assign(t, src.Base.Sub(0, nelems))
return nelems
}
return expr
case lenType:
if !checkCount(1, 1) {
return nil
}
arg := as[0].derefArray()
expr := a.newExpr(IntType, "function call")
switch t := arg.t.lit().(type) {
case *stringType:
vf := arg.asString()
expr.eval = func(t *Thread) int64 { return int64(len(vf(t))) }
case *ArrayType:
// TODO(austin) It would be nice if this could
// be a constant int.
v := t.Len
expr.eval = func(t *Thread) int64 { return v }
case *SliceType:
vf := arg.asSlice()
expr.eval = func(t *Thread) int64 { return vf(t).Len }
case *MapType:
vf := arg.asMap()
expr.eval = func(t *Thread) int64 {
// XXX(Spec) What's the len of an
// uninitialized map?
m := vf(t)
if m == nil {
return 0
}
return m.Len(t)
}
//case *ChanType:
default:
a.diag("illegal argument type for len function\n\t%v", arg.t)
return nil
}
return expr
case makeType:
if !checkCount(1, 3) {
return nil
}
// XXX(Spec) What are the types of the
// arguments? Do they have to be ints? 6g
// accepts any integral type.
var lenexpr, capexpr *expr
var lenf, capf func(*Thread) int64
if len(as) > 1 {
lenexpr = as[1].convertToInt(-1, "length", "make function")
if lenexpr == nil {
return nil
}
lenf = lenexpr.asInt()
}
if len(as) > 2 {
capexpr = as[2].convertToInt(-1, "capacity", "make function")
if capexpr == nil {
return nil
}
capf = capexpr.asInt()
}
switch t := as[0].valType.lit().(type) {
case *SliceType:
// A new, initialized slice value for a given
// element type T is made using the built-in
// function make, which takes a slice type and
// parameters specifying the length and
// optionally the capacity.
if !checkCount(2, 3) {
return nil
}
et := t.Elem
expr := a.newExpr(t, "function call")
expr.eval = func(t *Thread) Slice {
l := lenf(t)
// XXX(Spec) What if len or cap is
// negative? The runtime panics.
if l < 0 {
t.Abort(NegativeLengthError{l})
}
c := l
if capf != nil {
c = capf(t)
if c < 0 {
t.Abort(NegativeCapacityError{c})
}
// XXX(Spec) What happens if
// len > cap? The runtime
// sets cap to len.
if l > c {
c = l
}
}
base := arrayV(make([]Value, c))
for i := int64(0); i < c; i++ {
base[i] = et.Zero()
}
return Slice{&base, l, c}
}
return expr
case *MapType:
// A new, empty map value is made using the
// built-in function make, which takes the map
// type and an optional capacity hint as
// arguments.
if !checkCount(1, 2) {
return nil
}
expr := a.newExpr(t, "function call")
expr.eval = func(t *Thread) Map {
if lenf == nil {
return make(evalMap)
}
l := lenf(t)
return make(evalMap, l)
}
return expr
//case *ChanType:
default:
a.diag("illegal argument type for make function\n\t%v", as[0].valType)
return nil
}
case closeType, closedType:
a.diag("built-in function %s not implemented", ft.builtin)
return nil
case newType:
if !checkCount(1, 1) {
return nil
}
t := as[0].valType
expr := a.newExpr(NewPtrType(t), "new")
expr.eval = func(*Thread) Value { return t.Zero() }
return expr
case panicType, printType, printlnType:
evals := make([]func(*Thread) interface{}, len(as))
for i, x := range as {
evals[i] = x.asInterface()
}
spaces := ft == printlnType
newline := ft != printType
printer := func(t *Thread) {
for i, eval := range evals {
if i > 0 && spaces {
print(" ")
}
v := eval(t)
type stringer interface {
String() string
}
switch v1 := v.(type) {
case bool:
print(v1)
case uint64:
print(v1)
case int64:
print(v1)
case float64:
print(v1)
case string:
print(v1)
case stringer:
print(v1.String())
default:
print("???")
}
}
if newline {
print("\n")
}
}
expr := a.newExpr(EmptyType, "print")
expr.exec = printer
if ft == panicType {
expr.exec = func(t *Thread) {
printer(t)
t.Abort(os.NewError("panic"))
}
}
return expr
}
log.Panicf("unexpected built-in function '%s'", ft.builtin)
panic("unreachable")
}
func (a *exprInfo) compileStarExpr(v *expr) *expr {
switch vt := v.t.lit().(type) {
case *PtrType:
expr := a.newExpr(vt.Elem, "indirect expression")
vf := v.asPtr()
expr.genValue(func(t *Thread) Value {
v := vf(t)
if v == nil {
t.Abort(NilPointerError{})
}
return v
})
return expr
}
a.diagOpType(token.MUL, v.t)
return nil
}
var unaryOpDescs = make(map[token.Token]string)
func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr {
// Type check
var t Type
switch op {
case token.ADD, token.SUB:
if !v.t.isInteger() && !v.t.isFloat() {
a.diagOpType(op, v.t)
return nil
}
t = v.t
case token.NOT:
if !v.t.isBoolean() {
a.diagOpType(op, v.t)
return nil
}
t = BoolType
case token.XOR:
if !v.t.isInteger() {
a.diagOpType(op, v.t)
return nil
}
t = v.t
case token.AND:
// The unary prefix address-of operator & generates
// the address of its operand, which must be a
// variable, pointer indirection, field selector, or
// array or slice indexing operation.
if v.evalAddr == nil {
a.diag("cannot take the address of %s", v.desc)
return nil
}
// TODO(austin) Implement "It is illegal to take the
// address of a function result variable" once I have
// function result variables.
t = NewPtrType(v.t)
case token.ARROW:
log.Panicf("Unary op %v not implemented", op)
default:
log.Panicf("unknown unary operator %v", op)
}
desc, ok := unaryOpDescs[op]
if !ok {
desc = "unary " + op.String() + " expression"
unaryOpDescs[op] = desc
}
// Compile
expr := a.newExpr(t, desc)
switch op {
case token.ADD:
// Just compile it out
expr = v
expr.desc = desc
case token.SUB:
expr.genUnaryOpNeg(v)
case token.NOT:
expr.genUnaryOpNot(v)
case token.XOR:
expr.genUnaryOpXor(v)
case token.AND:
vf := v.evalAddr
expr.eval = func(t *Thread) Value { return vf(t) }
default:
log.Panicf("Compilation of unary op %v not implemented", op)
}
return expr
}
var binOpDescs = make(map[token.Token]string)
func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr {
// Save the original types of l.t and r.t for error messages.
origlt := l.t
origrt := r.t
// XXX(Spec) What is the exact definition of a "named type"?
// XXX(Spec) Arithmetic operators: "Integer types" apparently
// means all types compatible with basic integer types, though
// this is never explained. Likewise for float types, etc.
// This relates to the missing explanation of named types.
// XXX(Spec) Operators: "If both operands are ideal numbers,
// the conversion is to ideal floats if one of the operands is
// an ideal float (relevant for / and %)." How is that
// relevant only for / and %? If I add an ideal int and an
// ideal float, I get an ideal float.
if op != token.SHL && op != token.SHR {
// Except in shift expressions, if one operand has
// numeric type and the other operand is an ideal
// number, the ideal number is converted to match the
// type of the other operand.
if (l.t.isInteger() || l.t.isFloat()) && !l.t.isIdeal() && r.t.isIdeal() {
r = r.convertTo(l.t)
} else if (r.t.isInteger() || r.t.isFloat()) && !r.t.isIdeal() && l.t.isIdeal() {
l = l.convertTo(r.t)
}
if l == nil || r == nil {
return nil
}
// Except in shift expressions, if both operands are
// ideal numbers and one is an ideal float, the other
// is converted to ideal float.
if l.t.isIdeal() && r.t.isIdeal() {
if l.t.isInteger() && r.t.isFloat() {
l = l.convertTo(r.t)
} else if l.t.isFloat() && r.t.isInteger() {
r = r.convertTo(l.t)
}
if l == nil || r == nil {
return nil
}
}
}
// Useful type predicates
// TODO(austin) CL 33668 mandates identical types except for comparisons.
compat := func() bool { return l.t.compat(r.t, false) }
integers := func() bool { return l.t.isInteger() && r.t.isInteger() }
floats := func() bool { return l.t.isFloat() && r.t.isFloat() }
strings := func() bool {
// TODO(austin) Deal with named types
return l.t == StringType && r.t == StringType
}
booleans := func() bool { return l.t.isBoolean() && r.t.isBoolean() }
// Type check
var t Type
switch op {
case token.ADD:
if !compat() || (!integers() && !floats() && !strings()) {
a.diagOpTypes(op, origlt, origrt)
return nil
}
t = l.t
case token.SUB, token.MUL, token.QUO:
if !compat() || (!integers() && !floats()) {
a.diagOpTypes(op, origlt, origrt)
return nil
}
t = l.t
case token.REM, token.AND, token.OR, token.XOR, token.AND_NOT:
if !compat() || !integers() {
a.diagOpTypes(op, origlt, origrt)
return nil
}
t = l.t
case token.SHL, token.SHR:
// XXX(Spec) Is it okay for the right operand to be an
// ideal float with no fractional part? "The right
// operand in a shift operation must be always be of
// unsigned integer type or an ideal number that can
// be safely converted into an unsigned integer type
// (§Arithmetic operators)" suggests so and 6g agrees.
if !l.t.isInteger() || !(r.t.isInteger() || r.t.isIdeal()) {
a.diagOpTypes(op, origlt, origrt)
return nil
}
// The right operand in a shift operation must be
// always be of unsigned integer type or an ideal
// number that can be safely converted into an
// unsigned integer type.
if r.t.isIdeal() {
r2 := r.convertTo(UintType)
if r2 == nil {
return nil
}
// If the left operand is not ideal, convert
// the right to not ideal.
if !l.t.isIdeal() {
r = r2
}
// If both are ideal, but the right side isn't
// an ideal int, convert it to simplify things.
if l.t.isIdeal() && !r.t.isInteger() {
r = r.convertTo(IdealIntType)
if r == nil {
log.Panicf("conversion to uintType succeeded, but conversion to idealIntType failed")
}
}
} else if _, ok := r.t.lit().(*uintType); !ok {
a.diag("right operand of shift must be unsigned")
return nil
}
if l.t.isIdeal() && !r.t.isIdeal() {
// XXX(Spec) What is the meaning of "ideal >>
// non-ideal"? Russ says the ideal should be
// converted to an int. 6g propagates the
// type down from assignments as a hint.
l = l.convertTo(IntType)
if l == nil {
return nil
}
}
// At this point, we should have one of three cases:
// 1) uint SHIFT uint
// 2) int SHIFT uint
// 3) ideal int SHIFT ideal int
t = l.t
case token.LOR, token.LAND:
if !booleans() {
return nil
}
// XXX(Spec) There's no mention of *which* boolean
// type the logical operators return. From poking at
// 6g, it appears to be the named boolean type, NOT
// the type of the left operand, and NOT an unnamed
// boolean type.
t = BoolType
case token.ARROW:
// The operands in channel sends differ in type: one
// is always a channel and the other is a variable or
// value of the channel's element type.
log.Panic("Binary op <- not implemented")
t = BoolType
case token.LSS, token.GTR, token.LEQ, token.GEQ:
// XXX(Spec) It's really unclear what types which
// comparison operators apply to. I feel like the
// text is trying to paint a Venn diagram for me,
// which it's really pretty simple: <, <=, >, >= apply
// only to numeric types and strings. == and != apply
// to everything except arrays and structs, and there
// are some restrictions on when it applies to slices.
if !compat() || (!integers() && !floats() && !strings()) {
a.diagOpTypes(op, origlt, origrt)
return nil
}
t = BoolType
case token.EQL, token.NEQ:
// XXX(Spec) The rules for type checking comparison
// operators are spread across three places that all
// partially overlap with each other: the Comparison
// Compatibility section, the Operators section, and
// the Comparison Operators section. The Operators
// section should just say that operators require
// identical types (as it does currently) except that
// there a few special cases for comparison, which are
// described in section X. Currently it includes just
// one of the four special cases. The Comparison
// Compatibility section and the Comparison Operators
// section should either be merged, or at least the
// Comparison Compatibility section should be
// exclusively about type checking and the Comparison
// Operators section should be exclusively about
// semantics.
// XXX(Spec) Comparison operators: "All comparison
// operators apply to basic types except bools." This
// is very difficult to parse. It's explained much
// better in the Comparison Compatibility section.
// XXX(Spec) Comparison compatibility: "Function
// values are equal if they refer to the same
// function." is rather vague. It should probably be
// similar to the way the rule for map values is
// written: Function values are equal if they were
// created by the same execution of a function literal
// or refer to the same function declaration. This is
// *almost* but not quite waht 6g implements. If a
// function literals does not capture any variables,
// then multiple executions of it will result in the
// same closure. Russ says he'll change that.
// TODO(austin) Deal with remaining special cases
if !compat() {
a.diagOpTypes(op, origlt, origrt)
return nil
}
// Arrays and structs may not be compared to anything.
switch l.t.(type) {
case *ArrayType, *StructType:
a.diagOpTypes(op, origlt, origrt)
return nil
}
t = BoolType
default:
log.Panicf("unknown binary operator %v", op)
}
desc, ok := binOpDescs[op]
if !ok {
desc = op.String() + " expression"
binOpDescs[op] = desc
}
// Check for ideal divide by zero
switch op {
case token.QUO, token.REM:
if r.t.isIdeal() {
if (r.t.isInteger() && r.asIdealInt()().Sign() == 0) ||
(r.t.isFloat() && r.asIdealFloat()().Sign() == 0) {
a.diag("divide by zero")
return nil
}
}
}
// Compile
expr := a.newExpr(t, desc)
switch op {
case token.ADD:
expr.genBinOpAdd(l, r)
case token.SUB:
expr.genBinOpSub(l, r)
case token.MUL:
expr.genBinOpMul(l, r)
case token.QUO:
expr.genBinOpQuo(l, r)
case token.REM:
expr.genBinOpRem(l, r)
case token.AND:
expr.genBinOpAnd(l, r)
case token.OR:
expr.genBinOpOr(l, r)
case token.XOR:
expr.genBinOpXor(l, r)
case token.AND_NOT:
expr.genBinOpAndNot(l, r)
case token.SHL:
if l.t.isIdeal() {
lv := l.asIdealInt()()
rv := r.asIdealInt()()
const maxShift = 99999
if rv.Cmp(big.NewInt(maxShift)) > 0 {
a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift)
expr.t = nil
return nil
}
val := new(big.Int).Lsh(lv, uint(rv.Int64()))
expr.eval = func() *big.Int { return val }
} else {
expr.genBinOpShl(l, r)
}
case token.SHR:
if l.t.isIdeal() {
lv := l.asIdealInt()()
rv := r.asIdealInt()()
val := new(big.Int).Rsh(lv, uint(rv.Int64()))
expr.eval = func() *big.Int { return val }
} else {
expr.genBinOpShr(l, r)
}
case token.LSS:
expr.genBinOpLss(l, r)
case token.GTR:
expr.genBinOpGtr(l, r)
case token.LEQ:
expr.genBinOpLeq(l, r)
case token.GEQ:
expr.genBinOpGeq(l, r)
case token.EQL:
expr.genBinOpEql(l, r)
case token.NEQ:
expr.genBinOpNeq(l, r)
case token.LAND:
expr.genBinOpLogAnd(l, r)
case token.LOR:
expr.genBinOpLogOr(l, r)
default:
log.Panicf("Compilation of binary op %v not implemented", op)
}
return expr
}
// TODO(austin) This is a hack to eliminate a circular dependency
// between type.go and expr.go
func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) {
lenExpr := a.compileExpr(b, true, expr)
if lenExpr == nil {
return 0, false
}
// XXX(Spec) Are ideal floats with no fractional part okay?
if lenExpr.t.isIdeal() {
lenExpr = lenExpr.convertTo(IntType)
if lenExpr == nil {
return 0, false
}
}
if !lenExpr.t.isInteger() {
a.diagAt(expr.Pos(), "array size must be an integer")
return 0, false
}
switch lenExpr.t.lit().(type) {
case *intType:
return lenExpr.asInt()(nil), true
case *uintType:
return int64(lenExpr.asUint()(nil)), true
}
log.Panicf("unexpected integer type %T", lenExpr.t)
return 0, false
}
func (a *compiler) compileExpr(b *block, constant bool, expr ast.Expr) *expr {
ec := &exprCompiler{a, b, constant}
nerr := a.numError()
e := ec.compile(expr, false)
if e == nil && nerr == a.numError() {
log.Panicf("expression compilation failed without reporting errors")
}
return e
}
// extractEffect separates out any effects that the expression may
// have, returning a function that will perform those effects and a
// new exprCompiler that is guaranteed to be side-effect free. These
// are the moral equivalents of "temp := expr" and "temp" (or "temp :=
// &expr" and "*temp" for addressable exprs). Because this creates a
// temporary variable, the caller should create a temporary block for
// the compilation of this expression and the evaluation of the
// results.
func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) {
// Create "&a" if a is addressable
rhs := a
if a.evalAddr != nil {
rhs = a.compileUnaryExpr(token.AND, rhs)
}
// Create temp
ac, ok := a.checkAssign(a.pos, []*expr{rhs}, errOp, "")
if !ok {
return nil, nil
}
if len(ac.rmt.Elems) != 1 {
a.diag("multi-valued expression not allowed in %s", errOp)
return nil, nil
}
tempType := ac.rmt.Elems[0]
if tempType.isIdeal() {
// It's too bad we have to duplicate this rule.
switch {
case tempType.isInteger():
tempType = IntType
case tempType.isFloat():
tempType = Float64Type
default:
log.Panicf("unexpected ideal type %v", tempType)
}
}
temp := b.DefineTemp(tempType)
tempIdx := temp.Index
// Create "temp := rhs"
assign := ac.compile(b, tempType)
if assign == nil {
log.Panicf("compileAssign type check failed")
}
effect := func(t *Thread) {
tempVal := tempType.Zero()
t.f.Vars[tempIdx] = tempVal
assign(tempVal, t)
}
// Generate "temp" or "*temp"
getTemp := a.compileVariable(0, temp)
if a.evalAddr == nil {
return effect, getTemp
}
deref := a.compileStarExpr(getTemp)
if deref == nil {
return nil, nil
}
return effect, deref
}