// valString returns the string representation for the value v. // Setting floatFmt forces an integer value to be formatted in // normalized floating-point format. // TODO(gri) Move this code into package exact. func valString(v exact.Value, floatFmt bool) string { switch v.Kind() { case exact.Int: if floatFmt { return floatString(v) } case exact.Float: return floatString(v) case exact.Complex: re := exact.Real(v) im := exact.Imag(v) var s string if exact.Sign(re) != 0 { s = floatString(re) if exact.Sign(im) >= 0 { s += " + " } else { s += " - " im = exact.UnaryOp(token.SUB, im, 0) // negate im } } // im != 0, otherwise v would be exact.Int or exact.Float return s + floatString(im) + "i" } return v.String() }
// The unary expression e may be nil. It's passed in for better error messages only. func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) { switch op { case token.AND: // spec: "As an exception to the addressability // requirement x may also be a composite literal." if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable { check.invalidOp(x.pos(), "cannot take address of %s", x) x.mode = invalid return } x.mode = value x.typ = &Pointer{base: x.typ} return case token.ARROW: typ, ok := x.typ.Underlying().(*Chan) if !ok { check.invalidOp(x.pos(), "cannot receive from non-channel %s", x) x.mode = invalid return } if typ.dir == SendOnly { check.invalidOp(x.pos(), "cannot receive from send-only channel %s", x) x.mode = invalid return } x.mode = commaok x.typ = typ.elem check.hasCallOrRecv = true return } if !check.op(unaryOpPredicates, x, op) { x.mode = invalid return } if x.mode == constant { typ := x.typ.Underlying().(*Basic) size := -1 if isUnsigned(typ) { size = int(check.conf.sizeof(typ)) } x.val = exact.UnaryOp(op, x.val, size) // Typed constants must be representable in // their type after each constant operation. if isTyped(typ) { if e != nil { x.expr = e // for better error message } check.representable(x, typ) } return } x.mode = value // x.typ remains unchanged }
func (p *importer) fraction() exact.Value { sign := p.int() if sign == 0 { return exact.MakeInt64(0) } x := exact.BinaryOp(p.ufloat(), token.QUO, p.ufloat()) if sign < 0 { x = exact.UnaryOp(token.SUB, x, 0) } return x }