исправил работу оставшихся унарных операторов, и демку для них

fw.go

@@ -28,7 +28,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevDemo14"
+		name = "XevDemo15"
 	}
 	global := &stdDomain{god: true}
 	modList := rtmod.New()

rt2/rules/op.go

@@ -254,16 +254,16 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Is(sc.Select(n.Left().Object().Adr()), n.Object())
 			return frame.End()
 		case operation.ABS:
-			rt2.DataOf(f.Parent())[n] = abs(rt2.DataOf(f)[n.Left()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Abs(rt2.ValueOf(f)[n.Left().Adr()])
 			return frame.End()
 		case operation.ODD:
-			rt2.DataOf(f.Parent())[n] = odd(rt2.DataOf(f)[n.Left()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Odd(rt2.ValueOf(f)[n.Left().Adr()])
 			return frame.End()
 		case operation.CAP:
-			rt2.DataOf(f.Parent())[n] = cap_char(rt2.DataOf(f)[n.Left()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Cap(rt2.ValueOf(f)[n.Left().Adr()])
 			return frame.End()
 		case operation.BITS:
-			rt2.DataOf(f.Parent())[n] = bits(rt2.DataOf(f)[n.Left()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Bits(rt2.ValueOf(f)[n.Left().Adr()])
 			return frame.End()
 		default:
 			panic("no such op")
@@ -399,7 +399,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Neq(rt2.ValueOf(f)[n.Left().Adr()], rt2.ValueOf(f)[n.Right().Adr()])
 			return frame.End()
 		case operation.GREATER:
-			rt2.DataOf(f.Parent())[n] = gtr(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Gtr(rt2.ValueOf(f)[n.Left().Adr()], rt2.ValueOf(f)[n.Right().Adr()])
 			return frame.End()
 		case operation.MAX:
 			rt2.DataOf(f.Parent())[n] = max(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])

rt2/scope/data.go

@@ -13,8 +13,13 @@ type Operations interface {
 	Neq(Value, Value) Value
 	Lss(Value, Value) Value
 	Leq(Value, Value) Value
+	Gtr(Value, Value) Value
 
 	Not(Value) Value
+	Abs(Value) Value
+	Odd(Value) Value
+	Cap(Value) Value
+	Bits(Value) Value
 
 	Is(Value, object.ComplexType) Value
 	Conv(Value, object.Type) Value

rt2/scope/modern/val.go

@@ -6,8 +6,10 @@ import (
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2/scope"
+	"math"
 	"math/big"
 	"reflect"
+	"strings"
 	"ypk/assert"
 	"ypk/halt"
 )
@@ -377,6 +379,10 @@ func vfrom(v scope.Value) scope.Value {
 			return n.val.(INTEGER)
 		case object.BYTE:
 			return n.val.(BYTE)
+		case object.CHAR:
+			return n.val.(CHAR)
+		case object.SET:
+			return n.val.(SET)
 		default:
 			halt.As(100, n.link.Type())
 		}
@@ -427,6 +433,13 @@ func (o *ops) Sum(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case SET:
+				switch y := b.(type) {
+				case SET:
+					return SET{bits: x.bits.Add(x.bits, y.bits)}
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -533,6 +546,17 @@ func (o *ops) Conv(a scope.Value, typ object.Type) scope.Value {
 			return o.Conv(vfrom(x), typ)
 		case BYTE:
 			return INTEGER(x)
+		case SET:
+			return INTEGER(x.bits.Int64())
+		default:
+			halt.As(100, reflect.TypeOf(x))
+		}
+	case object.SET:
+		switch x := a.(type) {
+		case *data:
+			return o.Conv(vfrom(x), typ)
+		case INTEGER:
+			return SET{bits: big.NewInt(int64(x))}
 		default:
 			halt.As(100, reflect.TypeOf(x))
 		}
@@ -554,6 +578,53 @@ func (o *ops) Not(a scope.Value) scope.Value {
 	panic(100)
 }
 
+func (o *ops) Abs(a scope.Value) scope.Value {
+	switch x := a.(type) {
+	case *data:
+		return o.Abs(vfrom(x))
+	case INTEGER:
+		return INTEGER(int32(math.Abs(float64(x))))
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+	panic(100)
+}
+
+func (o *ops) Odd(a scope.Value) scope.Value {
+	switch x := a.(type) {
+	case *data:
+		return o.Odd(vfrom(x))
+	case INTEGER:
+		return BOOLEAN(int32(math.Abs(float64(x)))%2 == 1)
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+	panic(100)
+}
+
+func (o *ops) Cap(a scope.Value) scope.Value {
+	switch x := a.(type) {
+	case *data:
+		return o.Cap(vfrom(x))
+	case CHAR:
+		return CHAR([]rune(strings.ToUpper(string(x)))[0])
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+	panic(100)
+}
+
+func (o *ops) Bits(a scope.Value) scope.Value {
+	switch x := a.(type) {
+	case *data:
+		return o.Bits(vfrom(x))
+	case INTEGER:
+		return SET{bits: big.NewInt(int64(x))}
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+	panic(100)
+}
 func (o *ops) Eq(a, b scope.Value) scope.Value {
 	switch a.(type) {
 	case *data:
@@ -629,6 +700,31 @@ func (o *ops) Lss(a, b scope.Value) scope.Value {
 	panic(0)
 }
 
+func (o *ops) Gtr(a, b scope.Value) scope.Value {
+	switch a.(type) {
+	case *data:
+		return o.Gtr(vfrom(a), b)
+	default:
+		switch b.(type) {
+		case *data:
+			return o.Gtr(a, vfrom(b))
+		default:
+			switch x := a.(type) {
+			case INTEGER:
+				switch y := b.(type) {
+				case INTEGER:
+					return BOOLEAN(x > y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
+			default:
+				panic(fmt.Sprintln(reflect.TypeOf(x)))
+			}
+		}
+	}
+	panic(0)
+}
+
 func (o *ops) Leq(a, b scope.Value) scope.Value {
 	switch a.(type) {
 	case *data: