func (t *intType) maxVal() *bignum.Rational {
bits := t.Bits
if bits == 0 {
bits = uint(8 * unsafe.Sizeof(int(0)))
}
return bignum.MakeRat(bignum.Int(1).Shl(bits-1).Add(bignum.Int(-1)), bignum.Nat(1))
}
func (t *uintType) maxVal() *bignum.Rational {
bits := t.Bits
if bits == 0 {
if t.Ptr {
bits = uint(8 * unsafe.Sizeof(uintptr(0)))
} else {
bits = uint(8 * unsafe.Sizeof(uint(0)))
}
}
return bignum.MakeRat(bignum.Int(1).Shl(bits).Add(bignum.Int(-1)), bignum.Nat(1))
}
// 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.Crashf("attempted to convert from %v, expected ideal", a.t)
}
var rat *bignum.Rational
// 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", ratToString(rat))
return nil
}
case IdealIntType:
i := a.asIdealInt()()
rat = bignum.MakeRat(i, bignum.Nat(1))
default:
log.Crashf("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", ratToString(rat), t)
return nil
}
if rat.Cmp(t.maxVal()) > 0 {
a.diag("constant %v overflows %v", ratToString(rat), t)
return nil
}
}
// Convert rat to type t.
res := a.newExpr(t, a.desc)
switch t := t.lit().(type) {
case *uintType:
n, d := rat.Value()
f := n.Quo(bignum.MakeInt(false, d))
v := f.Abs().Value()
res.eval = func(*Thread) uint64 { return v }
case *intType:
n, d := rat.Value()
f := n.Quo(bignum.MakeInt(false, d))
v := f.Value()
res.eval = func(*Thread) int64 { return v }
case *idealIntType:
n, d := rat.Value()
f := n.Quo(bignum.MakeInt(false, d))
res.eval = func() *bignum.Integer { return f }
case *floatType:
n, d := rat.Value()
v := float64(n.Value()) / float64(d.Value())
res.eval = func(*Thread) float64 { return v }
case *idealFloatType:
res.eval = func() *bignum.Rational { return rat }
default:
log.Crashf("cannot convert to type %T", t)
}
return res
}
func (t *floatType) Zero() Value {
switch t.Bits {
case 32:
res := float32V(0)
return &res
case 64:
res := float64V(0)
return &res
case 0:
res := floatV(0)
return &res
}
panic("unexpected float bit count")
}
var maxFloat32Val = bignum.MakeRat(bignum.Int(0xffffff).Shl(127-23), bignum.Nat(1))
var maxFloat64Val = bignum.MakeRat(bignum.Int(0x1fffffffffffff).Shl(1023-52), bignum.Nat(1))
var minFloat32Val = maxFloat32Val.Neg()
var minFloat64Val = maxFloat64Val.Neg()
func (t *floatType) minVal() *bignum.Rational {
bits := t.Bits
if bits == 0 {
bits = uint(8 * unsafe.Sizeof(float(0)))
}
switch bits {
case 32:
return minFloat32Val
case 64:
return minFloat64Val
}
func MakeRat(x Big.Natural) *Big.Rational {
return Big.MakeRat(Big.MakeInt(false, x), Big.Nat(1))
}
