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.go1836
1 files changed, 0 insertions, 1836 deletions
diff --git a/usr/austin/eval/expr1.go b/usr/austin/eval/expr1.go
deleted file mode 100644
index 7787a2112..000000000
--- a/usr/austin/eval/expr1.go
+++ /dev/null
@@ -1,1836 +0,0 @@
-// This file is machine generated by gen.go.
-// 6g gen.go && 6l gen.6 && ./6.out >expr1.go
-
-package eval
-
-import (
- "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) 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) asIdealInt() (func() *bignum.Integer) {
- return a.eval.(func()(*bignum.Integer))
-}
-func (a *expr) asFloat() (func(*Thread) float64) {
- return a.eval.(func(*Thread)(float64))
-}
-func (a *expr) asIdealFloat() (func() *bignum.Rational) {
- return a.eval.(func()(*bignum.Rational))
-}
-func (a *expr) asString() (func(*Thread) string) {
- return a.eval.(func(*Thread)(string))
-}
-func (a *expr) asArray() (func(*Thread) ArrayValue) {
- return a.eval.(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) 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) asMulti() (func(*Thread) []Value) {
- return a.eval.(func(*Thread)[]Value)
-}
-
-func (a *expr) asInterface() (func(*Thread) interface{}) {
- switch sf := a.eval.(type) {
- case func(t *Thread)bool:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)uint64:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)int64:
- return func(t *Thread) interface{} { return sf(t) }
- case func()*bignum.Integer:
- return func(*Thread) interface{} { return sf() }
- case func(t *Thread)float64:
- return func(t *Thread) interface{} { return sf(t) }
- 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(t *Thread)ArrayValue:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)StructValue:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)Value:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)Func:
- return func(t *Thread) interface{} { return sf(t) }
- case func(t *Thread)Slice:
- return func(t *Thread) interface{} { return sf(t) }
- 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);
- }
- panic();
-}
-
-/*
- * Operator generators.
- */
-
-func (a *expr) genConstant(v Value) {
- switch a.t.lit().(type) {
- case *boolType:
- a.eval = func(t *Thread) bool { return v.(BoolValue).Get(t) }
- case *uintType:
- a.eval = func(t *Thread) uint64 { return v.(UintValue).Get(t) }
- 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 }
- 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 }
- case *stringType:
- a.eval = func(t *Thread) string { return v.(StringValue).Get(t) }
- case *ArrayType:
- a.eval = func(t *Thread) ArrayValue { return v.(ArrayValue).Get(t) }
- case *StructType:
- a.eval = func(t *Thread) StructValue { return v.(StructValue).Get(t) }
- case *PtrType:
- a.eval = func(t *Thread) Value { return v.(PtrValue).Get(t) }
- case *FuncType:
- a.eval = func(t *Thread) Func { return v.(FuncValue).Get(t) }
- case *SliceType:
- a.eval = func(t *Thread) Slice { return v.(SliceValue).Get(t) }
- case *MapType:
- a.eval = func(t *Thread) Map { return v.(MapValue).Get(t) }
- default:
- log.Crashf("unexpected constant type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genIdentOp(level, index int) {
- a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) };
- switch a.t.lit().(type) {
- case *boolType:
- a.eval = func(t *Thread) bool { return t.f.Get(level, index).(BoolValue).Get(t) }
- case *uintType:
- a.eval = func(t *Thread) uint64 { return t.f.Get(level, index).(UintValue).Get(t) }
- case *intType:
- a.eval = func(t *Thread) int64 { return t.f.Get(level, index).(IntValue).Get(t) }
- case *floatType:
- a.eval = func(t *Thread) float64 { return t.f.Get(level, index).(FloatValue).Get(t) }
- case *stringType:
- a.eval = func(t *Thread) string { return t.f.Get(level, index).(StringValue).Get(t) }
- case *ArrayType:
- a.eval = func(t *Thread) ArrayValue { return t.f.Get(level, index).(ArrayValue).Get(t) }
- case *StructType:
- a.eval = func(t *Thread) StructValue { return t.f.Get(level, index).(StructValue).Get(t) }
- case *PtrType:
- a.eval = func(t *Thread) Value { return t.f.Get(level, index).(PtrValue).Get(t) }
- case *FuncType:
- a.eval = func(t *Thread) Func { return t.f.Get(level, index).(FuncValue).Get(t) }
- case *SliceType:
- a.eval = func(t *Thread) Slice { return t.f.Get(level, index).(SliceValue).Get(t) }
- case *MapType:
- a.eval = func(t *Thread) Map { return t.f.Get(level, index).(MapValue).Get(t) }
- default:
- log.Crashf("unexpected identifier type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genFuncCall(call func(t *Thread) []Value) {
- a.exec = func(t *Thread) { call(t)};
- switch a.t.lit().(type) {
- case *boolType:
- a.eval = func(t *Thread) bool { return call(t)[0].(BoolValue).Get(t) }
- case *uintType:
- a.eval = func(t *Thread) uint64 { return call(t)[0].(UintValue).Get(t) }
- case *intType:
- a.eval = func(t *Thread) int64 { return call(t)[0].(IntValue).Get(t) }
- case *floatType:
- a.eval = func(t *Thread) float64 { return call(t)[0].(FloatValue).Get(t) }
- case *stringType:
- a.eval = func(t *Thread) string { return call(t)[0].(StringValue).Get(t) }
- case *ArrayType:
- a.eval = func(t *Thread) ArrayValue { return call(t)[0].(ArrayValue).Get(t) }
- case *StructType:
- a.eval = func(t *Thread) StructValue { return call(t)[0].(StructValue).Get(t) }
- case *PtrType:
- a.eval = func(t *Thread) Value { return call(t)[0].(PtrValue).Get(t) }
- case *FuncType:
- a.eval = func(t *Thread) Func { return call(t)[0].(FuncValue).Get(t) }
- case *SliceType:
- a.eval = func(t *Thread) Slice { return call(t)[0].(SliceValue).Get(t) }
- case *MapType:
- a.eval = func(t *Thread) Map { return call(t)[0].(MapValue).Get(t) }
- case *MultiType:
- a.eval = func(t *Thread) []Value { return call(t) }
- default:
- log.Crashf("unexpected result type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genValue(vf func(*Thread) Value) {
- a.evalAddr = vf;
- switch a.t.lit().(type) {
- case *boolType:
- a.eval = func(t *Thread) bool { return vf(t).(BoolValue).Get(t) }
- case *uintType:
- a.eval = func(t *Thread) uint64 { return vf(t).(UintValue).Get(t) }
- case *intType:
- a.eval = func(t *Thread) int64 { return vf(t).(IntValue).Get(t) }
- case *floatType:
- a.eval = func(t *Thread) float64 { return vf(t).(FloatValue).Get(t) }
- case *stringType:
- a.eval = func(t *Thread) string { return vf(t).(StringValue).Get(t) }
- case *ArrayType:
- a.eval = func(t *Thread) ArrayValue { return vf(t).(ArrayValue).Get(t) }
- case *StructType:
- a.eval = func(t *Thread) StructValue { return vf(t).(StructValue).Get(t) }
- case *PtrType:
- a.eval = func(t *Thread) Value { return vf(t).(PtrValue).Get(t) }
- case *FuncType:
- a.eval = func(t *Thread) Func { return vf(t).(FuncValue).Get(t) }
- case *SliceType:
- a.eval = func(t *Thread) Slice { return vf(t).(SliceValue).Get(t) }
- case *MapType:
- a.eval = func(t *Thread) Map { return vf(t).(MapValue).Get(t) }
- default:
- log.Crashf("unexpected result type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genUnaryOpNeg(v *expr) {
- switch a.t.lit().(type) {
- case *uintType:
- vf := v.asUint();
- a.eval = func(t *Thread) uint64 { v := vf(t); return -v }
- case *intType:
- vf := v.asInt();
- a.eval = func(t *Thread) int64 { v := vf(t); return -v }
- case *idealIntType:
- v := v.asIdealInt()();
- val := v.Neg();
- a.eval = func() *bignum.Integer { return val }
- case *floatType:
- vf := v.asFloat();
- a.eval = func(t *Thread) float64 { v := vf(t); return -v }
- case *idealFloatType:
- v := v.asIdealFloat()();
- val := v.Neg();
- a.eval = func() *bignum.Rational { return val }
- default:
- log.Crashf("unexpected type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genUnaryOpNot(v *expr) {
- switch a.t.lit().(type) {
- case *boolType:
- vf := v.asBool();
- a.eval = func(t *Thread) bool { v := vf(t); return !v }
- default:
- log.Crashf("unexpected type %v at %v", a.t, a.pos);
- }
-}
-
-func (a *expr) genUnaryOpXor(v *expr) {
- switch a.t.lit().(type) {
- case *uintType:
- vf := v.asUint();
- a.eval = func(t *Thread) uint64 { v := vf(t); return ^v }
- case *intType:
- vf := v.asInt();
- a.eval = func(t *Thread) int64 { v := vf(t); return ^v }
- case *idealIntType:
- v := v.asIdealInt()();
- val := v.Neg().Sub(bignum.Int(1));
- a.eval = func() *bignum.Integer { return val }
- 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) }
-}
-
-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 t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.Add(r);
- a.eval = func() *bignum.Integer { return val }
- case *floatType:
- 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))
- }
- 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()();
- val := l.Add(r);
- a.eval = func() *bignum.Rational { return val }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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 t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.Sub(r);
- a.eval = func() *bignum.Integer { return val }
- case *floatType:
- 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))
- }
- 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()();
- val := l.Sub(r);
- a.eval = func() *bignum.Rational { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpMul(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.Mul(r);
- a.eval = func() *bignum.Integer { return val }
- case *floatType:
- 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))
- }
- 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()();
- val := l.Mul(r);
- a.eval = func() *bignum.Rational { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpQuo(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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;
- 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();
- 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()();
- val := l.Quo(r);
- a.eval = func() *bignum.Integer { return val }
- case *floatType:
- 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;
- 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()();
- val := l.Quo(r);
- a.eval = func() *bignum.Rational { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpRem(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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;
- 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();
- 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()();
- val := l.Rem(r);
- a.eval = func() *bignum.Integer { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpAnd(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.And(r);
- a.eval = func() *bignum.Integer { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpOr(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.Or(r);
- a.eval = func() *bignum.Integer { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpXor(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.Xor(r);
- a.eval = func() *bignum.Integer { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpAndNot(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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()();
- val := l.AndNot(r);
- a.eval = func() *bignum.Integer { return val }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpShl(l, r *expr) {
- switch t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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 t := l.t.lit().(type) {
- case *uintType:
- 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))
- }
- 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();
- 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 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
- }
- case *intType:
- lf := l.asInt();
- rf := r.asInt();
- a.eval = func(t *Thread) bool {
- 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 }
- case *floatType:
- lf := l.asFloat();
- rf := r.asFloat();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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 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
- }
- case *intType:
- lf := l.asInt();
- rf := r.asInt();
- a.eval = func(t *Thread) bool {
- 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 }
- case *floatType:
- lf := l.asFloat();
- rf := r.asFloat();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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 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
- }
- case *intType:
- lf := l.asInt();
- rf := r.asInt();
- a.eval = func(t *Thread) bool {
- 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 }
- case *floatType:
- lf := l.asFloat();
- rf := r.asFloat();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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 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
- }
- case *intType:
- lf := l.asInt();
- rf := r.asInt();
- a.eval = func(t *Thread) bool {
- 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 }
- case *floatType:
- lf := l.asFloat();
- rf := r.asFloat();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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 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
- }
- case *uintType:
- lf := l.asUint();
- rf := r.asUint();
- 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
- }
- case *idealIntType:
- 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();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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
- }
- case *FuncType:
- lf := l.asFunc();
- rf := r.asFunc();
- 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
- }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-func (a *expr) genBinOpNeq(l, r *expr) {
- 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
- }
- case *uintType:
- lf := l.asUint();
- rf := r.asUint();
- 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
- }
- case *idealIntType:
- 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();
- a.eval = func(t *Thread) bool {
- 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 }
- case *stringType:
- lf := l.asString();
- rf := r.asString();
- 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
- }
- case *FuncType:
- lf := l.asFunc();
- rf := r.asFunc();
- 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
- }
- default:
- log.Crashf("unexpected type %v at %v", l.t, a.pos);
- }
-}
-
-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)) }
- case *uintType:
- 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)) }
- case *floatType:
- 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)) }
- case *ArrayType:
- 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)) }
- case *PtrType:
- 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)) }
- case *SliceType:
- 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)) }
- default:
- log.Crashf("unexpected left operand type %v at %v", lt, r.pos);
- }
- panic();
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-11 05:33:31 +0000