func (v *Variable) setValue(y *Variable) error {
var err error
switch v.Kind {
case reflect.Float32, reflect.Float64:
f, _ := constant.Float64Val(y.Value)
err = v.writeFloatRaw(f, v.RealType.Size())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n, _ := constant.Int64Val(y.Value)
err = v.writeUint(uint64(n), v.RealType.Size())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
n, _ := constant.Uint64Val(y.Value)
err = v.writeUint(n, v.RealType.Size())
case reflect.Bool:
err = v.writeBool(constant.BoolVal(y.Value))
case reflect.Complex64, reflect.Complex128:
real, _ := constant.Float64Val(constant.Real(y.Value))
imag, _ := constant.Float64Val(constant.Imag(y.Value))
err = v.writeComplex(real, imag, v.RealType.Size())
default:
fmt.Printf("default\n")
if t, isptr := v.RealType.(*dwarf.PtrType); isptr {
err = v.writeUint(uint64(y.Children[0].Addr), int64(t.ByteSize))
} else {
return fmt.Errorf("can not set variables of type %s (not implemented)", v.Kind.String())
}
}
return err
}
func (g *javaGen) genConst(o *types.Const) {
// TODO(hyangah): should const names use upper cases + "_"?
// TODO(hyangah): check invalid names.
jType := g.javaType(o.Type())
val := o.Val().String()
switch b := o.Type().(*types.Basic); b.Kind() {
case types.Int64, types.UntypedInt:
i, exact := constant.Int64Val(o.Val())
if !exact {
g.errorf("const value %s for %s cannot be represented as %s", val, o.Name(), jType)
return
}
val = fmt.Sprintf("%dL", i)
case types.Float32:
f, _ := constant.Float32Val(o.Val())
val = fmt.Sprintf("%gf", f)
case types.Float64, types.UntypedFloat:
f, _ := constant.Float64Val(o.Val())
if math.IsInf(f, 0) || math.Abs(f) > math.MaxFloat64 {
g.errorf("const value %s for %s cannot be represented as %s", val, o.Name(), jType)
return
}
val = fmt.Sprintf("%g", f)
}
g.Printf("public static final %s %s = %s;\n", g.javaType(o.Type()), o.Name(), val)
}
// goVal returns the Go value for val, or nil.
func goVal(val constant.Value) interface{} {
// val should exist, but be conservative and check
if val == nil {
return nil
}
// Match implementation restriction of other compilers.
// gc only checks duplicates for integer, floating-point
// and string values, so only create Go values for these
// types.
switch val.Kind() {
case constant.Int:
if x, ok := constant.Int64Val(val); ok {
return x
}
if x, ok := constant.Uint64Val(val); ok {
return x
}
case constant.Float:
if x, ok := constant.Float64Val(val); ok {
return x
}
case constant.String:
return constant.StringVal(val)
}
return nil
}
func roundFloat64(x exact.Value) exact.Value {
f, _ := exact.Float64Val(x)
if !math.IsInf(f, 0) {
return exact.MakeFloat64(f)
}
return nil
}
// constValString emulates Go 1.6's go/constant.ExactString well enough
// to make the tests pass. This is just a stopgap until we throw away
// all the *15.go files.
func constValString(v exact.Value) string {
if v.Kind() == exact.Float {
f, _ := exact.Float64Val(v)
return fmt.Sprintf("%g", f)
}
return v.String()
}
func roundFloat64(x constant.Value) constant.Value {
f, _ := constant.Float64Val(x)
if !math.IsInf(f, 0) {
return constant.MakeFloat64(f)
}
return nil
}
// Helper function to adjust go1.5 numeric go/constant formatting.
// Can be removed once we give up compatibility with go1.5.
func constValString(v exact.Value) string {
if v.Kind() == exact.Float {
// In go1.5, go/constant floating-point values are printed
// as fractions. Make them appear as floating-point numbers.
f, _ := exact.Float64Val(v)
return fmt.Sprintf("%g", f)
}
return v.String()
}
func ConvertVar(v *proc.Variable) *Variable {
r := Variable{
Addr: v.Addr,
Name: v.Name,
Kind: v.Kind,
Len: v.Len,
Cap: v.Cap,
}
if v.DwarfType != nil {
r.Type = v.DwarfType.String()
}
if v.RealType != nil {
r.RealType = v.RealType.String()
}
if v.Unreadable != nil {
r.Unreadable = v.Unreadable.Error()
}
if v.Value != nil {
switch v.Kind {
case reflect.Float32:
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 32)
case reflect.Float64:
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 64)
case reflect.String, reflect.Func:
r.Value = constant.StringVal(v.Value)
default:
r.Value = v.Value.String()
}
}
r.Children = make([]Variable, len(v.Children))
for i := range v.Children {
r.Children[i] = *ConvertVar(&v.Children[i])
}
return &r
}
// Uint64 returns the numeric value of this constant truncated to fit
// an unsigned 64-bit integer.
//
func (c *Const) Uint64() uint64 {
switch x := c.Value; x.Kind() {
case exact.Int:
if u, ok := exact.Uint64Val(x); ok {
return u
}
return 0
case exact.Float:
f, _ := exact.Float64Val(x)
return uint64(f)
}
panic(fmt.Sprintf("unexpected constant value: %T", c.Value))
}
// Int64 returns the numeric value of this constant truncated to fit
// a signed 64-bit integer.
//
func (c *Const) Int64() int64 {
switch x := exact.ToInt(c.Value); x.Kind() {
case exact.Int:
if i, ok := exact.Int64Val(x); ok {
return i
}
return 0
case exact.Float:
f, _ := exact.Float64Val(x)
return int64(f)
}
panic(fmt.Sprintf("unexpected constant value: %T", c.Value))
}
func (g *ObjcGen) genConstM(o *types.Const) {
if _, ok := o.Type().(*types.Basic); !ok {
g.Printf("// skipped const %s with unsupported type: %T\n\n", o.Name(), o)
return
}
cName := fmt.Sprintf("%s%s", g.namePrefix, o.Name())
objcType := g.objcType(o.Type())
switch b := o.Type().(*types.Basic); b.Kind() {
case types.Bool, types.UntypedBool:
v := "NO"
if constant.BoolVal(o.Val()) {
v = "YES"
}
g.Printf("const BOOL %s = %s;\n", cName, v)
case types.String, types.UntypedString:
g.Printf("NSString* const %s = @%s;\n", cName, constExactString(o))
case types.Int, types.Int8, types.Int16, types.Int32:
g.Printf("const %s %s = %s;\n", objcType, cName, o.Val())
case types.Int64, types.UntypedInt:
i, exact := constant.Int64Val(o.Val())
if !exact {
g.errorf("const value %s for %s cannot be represented as %s", o.Val(), o.Name(), objcType)
return
}
if i == math.MinInt64 {
// -9223372036854775808LL does not work because 922337203685477508 is
// larger than max int64.
g.Printf("const int64_t %s = %dLL-1;\n", cName, i+1)
} else {
g.Printf("const int64_t %s = %dLL;\n", cName, i)
}
case types.Float32, types.Float64, types.UntypedFloat:
f, _ := constant.Float64Val(o.Val())
if math.IsInf(f, 0) || math.Abs(f) > math.MaxFloat64 {
g.errorf("const value %s for %s cannot be represented as double", o.Val(), o.Name())
return
}
g.Printf("const %s %s = %g;\n", objcType, cName, f)
default:
g.errorf("unsupported const type %s for %s", b, o.Name())
}
}
func (p *exporter) float(x constant.Value) {
if x.Kind() != constant.Float {
log.Fatalf("gcimporter: unexpected constant %v, want float", x)
}
// extract sign (there is no -0)
sign := constant.Sign(x)
if sign == 0 {
// x == 0
p.int(0)
return
}
// x != 0
var f big.Float
if v, exact := constant.Float64Val(x); exact {
// float64
f.SetFloat64(v)
} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
// TODO(gri): add big.Rat accessor to constant.Value.
r := valueToRat(num)
f.SetRat(r.Quo(r, valueToRat(denom)))
} else {
// Value too large to represent as a fraction => inaccessible.
// TODO(gri): add big.Float accessor to constant.Value.
f.SetFloat64(math.MaxFloat64) // FIXME
}
// extract exponent such that 0.5 <= m < 1.0
var m big.Float
exp := f.MantExp(&m)
// extract mantissa as *big.Int
// - set exponent large enough so mant satisfies mant.IsInt()
// - get *big.Int from mant
m.SetMantExp(&m, int(m.MinPrec()))
mant, acc := m.Int(nil)
if acc != big.Exact {
log.Fatalf("gcimporter: internal error")
}
p.int(sign)
p.int(exp)
p.string(string(mant.Bytes()))
}
// ResolveAsType implements the Constant interface.
func (expr *NumVal) ResolveAsType(typ Datum) (Datum, error) {
switch {
case typ.TypeEqual(TypeInt):
i, exact := constant.Int64Val(constant.ToInt(expr.Value))
if !exact {
return nil, fmt.Errorf("integer value out of range: %v", expr.Value)
}
return NewDInt(DInt(i)), nil
case typ.TypeEqual(TypeFloat):
f, _ := constant.Float64Val(constant.ToFloat(expr.Value))
return NewDFloat(DFloat(f)), nil
case typ.TypeEqual(TypeDecimal):
dd := &DDecimal{}
s := expr.ExactString()
if idx := strings.IndexRune(s, '/'); idx != -1 {
// Handle constant.ratVal, which will return a rational string
// like 6/7. If only we could call big.Rat.FloatString() on it...
num, den := s[:idx], s[idx+1:]
if _, ok := dd.SetString(num); !ok {
return nil, fmt.Errorf("could not evaluate numerator of %v as Datum type DDecimal "+
"from string %q", expr, num)
}
denDec := new(inf.Dec)
if _, ok := denDec.SetString(den); !ok {
return nil, fmt.Errorf("could not evaluate denominator %v as Datum type DDecimal "+
"from string %q", expr, den)
}
dd.QuoRound(&dd.Dec, denDec, decimal.Precision, inf.RoundHalfUp)
} else {
if _, ok := dd.SetString(s); !ok {
return nil, fmt.Errorf("could not evaluate %v as Datum type DDecimal from "+
"string %q", expr, s)
}
}
return dd, nil
default:
return nil, fmt.Errorf("could not resolve %T %v into a %T", expr, expr, typ)
}
}
// Float64 returns the numeric value of this constant truncated to fit
// a float64.
//
func (c *Const) Float64() float64 {
f, _ := exact.Float64Val(c.Value)
return f
}
// ConvertVar converts from proc.Variable to api.Variable.
func ConvertVar(v *proc.Variable) *Variable {
r := Variable{
Addr: v.Addr,
OnlyAddr: v.OnlyAddr,
Name: v.Name,
Kind: v.Kind,
Len: v.Len,
Cap: v.Cap,
}
r.Type = prettyTypeName(v.DwarfType)
r.RealType = prettyTypeName(v.RealType)
if v.Unreadable != nil {
r.Unreadable = v.Unreadable.Error()
}
if v.Value != nil {
switch v.Kind {
case reflect.Float32:
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 32)
case reflect.Float64:
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 64)
case reflect.String, reflect.Func:
r.Value = constant.StringVal(v.Value)
default:
r.Value = v.Value.String()
}
}
switch v.Kind {
case reflect.Complex64:
r.Children = make([]Variable, 2)
r.Len = 2
real, _ := constant.Float64Val(constant.Real(v.Value))
imag, _ := constant.Float64Val(constant.Imag(v.Value))
r.Children[0].Name = "real"
r.Children[0].Kind = reflect.Float32
r.Children[0].Value = strconv.FormatFloat(real, 'f', -1, 32)
r.Children[1].Name = "imaginary"
r.Children[1].Kind = reflect.Float32
r.Children[1].Value = strconv.FormatFloat(imag, 'f', -1, 32)
case reflect.Complex128:
r.Children = make([]Variable, 2)
r.Len = 2
real, _ := constant.Float64Val(constant.Real(v.Value))
imag, _ := constant.Float64Val(constant.Imag(v.Value))
r.Children[0].Name = "real"
r.Children[0].Kind = reflect.Float64
r.Children[0].Value = strconv.FormatFloat(real, 'f', -1, 64)
r.Children[1].Name = "imaginary"
r.Children[1].Kind = reflect.Float64
r.Children[1].Value = strconv.FormatFloat(imag, 'f', -1, 64)
default:
r.Children = make([]Variable, len(v.Children))
for i := range v.Children {
r.Children[i] = *ConvertVar(&v.Children[i])
}
}
return &r
}
func TestVariableEvaluation(t *testing.T) {
testcases := []struct {
name string
st reflect.Kind
value interface{}
length, cap int64
childrenlen int
}{
{"a1", reflect.String, "foofoofoofoofoofoo", 18, 0, 0},
{"a11", reflect.Array, nil, 3, -1, 3},
{"a12", reflect.Slice, nil, 2, 2, 2},
{"a13", reflect.Slice, nil, 3, 3, 3},
{"a2", reflect.Int, int64(6), 0, 0, 0},
{"a3", reflect.Float64, float64(7.23), 0, 0, 0},
{"a4", reflect.Array, nil, 2, -1, 2},
{"a5", reflect.Slice, nil, 5, 5, 5},
{"a6", reflect.Struct, nil, 2, 0, 2},
{"a7", reflect.Ptr, nil, 1, 0, 1},
{"a8", reflect.Struct, nil, 2, 0, 2},
{"a9", reflect.Ptr, nil, 1, 0, 1},
{"baz", reflect.String, "bazburzum", 9, 0, 0},
{"neg", reflect.Int, int64(-1), 0, 0, 0},
{"f32", reflect.Float32, float64(float32(1.2)), 0, 0, 0},
{"c64", reflect.Complex64, complex128(complex64(1 + 2i)), 0, 0, 0},
{"c128", reflect.Complex128, complex128(2 + 3i), 0, 0, 0},
{"a6.Baz", reflect.Int, int64(8), 0, 0, 0},
{"a7.Baz", reflect.Int, int64(5), 0, 0, 0},
{"a8.Baz", reflect.String, "feh", 3, 0, 0},
{"a8", reflect.Struct, nil, 2, 0, 2},
{"i32", reflect.Array, nil, 2, -1, 2},
{"b1", reflect.Bool, true, 0, 0, 0},
{"b2", reflect.Bool, false, 0, 0, 0},
{"f", reflect.Func, "main.barfoo", 0, 0, 0},
{"ba", reflect.Slice, nil, 200, 200, 64},
}
withTestProcess("testvariables", t, func(p *Process, fixture protest.Fixture) {
assertNoError(p.Continue(), t, "Continue() returned an error")
for _, tc := range testcases {
v, err := evalVariable(p, tc.name)
assertNoError(err, t, fmt.Sprintf("EvalVariable(%s)", tc.name))
if v.Kind != tc.st {
t.Fatalf("%s simple type: expected: %s got: %s", tc.name, tc.st, v.Kind.String())
}
if v.Value == nil && tc.value != nil {
t.Fatalf("%s value: expected: %v got: %v", tc.name, tc.value, v.Value)
} else {
switch v.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
x, _ := constant.Int64Val(v.Value)
if y, ok := tc.value.(int64); !ok || x != y {
t.Fatalf("%s value: expected: %v got: %v", tc.name, tc.value, v.Value)
}
case reflect.Float32, reflect.Float64:
x, _ := constant.Float64Val(v.Value)
if y, ok := tc.value.(float64); !ok || x != y {
t.Fatalf("%s value: expected: %v got: %v", tc.name, tc.value, v.Value)
}
case reflect.Complex64, reflect.Complex128:
xr, _ := constant.Float64Val(constant.Real(v.Value))
xi, _ := constant.Float64Val(constant.Imag(v.Value))
if y, ok := tc.value.(complex128); !ok || complex(xr, xi) != y {
t.Fatalf("%s value: expected: %v got: %v", tc.name, tc.value, v.Value)
}
case reflect.String:
if y, ok := tc.value.(string); !ok || constant.StringVal(v.Value) != y {
t.Fatalf("%s value: expected: %v got: %v", tc.name, tc.value, v.Value)
}
}
}
if v.Len != tc.length {
t.Fatalf("%s len: expected: %d got: %d", tc.name, tc.length, v.Len)
}
if v.Cap != tc.cap {
t.Fatalf("%s cap: expected: %d got: %d", tc.name, tc.cap, v.Cap)
}
if len(v.Children) != tc.childrenlen {
t.Fatalf("%s children len: expected %d got: %d", tc.name, tc.childrenlen, len(v.Children))
}
}
})
}
func (c *funcContext) translateExpr(expr ast.Expr) *expression {
exprType := c.p.TypeOf(expr)
if value := c.p.Types[expr].Value; value != nil {
basic := exprType.Underlying().(*types.Basic)
switch {
case isBoolean(basic):
return c.formatExpr("%s", strconv.FormatBool(constant.BoolVal(value)))
case isInteger(basic):
if is64Bit(basic) {
if basic.Kind() == types.Int64 {
d, ok := constant.Int64Val(constant.ToInt(value))
if !ok {
panic("could not get exact uint")
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatInt(d>>32, 10), strconv.FormatUint(uint64(d)&(1<<32-1), 10))
}
d, ok := constant.Uint64Val(constant.ToInt(value))
if !ok {
panic("could not get exact uint")
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatUint(d>>32, 10), strconv.FormatUint(d&(1<<32-1), 10))
}
d, ok := constant.Int64Val(constant.ToInt(value))
if !ok {
panic("could not get exact int")
}
return c.formatExpr("%s", strconv.FormatInt(d, 10))
case isFloat(basic):
f, _ := constant.Float64Val(value)
return c.formatExpr("%s", strconv.FormatFloat(f, 'g', -1, 64))
case isComplex(basic):
r, _ := constant.Float64Val(constant.Real(value))
i, _ := constant.Float64Val(constant.Imag(value))
if basic.Kind() == types.UntypedComplex {
exprType = types.Typ[types.Complex128]
}
return c.formatExpr("new %s(%s, %s)", c.typeName(exprType), strconv.FormatFloat(r, 'g', -1, 64), strconv.FormatFloat(i, 'g', -1, 64))
case isString(basic):
return c.formatExpr("%s", encodeString(constant.StringVal(value)))
default:
panic("Unhandled constant type: " + basic.String())
}
}
var obj types.Object
switch e := expr.(type) {
case *ast.SelectorExpr:
obj = c.p.Uses[e.Sel]
case *ast.Ident:
obj = c.p.Defs[e]
if obj == nil {
obj = c.p.Uses[e]
}
}
if obj != nil && typesutil.IsJsPackage(obj.Pkg()) {
switch obj.Name() {
case "Global":
return c.formatExpr("$global")
case "Module":
return c.formatExpr("$module")
case "Undefined":
return c.formatExpr("undefined")
}
}
switch e := expr.(type) {
case *ast.CompositeLit:
if ptrType, isPointer := exprType.(*types.Pointer); isPointer {
exprType = ptrType.Elem()
}
collectIndexedElements := func(elementType types.Type) []string {
var elements []string
i := 0
zero := c.translateExpr(c.zeroValue(elementType)).String()
for _, element := range e.Elts {
if kve, isKve := element.(*ast.KeyValueExpr); isKve {
key, ok := constant.Int64Val(constant.ToInt(c.p.Types[kve.Key].Value))
if !ok {
panic("could not get exact int")
}
i = int(key)
element = kve.Value
}
for len(elements) <= i {
elements = append(elements, zero)
}
elements[i] = c.translateImplicitConversionWithCloning(element, elementType).String()
i++
}
return elements
}
switch t := exprType.Underlying().(type) {
case *types.Array:
elements := collectIndexedElements(t.Elem())
if len(elements) == 0 {
return c.formatExpr("%s.zero()", c.typeName(t))
}
zero := c.translateExpr(c.zeroValue(t.Elem())).String()
for len(elements) < int(t.Len()) {
elements = append(elements, zero)
}
return c.formatExpr(`$toNativeArray(%s, [%s])`, typeKind(t.Elem()), strings.Join(elements, ", "))
case *types.Slice:
return c.formatExpr("new %s([%s])", c.typeName(exprType), strings.Join(collectIndexedElements(t.Elem()), ", "))
case *types.Map:
entries := make([]string, len(e.Elts))
for i, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
entries[i] = fmt.Sprintf("{ k: %s, v: %s }", c.translateImplicitConversionWithCloning(kve.Key, t.Key()), c.translateImplicitConversionWithCloning(kve.Value, t.Elem()))
}
return c.formatExpr("$makeMap(%s.keyFor, [%s])", c.typeName(t.Key()), strings.Join(entries, ", "))
case *types.Struct:
elements := make([]string, t.NumFields())
isKeyValue := true
if len(e.Elts) != 0 {
_, isKeyValue = e.Elts[0].(*ast.KeyValueExpr)
}
if !isKeyValue {
for i, element := range e.Elts {
elements[i] = c.translateImplicitConversionWithCloning(element, t.Field(i).Type()).String()
}
}
if isKeyValue {
for i := range elements {
elements[i] = c.translateExpr(c.zeroValue(t.Field(i).Type())).String()
}
for _, element := range e.Elts {
kve := element.(*ast.KeyValueExpr)
for j := range elements {
if kve.Key.(*ast.Ident).Name == t.Field(j).Name() {
elements[j] = c.translateImplicitConversionWithCloning(kve.Value, t.Field(j).Type()).String()
break
}
}
}
}
return c.formatExpr("new %s.ptr(%s)", c.typeName(exprType), strings.Join(elements, ", "))
default:
panic(fmt.Sprintf("Unhandled CompositeLit type: %T\n", t))
}
case *ast.FuncLit:
_, fun := translateFunction(e.Type, nil, e.Body, c, exprType.(*types.Signature), c.p.FuncLitInfos[e], "")
if len(c.p.escapingVars) != 0 {
names := make([]string, 0, len(c.p.escapingVars))
for obj := range c.p.escapingVars {
names = append(names, c.p.objectNames[obj])
}
sort.Strings(names)
list := strings.Join(names, ", ")
return c.formatExpr("(function(%s) { return %s; })(%s)", list, fun, list)
}
return c.formatExpr("(%s)", fun)
case *ast.UnaryExpr:
t := c.p.TypeOf(e.X)
switch e.Op {
case token.AND:
if typesutil.IsJsObject(exprType) {
return c.formatExpr("%e.object", e.X)
}
switch t.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
switch x := astutil.RemoveParens(e.X).(type) {
case *ast.CompositeLit:
return c.formatExpr("$newDataPointer(%e, %s)", x, c.typeName(c.p.TypeOf(e)))
case *ast.Ident:
obj := c.p.Uses[x].(*types.Var)
if c.p.escapingVars[obj] {
return c.formatExpr("(%1s.$ptr || (%1s.$ptr = new %2s(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, %1s)))", c.p.objectNames[obj], c.typeName(exprType))
}
return c.formatExpr(`(%1s || (%1s = new %2s(function() { return %3s; }, function($v) { %4s })))`, c.varPtrName(obj), c.typeName(exprType), c.objectName(obj), c.translateAssign(x, c.newIdent("$v", exprType), false))
case *ast.SelectorExpr:
sel, ok := c.p.SelectionOf(x)
if !ok {
// qualified identifier
obj := c.p.Uses[x.Sel].(*types.Var)
return c.formatExpr(`(%1s || (%1s = new %2s(function() { return %3s; }, function($v) { %4s })))`, c.varPtrName(obj), c.typeName(exprType), c.objectName(obj), c.translateAssign(x, c.newIdent("$v", exprType), false))
}
newSel := &ast.SelectorExpr{X: c.newIdent("this.$target", c.p.TypeOf(x.X)), Sel: x.Sel}
c.setType(newSel, exprType)
c.p.additionalSelections[newSel] = sel
return c.formatExpr("(%1e.$ptr_%2s || (%1e.$ptr_%2s = new %3s(function() { return %4e; }, function($v) { %5s }, %1e)))", x.X, x.Sel.Name, c.typeName(exprType), newSel, c.translateAssign(newSel, c.newIdent("$v", exprType), false))
case *ast.IndexExpr:
if _, ok := c.p.TypeOf(x.X).Underlying().(*types.Slice); ok {
return c.formatExpr("$indexPtr(%1e.$array, %1e.$offset + %2e, %3s)", x.X, x.Index, c.typeName(exprType))
}
return c.formatExpr("$indexPtr(%e, %e, %s)", x.X, x.Index, c.typeName(exprType))
case *ast.StarExpr:
return c.translateExpr(x.X)
default:
panic(fmt.Sprintf("Unhandled: %T\n", x))
}
case token.ARROW:
call := &ast.CallExpr{
Fun: c.newIdent("$recv", types.NewSignature(nil, types.NewTuple(types.NewVar(0, nil, "", t)), types.NewTuple(types.NewVar(0, nil, "", exprType), types.NewVar(0, nil, "", types.Typ[types.Bool])), false)),
Args: []ast.Expr{e.X},
}
c.Blocking[call] = true
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr("%e", call)
}
return c.formatExpr("%e[0]", call)
}
basic := t.Underlying().(*types.Basic)
switch e.Op {
case token.ADD:
return c.translateExpr(e.X)
case token.SUB:
switch {
case is64Bit(basic):
return c.formatExpr("new %1s(-%2h, -%2l)", c.typeName(t), e.X)
case isComplex(basic):
return c.formatExpr("new %1s(-%2r, -%2i)", c.typeName(t), e.X)
case isUnsigned(basic):
return c.fixNumber(c.formatExpr("-%e", e.X), basic)
default:
return c.formatExpr("-%e", e.X)
}
case token.XOR:
if is64Bit(basic) {
return c.formatExpr("new %1s(~%2h, ~%2l >>> 0)", c.typeName(t), e.X)
}
return c.fixNumber(c.formatExpr("~%e", e.X), basic)
case token.NOT:
return c.formatExpr("!%e", e.X)
default:
panic(e.Op)
}
case *ast.BinaryExpr:
if e.Op == token.NEQ {
return c.formatExpr("!(%s)", c.translateExpr(&ast.BinaryExpr{
X: e.X,
Op: token.EQL,
Y: e.Y,
}))
}
t := c.p.TypeOf(e.X)
t2 := c.p.TypeOf(e.Y)
_, isInterface := t2.Underlying().(*types.Interface)
if isInterface || types.Identical(t, types.Typ[types.UntypedNil]) {
t = t2
}
if basic, isBasic := t.Underlying().(*types.Basic); isBasic && isNumeric(basic) {
if is64Bit(basic) {
switch e.Op {
case token.MUL:
return c.formatExpr("$mul64(%e, %e)", e.X, e.Y)
case token.QUO:
return c.formatExpr("$div64(%e, %e, false)", e.X, e.Y)
case token.REM:
return c.formatExpr("$div64(%e, %e, true)", e.X, e.Y)
case token.SHL:
return c.formatExpr("$shiftLeft64(%e, %f)", e.X, e.Y)
case token.SHR:
return c.formatExpr("$shiftRight%s(%e, %f)", toJavaScriptType(basic), e.X, e.Y)
case token.EQL:
return c.formatExpr("(%1h === %2h && %1l === %2l)", e.X, e.Y)
case token.LSS:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l < %2l))", e.X, e.Y)
case token.LEQ:
return c.formatExpr("(%1h < %2h || (%1h === %2h && %1l <= %2l))", e.X, e.Y)
case token.GTR:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l > %2l))", e.X, e.Y)
case token.GEQ:
return c.formatExpr("(%1h > %2h || (%1h === %2h && %1l >= %2l))", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1h %4t %2h, %1l %4t %2l)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND, token.OR, token.XOR:
return c.formatExpr("new %3s(%1h %4t %2h, (%1l %4t %2l) >>> 0)", e.X, e.Y, c.typeName(t), e.Op)
case token.AND_NOT:
return c.formatExpr("new %3s(%1h & ~%2h, (%1l & ~%2l) >>> 0)", e.X, e.Y, c.typeName(t))
default:
panic(e.Op)
}
}
if isComplex(basic) {
switch e.Op {
case token.EQL:
return c.formatExpr("(%1r === %2r && %1i === %2i)", e.X, e.Y)
case token.ADD, token.SUB:
return c.formatExpr("new %3s(%1r %4t %2r, %1i %4t %2i)", e.X, e.Y, c.typeName(t), e.Op)
case token.MUL:
return c.formatExpr("new %3s(%1r * %2r - %1i * %2i, %1r * %2i + %1i * %2r)", e.X, e.Y, c.typeName(t))
case token.QUO:
return c.formatExpr("$divComplex(%e, %e)", e.X, e.Y)
default:
panic(e.Op)
}
}
switch e.Op {
case token.EQL:
return c.formatParenExpr("%e === %e", e.X, e.Y)
case token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.ADD, token.SUB:
return c.fixNumber(c.formatExpr("%e %t %e", e.X, e.Op, e.Y), basic)
case token.MUL:
switch basic.Kind() {
case types.Int32, types.Int:
return c.formatParenExpr("$imul(%e, %e)", e.X, e.Y)
case types.Uint32, types.Uintptr:
return c.formatParenExpr("$imul(%e, %e) >>> 0", e.X, e.Y)
}
return c.fixNumber(c.formatExpr("%e * %e", e.X, e.Y), basic)
case token.QUO:
if isInteger(basic) {
// cut off decimals
shift := ">>"
if isUnsigned(basic) {
shift = ">>>"
}
return c.formatExpr(`(%1s = %2e / %3e, (%1s === %1s && %1s !== 1/0 && %1s !== -1/0) ? %1s %4s 0 : $throwRuntimeError("integer divide by zero"))`, c.newVariable("_q"), e.X, e.Y, shift)
}
if basic.Kind() == types.Float32 {
return c.fixNumber(c.formatExpr("%e / %e", e.X, e.Y), basic)
}
return c.formatExpr("%e / %e", e.X, e.Y)
case token.REM:
return c.formatExpr(`(%1s = %2e %% %3e, %1s === %1s ? %1s : $throwRuntimeError("integer divide by zero"))`, c.newVariable("_r"), e.X, e.Y)
case token.SHL, token.SHR:
op := e.Op.String()
if e.Op == token.SHR && isUnsigned(basic) {
op = ">>>"
}
if v := c.p.Types[e.Y].Value; v != nil {
i, _ := constant.Uint64Val(constant.ToInt(v))
if i >= 32 {
return c.formatExpr("0")
}
return c.fixNumber(c.formatExpr("%e %s %s", e.X, op, strconv.FormatUint(i, 10)), basic)
}
if e.Op == token.SHR && !isUnsigned(basic) {
return c.fixNumber(c.formatParenExpr("%e >> $min(%f, 31)", e.X, e.Y), basic)
}
y := c.newVariable("y")
return c.fixNumber(c.formatExpr("(%s = %f, %s < 32 ? (%e %s %s) : 0)", y, e.Y, y, e.X, op, y), basic)
case token.AND, token.OR:
if isUnsigned(basic) {
return c.formatParenExpr("(%e %t %e) >>> 0", e.X, e.Op, e.Y)
}
return c.formatParenExpr("%e %t %e", e.X, e.Op, e.Y)
case token.AND_NOT:
return c.fixNumber(c.formatParenExpr("%e & ~%e", e.X, e.Y), basic)
case token.XOR:
return c.fixNumber(c.formatParenExpr("%e ^ %e", e.X, e.Y), basic)
default:
panic(e.Op)
}
}
switch e.Op {
case token.ADD, token.LSS, token.LEQ, token.GTR, token.GEQ:
return c.formatExpr("%e %t %e", e.X, e.Op, e.Y)
case token.LAND:
if c.Blocking[e.Y] {
skipCase := c.caseCounter
c.caseCounter++
resultVar := c.newVariable("_v")
c.Printf("if (!(%s)) { %s = false; $s = %d; continue s; }", c.translateExpr(e.X), resultVar, skipCase)
c.Printf("%s = %s; case %d:", resultVar, c.translateExpr(e.Y), skipCase)
return c.formatExpr("%s", resultVar)
}
return c.formatExpr("%e && %e", e.X, e.Y)
case token.LOR:
if c.Blocking[e.Y] {
skipCase := c.caseCounter
c.caseCounter++
resultVar := c.newVariable("_v")
c.Printf("if (%s) { %s = true; $s = %d; continue s; }", c.translateExpr(e.X), resultVar, skipCase)
c.Printf("%s = %s; case %d:", resultVar, c.translateExpr(e.Y), skipCase)
return c.formatExpr("%s", resultVar)
}
return c.formatExpr("%e || %e", e.X, e.Y)
case token.EQL:
switch u := t.Underlying().(type) {
case *types.Array, *types.Struct:
return c.formatExpr("$equal(%e, %e, %s)", e.X, e.Y, c.typeName(t))
case *types.Interface:
return c.formatExpr("$interfaceIsEqual(%s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
case *types.Pointer:
if _, ok := u.Elem().Underlying().(*types.Array); ok {
return c.formatExpr("$equal(%s, %s, %s)", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t), c.typeName(u.Elem()))
}
case *types.Basic:
if isBoolean(u) {
if b, ok := analysis.BoolValue(e.X, c.p.Info.Info); ok && b {
return c.translateExpr(e.Y)
}
if b, ok := analysis.BoolValue(e.Y, c.p.Info.Info); ok && b {
return c.translateExpr(e.X)
}
}
}
return c.formatExpr("%s === %s", c.translateImplicitConversion(e.X, t), c.translateImplicitConversion(e.Y, t))
default:
panic(e.Op)
}
case *ast.ParenExpr:
return c.formatParenExpr("%e", e.X)
case *ast.IndexExpr:
switch t := c.p.TypeOf(e.X).Underlying().(type) {
case *types.Array, *types.Pointer:
pattern := rangeCheck("%1e[%2f]", c.p.Types[e.Index].Value != nil, true)
if _, ok := t.(*types.Pointer); ok { // check pointer for nix (attribute getter causes a panic)
pattern = `(%1e.nilCheck, ` + pattern + `)`
}
return c.formatExpr(pattern, e.X, e.Index)
case *types.Slice:
return c.formatExpr(rangeCheck("%1e.$array[%1e.$offset + %2f]", c.p.Types[e.Index].Value != nil, false), e.X, e.Index)
case *types.Map:
if typesutil.IsJsObject(c.p.TypeOf(e.Index)) {
c.p.errList = append(c.p.errList, types.Error{Fset: c.p.fileSet, Pos: e.Index.Pos(), Msg: "cannot use js.Object as map key"})
}
key := fmt.Sprintf("%s.keyFor(%s)", c.typeName(t.Key()), c.translateImplicitConversion(e.Index, t.Key()))
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? [%1s.v, true] : [%4e, false])`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
}
return c.formatExpr(`(%1s = %2e[%3s], %1s !== undefined ? %1s.v : %4e)`, c.newVariable("_entry"), e.X, key, c.zeroValue(t.Elem()))
case *types.Basic:
return c.formatExpr("%e.charCodeAt(%f)", e.X, e.Index)
default:
panic(fmt.Sprintf("Unhandled IndexExpr: %T\n", t))
}
case *ast.SliceExpr:
if b, isBasic := c.p.TypeOf(e.X).Underlying().(*types.Basic); isBasic && isString(b) {
switch {
case e.Low == nil && e.High == nil:
return c.translateExpr(e.X)
case e.Low == nil:
return c.formatExpr("%e.substring(0, %f)", e.X, e.High)
case e.High == nil:
return c.formatExpr("%e.substring(%f)", e.X, e.Low)
default:
return c.formatExpr("%e.substring(%f, %f)", e.X, e.Low, e.High)
}
}
slice := c.translateConversionToSlice(e.X, exprType)
switch {
case e.Low == nil && e.High == nil:
return c.formatExpr("%s", slice)
case e.Low == nil:
if e.Max != nil {
return c.formatExpr("$subslice(%s, 0, %f, %f)", slice, e.High, e.Max)
}
return c.formatExpr("$subslice(%s, 0, %f)", slice, e.High)
case e.High == nil:
return c.formatExpr("$subslice(%s, %f)", slice, e.Low)
default:
if e.Max != nil {
return c.formatExpr("$subslice(%s, %f, %f, %f)", slice, e.Low, e.High, e.Max)
}
return c.formatExpr("$subslice(%s, %f, %f)", slice, e.Low, e.High)
}
case *ast.SelectorExpr:
sel, ok := c.p.SelectionOf(e)
if !ok {
// qualified identifier
return c.formatExpr("%s", c.objectName(obj))
}
switch sel.Kind() {
case types.FieldVal:
fields, jsTag := c.translateSelection(sel, e.Pos())
if jsTag != "" {
if _, ok := sel.Type().(*types.Signature); ok {
return c.formatExpr("$internalize(%1e.%2s.%3s, %4s, %1e.%2s)", e.X, strings.Join(fields, "."), jsTag, c.typeName(sel.Type()))
}
return c.internalize(c.formatExpr("%e.%s.%s", e.X, strings.Join(fields, "."), jsTag), sel.Type())
}
return c.formatExpr("%e.%s", e.X, strings.Join(fields, "."))
case types.MethodVal:
return c.formatExpr(`$methodVal(%s, "%s")`, c.makeReceiver(e), sel.Obj().(*types.Func).Name())
case types.MethodExpr:
if !sel.Obj().Exported() {
c.p.dependencies[sel.Obj()] = true
}
if _, ok := sel.Recv().Underlying().(*types.Interface); ok {
return c.formatExpr(`$ifaceMethodExpr("%s")`, sel.Obj().(*types.Func).Name())
}
return c.formatExpr(`$methodExpr(%s, "%s")`, c.typeName(sel.Recv()), sel.Obj().(*types.Func).Name())
default:
panic(fmt.Sprintf("unexpected sel.Kind(): %T", sel.Kind()))
}
case *ast.CallExpr:
plainFun := astutil.RemoveParens(e.Fun)
if astutil.IsTypeExpr(plainFun, c.p.Info.Info) {
return c.formatExpr("%s", c.translateConversion(e.Args[0], c.p.TypeOf(plainFun)))
}
sig := c.p.TypeOf(plainFun).Underlying().(*types.Signature)
switch f := plainFun.(type) {
case *ast.Ident:
obj := c.p.Uses[f]
if o, ok := obj.(*types.Builtin); ok {
return c.translateBuiltin(o.Name(), sig, e.Args, e.Ellipsis.IsValid())
}
if typesutil.IsJsPackage(obj.Pkg()) && obj.Name() == "InternalObject" {
return c.translateExpr(e.Args[0])
}
return c.translateCall(e, sig, c.translateExpr(f))
case *ast.SelectorExpr:
sel, ok := c.p.SelectionOf(f)
if !ok {
// qualified identifier
obj := c.p.Uses[f.Sel]
if typesutil.IsJsPackage(obj.Pkg()) {
switch obj.Name() {
case "Debugger":
return c.formatExpr("debugger")
case "InternalObject":
return c.translateExpr(e.Args[0])
}
}
return c.translateCall(e, sig, c.translateExpr(f))
}
externalizeExpr := func(e ast.Expr) string {
t := c.p.TypeOf(e)
if types.Identical(t, types.Typ[types.UntypedNil]) {
return "null"
}
return c.externalize(c.translateExpr(e).String(), t)
}
externalizeArgs := func(args []ast.Expr) string {
s := make([]string, len(args))
for i, arg := range args {
s[i] = externalizeExpr(arg)
}
return strings.Join(s, ", ")
}
switch sel.Kind() {
case types.MethodVal:
recv := c.makeReceiver(f)
declaredFuncRecv := sel.Obj().(*types.Func).Type().(*types.Signature).Recv().Type()
if typesutil.IsJsObject(declaredFuncRecv) {
globalRef := func(id string) string {
if recv.String() == "$global" && id[0] == '$' && len(id) > 1 {
return id
}
return recv.String() + "." + id
}
switch sel.Obj().Name() {
case "Get":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s", globalRef(id))
}
return c.formatExpr("%s[$externalize(%e, $String)]", recv, e.Args[0])
case "Set":
if id, ok := c.identifierConstant(e.Args[0]); ok {
return c.formatExpr("%s = %s", globalRef(id), externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[$externalize(%e, $String)] = %s", recv, e.Args[0], externalizeExpr(e.Args[1]))
case "Delete":
return c.formatExpr("delete %s[$externalize(%e, $String)]", recv, e.Args[0])
case "Length":
return c.formatExpr("$parseInt(%s.length)", recv)
case "Index":
return c.formatExpr("%s[%e]", recv, e.Args[0])
case "SetIndex":
return c.formatExpr("%s[%e] = %s", recv, e.Args[0], externalizeExpr(e.Args[1]))
case "Call":
if id, ok := c.identifierConstant(e.Args[0]); ok {
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s.%s.apply(%s, %s))", objVar, recv, objVar, id, objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s(%s)", globalRef(id), externalizeArgs(e.Args[1:]))
}
if e.Ellipsis.IsValid() {
objVar := c.newVariable("obj")
return c.formatExpr("(%s = %s, %s[$externalize(%e, $String)].apply(%s, %s))", objVar, recv, objVar, e.Args[0], objVar, externalizeExpr(e.Args[1]))
}
return c.formatExpr("%s[$externalize(%e, $String)](%s)", recv, e.Args[0], externalizeArgs(e.Args[1:]))
case "Invoke":
if e.Ellipsis.IsValid() {
return c.formatExpr("%s.apply(undefined, %s)", recv, externalizeExpr(e.Args[0]))
}
return c.formatExpr("%s(%s)", recv, externalizeArgs(e.Args))
case "New":
if e.Ellipsis.IsValid() {
return c.formatExpr("new ($global.Function.prototype.bind.apply(%s, [undefined].concat(%s)))", recv, externalizeExpr(e.Args[0]))
}
return c.formatExpr("new (%s)(%s)", recv, externalizeArgs(e.Args))
case "Bool":
return c.internalize(recv, types.Typ[types.Bool])
case "String":
return c.internalize(recv, types.Typ[types.String])
case "Int":
return c.internalize(recv, types.Typ[types.Int])
case "Int64":
return c.internalize(recv, types.Typ[types.Int64])
case "Uint64":
return c.internalize(recv, types.Typ[types.Uint64])
case "Float":
return c.internalize(recv, types.Typ[types.Float64])
case "Interface":
return c.internalize(recv, types.NewInterface(nil, nil))
case "Unsafe":
return recv
default:
panic("Invalid js package object: " + sel.Obj().Name())
}
}
methodName := sel.Obj().Name()
if reservedKeywords[methodName] {
methodName += "$"
}
return c.translateCall(e, sig, c.formatExpr("%s.%s", recv, methodName))
case types.FieldVal:
fields, jsTag := c.translateSelection(sel, f.Pos())
if jsTag != "" {
call := c.formatExpr("%e.%s.%s(%s)", f.X, strings.Join(fields, "."), jsTag, externalizeArgs(e.Args))
switch sig.Results().Len() {
case 0:
return call
case 1:
return c.internalize(call, sig.Results().At(0).Type())
default:
c.p.errList = append(c.p.errList, types.Error{Fset: c.p.fileSet, Pos: f.Pos(), Msg: "field with js tag can not have func type with multiple results"})
}
}
return c.translateCall(e, sig, c.formatExpr("%e.%s", f.X, strings.Join(fields, ".")))
case types.MethodExpr:
return c.translateCall(e, sig, c.translateExpr(f))
default:
panic(fmt.Sprintf("unexpected sel.Kind(): %T", sel.Kind()))
}
default:
return c.translateCall(e, sig, c.translateExpr(plainFun))
}
case *ast.StarExpr:
if typesutil.IsJsObject(c.p.TypeOf(e.X)) {
return c.formatExpr("new $jsObjectPtr(%e)", e.X)
}
if c1, isCall := e.X.(*ast.CallExpr); isCall && len(c1.Args) == 1 {
if c2, isCall := c1.Args[0].(*ast.CallExpr); isCall && len(c2.Args) == 1 && types.Identical(c.p.TypeOf(c2.Fun), types.Typ[types.UnsafePointer]) {
if unary, isUnary := c2.Args[0].(*ast.UnaryExpr); isUnary && unary.Op == token.AND {
return c.translateExpr(unary.X) // unsafe conversion
}
}
}
switch exprType.Underlying().(type) {
case *types.Struct, *types.Array:
return c.translateExpr(e.X)
}
return c.formatExpr("%e.$get()", e.X)
case *ast.TypeAssertExpr:
if e.Type == nil {
return c.translateExpr(e.X)
}
t := c.p.TypeOf(e.Type)
if _, isTuple := exprType.(*types.Tuple); isTuple {
return c.formatExpr("$assertType(%e, %s, true)", e.X, c.typeName(t))
}
return c.formatExpr("$assertType(%e, %s)", e.X, c.typeName(t))
case *ast.Ident:
if e.Name == "_" {
panic("Tried to translate underscore identifier.")
}
switch o := obj.(type) {
case *types.Var, *types.Const:
return c.formatExpr("%s", c.objectName(o))
case *types.Func:
return c.formatExpr("%s", c.objectName(o))
case *types.TypeName:
return c.formatExpr("%s", c.typeName(o.Type()))
case *types.Nil:
if typesutil.IsJsObject(exprType) {
return c.formatExpr("null")
}
switch t := exprType.Underlying().(type) {
case *types.Basic:
if t.Kind() != types.UnsafePointer {
panic("unexpected basic type")
}
return c.formatExpr("0")
case *types.Slice, *types.Pointer:
return c.formatExpr("%s.nil", c.typeName(exprType))
case *types.Chan:
return c.formatExpr("$chanNil")
case *types.Map:
return c.formatExpr("false")
case *types.Interface:
return c.formatExpr("$ifaceNil")
case *types.Signature:
return c.formatExpr("$throwNilPointerError")
default:
panic(fmt.Sprintf("unexpected type: %T", t))
}
default:
panic(fmt.Sprintf("Unhandled object: %T\n", o))
}
case *this:
if isWrapped(c.p.TypeOf(e)) {
return c.formatExpr("this.$val")
}
return c.formatExpr("this")
case nil:
return c.formatExpr("")
default:
panic(fmt.Sprintf("Unhandled expression: %T\n", e))
}
}
func (c *funcContext) formatExprInternal(format string, a []interface{}, parens bool) *expression {
processFormat := func(f func(uint8, uint8, int)) {
n := 0
for i := 0; i < len(format); i++ {
b := format[i]
if b == '%' {
i++
k := format[i]
if k >= '0' && k <= '9' {
n = int(k - '0' - 1)
i++
k = format[i]
}
f(0, k, n)
n++
continue
}
f(b, 0, 0)
}
}
counts := make([]int, len(a))
processFormat(func(b, k uint8, n int) {
switch k {
case 'e', 'f', 'h', 'l', 'r', 'i':
counts[n]++
}
})
out := bytes.NewBuffer(nil)
vars := make([]string, len(a))
hasAssignments := false
for i, e := range a {
if counts[i] <= 1 {
continue
}
if _, isIdent := e.(*ast.Ident); isIdent {
continue
}
if val := c.p.Types[e.(ast.Expr)].Value; val != nil {
continue
}
if !hasAssignments {
hasAssignments = true
out.WriteByte('(')
parens = false
}
v := c.newVariable("x")
out.WriteString(v + " = " + c.translateExpr(e.(ast.Expr)).String() + ", ")
vars[i] = v
}
processFormat(func(b, k uint8, n int) {
writeExpr := func(suffix string) {
if vars[n] != "" {
out.WriteString(vars[n] + suffix)
return
}
out.WriteString(c.translateExpr(a[n].(ast.Expr)).StringWithParens() + suffix)
}
switch k {
case 0:
out.WriteByte(b)
case 's':
if e, ok := a[n].(*expression); ok {
out.WriteString(e.StringWithParens())
return
}
out.WriteString(a[n].(string))
case 'd':
out.WriteString(strconv.Itoa(a[n].(int)))
case 't':
out.WriteString(a[n].(token.Token).String())
case 'e':
e := a[n].(ast.Expr)
if val := c.p.Types[e].Value; val != nil {
out.WriteString(c.translateExpr(e).String())
return
}
writeExpr("")
case 'f':
e := a[n].(ast.Expr)
if val := c.p.Types[e].Value; val != nil {
d, _ := constant.Int64Val(constant.ToInt(val))
out.WriteString(strconv.FormatInt(d, 10))
return
}
if is64Bit(c.p.TypeOf(e).Underlying().(*types.Basic)) {
out.WriteString("$flatten64(")
writeExpr("")
out.WriteString(")")
return
}
writeExpr("")
case 'h':
e := a[n].(ast.Expr)
if val := c.p.Types[e].Value; val != nil {
d, _ := constant.Uint64Val(constant.ToInt(val))
if c.p.TypeOf(e).Underlying().(*types.Basic).Kind() == types.Int64 {
out.WriteString(strconv.FormatInt(int64(d)>>32, 10))
return
}
out.WriteString(strconv.FormatUint(d>>32, 10))
return
}
writeExpr(".$high")
case 'l':
if val := c.p.Types[a[n].(ast.Expr)].Value; val != nil {
d, _ := constant.Uint64Val(constant.ToInt(val))
out.WriteString(strconv.FormatUint(d&(1<<32-1), 10))
return
}
writeExpr(".$low")
case 'r':
if val := c.p.Types[a[n].(ast.Expr)].Value; val != nil {
r, _ := constant.Float64Val(constant.Real(val))
out.WriteString(strconv.FormatFloat(r, 'g', -1, 64))
return
}
writeExpr(".$real")
case 'i':
if val := c.p.Types[a[n].(ast.Expr)].Value; val != nil {
i, _ := constant.Float64Val(constant.Imag(val))
out.WriteString(strconv.FormatFloat(i, 'g', -1, 64))
return
}
writeExpr(".$imag")
case '%':
out.WriteRune('%')
default:
panic(fmt.Sprintf("formatExpr: %%%c%d", k, n))
}
})
if hasAssignments {
out.WriteByte(')')
}
return &expression{str: out.String(), parens: parens}
}
func fitsFloat64(x exact.Value) bool {
f, _ := exact.Float64Val(x)
return !math.IsInf(f, 0)
}
func fitsFloat64(x constant.Value) bool {
f, _ := constant.Float64Val(x)
return !math.IsInf(f, 0)
}
// ResolveAsType implements the Constant interface.
func (expr *NumVal) ResolveAsType(ctx *SemaContext, typ Datum) (Datum, error) {
switch {
case typ.TypeEqual(TypeInt):
// We may have already set expr.resInt in asInt64.
if expr.resInt == 0 {
if _, err := expr.asInt64(); err != nil {
return nil, err
}
}
return &expr.resInt, nil
case typ.TypeEqual(TypeFloat):
f, _ := constant.Float64Val(expr.Value)
expr.resFloat = DFloat(f)
return &expr.resFloat, nil
case typ.TypeEqual(TypeDecimal):
dd := &expr.resDecimal
s := expr.OrigString
if s == "" {
// TODO(nvanbenschoten) We should propagate width through constant folding so that we
// can control precision on folded values as well.
s = expr.ExactString()
}
if idx := strings.IndexRune(s, '/'); idx != -1 {
// Handle constant.ratVal, which will return a rational string
// like 6/7. If only we could call big.Rat.FloatString() on it...
num, den := s[:idx], s[idx+1:]
if _, ok := dd.SetString(num); !ok {
return nil, fmt.Errorf("could not evaluate numerator of %v as Datum type DDecimal "+
"from string %q", expr, num)
}
// TODO(nvanbenschoten) Should we try to avoid this allocation?
denDec := new(inf.Dec)
if _, ok := denDec.SetString(den); !ok {
return nil, fmt.Errorf("could not evaluate denominator %v as Datum type DDecimal "+
"from string %q", expr, den)
}
dd.QuoRound(&dd.Dec, denDec, decimal.Precision, inf.RoundHalfUp)
} else {
// TODO(nvanbenschoten) Handling e will not be necessary once the TODO about the
// OrigString workaround from above is addressed.
eScale := inf.Scale(0)
if eIdx := strings.IndexAny(s, "eE"); eIdx != -1 {
eInt, err := strconv.ParseInt(s[eIdx+1:], 10, 32)
if err != nil {
return nil, fmt.Errorf("could not evaluate %v as Datum type DDecimal from "+
"string %q: %v", expr, s, err)
}
eScale = inf.Scale(eInt)
s = s[:eIdx]
}
if _, ok := dd.SetString(s); !ok {
return nil, fmt.Errorf("could not evaluate %v as Datum type DDecimal from "+
"string %q", expr, s)
}
dd.SetScale(dd.Scale() - eScale)
}
return dd, nil
default:
return nil, fmt.Errorf("could not resolve %T %v into a %T", expr, expr, typ)
}
}
// Eval type cast expressions
func (scope *EvalScope) evalTypeCast(node *ast.CallExpr) (*Variable, error) {
argv, err := scope.evalAST(node.Args[0])
if err != nil {
return nil, err
}
argv.loadValue()
if argv.Unreadable != nil {
return nil, argv.Unreadable
}
fnnode := node.Fun
// remove all enclosing parenthesis from the type name
for {
p, ok := fnnode.(*ast.ParenExpr)
if !ok {
break
}
fnnode = p.X
}
styp, err := scope.Thread.dbp.findTypeExpr(fnnode)
if err != nil {
return nil, err
}
typ := resolveTypedef(styp)
converr := fmt.Errorf("can not convert %q to %s", exprToString(node.Args[0]), typ.String())
v := newVariable("", 0, styp, scope.Thread.dbp, scope.Thread)
v.loaded = true
switch ttyp := typ.(type) {
case *dwarf.PtrType:
switch argv.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
// ok
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
// ok
default:
return nil, converr
}
n, _ := constant.Int64Val(argv.Value)
v.Children = []Variable{*(scope.newVariable("", uintptr(n), ttyp.Type))}
return v, nil
case *dwarf.UintType:
switch argv.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n, _ := constant.Int64Val(argv.Value)
v.Value = constant.MakeUint64(convertInt(uint64(n), false, ttyp.Size()))
return v, nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
n, _ := constant.Uint64Val(argv.Value)
v.Value = constant.MakeUint64(convertInt(n, false, ttyp.Size()))
return v, nil
case reflect.Float32, reflect.Float64:
x, _ := constant.Float64Val(argv.Value)
v.Value = constant.MakeUint64(uint64(x))
return v, nil
}
case *dwarf.IntType:
switch argv.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n, _ := constant.Int64Val(argv.Value)
v.Value = constant.MakeInt64(int64(convertInt(uint64(n), true, ttyp.Size())))
return v, nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
n, _ := constant.Uint64Val(argv.Value)
v.Value = constant.MakeInt64(int64(convertInt(n, true, ttyp.Size())))
return v, nil
case reflect.Float32, reflect.Float64:
x, _ := constant.Float64Val(argv.Value)
v.Value = constant.MakeInt64(int64(x))
return v, nil
}
case *dwarf.FloatType:
switch argv.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fallthrough
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
fallthrough
case reflect.Float32, reflect.Float64:
v.Value = argv.Value
return v, nil
}
case *dwarf.ComplexType:
switch argv.Kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fallthrough
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
fallthrough
case reflect.Float32, reflect.Float64:
v.Value = argv.Value
return v, nil
}
}
return nil, converr
}
// Complex128 returns the complex value of this constant truncated to
// fit a complex128.
//
func (c *Const) Complex128() complex128 {
re, _ := exact.Float64Val(exact.Real(c.Value))
im, _ := exact.Float64Val(exact.Imag(c.Value))
return complex(re, im)
}