реализовал операцию сonvert, упростил работу с пользовательскими данными фрейма

rt2/frame/frame.go

@@ -39,11 +39,3 @@ func Tail(x WAIT) (seq Sequence) {
 }
 
 func End() (Sequence, WAIT) { return nil, STOP }
-
-type SetDataMsg struct {
-	Data interface{}
-}
-
-type GetDataMsg struct {
-	Data interface{}
-}

rt2/nodeframe/frame.go

@@ -19,6 +19,7 @@ func (fu FrameUtils) New(n node.Node) (f frame.Frame) {
 	f = new(nodeFrame)
 	f.(*nodeFrame).ir = n
 	f.(*nodeFrame).num = count
+	f.(*nodeFrame).data = make(map[interface{}]interface{})
 	count++
 	return f
 }
@@ -37,9 +38,7 @@ func (fu FrameUtils) NodeOf(f frame.Frame) node.Node {
 }
 
 func (fu FrameUtils) DataOf(f frame.Frame) map[interface{}]interface{} {
-	m := new(frame.GetDataMsg)
-	f.(context.ContextAware).Handle(m)
-	return m.Data.(map[interface{}]interface{})
+	return f.(*nodeFrame).data
 }
 
 type nodeFrame struct {
@@ -96,10 +95,5 @@ func (f *nodeFrame) Init(d context.Domain) {
 }
 func (f *nodeFrame) Handle(msg interface{}) {
 	assert.For(msg != nil, 20)
-	switch msg.(type) {
-	case *frame.SetDataMsg:
-		f.data = msg.(*frame.SetDataMsg).Data.(map[interface{}]interface{})
-	case *frame.GetDataMsg:
-		msg.(*frame.GetDataMsg).Data = f.data
-	}
+
 }

rt2/rules/assign.go

@@ -53,9 +53,6 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	}
 	switch a.(node.AssignNode).Statement() {
 	case statement.ASSIGN:
-		m := new(frame.SetDataMsg)
-		m.Data = make(map[interface{}]interface{})
-		f.(context.ContextAware).Handle(m)
 		switch a.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
 			seq, ret = right(f)

rt2/rules/call.go

@@ -2,7 +2,6 @@ package rules
 
 import (
 	"cp/node"
-	"rt2/context"
 	"rt2/frame"
 	mod "rt2/module"
 	"rt2/nodeframe"
@@ -27,11 +26,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		f.Root().Push(nf)
 		//передаем ссылку на цепочку значений параметров в данные фрейма входа в процедуру
 		if (n.Right() != nil) && (proc.Object() != nil) {
-			dd := make(map[interface{}]interface{})
-			dd[proc.Object()] = n.Right()
-			m := new(frame.SetDataMsg)
-			m.Data = dd
-			nf.(context.ContextAware).Handle(m)
+			fu.DataOf(nf)[proc.Object()] = n.Right()
 		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return frame.End()

rt2/rules/op.go

@@ -3,6 +3,7 @@ package rules
 import (
 	"cp/constant/operation"
 	"cp/node"
+	"cp/object"
 	"fmt"
 	"reflect"
 	"rt2/context"
@@ -27,22 +28,48 @@ func int32Of(x interface{}) (a int32) {
 }
 
 func sum(_a interface{}, _b interface{}) interface{} {
+	assert.For(_a != nil, 20)
+	assert.For(_b != nil, 21)
 	var a int32 = int32Of(_a)
 	var b int32 = int32Of(_b)
 	return a + b
 }
 
 func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	return frame.End()
+	var fu nodeframe.FrameUtils
+	n := fu.NodeOf(f).(node.MonadicNode)
+	switch n.Operation() {
+	case operation.CONVERT:
+		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+		switch n.Left().(type) {
+		case node.VariableNode, node.ParameterNode:
+			x := sc.Select(n.Left().Object())
+			assert.For(x != nil, 40)
+			switch n.Type() {
+			case object.INTEGER:
+				switch x.(type) {
+				case int8:
+					fu.DataOf(f.Parent())[n] = int32(x.(int8))
+				default:
+					panic(fmt.Sprintln("ooops", reflect.TypeOf(x)))
+				}
+			default:
+				panic("wrong type")
+			}
+			return frame.End()
+		default:
+			panic(fmt.Sprintln("unsupported left", reflect.TypeOf(n.Left())))
+
+		}
+	default:
+		panic(fmt.Sprintln("no such operation", n.(node.MonadicNode).Operation()))
+	}
+
 }
 
 func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	var fu nodeframe.FrameUtils
 
-	m := new(frame.SetDataMsg)
-	m.Data = make(map[interface{}]interface{}, 2)
-	f.(context.ContextAware).Handle(m)
-
 	op := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		n := fu.NodeOf(f)
 		switch n.(node.OperationNode).Operation() {
@@ -73,7 +100,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.OperationNode:
 			fu.Push(fu.New(n.Right()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				return frame.End()
+				return op, frame.DO
 			}
 			ret = frame.SKIP
 			return seq, ret
@@ -100,7 +127,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.OperationNode:
 			fu.Push(fu.New(n.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				return frame.End()
+				return right, frame.DO
 			}
 			ret = frame.SKIP
 			return seq, ret