добавил новый алгоритм адресации полей, заработала демо7

rt2/rules/assign.go

@@ -12,7 +12,6 @@ import (
 	"fw/rt2/frame"
 	"fw/rt2/scope"
 	"reflect"
-	"ypk/halt"
 )
 
 func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
@@ -50,22 +49,23 @@ func decSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	a := rt2.NodeOf(f)
 
-	var leftId cp.ID
+	var left scope.Value
 	var rightId cp.ID
 
 	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+		vleft := left.(scope.Variable)
 		switch 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)
-				sc.Update(leftId, sc.Provide(a.Right())) //scope.Simple(a.Right().(node.ConstantNode).Data()))
+				vleft.Set(sc.Provide(a.Right())(nil)) //scope.Simple(a.Right().(node.ConstantNode).Data()))
 				return frame.End()
 			}
 			ret = frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(leftId, scope.Simple(sc.Select(a.Right().Object().Adr())))
+				vleft.Set(sc.Select(a.Right().Object().Adr()))
 				return frame.End()
 			}
 			ret = frame.NOW
@@ -75,8 +75,8 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return rt2.ValueOf(f)[a.Right().Adr()] != nil, 61
 			})
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(leftId, scope.Simple(rt2.ValueOf(f)[a.Right().Adr()]))
+				//sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				vleft.Set(rt2.ValueOf(f)[a.Right().Adr()])
 				return frame.End()
 			}
 			ret = frame.LATER
@@ -95,7 +95,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			ret = frame.LATER
 		case node.ProcedureNode:
 			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			sc.Update(leftId, sc.Provide(a.Right().Object()))
+			vleft.Set(sc.Provide(a.Right().Object())(nil))
 			return frame.End()
 		default:
 			fmt.Println(reflect.TypeOf(a.Right()))
@@ -108,32 +108,19 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case statement.ASSIGN:
 		switch l := a.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
-			leftId = a.Left().Object().Adr()
+			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			left = sc.Select(a.Left().Object().Adr())
 			seq, ret = right(f)
 		case node.FieldNode:
-			switch l.Left().(type) {
-			case node.GuardNode:
-				rt2.Push(rt2.New(l.Left()), f)
-				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					//					x := rt2.DataOf(f)[l.Left()].(node.Node)
-					//					leftId = scope.Designator(a.Left(), x)
-					return right(f)
-				}
-				ret = frame.LATER
-			case node.DerefNode:
-				//				rt2.DataOf(f)[l.Left()] = scope.ID{}
-				rt2.Push(rt2.New(l.Left()), f)
-				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					//					leftId = rt2.DataOf(f)[l.Left()].(scope.ID)
-					//					leftId.Path = a.Left().Object().Name()
-					return right(f)
-				}
-				ret = frame.LATER
-			default:
-				halt.As(100, l.Object().Adr(), l.Left().Object().Adr())
-				//				leftId = scope.Designator(a.Left())
-				seq, ret = right(f)
+			rt2.Push(rt2.New(l), f)
+			rt2.Assert(f, func(f frame.Frame) (bool, int) {
+				return rt2.ValueOf(f)[l.Adr()] != nil, 62
+			})
+			seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+				left = rt2.ValueOf(f)[l.Adr()]
+				return right(f)
 			}
+			ret = frame.LATER
 		case node.IndexNode:
 			//			leftId = scope.Designator(a.Left())
 			rt2.Push(rt2.New(a.Left()), f)

rt2/rules/field.go

@@ -0,0 +1,42 @@
+package rules
+
+import (
+	"reflect"
+)
+
+import (
+	"fw/cp/node"
+	"fw/rt2"
+	"fw/rt2/context"
+	"fw/rt2/frame"
+	"fw/rt2/scope"
+	"ypk/halt"
+)
+
+func fieldSeq(in ...IN) (out OUT) {
+	f := in[0].frame
+	n := rt2.NodeOf(f)
+	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+	switch l := n.Left().(type) {
+	case node.VariableNode:
+		sc.Select(l.Object().Adr(), func(v scope.Value) {
+			rt2.ValueOf(f.Parent())[n.Adr()] = v.(scope.Record).Get(n.Object().Adr())
+		})
+		out = End()
+	case node.FieldNode:
+		rt2.Push(rt2.New(l), f)
+		rt2.Assert(f, func(f frame.Frame) (bool, int) {
+			_, ok := rt2.ValueOf(f)[l.Adr()].(scope.Record)
+			return ok, 60
+		})
+		out.do = func(in ...IN) OUT {
+			v := rt2.ValueOf(in[0].frame)[l.Adr()].(scope.Record)
+			rt2.ValueOf(f.Parent())[n.Adr()] = v.Get(n.Object().Adr())
+			return End()
+		}
+		out.next = LATER
+	default:
+		halt.As(100, reflect.TypeOf(l))
+	}
+	return out
+}

rt2/rules/op.go

@@ -476,7 +476,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 	left := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		n := rt2.NodeOf(f)
-		switch n.Left().(type) {
+		switch l := n.Left().(type) {
 		case node.ConstantNode:
 			rt2.ValueOf(f)[n.Left().Adr()] = sc.Provide(n.Left())(nil)
 			return right, frame.NOW
@@ -496,8 +496,10 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return seq, ret
 		case node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				//				rt2.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				sc.Select(l.Left().Object().Adr(), func(v scope.Value) {
+					rt2.ValueOf(f)[n.Left().Adr()] = v.(scope.Record).Get(l.Object().Adr())
+				})
 				return right, frame.NOW
 			}
 			ret = frame.NOW

rt2/rules/table.go

@@ -56,6 +56,8 @@ func prologue(n node.Node) frame.Sequence {
 		return frame.Tail(frame.STOP)
 	case node.IndexNode:
 		return indexSeq
+	case node.FieldNode:
+		return Propose(fieldSeq)
 	case node.TrapNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			switch code := next.Left().(type) {
@@ -129,7 +131,7 @@ func epilogue(n node.Node) frame.Sequence {
 			return frame.End()
 		}
 	case node.OperationNode, node.ReturnNode, node.IfNode, node.LoopNode,
-		node.DerefNode, node.IndexNode, node.TrapNode, node.GuardNode, node.RangeNode:
+		node.DerefNode, node.IndexNode, node.TrapNode, node.GuardNode, node.RangeNode, node.FieldNode:
 		return nil
 	default:
 		fmt.Println(reflect.TypeOf(n))

rt2/scope/area.go

@@ -20,7 +20,7 @@ type PARAM struct {
 type Manager interface {
 	context.ContextAware
 	Update(id cp.ID, val ValueFor)
-	Select(id cp.ID) Value
+	Select(cp.ID, ...ValueOf) Value
 	Target(...Allocator) Allocator
 	Provide(interface{}) ValueFor
 	String() string

rt2/scope/data.go

@@ -42,6 +42,7 @@ type Record interface {
 
 //средство обновления значенияx
 type ValueFor func(in Value) (out Value)
+type ValueOf func(in Value)
 
 func Simple(v Value) ValueFor {
 	return func(Value) Value {
@@ -50,7 +51,6 @@ func Simple(v Value) ValueFor {
 }
 
 var ValueFrom func(v Value) Value
-var ValueOf func(v Value)
 var GoTypeFrom func(v Value) interface{}
 var TypeFromGo func(v interface{}) Value
 var Ops Operations

rt2/scope/modern/ms.go

@@ -253,6 +253,7 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 	upd(len(a.data), id)
 	assert.For(k != 0, 60)
 }
+
 func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
 	fmt.Println("SELECT", id)
 	var sel func(x int, id cp.ID)
@@ -267,7 +268,11 @@ func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
 					if ret == nil { //ref?
 						r := l.r[k]
 						if r != nil {
-							sel(i, r.(*ref).id)
+							if l.l[k] != nil { //rec
+								panic(0)
+							} else {
+								sel(i, r.(*ref).id)
+							}
 							break
 						}
 					} else if len(val) > 0 {

rt2/scope/modern/val.go

@@ -50,6 +50,15 @@ func (r *rec) Set(v scope.Value) {
 
 }
 
+func (r *rec) Get(id cp.ID) scope.Value {
+	k := r.l.k[id]
+	if r.l.v[k] == nil { //ref
+		return r.l.r[k]
+	} else {
+		return r.l.v[k]
+	}
+}
+
 func newRec(o object.Object) *rec {
 	_, ok := o.Complex().(object.RecordType)
 	assert.For(ok, 20)