summaryrefslogtreecommitdiff
path: root/usr/austin/eval/expr1.go
diff options
context:
space:
mode:
Diffstat (limited to 'usr/austin/eval/expr1.go')
-rw-r--r--usr/austin/eval/expr1.go1226
1 files changed, 1134 insertions, 92 deletions
diff --git a/usr/austin/eval/expr1.go b/usr/austin/eval/expr1.go
index d337ea177..7787a2112 100644
--- a/usr/austin/eval/expr1.go
+++ b/usr/austin/eval/expr1.go
@@ -1,4 +1,3 @@
-
// This file is machine generated by gen.go.
// 6g gen.go && 6l gen.6 && ./6.out >expr1.go
@@ -58,31 +57,31 @@ func (a *expr) asMulti() (func(*Thread) []Value) {
func (a *expr) asInterface() (func(*Thread) interface{}) {
switch sf := a.eval.(type) {
- case func(*Thread)bool:
- return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)uint64:
+ case func(t *Thread)bool:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)int64:
+ case func(t *Thread)uint64:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)*bignum.Integer:
+ case func(t *Thread)int64:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)float64:
+ case func()*bignum.Integer:
+ return func(*Thread) interface{} { return sf() }
+ case func(t *Thread)float64:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)*bignum.Rational:
+ case func()*bignum.Rational:
+ return func(*Thread) interface{} { return sf() }
+ case func(t *Thread)string:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)string:
+ case func(t *Thread)ArrayValue:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)ArrayValue:
+ case func(t *Thread)StructValue:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)StructValue:
+ case func(t *Thread)Value:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)Value:
+ case func(t *Thread)Func:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)Func:
+ case func(t *Thread)Slice:
return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)Slice:
- return func(t *Thread) interface{} { return sf(t) }
- case func(*Thread)Map:
+ case func(t *Thread)Map:
return func(t *Thread) interface{} { return sf(t) }
default:
log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos);
@@ -272,16 +271,104 @@ func (a *expr) genUnaryOpXor(v *expr) {
}
}
+func (a *expr) genBinOpLogAnd(l, r *expr) {
+ 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) }
+}
+
func (a *expr) genBinOpAdd(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l + r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l + r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -290,7 +377,31 @@ func (a *expr) genBinOpAdd(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l + r }
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) float64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -299,22 +410,101 @@ func (a *expr) genBinOpAdd(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) string { l, r := lf(t), rf(t); return l + r }
+ a.eval = func(t *Thread) string {
+ l, r := lf(t), rf(t);
+ return l + r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpSub(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l - r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l - r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -323,7 +513,31 @@ func (a *expr) genBinOpSub(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l - r }
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) float64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -335,15 +549,91 @@ func (a *expr) genBinOpSub(l, r *expr) {
}
func (a *expr) genBinOpMul(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l * r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l * r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -352,7 +642,31 @@ func (a *expr) genBinOpMul(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l * r }
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) float64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -364,15 +678,91 @@ func (a *expr) genBinOpMul(l, r *expr) {
}
func (a *expr) genBinOpQuo(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+ switch t.Bits {
+ case 8:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return uint64(uint8(ret))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return uint64(uint16(ret))
+ }
+ case 32:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return uint64(uint32(ret))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return uint64(uint64(ret))
+ }
+ case 0:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } 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();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+ switch t.Bits {
+ case 8:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return int64(int8(ret))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return int64(int16(ret))
+ }
+ case 32:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return int64(int32(ret))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return int64(int64(ret))
+ }
+ case 0:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } 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()();
@@ -381,7 +771,31 @@ func (a *expr) genBinOpQuo(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+ switch t.Bits {
+ case 32:
+ a.eval = func(t *Thread) float64 {
+ l, r := lf(t), rf(t);
+ var ret float64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return float64(float32(ret))
+ }
+ case 64:
+ a.eval = func(t *Thread) float64 {
+ l, r := lf(t), rf(t);
+ var ret float64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l / r;
+ return float64(float64(ret))
+ }
+ case 0:
+ a.eval = func(t *Thread) float64 {
+ l, r := lf(t), rf(t);
+ var ret float64;
+ if r == 0 { t.Abort(DivByZeroError{}) } 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()();
@@ -393,15 +807,91 @@ func (a *expr) genBinOpQuo(l, r *expr) {
}
func (a *expr) genBinOpRem(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l % r }
+ switch t.Bits {
+ case 8:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return uint64(uint8(ret))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return uint64(uint16(ret))
+ }
+ case 32:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return uint64(uint32(ret))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return uint64(uint64(ret))
+ }
+ case 0:
+ a.eval = func(t *Thread) uint64 {
+ l, r := lf(t), rf(t);
+ var ret uint64;
+ if r == 0 { t.Abort(DivByZeroError{}) } 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();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l % r }
+ switch t.Bits {
+ case 8:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return int64(int8(ret))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return int64(int16(ret))
+ }
+ case 32:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return int64(int32(ret))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
+ return int64(int64(ret))
+ }
+ case 0:
+ a.eval = func(t *Thread) int64 {
+ l, r := lf(t), rf(t);
+ var ret int64;
+ if r == 0 { t.Abort(DivByZeroError{}) } 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()();
@@ -413,15 +903,91 @@ func (a *expr) genBinOpRem(l, r *expr) {
}
func (a *expr) genBinOpAnd(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l & r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l & r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -433,15 +999,91 @@ func (a *expr) genBinOpAnd(l, r *expr) {
}
func (a *expr) genBinOpOr(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l | r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l | r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -453,15 +1095,91 @@ func (a *expr) genBinOpOr(l, r *expr) {
}
func (a *expr) genBinOpXor(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l ^ r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l ^ r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -473,15 +1191,91 @@ func (a *expr) genBinOpXor(l, r *expr) {
}
func (a *expr) genBinOpAndNot(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l &^ r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l &^ r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -493,45 +1287,203 @@ func (a *expr) genBinOpAndNot(l, r *expr) {
}
func (a *expr) genBinOpShl(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l << r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asUint();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l << r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpShr(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l >> r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) uint64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
case *intType:
lf := l.asInt();
rf := r.asUint();
- a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l >> r }
+ 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))
+ }
+ case 16:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ case 64:
+ a.eval = func(t *Thread) int64 {
+ 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))
+ }
+ default:
+ log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpLss(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l < r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l < r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -540,7 +1492,10 @@ func (a *expr) genBinOpLss(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l < r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -549,22 +1504,31 @@ func (a *expr) genBinOpLss(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l < r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpGtr(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l > r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l > r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -573,7 +1537,10 @@ func (a *expr) genBinOpGtr(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l > r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -582,22 +1549,31 @@ func (a *expr) genBinOpGtr(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l > r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpLeq(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l <= r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l <= r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -606,7 +1582,10 @@ func (a *expr) genBinOpLeq(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l <= r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -615,22 +1594,31 @@ func (a *expr) genBinOpLeq(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l <= r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpGeq(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l >= r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l >= r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -639,7 +1627,10 @@ func (a *expr) genBinOpGeq(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l >= r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -648,26 +1639,38 @@ func (a *expr) genBinOpGeq(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l >= r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpEql(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *boolType:
lf := l.asBool();
rf := r.asBool();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -676,7 +1679,10 @@ func (a *expr) genBinOpEql(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -685,38 +1691,59 @@ func (a *expr) genBinOpEql(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *PtrType:
lf := l.asPtr();
rf := r.asPtr();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *FuncType:
lf := l.asFunc();
rf := r.asFunc();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
case *MapType:
lf := l.asMap();
rf := r.asMap();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l == r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
}
func (a *expr) genBinOpNeq(l, r *expr) {
- switch l.t.lit().(type) {
+ switch t := l.t.lit().(type) {
case *boolType:
lf := l.asBool();
rf := r.asBool();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *uintType:
lf := l.asUint();
rf := r.asUint();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *intType:
lf := l.asInt();
rf := r.asInt();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *idealIntType:
l := l.asIdealInt()();
r := r.asIdealInt()();
@@ -725,7 +1752,10 @@ func (a *expr) genBinOpNeq(l, r *expr) {
case *floatType:
lf := l.asFloat();
rf := r.asFloat();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *idealFloatType:
l := l.asIdealFloat()();
r := r.asIdealFloat()();
@@ -734,19 +1764,31 @@ func (a *expr) genBinOpNeq(l, r *expr) {
case *stringType:
lf := l.asString();
rf := r.asString();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *PtrType:
lf := l.asPtr();
rf := r.asPtr();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *FuncType:
lf := l.asFunc();
rf := r.asFunc();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
case *MapType:
lf := l.asMap();
rf := r.asMap();
- a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+ a.eval = func(t *Thread) bool {
+ l, r := lf(t), rf(t);
+ return l != r
+ }
default:
log.Crashf("unexpected type %v at %v", l.t, a.pos);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-11 03:30:52 +0000