реализация CLOSE секции модуля

fw/fw.go

@@ -15,16 +15,17 @@ func main() {
 	global := new(stdDomain)
 	modList := module.New()
 	global.ConnectTo(context.MOD, modList)
-	ret, err := modList.Load("PrivDemo1")
-	assert.For(err == nil, 20)
+	ret, err := modList.Load("XevDemo2")
+	assert.For(ret != nil, 40)
+	assert.For(err == nil, 41)
 	{
 		domain := new(stdDomain)
-		global.ConnectTo("PrivDemo1", domain)
+		global.ConnectTo("XevDemo2", domain)
 		root := frame.NewRoot()
 		domain.ConnectTo(context.STACK, root)
 		domain.ConnectTo(context.SCOPE, scope.New())
 		var fu nodeframe.FrameUtils
-		root.Push(fu.New(ret.Enter))
+		root.PushFor(fu.New(ret.Enter), nil)
 		i := 0
 		for x := frame.DO; x == frame.DO; x = root.Do() {
 			//fmt.Println(x)

rt2/frame/frame.go

@@ -15,7 +15,6 @@ const (
 
 // LIFO-стек, позволяет затолкнуть фрейм связанный с другим фреймом
 type Stack interface {
-	Push(f Frame)
 	PushFor(f, parent Frame)
 	Pop()
 	Top() Frame

rt2/frame/stdFrame.go

@@ -20,10 +20,6 @@ func NewRoot() *RootFrame {
 	return new(RootFrame).init()
 }
 
-func (f *RootFrame) Push(frame Frame) {
-	f.PushFor(frame, nil)
-}
-
 func (f *RootFrame) PushFor(frame, parent Frame) {
 	_, ok := frame.(*RootFrame)
 	if ok {

rt2/rules/call.go

@@ -23,12 +23,14 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		m := mod.DomainModule(f.Domain())
 		proc := m.NodeByObject(n.Left().Object())
 		nf := fu.New(proc)
-		f.Root().Push(nf)
+		fu.Push(nf, f)
 		//передаем ссылку на цепочку значений параметров в данные фрейма входа в процедуру
 		if (n.Right() != nil) && (proc.Object() != nil) {
 			fu.DataOf(nf)[proc.Object()] = n.Right()
 		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+			var fu nodeframe.FrameUtils
+			fu.DataOf(f.Parent())[n] = fu.DataOf(f)[n.Left().Object()]
 			return frame.End()
 		}
 		ret = frame.SKIP

rt2/rules/return.go

@@ -1,9 +1,46 @@
 package rules
 
 import (
+	"cp/node"
+	"fmt"
+	"reflect"
+	"rt2/context"
 	"rt2/frame"
+	"rt2/nodeframe"
+	"rt2/scope"
 )
 
 func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
-	return frame.End()
+	var fu nodeframe.FrameUtils
+	a := fu.NodeOf(f)
+
+	left := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+		switch a.Left().(type) {
+		case node.ConstantNode:
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				fu.DataOf(f.Parent())[a.Object()] = a.Left().(node.ConstantNode).Data()
+				return frame.End()
+			}
+			ret = frame.DO
+		case node.VariableNode:
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				fu.DataOf(f.Parent())[a.Object()] = sc.Select(a.Left().Object())
+				return frame.End()
+			}
+			ret = frame.DO
+		case node.OperationNode, node.CallNode:
+			fu.Push(fu.New(a.Left()), f)
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				fu.DataOf(f.Parent())[a.Object()] = fu.DataOf(f)[a.Left()]
+				return frame.End()
+			}
+			ret = frame.SKIP
+		default:
+			fmt.Println(reflect.TypeOf(a.Left()))
+			panic("wrong right")
+		}
+		return seq, ret
+	}
+	return left, frame.DO
 }

rt2/rules/table.go

@@ -18,7 +18,7 @@ func prologue(n node.Node) frame.Sequence {
 	//fmt.Println(reflect.TypeOf(n))
 	switch n.(type) {
 	case node.EnterNode:
-		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+		return func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			body := fu.NodeOf(f).Right()
 			assert.For(body != nil, 40)
 			sm := scope.This(f.Domain().Discover(context.SCOPE))
@@ -29,8 +29,27 @@ func prologue(n node.Node) frame.Sequence {
 					sm.Initialize(n, n.Object().Link(), par)
 				}
 			}
-			f.Root().Push(fu.New(body))
-			return frame.Tail(frame.STOP), frame.SKIP
+			if f.Parent() != nil {
+				//Вход в процедуру не несет значимых действий и просто заменяет себя в цепочке родителей на своего родителя
+				fu.Push(fu.New(body), f.Parent())
+			} else {
+				//Особый случай, вход в модуль
+				fu.Push(fu.New(body), f)
+			}
+			next := n.Link()
+			if next != nil {
+				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+					if f.Parent() != nil {
+						f.Root().PushFor(fu.New(next), f.Parent())
+					} else {
+						f.Root().PushFor(fu.New(next), f)
+					}
+					return frame.Tail(frame.STOP), frame.SKIP
+				}
+				return seq, frame.SKIP
+			} else {
+				return frame.Tail(frame.STOP), frame.SKIP
+			}
 		}
 	case node.AssignNode:
 		return assignSeq
@@ -55,24 +74,31 @@ func prologue(n node.Node) frame.Sequence {
 func epilogue(n node.Node) frame.Sequence {
 	var fu nodeframe.FrameUtils
 	switch n.(type) {
-	case node.AssignNode, node.CallNode:
+	case node.AssignNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			next := n.Link()
 			if next != nil {
-				f.Root().Push(fu.New(next))
+				f.Root().PushFor(fu.New(next), f.Parent())
 			}
 			return frame.End()
 		}
 	case node.EnterNode:
-		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+		return func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			sm := scope.This(f.Domain().Discover(context.SCOPE))
 			sm.Dispose(n)
 			return frame.End()
 		}
 	case node.OperationNode:
 		return nil //do nothing
+	case node.CallNode:
+		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+			next := n.Link()
+			if next != nil {
+				f.Root().PushFor(fu.New(next), f.Parent())
+			}
+			return frame.End()
+		}
 	case node.ReturnNode:
-		fmt.Println("return")
 		return nil
 	default:
 		fmt.Println(reflect.TypeOf(n))