stmt.go\
type.go\
typec.go\
- util.go\
value.go\
world.go\
eval: main.$O
$(QUOTED_GOBIN)/$(LD) -o $@ $<
+
+gen.$O: gen.go
+ $(QUOTED_GOBIN)/$(GC) $<
+
+expr1.go: gen.$O
+ $(QUOTED_GOBIN)/$(LD) -o generate $<;\
+ ./generate > expr1.go;\
+ gofmt -w expr1.go
+
package eval
import (
- "exp/bignum"
+ "big"
"flag"
"fmt"
"log"
case int:
r := intV(val)
return &r
- case *bignum.Integer:
+ case *big.Int:
return &idealIntV{val}
case float:
r := floatV(val)
return &r
- case *bignum.Rational:
+ case *big.Rat:
return &idealFloatV{val}
case string:
r := stringV(val)
def := func(name string, t Type, val interface{}) { w.DefineVar(name, t, toValue(val)) }
- w.DefineConst("c", IdealIntType, toValue(bignum.Int(1)))
+ w.DefineConst("c", IdealIntType, toValue(big.NewInt(1)))
def("i", IntType, 1)
def("i2", IntType, 2)
def("u", UintType, uint(1))
package eval
import (
- "exp/bignum"
+ "big"
"fmt"
"go/ast"
"go/token"
"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 {
log.Crashf("attempted to convert from %v, expected ideal", a.t)
}
- var rat *bignum.Rational
+ var rat *big.Rat
// XXX(Spec) The spec says "It is erroneous".
//
case IdealFloatType:
rat = a.asIdealFloat()()
if t.isInteger() && !rat.IsInt() {
- a.diag("constant %v truncated to integer", ratToString(rat))
+ a.diag("constant %v truncated to integer", rat.FloatString(6))
return nil
}
case IdealIntType:
i := a.asIdealInt()()
- rat = bignum.MakeRat(i, bignum.Nat(1))
+ rat = new(big.Rat).SetInt(i)
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)
+ a.diag("constant %v underflows %v", rat.FloatString(6), t)
return nil
}
if rat.Cmp(t.maxVal()) > 0 {
- a.diag("constant %v overflows %v", ratToString(rat), t)
+ a.diag("constant %v overflows %v", rat.FloatString(6), t)
return nil
}
}
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()
+ 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.Value()
- f := n.Quo(bignum.MakeInt(false, d))
- v := f.Value()
+ 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.Value()
- f := n.Quo(bignum.MakeInt(false, d))
- res.eval = func() *bignum.Integer { return f }
+ 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.Value()
- v := float64(n.Value()) / float64(d.Value())
+ 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() *bignum.Rational { return rat }
+ res.eval = func() *big.Rat { return rat }
default:
log.Crashf("cannot convert to type %T", t)
}
switch a.t.lit().(type) {
case *idealIntType:
val := a.asIdealInt()()
- if negErr != "" && val.IsNeg() {
+ if negErr != "" && val.Sign() < 0 {
a.diag("negative %s: %s", negErr, val)
return nil
}
if negErr == "slice" {
bound++
}
- if max != -1 && val.Cmp(bignum.Int(bound)) >= 0 {
+ if max != -1 && val.Cmp(big.NewInt(bound)) >= 0 {
a.diag("index %s exceeds length %d", val, max)
return nil
}
return expr
}
-func (a *exprInfo) compileIdealInt(i *bignum.Integer, desc string) *expr {
+func (a *exprInfo) compileIdealInt(i *big.Int, desc string) *expr {
expr := a.newExpr(IdealIntType, desc)
- expr.eval = func() *bignum.Integer { return i }
+ expr.eval = func() *big.Int { return i }
return expr
}
func (a *exprInfo) compileIntLit(lit string) *expr {
- i, _, _ := bignum.IntFromString(lit, 0)
+ i, _ := new(big.Int).SetString(lit, 0)
return a.compileIdealInt(i, "integer literal")
}
a.silentErrors++
return nil
}
- return a.compileIdealInt(bignum.Int(int64(v)), "character literal")
+ return a.compileIdealInt(big.NewInt(int64(v)), "character literal")
}
func (a *exprInfo) compileFloatLit(lit string) *expr {
- f, _, n := bignum.RatFromString(lit, 10)
- if n != len(lit) {
+ f, ok := new(big.Rat).SetString(lit)
+ if !ok {
log.Crashf("malformed float literal %s at %v passed parser", lit, a.pos)
}
expr := a.newExpr(IdealFloatType, "float literal")
- expr.eval = func() *bignum.Rational { return f }
+ expr.eval = func() *big.Rat { return f }
return expr
}
switch op {
case token.QUO, token.REM:
if r.t.isIdeal() {
- if (r.t.isInteger() && r.asIdealInt()().IsZero()) ||
- (r.t.isFloat() && r.asIdealFloat()().IsZero()) {
+ if (r.t.isInteger() && r.asIdealInt()().Sign() == 0) ||
+ (r.t.isFloat() && r.asIdealFloat()().Sign() == 0) {
a.diag("divide by zero")
return nil
}
lv := l.asIdealInt()()
rv := r.asIdealInt()()
const maxShift = 99999
- if rv.Cmp(bignum.Int(maxShift)) > 0 {
+ 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 := lv.Shl(uint(rv.Value()))
- expr.eval = func() *bignum.Integer { return val }
+ val := new(big.Int).Lsh(lv, uint(rv.Int64()))
+ expr.eval = func() *big.Int { return val }
} else {
expr.genBinOpShl(l, r)
}
if l.t.isIdeal() {
lv := l.asIdealInt()()
rv := r.asIdealInt()()
- val := lv.Shr(uint(rv.Value()))
- expr.eval = func() *bignum.Integer { return val }
+ val := new(big.Int).Rsh(lv, uint(rv.Int64()))
+ expr.eval = func() *big.Int { return val }
} else {
expr.genBinOpShr(l, r)
}
package eval
import (
- "exp/bignum"
+ "big"
"log"
)
/*
- * "As" functions. These retrieve evaluator functions from an
- * expr, panicking if the requested evaluator has the wrong type.
+* "As" functions. These retrieve evaluator functions from an
+* expr, panicking if the requested evaluator has the wrong type.
*/
func (a *expr) asBool() func(*Thread) bool {
return a.eval.(func(*Thread) bool)
func (a *expr) asInt() func(*Thread) int64 {
return a.eval.(func(*Thread) int64)
}
-func (a *expr) asIdealInt() func() *bignum.Integer {
- return a.eval.(func() *bignum.Integer)
+func (a *expr) asIdealInt() func() *big.Int {
+ return a.eval.(func() *big.Int)
}
func (a *expr) asFloat() func(*Thread) float64 {
return a.eval.(func(*Thread) float64)
}
-func (a *expr) asIdealFloat() func() *bignum.Rational {
- return a.eval.(func() *bignum.Rational)
+func (a *expr) asIdealFloat() func() *big.Rat {
+ return a.eval.(func() *big.Rat)
}
func (a *expr) asString() func(*Thread) string {
return a.eval.(func(*Thread) string)
return func(t *Thread) interface{} { return sf(t) }
case func(t *Thread) int64:
return func(t *Thread) interface{} { return sf(t) }
- case func() *bignum.Integer:
+ case func() *big.Int:
return func(*Thread) interface{} { return sf() }
case func(t *Thread) float64:
return func(t *Thread) interface{} { return sf(t) }
- case func() *bignum.Rational:
+ case func() *big.Rat:
return func(*Thread) interface{} { return sf() }
case func(t *Thread) string:
return func(t *Thread) interface{} { return sf(t) }
}
/*
- * Operator generators.
+* Operator generators.
*/
func (a *expr) genConstant(v Value) {
a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) }
case *idealIntType:
val := v.(IdealIntValue).Get()
- a.eval = func() *bignum.Integer { return val }
+ a.eval = func() *big.Int { return val }
case *floatType:
a.eval = func(t *Thread) float64 { return v.(FloatValue).Get(t) }
case *idealFloatType:
val := v.(IdealFloatValue).Get()
- a.eval = func() *bignum.Rational { return val }
+ a.eval = func() *big.Rat { return val }
case *stringType:
a.eval = func(t *Thread) string { return v.(StringValue).Get(t) }
case *ArrayType:
vf := v.asInt()
a.eval = func(t *Thread) int64 { v := vf(t); return -v }
case *idealIntType:
- v := v.asIdealInt()()
- val := v.Neg()
- a.eval = func() *bignum.Integer { return val }
+ val := v.asIdealInt()()
+ val.Neg(val)
+ a.eval = func() *big.Int { return val }
case *floatType:
vf := v.asFloat()
a.eval = func(t *Thread) float64 { v := vf(t); return -v }
case *idealFloatType:
- v := v.asIdealFloat()()
- val := v.Neg()
- a.eval = func() *bignum.Rational { return val }
+ val := v.asIdealFloat()()
+ val.Neg(val)
+ a.eval = func() *big.Rat { return val }
default:
log.Crashf("unexpected type %v at %v", a.t, a.pos)
}
vf := v.asInt()
a.eval = func(t *Thread) int64 { v := vf(t); return ^v }
case *idealIntType:
- v := v.asIdealInt()()
- val := v.Neg().Sub(bignum.Int(1))
- a.eval = func() *bignum.Integer { return val }
+ val := v.asIdealInt()()
+ val.Not(val)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", a.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Add(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Add(l, r)
+ a.eval = func() *big.Int { return val }
case *floatType:
lf := l.asFloat()
rf := r.asFloat()
case *idealFloatType:
l := l.asIdealFloat()()
r := r.asIdealFloat()()
- val := l.Add(r)
- a.eval = func() *bignum.Rational { return val }
+ val := l.Add(l, r)
+ a.eval = func() *big.Rat { return val }
case *stringType:
lf := l.asString()
rf := r.asString()
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Sub(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Sub(l, r)
+ a.eval = func() *big.Int { return val }
case *floatType:
lf := l.asFloat()
rf := r.asFloat()
case *idealFloatType:
l := l.asIdealFloat()()
r := r.asIdealFloat()()
- val := l.Sub(r)
- a.eval = func() *bignum.Rational { return val }
+ val := l.Sub(l, r)
+ a.eval = func() *big.Rat { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Mul(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Mul(l, r)
+ a.eval = func() *big.Int { return val }
case *floatType:
lf := l.asFloat()
rf := r.asFloat()
case *idealFloatType:
l := l.asIdealFloat()()
r := r.asIdealFloat()()
- val := l.Mul(r)
- a.eval = func() *bignum.Rational { return val }
+ val := l.Mul(l, r)
+ a.eval = func() *big.Rat { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Quo(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Quo(l, r)
+ a.eval = func() *big.Int { return val }
case *floatType:
lf := l.asFloat()
rf := r.asFloat()
case *idealFloatType:
l := l.asIdealFloat()()
r := r.asIdealFloat()()
- val := l.Quo(r)
- a.eval = func() *bignum.Rational { return val }
+ val := l.Quo(l, r)
+ a.eval = func() *big.Rat { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Rem(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Rem(l, r)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.And(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.And(l, r)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Or(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Or(l, r)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.Xor(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.Xor(l, r)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
case *idealIntType:
l := l.asIdealInt()()
r := r.asIdealInt()()
- val := l.AndNot(r)
- a.eval = func() *bignum.Integer { return val }
+ val := l.AndNot(l, r)
+ a.eval = func() *big.Int { return val }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
package eval
import (
- "exp/bignum"
+ "big"
"testing"
)
var mustBeUnsigned = "must be unsigned"
var divByZero = "divide by zero"
-var hugeInteger = bignum.Int(1).Shl(64)
+var hugeInteger = new(big.Int).Lsh(idealOne, 64)
var exprTests = []test{
Val("i", 1),
// TODO(austin) Test variable in constant context
//CErr("t", typeAsExpr),
- Val("'a'", bignum.Int('a')),
- Val("'\\uffff'", bignum.Int('\uffff')),
- Val("'\\n'", bignum.Int('\n')),
+ Val("'a'", big.NewInt('a')),
+ Val("'\\uffff'", big.NewInt('\uffff')),
+ Val("'\\n'", big.NewInt('\n')),
CErr("''+x", badCharLit),
// Produces two parse errors
//CErr("'''", ""),
CErr("'\\z'", unknownEscape),
CErr("'ab'", badCharLit),
- Val("1.0", bignum.Rat(1, 1)),
- Val("1.", bignum.Rat(1, 1)),
- Val(".1", bignum.Rat(1, 10)),
- Val("1e2", bignum.Rat(100, 1)),
+ Val("1.0", big.NewRat(1, 1)),
+ Val("1.", big.NewRat(1, 1)),
+ Val(".1", big.NewRat(1, 10)),
+ Val("1e2", big.NewRat(100, 1)),
Val("\"abc\"", "abc"),
Val("\"\"", ""),
CErr("&c", badAddrOf),
Val("*(&ai[0])", 1),
- Val("+1", bignum.Int(+1)),
- Val("+1.0", bignum.Rat(1, 1)),
- Val("01.5", bignum.Rat(15, 10)),
+ Val("+1", big.NewInt(+1)),
+ Val("+1.0", big.NewRat(1, 1)),
+ Val("01.5", big.NewRat(15, 10)),
CErr("+\"x\"", opTypes),
- Val("-42", bignum.Int(-42)),
+ Val("-42", big.NewInt(-42)),
Val("-i", -1),
Val("-f", -1.0),
// 6g bug?
// TODO(austin) Test unary !
- Val("^2", bignum.Int(^2)),
- Val("^(-2)", bignum.Int(^(-2))),
+ Val("^2", big.NewInt(^2)),
+ Val("^(-2)", big.NewInt(^(-2))),
CErr("^2.0", opTypes),
CErr("^2.5", opTypes),
Val("^i", ^1),
Val("1+i", 2),
Val("1+u", uint(2)),
Val("3.0+i", 4),
- Val("1+1", bignum.Int(2)),
+ Val("1+1", big.NewInt(2)),
Val("f+f", 2.0),
Val("1+f", 2.0),
- Val("1.0+1", bignum.Rat(2, 1)),
+ Val("1.0+1", big.NewRat(2, 1)),
Val("\"abc\" + \"def\"", "abcdef"),
CErr("i+u", opTypes),
CErr("-1+u", constantUnderflows),
// TODO(austin) Test named types
- Val("2-1", bignum.Int(1)),
- Val("2.0-1", bignum.Rat(1, 1)),
+ Val("2-1", big.NewInt(1)),
+ Val("2.0-1", big.NewRat(1, 1)),
Val("f-2", -1.0),
- // TOOD(austin) bignum can't do negative 0?
- //Val("-0.0", XXX),
- Val("2*2", bignum.Int(4)),
+ Val("-0.0", big.NewRat(0, 1)),
+ Val("2*2", big.NewInt(4)),
Val("2*i", 2),
- Val("3/2", bignum.Int(1)),
+ Val("3/2", big.NewInt(1)),
Val("3/i", 3),
CErr("1/0", divByZero),
CErr("1.0/0", divByZero),
RErr("i/0", divByZero),
- Val("3%2", bignum.Int(1)),
+ Val("3%2", big.NewInt(1)),
Val("i%2", 1),
CErr("3%0", divByZero),
CErr("3.0%0", opTypes),
RErr("i%0", divByZero),
// Examples from "Arithmetic operators"
- Val("5/3", bignum.Int(1)),
+ Val("5/3", big.NewInt(1)),
Val("(i+4)/(i+2)", 1),
- Val("5%3", bignum.Int(2)),
+ Val("5%3", big.NewInt(2)),
Val("(i+4)%(i+2)", 2),
- Val("-5/3", bignum.Int(-1)),
+ Val("-5/3", big.NewInt(-1)),
Val("(i-6)/(i+2)", -1),
- Val("-5%3", bignum.Int(-2)),
+ Val("-5%3", big.NewInt(-2)),
Val("(i-6)%(i+2)", -2),
- Val("5/-3", bignum.Int(-1)),
+ Val("5/-3", big.NewInt(-1)),
Val("(i+4)/(i-4)", -1),
- Val("5%-3", bignum.Int(2)),
+ Val("5%-3", big.NewInt(2)),
Val("(i+4)%(i-4)", 2),
- Val("-5/-3", bignum.Int(1)),
+ Val("-5/-3", big.NewInt(1)),
Val("(i-6)/(i-4)", 1),
- Val("-5%-3", bignum.Int(-2)),
+ Val("-5%-3", big.NewInt(-2)),
Val("(i-6)%(i-4)", -2),
// Examples from "Arithmetic operators"
- Val("11/4", bignum.Int(2)),
+ Val("11/4", big.NewInt(2)),
Val("(i+10)/4", 2),
- Val("11%4", bignum.Int(3)),
+ Val("11%4", big.NewInt(3)),
Val("(i+10)%4", 3),
- Val("11>>2", bignum.Int(2)),
+ Val("11>>2", big.NewInt(2)),
Val("(i+10)>>2", 2),
- Val("11&3", bignum.Int(3)),
+ Val("11&3", big.NewInt(3)),
Val("(i+10)&3", 3),
- Val("-11/4", bignum.Int(-2)),
+ Val("-11/4", big.NewInt(-2)),
Val("(i-12)/4", -2),
- Val("-11%4", bignum.Int(-3)),
+ Val("-11%4", big.NewInt(-3)),
Val("(i-12)%4", -3),
- Val("-11>>2", bignum.Int(-3)),
+ Val("-11>>2", big.NewInt(-3)),
Val("(i-12)>>2", -3),
- Val("-11&3", bignum.Int(1)),
+ Val("-11&3", big.NewInt(1)),
Val("(i-12)&3", 1),
// TODO(austin) Test bit ops
// ideal int, negative ideal int, big ideal int, ideal
// fractional float, ideal non-fractional float, int, uint,
// and float.
- Val("2<<2", bignum.Int(2<<2)),
+ Val("2<<2", big.NewInt(2<<2)),
CErr("2<<(-1)", constantUnderflows),
CErr("2<<0x10000000000000000", constantOverflows),
CErr("2<<2.5", constantTruncated),
- Val("2<<2.0", bignum.Int(2<<2.0)),
+ Val("2<<2.0", big.NewInt(2<<2.0)),
CErr("2<<i", mustBeUnsigned),
Val("2<<u", 2<<1),
CErr("2<<f", opTypes),
- Val("-2<<2", bignum.Int(-2<<2)),
+ Val("-2<<2", big.NewInt(-2<<2)),
CErr("-2<<(-1)", constantUnderflows),
CErr("-2<<0x10000000000000000", constantOverflows),
CErr("-2<<2.5", constantTruncated),
- Val("-2<<2.0", bignum.Int(-2<<2.0)),
+ Val("-2<<2.0", big.NewInt(-2<<2.0)),
CErr("-2<<i", mustBeUnsigned),
Val("-2<<u", -2<<1),
CErr("-2<<f", opTypes),
- Val("0x10000000000000000<<2", hugeInteger.Shl(2)),
+ Val("0x10000000000000000<<2", new(big.Int).Lsh(hugeInteger, 2)),
CErr("0x10000000000000000<<(-1)", constantUnderflows),
CErr("0x10000000000000000<<0x10000000000000000", constantOverflows),
CErr("0x10000000000000000<<2.5", constantTruncated),
- Val("0x10000000000000000<<2.0", hugeInteger.Shl(2)),
+ Val("0x10000000000000000<<2.0", new(big.Int).Lsh(hugeInteger, 2)),
CErr("0x10000000000000000<<i", mustBeUnsigned),
CErr("0x10000000000000000<<u", constantOverflows),
CErr("0x10000000000000000<<f", opTypes),
intType = &Type{Repr: "*intType", Value: "IntValue", Native: "int64", As: "asInt",
Sizes: []Size{Size{8, "int8"}, Size{16, "int16"}, Size{32, "int32"}, Size{64, "int64"}, Size{0, "int"}},
}
- idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*bignum.Integer", As: "asIdealInt", IsIdeal: true}
+ idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*big.Int", As: "asIdealInt", IsIdeal: true}
floatType = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat",
Sizes: []Size{Size{32, "float32"}, Size{64, "float64"}, Size{0, "float"}},
}
- idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*bignum.Rational", As: "asIdealFloat", IsIdeal: true}
+ idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*big.Rat", As: "asIdealFloat", IsIdeal: true}
stringType = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"}
arrayType = &Type{Repr: "*ArrayType", Value: "ArrayValue", Native: "ArrayValue", As: "asArray", HasAssign: true}
structType = &Type{Repr: "*StructType", Value: "StructValue", Native: "StructValue", As: "asStruct", HasAssign: true}
)
var unOps = []Op{
- Op{Name: "Neg", Expr: "-v", ConstExpr: "v.Neg()", Types: numbers},
+ Op{Name: "Neg", Expr: "-v", ConstExpr: "val.Neg(val)", Types: numbers},
Op{Name: "Not", Expr: "!v", Types: bools},
- Op{Name: "Xor", Expr: "^v", ConstExpr: "v.Neg().Sub(bignum.Int(1))", Types: integers},
+ Op{Name: "Xor", Expr: "^v", ConstExpr: "val.Not(val)", Types: integers},
}
var binOps = []Op{
- Op{Name: "Add", Expr: "l + r", ConstExpr: "l.Add(r)", Types: addable},
- Op{Name: "Sub", Expr: "l - r", ConstExpr: "l.Sub(r)", Types: numbers},
- Op{Name: "Mul", Expr: "l * r", ConstExpr: "l.Mul(r)", Types: numbers},
+ Op{Name: "Add", Expr: "l + r", ConstExpr: "l.Add(l, r)", Types: addable},
+ Op{Name: "Sub", Expr: "l - r", ConstExpr: "l.Sub(l, r)", Types: numbers},
+ Op{Name: "Mul", Expr: "l * r", ConstExpr: "l.Mul(l, r)", Types: numbers},
Op{Name: "Quo",
Body: "if r == 0 { t.Abort(DivByZeroError{}) }; ret = l / r",
- ConstExpr: "l.Quo(r)",
+ ConstExpr: "l.Quo(l, r)",
Types: numbers,
},
Op{Name: "Rem",
Body: "if r == 0 { t.Abort(DivByZeroError{}) }; ret = l % r",
- ConstExpr: "l.Rem(r)",
+ ConstExpr: "l.Rem(l, r)",
Types: integers,
},
- Op{Name: "And", Expr: "l & r", ConstExpr: "l.And(r)", Types: integers},
- Op{Name: "Or", Expr: "l | r", ConstExpr: "l.Or(r)", Types: integers},
- Op{Name: "Xor", Expr: "l ^ r", ConstExpr: "l.Xor(r)", Types: integers},
- Op{Name: "AndNot", Expr: "l &^ r", ConstExpr: "l.AndNot(r)", Types: integers},
- Op{Name: "Shl", Expr: "l << r", ConstExpr: "l.Shl(uint(r.Value()))",
+ Op{Name: "And", Expr: "l & r", ConstExpr: "l.And(l, r)", Types: integers},
+ Op{Name: "Or", Expr: "l | r", ConstExpr: "l.Or(l, r)", Types: integers},
+ Op{Name: "Xor", Expr: "l ^ r", ConstExpr: "l.Xor(l, r)", Types: integers},
+ Op{Name: "AndNot", Expr: "l &^ r", ConstExpr: "l.AndNot(l, r)", Types: integers},
+ Op{Name: "Shl", Expr: "l << r", ConstExpr: "l.Lsh(l, uint(r.Value()))",
AsRightName: "asUint", Types: shiftable,
},
- Op{Name: "Shr", Expr: "l >> r", ConstExpr: "l.Shr(uint(r.Value()))",
+ Op{Name: "Shr", Expr: "l >> r", ConstExpr: "new(big.Int).Rsh(l, uint(r.Value()))",
AsRightName: "asUint", Types: shiftable,
},
Op{Name: "Lss", Expr: "l < r", ConstExpr: "l.Cmp(r) < 0", ReturnType: "bool", Types: addable},
package eval
import (
- "bignum";
- "log";
+ "big"
+ "log"
)
/*
«.end»
«.end»
default:
- log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos);
+ log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos)
}
- panic("fail");
+ panic("fail")
}
/*
«.repeated section Types»
case «Repr»:
«.section IsIdeal»
- val := v.(«Value»).Get();
+ val := v.(«Value»).Get()
a.eval = func() «Native» { return val }
«.or»
a.eval = func(t *Thread) «Native» { return v.(«Value»).Get(t) }
«.end»
«.end»
default:
- log.Crashf("unexpected constant type %v at %v", a.t, a.pos);
+ log.Crashf("unexpected constant type %v at %v", a.t, a.pos)
}
}
func (a *expr) genIdentOp(level, index int) {
- a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) };
+ a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) }
switch a.t.lit().(type) {
«.repeated section Types»
«.section IsIdeal»
«.end»
«.end»
default:
- log.Crashf("unexpected identifier type %v at %v", a.t, a.pos);
+ log.Crashf("unexpected identifier type %v at %v", a.t, a.pos)
}
}
func (a *expr) genFuncCall(call func(t *Thread) []Value) {
- a.exec = func(t *Thread) { call(t)};
+ a.exec = func(t *Thread) { call(t)}
switch a.t.lit().(type) {
«.repeated section Types»
«.section IsIdeal»
case *MultiType:
a.eval = func(t *Thread) []Value { return call(t) }
default:
- log.Crashf("unexpected result type %v at %v", a.t, a.pos);
+ log.Crashf("unexpected result type %v at %v", a.t, a.pos)
}
}
func (a *expr) genValue(vf func(*Thread) Value) {
- a.evalAddr = vf;
+ a.evalAddr = vf
switch a.t.lit().(type) {
«.repeated section Types»
«.section IsIdeal»
«.end»
«.end»
default:
- log.Crashf("unexpected result type %v at %v", a.t, a.pos);
+ log.Crashf("unexpected result type %v at %v", a.t, a.pos)
}
}
«.repeated section Types»
case «Repr»:
«.section IsIdeal»
- v := v.«As»()();
- val := «ConstExpr»;
+ val := v.«As»()()
+ «ConstExpr»
a.eval = func() «Native» { return val }
«.or»
- vf := v.«As»();
+ vf := v.«As»()
a.eval = func(t *Thread) «Native» { v := vf(t); return «Expr» }
«.end»
«.end»
default:
- log.Crashf("unexpected type %v at %v", a.t, a.pos);
+ log.Crashf("unexpected type %v at %v", a.t, a.pos)
}
}
«.end»
func (a *expr) genBinOpLogAnd(l, r *expr) {
- lf := l.asBool();
- rf := r.asBool();
+ lf := l.asBool()
+ rf := r.asBool()
a.eval = func(t *Thread) bool { return lf(t) && rf(t) }
}
func (a *expr) genBinOpLogOr(l, r *expr) {
- lf := l.asBool();
- rf := r.asBool();
+ lf := l.asBool()
+ rf := r.asBool()
a.eval = func(t *Thread) bool { return lf(t) || rf(t) }
}
«.repeated section Types»
case «Repr»:
«.section IsIdeal»
- l := l.«As»()();
- r := r.«As»()();
- val := «ConstExpr»;
+ l := l.«As»()()
+ r := r.«As»()()
+ val := «ConstExpr»
«.section ReturnType»
a.eval = func(t *Thread) «ReturnType» { return val }
«.or»
a.eval = func() «Native» { return val }
«.end»
«.or»
- lf := l.«As»();
- rf := r.«.section AsRightName»«@»«.or»«As»«.end»();
+ lf := l.«As»()
+ rf := r.«.section AsRightName»«@»«.or»«As»«.end»()
«.section ReturnType»
a.eval = func(t *Thread) «@» {
- l, r := lf(t), rf(t);
+ l, r := lf(t), rf(t)
return «Expr»
}
«.or»
«.repeated section @»
case «Bits»:
a.eval = func(t *Thread) «Native» {
- l, r := lf(t), rf(t);
- var ret «Native»;
+ l, r := lf(t), rf(t)
+ var ret «Native»
«.section Body»
- «Body»;
+ «Body»
«.or»
- ret = «Expr»;
+ ret = «Expr»
«.end»
return «Native»(«Sized»(ret))
}
«.end»
default:
- log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos)
}
«.or»
a.eval = func(t *Thread) «Native» {
- l, r := lf(t), rf(t);
+ l, r := lf(t), rf(t)
return «Expr»
}
«.end»
«.end»
«.end»
default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
+ log.Crashf("unexpected type %v at %v", l.t, a.pos)
}
}
«.section IsIdeal»
«.or»
case «Repr»:
- rf := r.«As»();
+ rf := r.«As»()
return func(lv Value, t *Thread) { «.section HasAssign»lv.Assign(t, rf(t))«.or»lv.(«Value»).Set(t, rf(t))«.end» }
«.end»
«.end»
default:
- log.Crashf("unexpected left operand type %v at %v", lt, r.pos);
+ log.Crashf("unexpected left operand type %v at %v", lt, r.pos)
}
- panic("fail");
+ panic("fail")
}
`
package eval
import (
- "exp/bignum"
+ "big"
"log"
"go/ast"
"go/token"
one := l.newExpr(IdealIntType, "constant")
one.pos = s.Pos()
- one.eval = func() *bignum.Integer { return bignum.Int(1) }
+ one.eval = func() *big.Int { return big.NewInt(1) }
binop := l.compileBinaryExpr(op, l, one)
if binop == nil {
package eval
import (
- "exp/bignum"
+ "big"
"go/ast"
"go/token"
"log"
type BoundedType interface {
Type
// minVal returns the smallest value of this type.
- minVal() *bignum.Rational
+ minVal() *big.Rat
// maxVal returns the largest value of this type.
- maxVal() *bignum.Rational
+ maxVal() *big.Rat
}
var universePos = token.Position{"<universe>", 0, 0, 0}
panic("unexpected uint bit count")
}
-func (t *uintType) minVal() *bignum.Rational { return bignum.Rat(0, 1) }
+func (t *uintType) minVal() *big.Rat { return big.NewRat(0, 1) }
-func (t *uintType) maxVal() *bignum.Rational {
+func (t *uintType) maxVal() *big.Rat {
bits := t.Bits
if bits == 0 {
if t.Ptr {
bits = uint(8 * unsafe.Sizeof(uint(0)))
}
}
- return bignum.MakeRat(bignum.Int(1).Shl(bits).Add(bignum.Int(-1)), bignum.Nat(1))
+ numer := big.NewInt(1)
+ numer.Lsh(numer, bits)
+ numer.Sub(numer, idealOne)
+ return new(big.Rat).SetInt(numer)
}
/*
panic("unexpected int bit count")
}
-func (t *intType) minVal() *bignum.Rational {
+func (t *intType) minVal() *big.Rat {
bits := t.Bits
if bits == 0 {
bits = uint(8 * unsafe.Sizeof(int(0)))
}
- return bignum.MakeRat(bignum.Int(-1).Shl(bits-1), bignum.Nat(1))
+ numer := big.NewInt(-1)
+ numer.Lsh(numer, bits-1)
+ return new(big.Rat).SetInt(numer)
}
-func (t *intType) maxVal() *bignum.Rational {
+func (t *intType) maxVal() *big.Rat {
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))
+ numer := big.NewInt(1)
+ numer.Lsh(numer, bits-1)
+ numer.Sub(numer, idealOne)
+ return new(big.Rat).SetInt(numer)
}
/*
func (t *idealIntType) String() string { return "ideal integer" }
-func (t *idealIntType) Zero() Value { return &idealIntV{bignum.Int(0)} }
+func (t *idealIntType) Zero() Value { return &idealIntV{idealZero} }
/*
* Float
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()
+var maxFloat32Val *big.Rat
+var maxFloat64Val *big.Rat
+var minFloat32Val *big.Rat
+var minFloat64Val *big.Rat
-func (t *floatType) minVal() *bignum.Rational {
+func (t *floatType) minVal() *big.Rat {
bits := t.Bits
if bits == 0 {
bits = uint(8 * unsafe.Sizeof(float(0)))
panic("unreachable")
}
-func (t *floatType) maxVal() *bignum.Rational {
+func (t *floatType) maxVal() *big.Rat {
bits := t.Bits
if bits == 0 {
bits = uint(8 * unsafe.Sizeof(float(0)))
func (t *idealFloatType) String() string { return "ideal float" }
-func (t *idealFloatType) Zero() Value { return &idealFloatV{bignum.Rat(1, 0)} }
+func (t *idealFloatType) Zero() Value { return &idealFloatV{big.NewRat(0, 1)} }
/*
* String
*/
func init() {
+ numer := big.NewInt(0xffffff)
+ numer.Lsh(numer, 127-23)
+ maxFloat32Val = new(big.Rat).SetInt(numer)
+ numer.SetInt64(0x1fffffffffffff)
+ numer.Lsh(numer, 1023-52)
+ maxFloat64Val = new(big.Rat).SetInt(numer)
+ minFloat32Val = new(big.Rat).Neg(maxFloat32Val)
+ minFloat64Val = new(big.Rat).Neg(maxFloat64Val)
+
// To avoid portability issues all numeric types are distinct
// except byte, which is an alias for uint8.
+++ /dev/null
-// 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 (
- "exp/bignum"
-)
-
-// TODO(austin): Maybe add to bignum in more general form
-func ratToString(rat *bignum.Rational) string {
- n, dnat := rat.Value()
- d := bignum.MakeInt(false, dnat)
- w, frac := n.QuoRem(d)
- out := w.String()
- if frac.IsZero() {
- return out
- }
-
- r := frac.Abs()
- r = r.Mul(bignum.Nat(1e6))
- dec, tail := r.DivMod(dnat)
- // Round last digit
- if tail.Cmp(dnat.Div(bignum.Nat(2))) >= 0 {
- dec = dec.Add(bignum.Nat(1))
- }
- // Strip zeros
- ten := bignum.Nat(10)
- for !dec.IsZero() {
- dec2, r2 := dec.DivMod(ten)
- if !r2.IsZero() {
- break
- }
- dec = dec2
- }
- out += "." + dec.String()
- return out
-}
package eval
import (
- "exp/bignum"
+ "big"
"fmt"
)
// because ideals are not l-values.
type IdealIntValue interface {
Value
- Get() *bignum.Integer
+ Get() *big.Int
}
type FloatValue interface {
type IdealFloatValue interface {
Value
- Get() *bignum.Rational
+ Get() *big.Rat
}
type StringValue interface {
*/
type idealIntV struct {
- V *bignum.Integer
+ V *big.Int
}
func (v *idealIntV) String() string { return v.V.String() }
v.V = o.(IdealIntValue).Get()
}
-func (v *idealIntV) Get() *bignum.Integer { return v.V }
+func (v *idealIntV) Get() *big.Int { return v.V }
/*
* Float
*/
type idealFloatV struct {
- V *bignum.Rational
+ V *big.Rat
}
-func (v *idealFloatV) String() string { return ratToString(v.V) }
+func (v *idealFloatV) String() string { return v.V.FloatString(6) }
func (v *idealFloatV) Assign(t *Thread, o Value) {
v.V = o.(IdealFloatValue).Get()
}
-func (v *idealFloatV) Get() *bignum.Rational { return v.V }
+func (v *idealFloatV) Get() *big.Rat { return v.V }
/*
* String
* Universal constants
*/
-// TODO(austin) Nothing complains if I accidentally define init with
-// arguments. Is this intentional?
func init() {
s := universe