реализован новый алгоритм выбора по индексу, демо9 заработало

fw.go

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

rt2/rules/assign.go

@@ -54,7 +54,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		vleft := left.(scope.Variable)
-		switch a.Right().(type) {
+		switch l := a.Right().(type) {
 		case node.ConstantNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
@@ -81,15 +81,17 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.LATER
 		case node.IndexNode:
-			rightId = a.Right().Adr()
-			rt2.Push(rt2.New(a.Right()), f)
+			rightId = l.Adr()
+			rt2.Push(rt2.New(l), f)
+			rt2.Assert(f, func(f frame.Frame) (bool, int) {
+				return rt2.ValueOf(f)[rightId] != nil, 62
+			})
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				/*				rightId.Index = new(int64)
-								*rightId.Index = int64(rt2.DataOf(f)[a.Right()].(int32))
-								sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-								sc.Update(leftId, func(interface{}) interface{} {
-									return sc.Select(rightId)
-								}) */
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				right := rt2.ValueOf(f)[l.Adr()]
+				arr := sc.Select(l.Left().Object().Adr()).(scope.Array)
+				right = arr.Get(right)
+				vleft.Set(right)
 				return frame.End()
 			}
 			ret = frame.LATER
@@ -122,11 +124,15 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.LATER
 		case node.IndexNode:
-			//			leftId = scope.Designator(a.Left())
 			rt2.Push(rt2.New(a.Left()), f)
+			rt2.Assert(f, func(f frame.Frame) (bool, int) {
+				return rt2.ValueOf(f)[l.Adr()] != nil, 62
+			})
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				/*				leftId.Index = new(int64)
-				*leftId.Index = int64(rt2.DataOf(f)[a.Left()].(int32))*/
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				left = rt2.ValueOf(f)[l.Adr()]
+				arr := sc.Select(l.Left().Object().Adr()).(scope.Array)
+				left = arr.Get(left)
 				return right(f)
 			}
 			ret = frame.LATER

rt2/rules/index.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"fw/cp/node"
 	"fw/rt2"
-	//	"fw/rt2/context"
+	"fw/rt2/context"
 	"fw/rt2/frame"
-	//	"fw/rt2/scope"
+	"fw/rt2/scope"
 	"reflect"
 )
 
@@ -16,21 +16,25 @@ func indexSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	switch i.Right().(type) {
 	case node.ConstantNode:
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			rt2.DataOf(f.Parent())[i] = i.Right().(node.ConstantNode).Data()
+			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			rt2.ValueOf(f.Parent())[i.Adr()] = sc.Provide(i.Right())(nil)
 			return frame.End()
 		}
 		ret = frame.NOW
 	case node.VariableNode:
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			//			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			//			rt2.DataOf(f.Parent())[i] = sc.Select(scope.Designator(i.Right()))
+			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			rt2.ValueOf(f.Parent())[i.Adr()] = sc.Select(i.Right().Object().Adr())
 			return frame.End()
 		}
 		ret = frame.NOW
 	case node.OperationNode, node.CallNode:
 		rt2.Push(rt2.New(i.Right()), f)
+		rt2.Assert(f, func(f frame.Frame) (bool, int) {
+			return rt2.ValueOf(f)[i.Right().Adr()] != nil, 60
+		})
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			rt2.DataOf(f.Parent())[i] = rt2.DataOf(f)[i.Right()]
+			rt2.ValueOf(f.Parent())[i.Adr()] = rt2.ValueOf(f)[i.Right().Adr()]
 			return frame.End()
 		}
 		ret = frame.LATER

rt2/scope/data.go

@@ -40,6 +40,11 @@ type Record interface {
 	Get(cp.ID) Value
 }
 
+type Array interface {
+	Variable
+	Get(Value) Value
+}
+
 //средство обновления значенияx
 type ValueFor func(in Value) (out Value)
 type ValueOf func(in Value)

rt2/scope/modern/val.go

@@ -38,6 +38,11 @@ type rec struct {
 	l *level
 }
 
+type idx struct {
+	arr *arr
+	idx int
+}
+
 func (r *rec) String() string {
 	return r.link.Name()
 }
@@ -130,6 +135,42 @@ func (a *arr) String() (ret string) {
 	return ret
 }
 
+func (a *arr) Get(id scope.Value) scope.Value {
+	switch i := id.(type) {
+	case *data:
+		return a.Get(i.val.(scope.Value))
+	case INTEGER:
+		assert.For(int64(i) < a.length, 20)
+		if len(a.val) == 0 {
+			a.val = make([]interface{}, int(a.length))
+		}
+		return &idx{arr: a, idx: int(i)}
+	default:
+		halt.As(100, reflect.TypeOf(i))
+	}
+	panic(0)
+}
+
+func (i *idx) Id() cp.ID {
+	return i.arr.Id()
+}
+
+func (i *idx) String() string {
+	return fmt.Sprint("@", i.Id(), "[", i.idx, "]")
+}
+
+func (i *idx) Set(v scope.Value) {
+	fmt.Println(i, len(i.arr.val))
+	switch x := v.(type) {
+	case *idx:
+		i.arr.val[i.idx] = x.arr.val[x.idx]
+	case CHAR:
+		i.arr.val[i.idx] = x
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+}
+
 func (a *dynarr) String() (ret string) {
 	ret = fmt.Sprint("dyn array")
 	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {