попытка сделать лог со скрытой реализацией

cp/module/module.go

@@ -25,28 +25,26 @@ type named interface {
 	Name() string
 }
 
-func (m *Module) ObjectByName(scope node.Node, name string) (ret object.Object) {
+func (m *Module) ObjectByName(scope node.Node, name string) (rl []object.Object) {
 	assert.For(name != "", 20)
-	find := func(v []object.Object) object.Object {
+	find := func(v []object.Object) (ret []object.Object) {
 		for _, o := range v {
 			if o.Name() == name {
-				return o
+				ret = append(ret, o)
 			}
+			//fmt.Println(o.Name(), name, o.Name() == name)
 		}
-		return nil
+		return ret
 	}
 	if scope == nil {
 		for _, v := range m.Objects {
-			ret = find(v)
-			if ret != nil {
-				break
-			}
+			rl = append(rl, find(v)...)
 		}
 	} else {
-		ret = find(m.Objects[scope])
+		rl = find(m.Objects[scope])
 	}
 
-	return ret
+	return rl
 }
 
 func (m *Module) TypeByName(scope node.Node, name string) (ret object.ComplexType) {

cp/object/object.go

@@ -2,6 +2,7 @@ package object
 
 import (
 	"fw/cp"
+	"strconv"
 	"ypk/assert"
 )
 
@@ -20,6 +21,33 @@ const (
 	MODULE
 )
 
+func (m Mode) String() string {
+	switch m {
+	case HEAD:
+		return "HEAD"
+	case VARIABLE:
+		return "VARIABLE"
+	case LOCAL_PROC:
+		return "LOCAL PROCEDURE"
+	case EXTERNAL_PROC:
+		return "EXTERNAL PROCEDURE"
+	case TYPE_PROC:
+		return "METHOD"
+	case CONSTANT:
+		return "CONSTANT"
+	case PARAMETER:
+		return "PARAMETER"
+	case FIELD:
+		return "FIELD"
+	case TYPE:
+		return "TYPE"
+	case MODULE:
+		return "MODULE"
+	default:
+		return strconv.Itoa(int(m))
+	}
+}
+
 type Object interface {
 	SetName(name string)
 	SetType(typ Type)
@@ -32,6 +60,7 @@ type Object interface {
 	SetRef(n Ref)
 	Ref() []Ref
 	cp.Id
+	Mode(...Mode) Mode
 }
 
 type Ref interface {
@@ -98,6 +127,7 @@ func New(mode Mode, id int) (ret Object) {
 	default:
 		panic("no such object mode")
 	}
+	ret.Mode(mode)
 	ret.Adr(id)
 	return ret
 }
@@ -109,6 +139,7 @@ type objectFields struct {
 	comp ComplexType
 	ref  []Ref
 	adr  cp.ID
+	mod  Mode
 }
 
 func (of *objectFields) SetType(typ Type)         { of.typ = typ }
@@ -128,6 +159,14 @@ func (of *objectFields) Adr(a ...int) cp.ID {
 	return of.adr
 }
 
+func (of *objectFields) Mode(a ...Mode) Mode {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		of.mod = a[0]
+	}
+	return of.mod
+}
+
 func (of *objectFields) SetRef(n Ref) {
 	assert.For(n != nil, 20)
 	exists := func() bool {

fw.go

@@ -33,7 +33,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevTest0"
+		name = "XevInit"
 	}
 	global := &stdDomain{god: true}
 	global.global = global

fw_test_all.bat

@@ -23,4 +23,5 @@ start fw_test XevDemo20
 start fw_test XevDemo21
 start fw_test XevDemo22
 
-start fw_test XevTest0
+start fw_test XevTest0
+start fw_test XevInit

rt2/rules/call.go

@@ -161,16 +161,60 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			seq = Propose(Tail(STOP))
 			ret = frame.NOW
 		} else {
-			if imp := m.ImportOf(n.Left().Object()); imp == "" {
-				proc := m.NodeByObject(n.Left().Object())
+			if imp := m.ImportOf(n.Left().Object()); imp == "" || imp == m.Name {
+				switch p.Object().Mode() {
+				case object.LOCAL_PROC, object.EXTERNAL_PROC:
+					proc := m.NodeByObject(n.Left().Object())
+					call(proc[0], nil)
+				case object.TYPE_PROC:
+					sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+					var fn object.ProcedureObject
+					var dm context.Domain
+					sc.Select(n.Right().Object().Adr(), func(v scope.Value) {
+						_, c := scope.Ops.TypeOf(v)
+						mod := rtm.ModuleOfType(f.Domain(), c)
+						dm = f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(mod.Name).(context.Domain)
+						ol := mod.Objects[mod.Enter]
+						for _, _po := range ol {
+							switch po := _po.(type) {
+							case object.ProcedureObject:
+								if po.Name() == p.Object().Name() && po.Link().Complex() == c {
+									fn = po
+								}
+
+							}
+						}
+					})
+					assert.For(fn != nil, 40)
+					proc := m.NodeByObject(fn)
+					call(proc[0], nil)
+					panic(0)
+				default:
+					halt.As(100, "wrong proc mode ", p.Object().Mode())
+				}
+
 				//fmt.Println(len(proc), len(n.Left().Object().Ref()))
-				call(proc[0], nil)
+				//fmt.Println("proc refs", proc)
+
 			} else {
 				m := ml.Loaded(imp)
-				proc := m.ObjectByName(m.Enter, n.Left().Object().Name())
-				nl := m.NodeByObject(proc)
-				utils.PrintFrame("foreign call", len(nl))
-				call(nl[0], f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(imp).(context.Domain))
+				pl := m.ObjectByName(m.Enter, n.Left().Object().Name())
+				var proc object.ProcedureObject
+				var nl []node.Node
+				for _, n := range pl {
+					if n.Mode() == p.Object().Mode() {
+						proc = n.(object.ProcedureObject)
+					}
+				}
+				//utils.PrintFrame("proc refs", len(proc))
+				switch proc.Mode() {
+				case object.LOCAL_PROC, object.EXTERNAL_PROC:
+					nl = m.NodeByObject(proc)
+					utils.PrintFrame("foreign call", len(nl), "proc refs", proc)
+					call(nl[0], f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(imp).(context.Domain))
+				default:
+					halt.As(100, "wrong proc mode ", p.Object().Mode())
+				}
 			}
 		}
 	case node.VariableNode:

rt2/scope/data.go

@@ -34,6 +34,7 @@ type Operations interface {
 	Is(Value, object.ComplexType) Value
 	Conv(Value, object.Type, ...object.ComplexType) Value
 	Len(object.Object, Value, Value) Value
+	TypeOf(Value) (object.Type, object.ComplexType)
 }
 
 type Value interface {

rt2/scope/modern/val.go

@@ -1377,6 +1377,18 @@ func (o *ops) Geq(a, b scope.Value) scope.Value {
 	panic(0)
 }
 
+func (o *ops) TypeOf(x scope.Value) (object.Type, object.ComplexType) {
+	switch v := x.(type) {
+	case *ptr:
+		if v.val != nil {
+			return v.val.link.Type(), v.val.link.Complex()
+		}
+	default:
+		halt.As(100, reflect.TypeOf(v))
+	}
+	return object.NOTYPE, nil
+}
+
 func init() {
 	scope.ValueFrom = vfrom
 	scope.GoTypeFrom = gfrom

utils/debug.go

@@ -2,7 +2,7 @@ package utils
 
 import "fmt"
 
-var debugFrame = false
+var debugFrame = true
 var debugScope = false
 var debugTrap = true