добавил возможность динамической загрузки модулей

fw.go

@@ -3,10 +3,10 @@ package main
 import (
 	"flag"
 	"fmt"
-	mod "fw/cp/module"
+	cpm "fw/cp/module"
 	"fw/rt2/context"
 	"fw/rt2/decision"
-	rtmod "fw/rt2/module"
+	rtm "fw/rt2/module"
 	_ "fw/rt2/rules"
 	"fw/rt2/scope"
 	_ "fw/rt2/scope/modern"
@@ -37,13 +37,13 @@ func main() {
 	}
 	global := &stdDomain{god: true}
 	global.global = global
-	modList := rtmod.New()
+	modList := rtm.New()
 	global.Attach(context.MOD, modList)
 	heap = scope.New(context.HEAP)
 	global.Attach(context.HEAP, heap)
 	t0 := time.Now()
-	var init []*mod.Module
-	_, err := modList.Load(name, func(m *mod.Module) {
+	var init []*cpm.Module
+	_, err := modList.Load(name, func(m *cpm.Module) {
 		init = append(init, m)
 	})
 	t1 := time.Now()

rt2/context/ctx.go

@@ -6,6 +6,7 @@ const (
 	MOD      = "fw/rt2/module"
 	UNIVERSE = "fw/rt2/ctx"
 	HEAP     = "fw/rt2/scope,heap"
+	MT       = "fw/rt2/table,flow"
 )
 
 type Factory interface {

rt2/rules/call.go

@@ -5,12 +5,13 @@ import (
 	"fmt"
 	"fw/cp"
 	"fw/cp/constant"
+	cpm "fw/cp/module"
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
-	rt_mod "fw/rt2/module"
+	rtm "fw/rt2/module"
 	"fw/rt2/scope"
 	"fw/utils"
 	"reflect"
@@ -30,8 +31,9 @@ import (
 var sys map[string]func(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT)
 
 type Msg struct {
-	Type string
-	Data string
+	Type    string
+	Command string
+	Data    string
 }
 
 func callHandler(f frame.Frame, obj object.Object, data interface{}) {
@@ -40,7 +42,7 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 	if obj == nil {
 		return
 	}
-	m := rt_mod.DomainModule(f.Domain())
+	m := rtm.DomainModule(f.Domain())
 	cn := node.New(constant.CALL, int(cp.SomeAdr()))
 	ol := m.NodeByObject(obj)
 	assert.For(len(ol) <= 1, 40)
@@ -63,6 +65,20 @@ func process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
 				case "log":
 					fmt.Print(msg.Data)
 					callHandler(f, scope.FindObjByName(sm, "go_handler"), `{"type":"log"}`)
+				case "core":
+					switch msg.Command {
+					case "load":
+						fmt.Println("try to load", msg.Data)
+						glob := f.Domain().Discover(context.UNIVERSE).(context.Domain)
+						modList := glob.Discover(context.MOD).(rtm.List)
+						fl := glob.Discover(context.MT).(*flow)
+						_, err := modList.Load(msg.Data, func(m *cpm.Module) {
+							fl.grow(glob, m)
+						})
+						assert.For(err == nil, 60)
+					default:
+						halt.As(100, msg.Command)
+					}
 				default:
 					panic(40)
 				}
@@ -138,8 +154,8 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case node.EnterNode:
 		call(p, nil)
 	case node.ProcedureNode:
-		m := rt_mod.DomainModule(f.Domain())
-		ml := f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(context.MOD).(rt_mod.List)
+		m := rtm.DomainModule(f.Domain())
+		ml := f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(context.MOD).(rtm.List)
 		if p.Super() {
 			fmt.Println("supercall, stop for now")
 			seq = Propose(Tail(STOP))
@@ -158,7 +174,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 		}
 	case node.VariableNode:
-		m := rt_mod.DomainModule(f.Domain())
+		m := rtm.DomainModule(f.Domain())
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 		obj := scope.GoTypeFrom(sc.Select(n.Left().Object().Adr()))
 

rt2/rules/table.go

@@ -217,26 +217,26 @@ func (f *flow) Handle(msg interface{}) {
 	assert.For(msg != nil, 20)
 }
 
+func (f *flow) grow(global context.Domain, m *module.Module) {
+	utils.PrintScope("queue", m.Name)
+	nf := rt2.New(m.Enter)
+	f.root.PushFor(nf, nil)
+	f.fl = append(f.fl, nf)
+	global.Attach(m.Name, nf.Domain())
+}
+
 func run(global context.Domain, init []*module.Module) {
 	{
-		var (
-			root *std.RootFrame = std.NewRoot()
-			nf   frame.Frame
-			ff   []frame.Frame
-		)
-		global.Attach(context.STACK, root)
+		fl := &flow{root: std.NewRoot()}
+		global.Attach(context.STACK, fl.root.(context.ContextAware))
+		global.Attach(context.MT, fl)
 		for i := len(init) - 1; i >= 0; i-- {
-			ret := init[i]
-			utils.PrintScope("queue", ret.Name)
-			nf = rt2.New(ret.Enter)
-			root.PushFor(nf, nil)
-			ff = append(ff, nf)
-			global.Attach(ret.Name, nf.Domain())
+			fl.grow(global, init[i])
 		}
-		root.PushFor(&flow{fl: ff}, nil)
+		fl.root.PushFor(fl, nil)
 		i := 0
 		t0 := time.Now()
-		for x := frame.NOW; x == frame.NOW; x = root.Do() {
+		for x := frame.NOW; x == frame.NOW; x = fl.root.(frame.Frame).Do() {
 			utils.PrintFrame("STEP", i)
 			//assert.For(i < 1000, 40)
 			i++