diff options
author | Robert Griesemer <gri@golang.org> | 2009-12-15 15:27:16 -0800 |
---|---|---|
committer | Robert Griesemer <gri@golang.org> | 2009-12-15 15:27:16 -0800 |
commit | 881d6064d23d9da5c7ff368bc7d41d271290deff (patch) | |
tree | 44d5d948e3f27cc7eff15ec8cd7ee5165d9a7e90 /src/pkg/exp/eval/expr1.go | |
parent | d9dfea3ebd51cea89fef8afc6b2377c2958b24f1 (diff) | |
download | golang-881d6064d23d9da5c7ff368bc7d41d271290deff.tar.gz |
1) Change default gofmt default settings for
parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
2nd set of files.
R=rsc
CC=golang-dev
http://codereview.appspot.com/179067
Diffstat (limited to 'src/pkg/exp/eval/expr1.go')
-rw-r--r-- | src/pkg/exp/eval/expr1.go | 1764 |
1 files changed, 882 insertions, 882 deletions
diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go index ed2081c71..a77e40fb0 100644 --- a/src/pkg/exp/eval/expr1.go +++ b/src/pkg/exp/eval/expr1.go @@ -4,19 +4,19 @@ package eval import ( - "bignum"; - "log"; + "bignum" + "log" ) /* * "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) asBool() (func(*Thread) bool) { return a.eval.(func(*Thread) bool) } func (a *expr) asUint() (func(*Thread) uint64) { return a.eval.(func(*Thread) uint64) } -func (a *expr) asInt() (func(*Thread) int64) { return a.eval.(func(*Thread) int64) } +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) } @@ -35,12 +35,12 @@ func (a *expr) asArray() (func(*Thread) ArrayValue) { func (a *expr) asStruct() (func(*Thread) StructValue) { return a.eval.(func(*Thread) StructValue) } -func (a *expr) asPtr() (func(*Thread) Value) { return a.eval.(func(*Thread) Value) } -func (a *expr) asFunc() (func(*Thread) Func) { return a.eval.(func(*Thread) Func) } +func (a *expr) asPtr() (func(*Thread) Value) { return a.eval.(func(*Thread) Value) } +func (a *expr) asFunc() (func(*Thread) Func) { return a.eval.(func(*Thread) Func) } func (a *expr) asSlice() (func(*Thread) Slice) { return a.eval.(func(*Thread) Slice) } -func (a *expr) asMap() (func(*Thread) Map) { return a.eval.(func(*Thread) Map) } +func (a *expr) asMap() (func(*Thread) Map) { return a.eval.(func(*Thread) Map) } func (a *expr) asMulti() (func(*Thread) []Value) { return a.eval.(func(*Thread) []Value) } @@ -76,7 +76,7 @@ func (a *expr) asInterface() (func(*Thread) interface{}) { default: log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos) } - panic(); + panic() } /* @@ -92,13 +92,13 @@ func (a *expr) genConstant(v Value) { case *intType: a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) } case *idealIntType: - val := v.(IdealIntValue).Get(); - a.eval = func() *bignum.Integer { return val }; + val := v.(IdealIntValue).Get() + a.eval = func() *bignum.Integer { 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 }; + val := v.(IdealFloatValue).Get() + a.eval = func() *bignum.Rational { return val } case *stringType: a.eval = func(t *Thread) string { return v.(StringValue).Get(t) } case *ArrayType: @@ -119,7 +119,7 @@ func (a *expr) genConstant(v Value) { } 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) { case *boolType: a.eval = func(t *Thread) bool { return t.f.Get(level, index).(BoolValue).Get(t) } @@ -149,7 +149,7 @@ func (a *expr) genIdentOp(level, index int) { } 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) { case *boolType: a.eval = func(t *Thread) bool { return call(t)[0].(BoolValue).Get(t) } @@ -181,7 +181,7 @@ func (a *expr) genFuncCall(call func(t *Thread) []Value) { } func (a *expr) genValue(vf func(*Thread) Value) { - a.evalAddr = vf; + a.evalAddr = vf switch a.t.lit().(type) { case *boolType: a.eval = func(t *Thread) bool { return vf(t).(BoolValue).Get(t) } @@ -213,31 +213,31 @@ func (a *expr) genValue(vf func(*Thread) Value) { func (a *expr) genUnaryOpNeg(v *expr) { switch a.t.lit().(type) { case *uintType: - vf := v.asUint(); + vf := v.asUint() a.eval = func(t *Thread) uint64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *intType: - vf := v.asInt(); + vf := v.asInt() a.eval = func(t *Thread) int64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *idealIntType: - v := v.asIdealInt()(); - val := v.Neg(); - a.eval = func() *bignum.Integer { return val }; + v := v.asIdealInt()() + val := v.Neg() + a.eval = func() *bignum.Integer { return val } case *floatType: - vf := v.asFloat(); + vf := v.asFloat() a.eval = func(t *Thread) float64 { - v := vf(t); - return -v; - }; + v := vf(t) + return -v + } case *idealFloatType: - v := v.asIdealFloat()(); - val := v.Neg(); - a.eval = func() *bignum.Rational { return val }; + v := v.asIdealFloat()() + val := v.Neg() + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } @@ -246,11 +246,11 @@ func (a *expr) genUnaryOpNeg(v *expr) { func (a *expr) genUnaryOpNot(v *expr) { switch a.t.lit().(type) { case *boolType: - vf := v.asBool(); + vf := v.asBool() a.eval = func(t *Thread) bool { - v := vf(t); - return !v; - }; + v := vf(t) + return !v + } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } @@ -259,169 +259,169 @@ func (a *expr) genUnaryOpNot(v *expr) { func (a *expr) genUnaryOpXor(v *expr) { switch a.t.lit().(type) { case *uintType: - vf := v.asUint(); + vf := v.asUint() a.eval = func(t *Thread) uint64 { - v := vf(t); - return ^v; - }; + v := vf(t) + return ^v + } case *intType: - vf := v.asInt(); + vf := v.asInt() a.eval = func(t *Thread) int64 { - v := vf(t); - return ^v; - }; + v := vf(t) + return ^v + } case *idealIntType: - v := v.asIdealInt()(); - val := v.Neg().Sub(bignum.Int(1)); - a.eval = func() *bignum.Integer { return val }; + v := v.asIdealInt()() + val := v.Neg().Sub(bignum.Int(1)) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", a.t, a.pos) } } func (a *expr) genBinOpLogAnd(l, r *expr) { - lf := l.asBool(); - rf := r.asBool(); - a.eval = func(t *Thread) bool { return lf(t) && rf(t) }; + 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(); - a.eval = func(t *Thread) bool { return lf(t) || rf(t) }; + lf := l.asBool() + rf := r.asBool() + a.eval = func(t *Thread) bool { return lf(t) || rf(t) } } func (a *expr) genBinOpAdd(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l + r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l + r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l + r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l + r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Add(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Add(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l + r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l + r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Add(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Add(r) + a.eval = func() *bignum.Rational { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) string { - l, r := lf(t), rf(t); - return l + r; - }; + l, r := lf(t), rf(t) + return l + r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -430,127 +430,127 @@ func (a *expr) genBinOpAdd(l, r *expr) { func (a *expr) genBinOpSub(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l - r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l - r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l - r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l - r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Sub(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Sub(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l - r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l - r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Sub(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Sub(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -559,127 +559,127 @@ func (a *expr) genBinOpSub(l, r *expr) { func (a *expr) genBinOpMul(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l * r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l * r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l * r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l * r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Mul(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Mul(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float32(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float64(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; - ret = l * r; - return float64(float(ret)); + l, r := lf(t), rf(t) + var ret float64 + ret = l * r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Mul(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Mul(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -688,166 +688,166 @@ func (a *expr) genBinOpMul(l, r *expr) { func (a *expr) genBinOpQuo(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint8(ret)); + ret = l / r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint16(ret)); + ret = l / r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint32(ret)); + ret = l / r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint64(ret)); + ret = l / r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return uint64(uint(ret)); + ret = l / r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int8(ret)); + ret = l / r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int16(ret)); + ret = l / r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int32(ret)); + ret = l / r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int64(ret)); + ret = l / r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return int64(int(ret)); + ret = l / r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Quo(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Quo(r) + a.eval = func() *bignum.Integer { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() switch t.Bits { case 32: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float32(ret)); + ret = l / r + return float64(float32(ret)) } case 64: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float64(ret)); + ret = l / r + return float64(float64(ret)) } case 0: a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t); - var ret float64; + l, r := lf(t), rf(t) + var ret float64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l / r; - return float64(float(ret)); + ret = l / r + return float64(float(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Quo(r); - a.eval = func() *bignum.Rational { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Quo(r) + a.eval = func() *bignum.Rational { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -856,124 +856,124 @@ func (a *expr) genBinOpQuo(l, r *expr) { func (a *expr) genBinOpRem(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint8(ret)); + ret = l % r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint16(ret)); + ret = l % r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint32(ret)); + ret = l % r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint64(ret)); + ret = l % r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; + l, r := lf(t), rf(t) + var ret uint64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return uint64(uint(ret)); + ret = l % r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int8(ret)); + ret = l % r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int16(ret)); + ret = l % r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int32(ret)); + ret = l % r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int64(ret)); + ret = l % r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; + l, r := lf(t), rf(t) + var ret int64 if r == 0 { t.Abort(DivByZeroError{}) } - ret = l % r; - return int64(int(ret)); + ret = l % r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Rem(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Rem(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -982,94 +982,94 @@ func (a *expr) genBinOpRem(l, r *expr) { func (a *expr) genBinOpAnd(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l & r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l & r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l & r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l & r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.And(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.And(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1078,94 +1078,94 @@ func (a *expr) genBinOpAnd(l, r *expr) { func (a *expr) genBinOpOr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l | r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l | r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l | r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l | r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Or(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Or(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1174,94 +1174,94 @@ func (a *expr) genBinOpOr(l, r *expr) { func (a *expr) genBinOpXor(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l ^ r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l ^ r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l ^ r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l ^ r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Xor(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Xor(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1270,94 +1270,94 @@ func (a *expr) genBinOpXor(l, r *expr) { func (a *expr) genBinOpAndNot(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l &^ r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l &^ r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l &^ r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l &^ r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.AndNot(r); - a.eval = func() *bignum.Integer { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.AndNot(r) + a.eval = func() *bignum.Integer { return val } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1366,85 +1366,85 @@ func (a *expr) genBinOpAndNot(l, r *expr) { func (a *expr) genBinOpShl(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l << r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l << r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asUint(); + lf := l.asInt() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l << r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l << r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) @@ -1457,85 +1457,85 @@ func (a *expr) genBinOpShl(l, r *expr) { func (a *expr) genBinOpShr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint8(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint8(ret)) } case 16: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint16(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint16(ret)) } case 32: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint32(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint32(ret)) } case 64: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint64(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint64(ret)) } case 0: a.eval = func(t *Thread) uint64 { - l, r := lf(t), rf(t); - var ret uint64; - ret = l >> r; - return uint64(uint(ret)); + l, r := lf(t), rf(t) + var ret uint64 + ret = l >> r + return uint64(uint(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: - lf := l.asInt(); - rf := r.asUint(); + lf := l.asInt() + rf := r.asUint() switch t.Bits { case 8: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int8(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int8(ret)) } case 16: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int16(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int16(ret)) } case 32: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int32(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int32(ret)) } case 64: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int64(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int64(ret)) } case 0: a.eval = func(t *Thread) int64 { - l, r := lf(t), rf(t); - var ret int64; - ret = l >> r; - return int64(int(ret)); + l, r := lf(t), rf(t) + var ret int64 + ret = l >> r + return int64(int(ret)) } default: log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) @@ -1548,43 +1548,43 @@ func (a *expr) genBinOpShr(l, r *expr) { func (a *expr) genBinOpLss(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) < 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) < 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) < 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) < 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l < r; - }; + l, r := lf(t), rf(t) + return l < r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1593,43 +1593,43 @@ func (a *expr) genBinOpLss(l, r *expr) { func (a *expr) genBinOpGtr(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) > 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) > 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) > 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) > 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l > r; - }; + l, r := lf(t), rf(t) + return l > r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1638,43 +1638,43 @@ func (a *expr) genBinOpGtr(l, r *expr) { func (a *expr) genBinOpLeq(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) <= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) <= 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) <= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) <= 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l <= r; - }; + l, r := lf(t), rf(t) + return l <= r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1683,43 +1683,43 @@ func (a *expr) genBinOpLeq(l, r *expr) { func (a *expr) genBinOpGeq(l, r *expr) { switch t := l.t.lit().(type) { case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) >= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) >= 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) >= 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) >= 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l >= r; - }; + l, r := lf(t), rf(t) + return l >= r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1728,71 +1728,71 @@ func (a *expr) genBinOpGeq(l, r *expr) { func (a *expr) genBinOpEql(l, r *expr) { switch t := l.t.lit().(type) { case *boolType: - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) == 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) == 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) == 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) == 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *PtrType: - lf := l.asPtr(); - rf := r.asPtr(); + lf := l.asPtr() + rf := r.asPtr() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *FuncType: - lf := l.asFunc(); - rf := r.asFunc(); + lf := l.asFunc() + rf := r.asFunc() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } case *MapType: - lf := l.asMap(); - rf := r.asMap(); + lf := l.asMap() + rf := r.asMap() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l == r; - }; + l, r := lf(t), rf(t) + return l == r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1801,71 +1801,71 @@ func (a *expr) genBinOpEql(l, r *expr) { func (a *expr) genBinOpNeq(l, r *expr) { switch t := l.t.lit().(type) { case *boolType: - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *uintType: - lf := l.asUint(); - rf := r.asUint(); + lf := l.asUint() + rf := r.asUint() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *intType: - lf := l.asInt(); - rf := r.asInt(); + lf := l.asInt() + rf := r.asInt() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *idealIntType: - l := l.asIdealInt()(); - r := r.asIdealInt()(); - val := l.Cmp(r) != 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealInt()() + r := r.asIdealInt()() + val := l.Cmp(r) != 0 + a.eval = func(t *Thread) bool { return val } case *floatType: - lf := l.asFloat(); - rf := r.asFloat(); + lf := l.asFloat() + rf := r.asFloat() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *idealFloatType: - l := l.asIdealFloat()(); - r := r.asIdealFloat()(); - val := l.Cmp(r) != 0; - a.eval = func(t *Thread) bool { return val }; + l := l.asIdealFloat()() + r := r.asIdealFloat()() + val := l.Cmp(r) != 0 + a.eval = func(t *Thread) bool { return val } case *stringType: - lf := l.asString(); - rf := r.asString(); + lf := l.asString() + rf := r.asString() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *PtrType: - lf := l.asPtr(); - rf := r.asPtr(); + lf := l.asPtr() + rf := r.asPtr() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *FuncType: - lf := l.asFunc(); - rf := r.asFunc(); + lf := l.asFunc() + rf := r.asFunc() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } case *MapType: - lf := l.asMap(); - rf := r.asMap(); + lf := l.asMap() + rf := r.asMap() a.eval = func(t *Thread) bool { - l, r := lf(t), rf(t); - return l != r; - }; + l, r := lf(t), rf(t) + return l != r + } default: log.Crashf("unexpected type %v at %v", l.t, a.pos) } @@ -1874,40 +1874,40 @@ func (a *expr) genBinOpNeq(l, r *expr) { func genAssign(lt Type, r *expr) (func(lv Value, t *Thread)) { switch lt.lit().(type) { case *boolType: - rf := r.asBool(); - return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) }; + rf := r.asBool() + return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) } case *uintType: - rf := r.asUint(); - return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) }; + rf := r.asUint() + return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) } case *intType: - rf := r.asInt(); - return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) }; + rf := r.asInt() + return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) } case *floatType: - rf := r.asFloat(); - return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) }; + rf := r.asFloat() + return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) } case *stringType: - rf := r.asString(); - return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) }; + rf := r.asString() + return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) } case *ArrayType: - rf := r.asArray(); - return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }; + rf := r.asArray() + return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) } case *StructType: - rf := r.asStruct(); - return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }; + rf := r.asStruct() + return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) } case *PtrType: - rf := r.asPtr(); - return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) }; + rf := r.asPtr() + return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) } case *FuncType: - rf := r.asFunc(); - return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) }; + rf := r.asFunc() + return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) } case *SliceType: - rf := r.asSlice(); - return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) }; + rf := r.asSlice() + return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) } case *MapType: - rf := r.asMap(); - return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) }; + rf := r.asMap() + return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) } default: log.Crashf("unexpected left operand type %v at %v", lt, r.pos) } - panic(); + panic() } |