завершил схему с доменами, теперь они обеспечивают сервисы поиска контекстнозависимых объектов для узлов и фреймов

cp/module/module.go

@@ -3,6 +3,7 @@ package module
 import (
 	"cp/node"
 	"cp/object"
+	"ypk/assert"
 )
 
 type Module struct {
@@ -12,9 +13,7 @@ type Module struct {
 }
 
 func (m *Module) NodeByObject(obj object.Object) (ret node.Node) {
-	if obj == nil {
-		panic("obj must not be nil")
-	}
+	assert.For(obj != nil, 20)
 	for i := 0; (i < len(m.Nodes)) && (ret == nil); i++ {
 		node := m.Nodes[i]
 		if node.Object() == obj {

fw/domain.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"rt2/context"
+	"ypk/assert"
+)
+
+type stdDomain struct {
+	list   map[string]context.ContextAware
+	parent context.Domain
+	global context.Domain
+}
+
+func (d *stdDomain) ConnectTo(name string, x context.ContextAware) {
+	assert.For(x != nil, 20)
+	assert.For(name != context.UNIVERSE, 21)
+	if d.list == nil {
+		d.list = make(map[string]context.ContextAware)
+	}
+	assert.For(d.list[name] == nil, 40)
+	x.Init(d)
+	d.list[name] = x
+}
+
+func (d *stdDomain) Discover(name string) (ret context.ContextAware) {
+	assert.For(name != "", 20)
+	if d.list != nil {
+		ret = d.list[name]
+	}
+	if name == context.UNIVERSE {
+		ret = d.global
+	}
+	return ret
+}
+
+func (d *stdDomain) Domain() context.Domain {
+	return d.parent
+}
+
+func (d *stdDomain) Init(dd context.Domain) {
+	glob := dd.(*stdDomain).global
+	assert.For(glob == nil, 20) //допустим только один уровень вложенности доменов пока
+	d.parent = dd
+	if dd.(*stdDomain).global == nil {
+		d.global = dd
+	} else {
+		d.global = glob
+	}
+}
+
+func (d *stdDomain) Id(c context.ContextAware) (ret string) {
+	for k, v := range d.list {
+		if v == c {
+			ret = k
+			break //стыд-то какой
+		}
+	}
+	return ret
+}

fw/fw.go

@@ -2,36 +2,34 @@ package main
 
 import (
 	"fmt"
-	"os"
 	"rt2/context"
 	"rt2/frame"
+	"rt2/module"
 	"rt2/nodeframe"
 	_ "rt2/rules"
-	"xev"
+	"rt2/scope"
 	"ypk/assert"
 )
 
-type stdDomain struct {
-}
-
-func (d *stdDomain) ConnectTo(x context.ContextAware) {
-	assert.For(x != nil, 20)
-	x.Init(d)
-}
-
 func main() {
-	path, _ := os.Getwd()
-	ret := xev.Load(path, "PrivDemo1.oxf")
-	assert.For(ret != nil, 20)
-	domain := new(stdDomain)
-	root := frame.NewRoot()
-	domain.ConnectTo(root)
-	var fu nodeframe.FrameUtils
-	root.Push(fu.New(ret.Enter))
-	i := 0
-	for x := frame.DO; x == frame.DO; x = root.Do() {
-		fmt.Println(x)
-		i++
+	global := new(stdDomain)
+	modList := module.New()
+	global.ConnectTo(context.MOD, modList)
+	ret, err := modList.Load("PrivDemo1")
+	assert.For(err == nil, 20)
+	{
+		domain := new(stdDomain)
+		global.ConnectTo("PrivDemo1", 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))
+		i := 0
+		for x := frame.DO; x == frame.DO; x = root.Do() {
+			fmt.Println(x)
+			i++
+		}
+		fmt.Println("total steps", i)
 	}
-	fmt.Println("total steps", i)
 }

rt2/context/ctx.go

@@ -1,7 +1,17 @@
 package context
 
+const (
+	STACK    = "rt2/frame"
+	SCOPE    = "rt2/scope"
+	MOD      = "rt2/module"
+	UNIVERSE = "rt2/ctx"
+)
+
 type Domain interface {
-	ConnectTo(c ContextAware)
+	ConnectTo(name string, c ContextAware)
+	Discover(name string) ContextAware
+	Id(c ContextAware) string
+	ContextAware
 }
 
 type ContextAware interface {

rt2/module/ml.go

@@ -0,0 +1,71 @@
+package module
+
+import (
+	mod "cp/module"
+	"os"
+	"rt2/context"
+	"xev"
+	"ypk/assert"
+)
+
+type List interface {
+	context.ContextAware
+	AsList() []*mod.Module
+	Load(name string) (*mod.Module, error)
+	Loaded(name string) *mod.Module
+}
+
+func New() List {
+	return new(list).init()
+}
+
+type list struct {
+	inner map[string]*mod.Module
+	d     context.Domain
+}
+
+func (l *list) init() *list {
+	l.inner = make(map[string]*mod.Module)
+	return l
+}
+
+func (l *list) AsList() (ret []*mod.Module) {
+	if len(l.inner) > 0 {
+		ret = make([]*mod.Module, 0)
+	}
+	for _, v := range l.inner {
+		ret = append(ret, v)
+	}
+	return ret
+}
+
+func (l *list) Domain() context.Domain {
+	return l.d
+}
+
+func (l *list) Init(d context.Domain) {
+	l.d = d
+}
+
+func (l *list) Load(name string) (*mod.Module, error) {
+	assert.For(name != "", 20)
+	ret := l.Loaded(name)
+	if ret == nil {
+		path, _ := os.Getwd()
+		ret = xev.Load(path, name+".oxf")
+		l.inner[name] = ret
+	}
+	return ret, nil
+}
+
+func (l *list) Loaded(name string) *mod.Module {
+	assert.For(name != "", 20)
+	return l.inner[name]
+}
+
+func DomainModule(d context.Domain) *mod.Module {
+	uni := d.Discover(context.UNIVERSE).(context.Domain)
+	name := uni.Id(d)
+	ml := uni.Discover(context.MOD).(List)
+	return ml.Loaded(name)
+}

rt2/rules/call.go

@@ -3,6 +3,7 @@ package rules
 import (
 	"cp/node"
 	"rt2/frame"
+	mod "rt2/module"
 	"rt2/nodeframe"
 )
 
@@ -11,13 +12,13 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := fu.NodeOf(f)
 	switch n.Left().(type) {
 	case node.ProcedureNode:
-		//proc := f.p.thisMod.NodeByObject(f.ir.Left().Object())
-		//f.Root().Push(fu.New(?))
+		m := mod.DomainModule(f.Domain())
+		proc := m.NodeByObject(n.Left().Object())
+		f.Root().Push(fu.New(proc))
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return frame.End()
 		}
-		ret = frame.STOP
-		seq = nil //frame.SKIP //uncomment when truly work
+		ret = frame.SKIP
 	default:
 		panic("unknown call left")
 	}

rt2/rules/table.go

@@ -5,9 +5,11 @@ import (
 	"cp/node"
 	"fmt"
 	"reflect"
+	"rt2/context"
 	"rt2/decision"
 	"rt2/frame"
 	"rt2/nodeframe"
+	"rt2/scope"
 	"ypk/assert"
 )
 
@@ -19,6 +21,8 @@ func prologue(n node.Node) frame.Sequence {
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			node := fu.NodeOf(f).Right()
 			assert.For(node != nil, 40)
+			sm := scope.This(f.Domain().Discover(context.SCOPE))
+			sm.Allocate(n)
 			f.Root().Push(fu.New(node))
 			return frame.Tail(frame.STOP), frame.SKIP
 		}
@@ -44,7 +48,13 @@ func epilogue(n node.Node) frame.Sequence {
 			}
 			return frame.End()
 		}
-	case node.OperationNode, node.EnterNode:
+	case node.EnterNode:
+		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+			sm := scope.This(f.Domain().Discover(context.SCOPE))
+			sm.Dispose(n)
+			return frame.End()
+		}
+	case node.OperationNode:
 		return nil //do nothing
 	default:
 		fmt.Println(reflect.TypeOf(n))

rt2/scope/area.go

@@ -0,0 +1,24 @@
+package scope
+
+import (
+	"cp/node"
+	"cp/object"
+	"rt2/context"
+)
+
+//менеджер зон видимости
+type Manager interface {
+	context.ContextAware
+	Calculate(n node.Node) Area
+	Allocate(n node.Node)
+	Dispose(n node.Node)
+}
+
+//зона видимости
+type Area interface {
+	Get(o object.Object) Object
+	Set(o Object)
+}
+
+//объект зоны видимости
+type Object interface{}

rt2/scope/stdScope.go

@@ -0,0 +1,47 @@
+package scope
+
+import (
+	"cp/node"
+	"fmt"
+	"rt2/context"
+	rt_mod "rt2/module"
+	"ypk/assert"
+)
+
+func This(i interface{}) Manager {
+	assert.For(i != nil, 20)
+	return i.(Manager)
+}
+
+func New() Manager {
+	return new(manager).init()
+}
+
+type manager struct {
+	d context.Domain
+}
+
+func (m *manager) init() *manager {
+	return m
+}
+
+func (m *manager) Allocate(n node.Node) {
+	mod := rt_mod.DomainModule(m.Domain())
+	fmt.Println("allocate", len(mod.Objects[n]), "obj")
+}
+
+func (m *manager) Dispose(n node.Node) {
+	fmt.Println("dispose")
+}
+
+func (m *manager) Calculate(n node.Node) Area {
+	return nil
+}
+
+func (m *manager) Init(d context.Domain) {
+	m.d = d
+}
+
+func (m *manager) Domain() context.Domain {
+	return m.d
+}