разобрался с вызовом методов и обращением к полям из записей-предков, а так же к полям других модулей

cp/module/module.go

@@ -109,7 +109,7 @@ func (m *Module) NodeByObject(obj object.Object) (ret []node.Node) {
 	return ret
 }
 
-func (m *Module) Init(inittd func(t object.ComplexType)) {
+func (m *Module) Init(inittd ...func(t object.ComplexType)) {
 	typeName := func(id cp.ID) string {
 		for _, s := range m.Objects {
 			for _, o := range s {
@@ -157,11 +157,14 @@ func (m *Module) Init(inittd func(t object.ComplexType)) {
 		for _, t := range s.Types {
 			t.Qualident(q + "." + typeName(t.Adr()))
 		}
+		for _, o := range s.Objects {
+			o.Imp(s.Name)
+		}
 	}
-	if inittd != nil {
+	if len(inittd) > 0 {
 		for _, s := range m.Types {
 			for _, t := range s {
-				inittd(t)
+				inittd[0](t)
 			}
 		}
 	}

cp/object/comp.go

@@ -46,8 +46,7 @@ func (a *rec) Equals(x ComplexType) bool {
 	case *rec:
 		//fmt.Println("rec:rec")
 		return a.Qualident() == b.Qualident()
-	case *ptr:
-		//fmt.Println("rec:ptr")
+	case *ptr, nil, *dyn:
 		return false
 	default:
 		halt.As(100, reflect.TypeOf(b))
@@ -61,10 +60,7 @@ func (a *ptr) Equals(x ComplexType) bool {
 		//fmt.Println("ptr:ptr")
 		//fmt.Println("pointer comp", a.Name(), ":", a.Qualident(), ",", b.Name(), ":", b.Qualident())
 		return a.Qualident() == b.Qualident()
-	case *rec:
-		//fmt.Println("ptr:rec")
-		return false
-	case nil:
+	case nil, *rec, *dyn:
 		return false
 	default:
 		halt.As(100, reflect.TypeOf(b))

cp/object/object.go

@@ -59,6 +59,7 @@ type Object interface {
 	Name() string
 	SetRef(n Ref)
 	Ref() []Ref
+	Imp(...string) string
 	cp.Id
 	Mode(...Mode) Mode
 }
@@ -140,6 +141,7 @@ type objectFields struct {
 	ref  []Ref
 	adr  cp.ID
 	mod  Mode
+	imp  string
 }
 
 func (of *objectFields) SetType(typ Type)         { of.typ = typ }
@@ -152,13 +154,23 @@ func (of *objectFields) SetComplex(t ComplexType) { of.comp = t }
 func (of *objectFields) Complex() ComplexType     { return of.comp }
 
 func (of *objectFields) Adr(a ...cp.ID) cp.ID {
-	assert.For(len(a) <= 1, 20)
+	assert.For(len(a) <= 2, 20)
 	if len(a) == 1 {
 		of.adr = a[0]
+	} else if len(a) == 0 && of.imp != "" {
+		panic(123)
 	}
 	return of.adr
 }
 
+func (of *objectFields) Imp(a ...string) string {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		of.imp = a[0]
+	}
+	return of.imp
+}
+
 func (of *objectFields) Mode(a ...Mode) Mode {
 	assert.For(len(a) <= 1, 20)
 	if len(a) == 1 {

cp/object/type.go

@@ -128,8 +128,8 @@ type DynArrayType interface {
 type RecordType interface {
 	ComplexType
 	BaseName() string
-	Base() RecordType
-	SetBase(ComplexType)
+	BaseRec() RecordType
+	Base(t ...ComplexType) ComplexType
 	Name() string
 }
 
@@ -209,9 +209,12 @@ func NewRecordType(n string, id int, par ...string) (ret RecordType) {
 	return ret
 }
 
-func (r *rec) Base() RecordType { return r.basetyp }
-func (r *rec) SetBase(t ComplexType) {
-	r.basetyp = t.(RecordType)
+func (r *rec) BaseRec() RecordType { return r.basetyp }
+func (r *rec) Base(t ...ComplexType) ComplexType {
+	if len(t) == 1 {
+		r.basetyp = t[0].(RecordType)
+	}
+	return r.basetyp
 }
 
 type ptr struct {

fw.go

@@ -34,7 +34,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "Start3"
+		name = "Start"
 		utils.Debug(false)
 	}
 	global := &stdDomain{god: true}

rt2/module/ml.go

@@ -74,52 +74,7 @@ func (l *list) Load(name string, ldr ...Loader) (ret *mod.Module, err error) {
 			_, err = l.Load(imp.Name, loader)
 		}
 		if err == nil {
-			ret.Init(func(t object.ComplexType) {
-				var base func(t object.ComplexType)
-				base = func(t object.ComplexType) {
-					switch i := t.(type) {
-					case object.PointerType:
-						if i.Base() != nil {
-							fmt.Print(i.Base().Qualident(), "(")
-							base(i.Base())
-							fmt.Print(")")
-						} else {
-							/*for _, n := range ret.Imports {
-								for _, _it := range n.Objects {
-									switch it := _it.(type) {
-									case object.TypeObject:
-										if it.Complex().Adr() == i.Adr() {
-											fmt.Print(it.Complex().Qualident(), "(")
-											fmt.Print(")")
-										}
-									}
-								}
-							}*/
-						}
-					case object.RecordType:
-						if i.Base() != nil {
-							fmt.Print(i.Base().Qualident(), "(")
-							base(i.Base())
-							fmt.Print(")")
-						} else {
-							/*for _, n := range ret.Imports {
-								for _, _it := range n.Objects {
-									switch it := _it.(type) {
-									case object.TypeObject:
-										if it.Complex().Adr() == i.Adr() {
-											fmt.Print(it.Complex().Qualident(), "(")
-											fmt.Print(")")
-										}
-									}
-								}
-							}*/
-						}
-					}
-				}
-				fmt.Print(t.Qualident(), "(")
-				base(t)
-				fmt.Println(")")
-			})
+			ret.Init()
 			l.inner[name] = ret
 			loader(ret)
 			//fmt.Println("loaded", name)
@@ -137,6 +92,16 @@ func (l *list) NewTypeCalc() TypeCalc {
 	return &tc{ml: l}
 }
 
+func ModuleDomain(d context.Domain, name string) context.Domain {
+	uni := d.Discover(context.UNIVERSE).(context.Domain)
+	return uni.Discover(name).(context.Domain)
+}
+
+func Module(d context.Domain, name string) *mod.Module {
+	uni := d.Discover(context.UNIVERSE).(context.Domain)
+	return uni.Discover(context.MOD).(List).Loaded(name)
+}
+
 func DomainModule(d context.Domain) *mod.Module {
 	uni := d.Discover(context.UNIVERSE).(context.Domain)
 	name := uni.Id(d)
@@ -159,6 +124,7 @@ func ModuleOfNode(d context.Domain, x node.Node) *mod.Module {
 }
 
 func ModuleOfObject(d context.Domain, x object.Object) *mod.Module {
+	assert.For(x != nil, 20)
 	uni := d.Discover(context.UNIVERSE).(context.Domain)
 	ml := uni.Discover(context.MOD).(List)
 	for _, m := range ml.AsList() {
@@ -169,6 +135,13 @@ func ModuleOfObject(d context.Domain, x object.Object) *mod.Module {
 				}
 			}
 		}
+		for _, i := range m.Imports {
+			for _, o := range i.Objects {
+				if o == x {
+					return m
+				}
+			}
+		}
 	}
 	return nil
 }
@@ -200,9 +173,28 @@ func MapImportType(d context.Domain, imp string, t object.ComplexType) object.Co
 	return nil
 }
 
+func MapImportObject(d context.Domain, t object.Object) object.Object {
+	if t.Imp() == "" {
+		return t
+	}
+	imp := t.Imp()
+	uni := d.Discover(context.UNIVERSE).(context.Domain)
+	ml := uni.Discover(context.MOD).(List)
+	m := ml.Loaded(imp)
+	for _, v := range m.Objects[m.Enter] {
+		if v.Name() == t.Name() {
+			if v.Type() == t.Type() {
+				return v
+			}
+		}
+	}
+	panic(0)
+}
+
 type TypeCalc interface {
 	ConnectTo(interface{})
-	MethodList() map[int]Method
+	MethodList() map[int][]Method
+	ForeignBase() (*mod.Module, object.ComplexType)
 }
 
 type Method struct {
@@ -235,32 +227,42 @@ func (c *tc) ConnectTo(x interface{}) {
 	assert.For(c.m != nil, 60)
 }
 
-func (c *tc) MethodList() (ret map[int]Method) {
-	ret = make(map[int]Method, 0)
-	//depth := 0
+func (c *tc) MethodList() (ret map[int][]Method) {
+	ret = make(map[int][]Method, 0)
+	tmp := make(map[string]object.Object, 0)
+	depth := -1
 	var deep func(*mod.Module, object.ComplexType)
 	list := func(m *mod.Module, t object.ComplexType) {
-		ol := m.Objects[c.m.Enter]
+		ol := m.Objects[m.Enter]
 		for _, _po := range ol {
 			switch po := _po.(type) {
 			case object.ProcedureObject:
+				var et node.EnterNode
 				proc := m.NodeByObject(po)
-				//local := false
+				local := false
 				for i := range proc {
-					if _, ok := proc[i].(node.EnterNode); ok {
-						//local = true
+					if e, ok := proc[i].(node.EnterNode); ok {
+						local = true
+						et = e
 					}
 				}
-				if po.Link() != nil {
-					pt := po.Link().Complex()
-					var pb object.ComplexType
-					if _, ok := pt.(inherited); ok {
-						pb = pt.(inherited).Base()
-					}
-					if t.Equals(pt) || t.Equals(pb) {
-						fmt.Println(po.Name())
+				if local && po.Link() != nil {
+					for pt := po.Link().Complex(); pt != nil; {
+						if t.Equals(pt) && tmp[po.Name()] == nil {
+							//fmt.Println("method", m.Name, po.Name(), local)
+							tmp[po.Name()] = po
+							ret[depth] = append(ret[depth], Method{Enter: et, Obj: po, Mod: m})
+							break
+						}
+						if _, ok := pt.(inherited); ok {
+							pt = pt.(inherited).Base()
+						} else {
+							pt = nil
+						}
+
 					}
 				}
+
 			}
 		}
 	}
@@ -279,33 +281,39 @@ func (c *tc) MethodList() (ret map[int]Method) {
 		}
 	}
 	deep = func(m *mod.Module, x object.ComplexType) {
+		depth++
+		tmp = make(map[string]object.Object, 0)
 		for t := x; t != nil; {
 			list(m, t)
-			switch z := t.(type) {
-			case object.PointerType:
-				if z.Base() != nil {
-					t = z.Base()
-				} else {
-					foreign(t)
-					t = nil
-				}
-			case object.RecordType:
-				if z.Base() != nil {
-					t = z.Base()
-				} else {
-					foreign(t)
-					t = nil
-				}
-			default:
-				halt.As(0, reflect.TypeOf(t))
+			z := t.(inherited).Base()
+			if z != nil {
+				t = z
+			} else {
+				foreign(t)
+				t = nil
 			}
 		}
-		return
 	}
 	deep(c.m, c.typ)
 	return
 }
 
+func (c *tc) ForeignBase() (*mod.Module, object.ComplexType) {
+	for _, n := range c.m.Imports {
+		for _, _it := range n.Objects {
+			switch it := _it.(type) {
+			case object.TypeObject:
+				if it.Complex().Adr() == c.typ.Adr() {
+					nm := c.ml.Loaded(n.Name)
+					nt := nm.TypeByName(nm.Enter, it.Name())
+					return nm, nt
+				}
+			}
+		}
+	}
+	return nil, nil
+}
+
 func (c *tc) String() (ret string) {
 	foreign := func(t object.ComplexType) {
 		for _, n := range c.m.Imports {

rt2/nodeframe/frame.go

@@ -23,7 +23,7 @@ func (fu NodeFrameUtils) New(n node.Node) (f frame.Frame) {
 	f.(*nodeFrame).ir = n
 	f.(*nodeFrame).data = make(map[interface{}]interface{})
 	f.(*nodeFrame).value = make(map[cp.ID]scope.Value)
-	utils.PrintFrame("_", "NEW", reflect.TypeOf(n))
+	utils.PrintFrame("_", "NEW", reflect.TypeOf(n), n.Adr())
 	return f
 }
 

rt2/rules/call.go

@@ -74,9 +74,13 @@ func go_process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
 						glob := f.Domain().Discover(context.UNIVERSE).(context.Domain)
 						modList := glob.Discover(context.MOD).(rtm.List)
 						fl := glob.Discover(context.MT).(*flow)
+						ml := make([]*cpm.Module, 0)
 						_, err := modList.Load(msg.Data, func(m *cpm.Module) {
-							fl.grow(glob, m)
+							ml = append(ml, m)
 						})
+						for i := len(ml) - 1; i >= 0; i-- {
+							fl.grow(glob, ml[i])
+						}
 						assert.For(err == nil, 60)
 					default:
 						halt.As(100, msg.Command)
@@ -182,7 +186,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			if f.Parent() != nil {
-				rt2.ValueOf(f.Parent())[n.Adr()] = rt2.ValueOf(f)[n.Left().Object().Adr()]
+				rt2.ValueOf(f.Parent())[n.Adr()] = rt2.ValueOf(f)[n.Left().Object().Adr(0, 0)]
 			}
 			return frame.End()
 		}
@@ -200,77 +204,59 @@ 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 == "" || imp == m.Name {
-				switch p.Object().Mode() {
-				case object.LOCAL_PROC, object.EXTERNAL_PROC:
+			switch p.Object().Mode() {
+			case object.LOCAL_PROC, object.EXTERNAL_PROC:
+				if imp := m.ImportOf(n.Left().Object()); imp == "" || imp == m.Name {
 					proc := m.NodeByObject(n.Left().Object())
 					assert.For(proc != nil, 40)
 					call(proc[0], nil)
-				case object.TYPE_PROC:
-					//sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-					return This(expectExpr(f, n.Right(), func(...IN) (out OUT) {
-						var proc []node.Node
-						v := rt2.ValueOf(f)[n.Right().Adr()]
-						_, c := scope.Ops.TypeOf(v)
-
-						var dm context.Domain
-						var fn object.ProcedureObject
-						//fmt.Println(c.Qualident())
-						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() {
-									if po.Link() != nil && po.Link().Complex().Equals(c) {
-										fn = po
-									} else if po.Link() != nil {
-									}
-								}
-							}
+				} else {
+					m := ml.Loaded(imp)
+					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)
 						}
-						if fn == nil {
-							x := ml.NewTypeCalc()
-							x.ConnectTo(c)
-							fmt.Println(x)
-							x.MethodList()
-						}
-						assert.For(fn != nil, 40, p.Object().Name())
-						proc = mod.NodeByObject(fn)
-						assert.For(proc != nil, 40)
-						call(proc[0], dm)
-						out.do = Tail(STOP)
-						out.next = LATER
-						return out
-					}))
 
-				default:
-					halt.As(100, "wrong proc mode ", p.Object().Mode())
-				}
-
-				//fmt.Println(len(proc), len(n.Left().Object().Ref()))
-				//fmt.Println("proc refs", proc)
-
-			} else {
-				m := ml.Loaded(imp)
-				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 object.TYPE_PROC:
+				//sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				return This(expectExpr(f, n.Right(), func(...IN) (out OUT) {
+					var (
+						proc []node.Node
+						dm   context.Domain
+					)
+					v := rt2.ValueOf(f)[n.Right().Adr()]
+					_, c := scope.Ops.TypeOf(v)
+					x := ml.NewTypeCalc()
+					x.ConnectTo(c)
+					for _, ml := range x.MethodList() {
+						for _, m := range ml {
+							if m.Obj.Name() == p.Object().Name() {
+								proc = append(proc, m.Enter)
+								dm = f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(m.Mod.Name).(context.Domain)
+								break
+							}
+						}
+						if len(proc) > 0 {
+							break
+						}
+					}
+					assert.For(len(proc) > 0, 40, p.Object().Name())
+					call(proc[0], dm)
+					out.do = Tail(STOP)
+					out.next = LATER
+					return out
+				}))
+
+			default:
+				halt.As(100, "wrong proc mode ", p.Object().Mode(), p.Object().Adr(), p.Object().Name())
 			}
 		}
 	case node.VariableNode:

rt2/rules/enter.go

@@ -1,6 +1,7 @@
 package rules
 
 import (
+	"fmt"
 	"fw/cp/node"
 	"fw/rt2"
 	"fw/rt2/context"
@@ -27,7 +28,7 @@ func enterSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		} else {
 			//Особый случай, вход в модуль, секция BEGIN
 			rt2.Push(rt2.New(body), f)
-			utils.PrintFrame("begin", module.DomainModule(f.Domain()).Name)
+			fmt.Println("begin", module.DomainModule(f.Domain()).Name)
 			//Выход из модуля, секция CLOSE
 			next := n.Link()
 			if next != nil {

rt2/rules/expect.go

@@ -3,8 +3,11 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/cp/object"
 	"fw/rt2"
+	"fw/rt2/context"
 	"fw/rt2/frame"
+	rtm "fw/rt2/module"
 	"fw/rt2/scope"
 	"reflect"
 	"ypk/assert"
@@ -20,9 +23,29 @@ func expectExpr(parent frame.Frame, expr node.Node, next Do) OUT {
 		rt2.ValueOf(parent)[expr.Adr()] = sm.Provide(e)(nil)
 		return OUT{do: next, next: NOW}
 	case node.VariableNode, node.ParameterNode:
-		rt2.ValueOf(parent)[expr.Adr()] = sm.Select(expr.Object().Adr())
+		m := rtm.ModuleOfObject(parent.Domain(), expr.Object())
+		assert.For(m != nil, 40)
+		imp := m.ImportOf(expr.Object())
+		if imp != "" {
+			md := rtm.ModuleDomain(parent.Domain(), imp)
+			sm = md.Discover(context.SCOPE).(scope.Manager)
+			fm := rtm.Module(parent.Domain(), imp)
+			ol := fm.ObjectByName(fm.Enter, expr.Object().Name())
+			for _, obj := range ol {
+				fmt.Println(obj.Adr())
+			}
+			for _, obj := range ol {
+				if _, ok := obj.(object.VariableObject); ok {
+					fmt.Println(m.Name, sm, imp)
+					rt2.ValueOf(parent)[expr.Adr()] = sm.Select(obj.Adr())
+				}
+			}
+		} else {
+			sm = rt2.ScopeOf(parent)
+			rt2.ValueOf(parent)[expr.Adr()] = sm.Select(expr.Object().Adr())
+		}
 		return OUT{do: next, next: NOW}
-	case node.OperationNode, node.CallNode, node.DerefNode:
+	case node.OperationNode, node.CallNode, node.DerefNode, node.FieldNode:
 		rt2.Push(rt2.New(expr), parent)
 		wait := func(...IN) OUT {
 			if rt2.RegOf(parent)[expr] == nil && rt2.ValueOf(parent)[expr.Adr()] == nil {

rt2/rules/return.go

@@ -32,7 +32,7 @@ func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
 				return frame.End()
 			}
 			ret = frame.NOW
-		case node.OperationNode, node.CallNode:
+		case node.OperationNode, node.CallNode, node.FieldNode:
 			rt2.Push(rt2.New(a.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				rt2.ValueOf(f.Parent())[a.Object().Adr()] = rt2.ValueOf(f)[a.Left().Adr()]

rt2/rules/table.go

@@ -3,6 +3,7 @@ package rules
 
 import (
 	"fmt"
+	"fw/cp/constant/enter"
 	"fw/cp/module"
 	"fw/cp/node"
 	"fw/cp/traps"
@@ -110,7 +111,7 @@ func prologue(n node.Node) frame.Sequence {
 }
 
 func epilogue(n node.Node) frame.Sequence {
-	switch n.(type) {
+	switch e := n.(type) {
 	case node.AssignNode, node.InitNode, node.CallNode, node.ConditionalNode, node.WhileNode,
 		node.RepeatNode, node.ExitNode, node.WithNode, node.CaseNode, node.CompNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
@@ -138,7 +139,9 @@ func epilogue(n node.Node) frame.Sequence {
 		return func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			//fmt.Println(rt_module.DomainModule(f.Domain()).Name)
 			sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			sm.Target().(scope.ScopeAllocator).Dispose(n)
+			if e.Enter() == enter.PROCEDURE {
+				sm.Target().(scope.ScopeAllocator).Dispose(n)
+			}
 			//возвращаем результаты вызова функции
 			if f.Parent() != nil {
 				par := rt2.RegOf(f.Parent())

rt2/scope/modern/hp.go

@@ -78,7 +78,7 @@ func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
 			fake.SetComplex(bt)
 			fake.SetType(object.COMPLEX)
 			fake.SetName("{}")
-			l.alloc(mod, nil, append(ol, fake), skip)
+			l.alloc(h.area.d, mod, nil, append(ol, fake), skip)
 			res = &ptrValue{scope: h.area, id: fake.Adr(), link: n.Object()}
 		case object.DynArrayType:
 			assert.For(len(par) > 0, 20)
@@ -86,7 +86,7 @@ func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
 			fake.SetComplex(bt)
 			fake.SetType(object.COMPLEX)
 			fake.SetName("[]")
-			l.alloc(mod, nil, append(ol, fake), skip)
+			l.alloc(h.area.d, mod, nil, append(ol, fake), skip)
 			h.area.Select(fake.Adr(), func(v scope.Value) {
 				arr, ok := v.(*dynarr)
 				assert.For(ok, 60)

rt2/scope/modern/ms.go

@@ -87,7 +87,8 @@ func (a *area) Provide(x interface{}) scope.ValueFor {
 }
 
 //var alloc func(*level, []object.Object, map[cp.ID]interface{})
-func (l *level) alloc(mod *cpm.Module, root node.Node, ol []object.Object, skip map[cp.ID]interface{}) {
+func (l *level) alloc(d context.Domain, mod *cpm.Module, root node.Node, ol []object.Object, skip map[cp.ID]interface{}) {
+	ml := d.Discover(context.UNIVERSE).(context.Domain).Discover(context.MOD).(rtm.List)
 	for _, o := range ol {
 		imp := mod.ImportOf(o)
 		utils.PrintScope(reflect.TypeOf(o), o.Adr())
@@ -117,11 +118,19 @@ func (l *level) alloc(mod *cpm.Module, root node.Node, ol []object.Object, skip
 							//fmt.Println(o.Name(), ".", x.Name(), x.Adr())
 							fl = append(fl, x)
 						}
-						rec = rec.Base()
+						if rec.BaseRec() == nil {
+							x := ml.NewTypeCalc()
+							x.ConnectTo(rec)
+							_, frec := x.ForeignBase()
+							//fmt.Println(frec)
+							rec, _ = frec.(object.RecordType)
+						} else {
+							rec = rec.BaseRec()
+						}
 					}
 					//fmt.Println("record")
 					l.v[l.next].(*rec).l = nl
-					nl.alloc(mod, root, fl, skip)
+					nl.alloc(d, mod, root, fl, skip)
 					l.next++
 				case object.PointerType:
 					l.v[l.next] = newPtr(x)
@@ -184,7 +193,7 @@ func (a *salloc) Allocate(n node.Node, final bool) {
 	nl := newlvl()
 	nl.ready = final
 	a.area.data = append(a.area.data, nl)
-	nl.alloc(mod, n, ol, skip)
+	nl.alloc(a.area.d, mod, n, ol, skip)
 }
 
 func (a *salloc) Dispose(n node.Node) {
@@ -235,7 +244,11 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 				v := newConst(nv)
 				l.v[l.k[o.Adr()]].Set(v)
 			case node.VariableNode, node.ParameterNode:
-				v := sm.Select(nv.Object().Adr())
+				if nv.Object().Imp() != "" {
+					md := rtm.ModuleDomain(f.Domain(), nv.Object().Imp())
+					sm = md.Discover(context.SCOPE).(scope.Manager)
+				}
+				v := sm.Select(rtm.MapImportObject(f.Domain(), nv.Object()).Adr())
 				l.v[l.k[o.Adr()]].Set(v)
 			case node.OperationNode:
 				nf := rt2.New(nv)
@@ -291,6 +304,22 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			case node.VariableNode, node.ParameterNode:
 				old := l.r[l.k[o.Adr()]].(*ref)
 				l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: sm, id: nv.Object().Adr()}
+			case node.FieldNode:
+				nf := rt2.New(nv)
+				rt2.Push(nf, f)
+				rt2.ReplaceDomain(nf, global)
+				rt2.Assert(f, func(f frame.Frame) (bool, int) {
+					return rt2.ValueOf(f)[nv.Adr()] != nil, 60
+				})
+				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+					v := rt2.ValueOf(f)[nv.Adr()]
+					assert.For(v != nil, 40)
+					//old := l.r[l.k[o.Adr()]].(*ref)
+					l.v[l.k[o.Adr()]] = v.(scope.Variable)
+					l.r[l.k[o.Adr()]] = nil
+					return end, frame.NOW
+				}
+				ret = frame.LATER
 			case node.ConstantNode: //array :) заменяем ссылку на переменную
 				old := l.r[l.k[o.Adr()]].(*ref)
 				l.r[l.k[o.Adr()]] = nil

rt2/scope/modern/val.go

@@ -89,6 +89,7 @@ func (r *rec) Set(v scope.Value) {
 func (r *rec) Get(id cp.ID) scope.Value {
 	k := r.l.k[id]
 	if r.l.v[k] == nil { //ref
+		assert.For(r.l.r[k] != nil, 20, id, k)
 		return r.l.r[k]
 	} else {
 		return r.l.v[k]
@@ -408,7 +409,11 @@ func (d *data) String() string {
 }
 
 func (p *ptr) String() string {
-	return fmt.Sprint("pointer ", p.link.Complex().(object.PointerType).Name(), "&", p.val)
+	if p.link.Complex() != nil {
+		return fmt.Sprint("pointer ", p.link.Complex().(object.PointerType).Name(), "&", p.val)
+	} else {
+		return fmt.Sprint("pointer simple", p.link.Type())
+	}
 }
 
 func (p *ptr) Id() cp.ID { return p.link.Adr() }
@@ -700,11 +705,23 @@ func gfrom(v scope.Value) interface{} {
 		}
 		panic(0)
 	case *idx:
-		switch n.link().Complex().(object.ArrayType).Base() {
-		case object.CHAR:
-			return rune(n.Get().(CHAR))
+		switch t := n.link().Complex().(type) {
+		case object.ArrayType:
+			switch t.Base() {
+			case object.CHAR:
+				return rune(n.Get().(CHAR))
+			default:
+				halt.As(100, t.Base())
+			}
+		case object.DynArrayType:
+			switch t.Base() {
+			case object.CHAR:
+				return rune(n.Get().(CHAR))
+			default:
+				halt.As(100, t.Base())
+			}
 		default:
-			halt.As(100, n.link().Complex().(object.ArrayType).Base())
+			halt.As(100, reflect.TypeOf(t))
 		}
 		panic(0)
 	case PTR:

xev/converter.go

@@ -272,8 +272,8 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 			}
 			base := r.findLink(n, "base")
 			if base != nil {
-				ret.(object.RecordType).SetBase(r.doType(base))
-				assert.For(ret.(object.RecordType).Base() != nil, 41)
+				ret.(object.RecordType).Base(r.doType(base))
+				assert.For(ret.(object.RecordType).BaseRec() != nil, 41)
 			}
 		default:
 			panic(fmt.Sprintln("unknown form", n.Data.Typ.Form))