|
@@ -1,13 +1,16 @@
|
|
|
package module
|
|
|
|
|
|
import (
|
|
|
+ "fmt"
|
|
|
mod "fw/cp/module"
|
|
|
"fw/cp/node"
|
|
|
"fw/cp/object"
|
|
|
"fw/rt2/context"
|
|
|
"fw/xev"
|
|
|
"os"
|
|
|
+ "reflect"
|
|
|
"ypk/assert"
|
|
|
+ "ypk/halt"
|
|
|
)
|
|
|
|
|
|
type Loader func(*mod.Module)
|
|
@@ -17,6 +20,7 @@ type List interface {
|
|
|
AsList() []*mod.Module
|
|
|
Load(string, ...Loader) (*mod.Module, error)
|
|
|
Loaded(string) *mod.Module
|
|
|
+ NewTypeCalc() TypeCalc
|
|
|
}
|
|
|
|
|
|
func New() List {
|
|
@@ -70,7 +74,52 @@ func (l *list) Load(name string, ldr ...Loader) (ret *mod.Module, err error) {
|
|
|
_, err = l.Load(imp.Name, loader)
|
|
|
}
|
|
|
if err == nil {
|
|
|
- ret.Init()
|
|
|
+ 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(")")
|
|
|
+ })
|
|
|
l.inner[name] = ret
|
|
|
loader(ret)
|
|
|
//fmt.Println("loaded", name)
|
|
@@ -84,6 +133,10 @@ func (l *list) Loaded(name string) *mod.Module {
|
|
|
return l.inner[name]
|
|
|
}
|
|
|
|
|
|
+func (l *list) NewTypeCalc() TypeCalc {
|
|
|
+ return &tc{ml: l}
|
|
|
+}
|
|
|
+
|
|
|
func DomainModule(d context.Domain) *mod.Module {
|
|
|
uni := d.Discover(context.UNIVERSE).(context.Domain)
|
|
|
name := uni.Id(d)
|
|
@@ -126,7 +179,7 @@ func ModuleOfType(d context.Domain, x object.ComplexType) *mod.Module {
|
|
|
for _, m := range ml.AsList() {
|
|
|
for _, v := range m.Types {
|
|
|
for _, o := range v {
|
|
|
- if o == x {
|
|
|
+ if o.Adr() == x.Adr() { //сравнение по конкретному типу
|
|
|
return m
|
|
|
}
|
|
|
}
|
|
@@ -134,3 +187,185 @@ func ModuleOfType(d context.Domain, x object.ComplexType) *mod.Module {
|
|
|
}
|
|
|
return nil
|
|
|
}
|
|
|
+
|
|
|
+func MapImportType(d context.Domain, imp string, t object.ComplexType) object.ComplexType {
|
|
|
+ uni := d.Discover(context.UNIVERSE).(context.Domain)
|
|
|
+ ml := uni.Discover(context.MOD).(List)
|
|
|
+ m := ml.Loaded(imp)
|
|
|
+ for _, v := range m.Types[m.Enter] {
|
|
|
+ if v.Equals(t) {
|
|
|
+ return v
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+type TypeCalc interface {
|
|
|
+ ConnectTo(interface{})
|
|
|
+ MethodList() map[int]Method
|
|
|
+}
|
|
|
+
|
|
|
+type Method struct {
|
|
|
+ Enter node.EnterNode
|
|
|
+ Obj object.Object
|
|
|
+ Mod *mod.Module
|
|
|
+}
|
|
|
+
|
|
|
+type tc struct {
|
|
|
+ ml List
|
|
|
+ m *mod.Module
|
|
|
+ typ object.ComplexType
|
|
|
+ TypeCalc
|
|
|
+}
|
|
|
+
|
|
|
+type inherited interface {
|
|
|
+ Base(...object.ComplexType) object.ComplexType
|
|
|
+}
|
|
|
+
|
|
|
+func (c *tc) ConnectTo(x interface{}) {
|
|
|
+ switch t := x.(type) {
|
|
|
+ case object.ComplexType:
|
|
|
+ c.typ = t
|
|
|
+ case object.TypeObject:
|
|
|
+ c.typ = t.Complex()
|
|
|
+ default:
|
|
|
+ halt.As(100, reflect.TypeOf(t))
|
|
|
+ }
|
|
|
+ c.m = ModuleOfType(c.ml.Domain(), c.typ)
|
|
|
+ assert.For(c.m != nil, 60)
|
|
|
+}
|
|
|
+
|
|
|
+func (c *tc) MethodList() (ret map[int]Method) {
|
|
|
+ ret = make(map[int]Method, 0)
|
|
|
+ //depth := 0
|
|
|
+ var deep func(*mod.Module, object.ComplexType)
|
|
|
+ list := func(m *mod.Module, t object.ComplexType) {
|
|
|
+ ol := m.Objects[c.m.Enter]
|
|
|
+ for _, _po := range ol {
|
|
|
+ switch po := _po.(type) {
|
|
|
+ case object.ProcedureObject:
|
|
|
+ proc := m.NodeByObject(po)
|
|
|
+ //local := false
|
|
|
+ for i := range proc {
|
|
|
+ if _, ok := proc[i].(node.EnterNode); ok {
|
|
|
+ //local = true
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 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())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ foreign := func(t object.ComplexType) {
|
|
|
+ for _, n := range c.m.Imports {
|
|
|
+ for _, _it := range n.Objects {
|
|
|
+ switch it := _it.(type) {
|
|
|
+ case object.TypeObject:
|
|
|
+ if it.Complex().Adr() == t.Adr() {
|
|
|
+ nm := c.ml.Loaded(n.Name)
|
|
|
+ nt := nm.TypeByName(nm.Enter, it.Name())
|
|
|
+ deep(nm, nt)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ deep = func(m *mod.Module, x object.ComplexType) {
|
|
|
+ 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))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return
|
|
|
+ }
|
|
|
+ deep(c.m, c.typ)
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+func (c *tc) String() (ret string) {
|
|
|
+ foreign := func(t object.ComplexType) {
|
|
|
+ for _, n := range c.m.Imports {
|
|
|
+ for _, _it := range n.Objects {
|
|
|
+ switch it := _it.(type) {
|
|
|
+ case object.TypeObject:
|
|
|
+ if it.Complex().Adr() == t.Adr() {
|
|
|
+ nm := c.ml.Loaded(n.Name)
|
|
|
+ nt := nm.TypeByName(nm.Enter, it.Name())
|
|
|
+ other := c.ml.NewTypeCalc()
|
|
|
+ other.ConnectTo(nt)
|
|
|
+ ret = fmt.Sprintln(ret, "foreign", other)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for t := c.typ; t != nil; {
|
|
|
+ ret = fmt.Sprintln(ret, t.Qualident())
|
|
|
+ ol := c.m.Objects[c.m.Enter]
|
|
|
+ for _, _po := range ol {
|
|
|
+ switch po := _po.(type) {
|
|
|
+ case object.ProcedureObject:
|
|
|
+ proc := c.m.NodeByObject(po)
|
|
|
+ local := false
|
|
|
+ for i := range proc {
|
|
|
+ if _, ok := proc[i].(node.EnterNode); ok {
|
|
|
+ local = true
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 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) {
|
|
|
+ ret = fmt.Sprintln(ret, po.Name(), local)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 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))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|