разбираюсь с типами и импортами

cp/module/module.go

@@ -4,12 +4,15 @@ import (
 	"fmt"
 	"fw/cp/node"
 	"fw/cp/object"
+	"reflect"
 	"ypk/assert"
+	"ypk/halt"
 )
 
 type Import struct {
 	Name    string
 	Objects []object.Object
+	Types   []object.ComplexType
 }
 
 type Module struct {
@@ -86,3 +89,27 @@ func (m *Module) NodeByObject(obj object.Object) (ret []node.Node) {
 	}
 	return ret
 }
+
+func (m *Module) Init() {
+	for k, s := range m.Types {
+		q := ""
+		if m.Enter.Adr() == k.Adr() {
+			q = m.Name
+		} else {
+			switch e := k.(type) {
+			case node.EnterNode:
+				fmt.Println(e.Adr(), e.Enter())
+			default:
+				halt.As(100, reflect.TypeOf(e))
+			}
+		}
+		for _, t := range s {
+			t.Qualident(q)
+		}
+	}
+	for i, s := range m.Imports {
+		for _, t := range s.Types {
+			fmt.Println(i, t)
+		}
+	}
+}

cp/object/comp.go

@@ -0,0 +1,61 @@
+package object
+
+import (
+	"fmt"
+	"reflect"
+)
+
+import (
+	"ypk/halt"
+)
+
+func (a *basic) Equals(x ComplexType) bool {
+	switch b := x.(type) {
+	case *basic:
+		return a == b
+	default:
+		halt.As(100, reflect.TypeOf(b))
+	}
+	panic(0)
+}
+
+func (a *arr) Equals(x ComplexType) bool {
+	switch b := x.(type) {
+	case *arr:
+		return a == b
+	default:
+		halt.As(100, reflect.TypeOf(b))
+	}
+	panic(0)
+}
+
+func (a *dyn) Equals(x ComplexType) bool {
+	switch b := x.(type) {
+	case *dyn:
+		return a == b
+	default:
+		halt.As(100, reflect.TypeOf(b))
+	}
+	panic(0)
+}
+
+func (a *rec) Equals(x ComplexType) bool {
+	switch b := x.(type) {
+	case *rec:
+		return a == b
+	default:
+		halt.As(100, reflect.TypeOf(b))
+	}
+	panic(0)
+}
+
+func (a *ptr) Equals(x ComplexType) bool {
+	switch b := x.(type) {
+	case *ptr:
+		fmt.Println(a.Name(), ":", a.Qualident(), ",", b.Name(), ":", b.Qualident())
+		return a == b
+	default:
+		halt.As(100, reflect.TypeOf(b))
+	}
+	panic(0)
+}

cp/object/type.go

@@ -71,12 +71,15 @@ func (t Type) String() string {
 type ComplexType interface {
 	Link() Object
 	SetLink(o Object)
+	Equals(ComplexType) bool
+	Qualident(...string) string
 	cp.Id
 }
 
 type comp struct {
 	link Object
 	adr  cp.ID
+	id   string
 }
 
 func (c *comp) Link() Object     { return c.link }
@@ -90,6 +93,14 @@ func (c *comp) Adr(a ...cp.ID) cp.ID {
 	return c.adr
 }
 
+func (c *comp) Qualident(a ...string) string {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		c.id = a[0]
+	}
+	return c.id
+}
+
 type BasicType interface {
 	ComplexType
 	Type() Type
@@ -209,9 +220,11 @@ type ptr struct {
 	name    string
 }
 
-func NewPointerType(n string) PointerType {
+func NewPointerType(n string, id int) PointerType {
 	//fmt.Println("new ptr type", n)
-	return &ptr{name: n}
+	p := &ptr{name: n}
+	p.Adr(cp.Next(id))
+	return p
 }
 
 func (p *ptr) Name() string { return p.name }

fw.go

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

fw_test_all.bat

@@ -24,4 +24,5 @@ start fw_test XevDemo21
 start fw_test XevDemo22
 
 start fw_test TestA0
-start fw_test Start
+start fw_test Start
+start fw_test Start2

rt2/module/ml.go

@@ -70,6 +70,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()
 			l.inner[name] = ret
 			loader(ret)
 			//fmt.Println("loaded", name)

rt2/rules/call.go

@@ -218,13 +218,16 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 						for _, _po := range ol {
 							switch po := _po.(type) {
 							case object.ProcedureObject:
-								if po.Name() == p.Object().Name() && po.Link() != nil && po.Link().Complex() == c {
-									fn = po
-								}
+								if po.Name() == p.Object().Name() {
+									if po.Link() != nil && po.Link().Complex().Equals(c) {
+										fn = po
+									} else if po.Link() != nil {
 
+									}
+								}
 							}
 						}
-						assert.For(fn != nil, 40)
+						assert.For(fn != nil, 40, p.Object().Name())
 						proc = mod.NodeByObject(fn)
 						assert.For(proc != nil, 40)
 						call(proc[0], dm)

rt2/rules/op.go

@@ -41,7 +41,7 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Not(rt2.ValueOf(f)[n.Left().Adr()])
 			return frame.End()
 		case operation.IS:
-			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Is(sc.Select(n.Left().Object().Adr()), n.Object())
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Is(sc.Select(n.Left().Object().Adr()), n.Object().Complex())
 			return frame.End()
 		case operation.ABS:
 			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Abs(rt2.ValueOf(f)[n.Left().Adr()])

rt2/scope/modern/hp.go

@@ -31,7 +31,7 @@ func fin(x interface{}) {
 			for _, _po := range ol {
 				switch po := _po.(type) {
 				case object.ProcedureObject:
-					if po.Name() == "FINALIZE" && po.Link().Complex() == p.link.Complex() {
+					if po.Name() == "FINALIZE" && po.Link().Complex().Equals(p.link.Complex()) {
 						fn = po
 						break
 					}

rt2/scope/modern/val.go

@@ -534,10 +534,16 @@ func newData(o object.Object) (ret scope.Variable) {
 			ret = &dynarr{link: o}
 		default:
 			halt.As(100, reflect.TypeOf(t))
-
+		}
+	case object.NOTYPE:
+		switch t := o.Complex().(type) {
+		case nil:
+			ret = &ptr{link: o}
+		default:
+			halt.As(100, reflect.TypeOf(t))
 		}
 	default:
-		panic(fmt.Sprintln("unsupported type", o.Type()))
+		panic(fmt.Sprintln("unsupported type", o, o.Type(), o.Complex()))
 	}
 	return ret
 }
@@ -1291,6 +1297,8 @@ func (o *ops) Conv(a scope.Value, typ object.Type, comp ...object.ComplexType) s
 			return INTEGER(x.bits.Int64())
 		case REAL:
 			return INTEGER(x)
+		case LONGINT:
+			return INTEGER(x)
 		default:
 			halt.As(100, reflect.TypeOf(x))
 		}

xev/converter.go

@@ -216,7 +216,7 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				"SHORTINT", "BOOLEAN", "REAL", "SHORTREAL", "SET", "UNDEF",
 				"NOTYP":
 			case "POINTER":
-				t := object.NewPointerType(n.Data.Typ.Name)
+				t := object.NewPointerType(n.Data.Typ.Name, n.Id)
 				base := r.findLink(n, "base")
 				if base != nil {
 					t.Base(r.doType(base))
@@ -497,6 +497,8 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")
 		}
+	} else {
+		return ret
 	}
 	if ret != nil {
 		nodeMap[n.Id] = ret
@@ -595,8 +597,7 @@ func buildMod(r *Result) *module.Module {
 	}
 	for k, v := range scopes {
 		if k < 0 {
-			impList[v.mod] = module.Import{Objects: v.scopes[k], Name: v.mod}
-			//fmt.Println("типы не учтены", len(v.types[k]))
+			impList[v.mod] = module.Import{Objects: v.scopes[k], Name: v.mod, Types: v.types[k]}
 		}
 	}
 	return &module.Module{Nodes: nodeList, Objects: scopeList, Types: typeList, Enter: root, Imports: impList}