демо12, верное определение класса-предка в операторе IS

cp/module/module.go

@@ -1,6 +1,7 @@
 package module
 
 import (
+	"fmt"
 	"fw/cp/node"
 	"fw/cp/object"
 	"ypk/assert"
@@ -20,9 +21,10 @@ type named interface {
 func (m *Module) TypeByName(scope node.Node, name string) (ret object.ComplexType) {
 	assert.For(name != "", 20)
 	for _, typ := range m.Types[scope] {
+		fmt.Print(typ)
 		if v, ok := typ.(named); ok && v.Name() == name {
 			ret = typ
-			break
+			break //стыд какой
 		}
 	}
 	return ret

cp/object/type.go

@@ -89,6 +89,8 @@ type DynArrayType interface {
 type RecordType interface {
 	ComplexType
 	Base() string
+	BaseType() RecordType
+	SetBase(ComplexType)
 	Name() string
 }
 
@@ -131,6 +133,7 @@ func (a *arr) Len() int64 { return a.length }
 type rec struct {
 	comp
 	name, base string
+	basetyp    RecordType
 }
 
 func (r *rec) Name() string { return r.name }
@@ -142,3 +145,8 @@ func NewRecordType(n string, par ...string) RecordType {
 		return &rec{name: n, base: par[0]}
 	}
 }
+
+func (r *rec) BaseType() RecordType { return r.basetyp }
+func (r *rec) SetBase(t ComplexType) {
+	r.basetyp = t.(RecordType)
+}

fw.go

@@ -26,7 +26,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevDemo11"
+		name = "XevDemo12"
 	}
 	global := new(stdDomain)
 	modList := module.New()

fw_test.bat

@@ -23,6 +23,8 @@ fw -i=XevDemo10
 IF ERRORLEVEL 1 GOTO err
 fw -i=XevDemo11
 IF ERRORLEVEL 1 GOTO err
+fw -i=XevDemo12
+IF ERRORLEVEL 1 GOTO err
 
 GOTO ok
 :err

rt2/rules/op.go

@@ -96,8 +96,23 @@ func not(_a interface{}) bool {
 }
 
 func is(p, typ object.Object) bool {
-	fmt.Println(p.Complex().(object.RecordType).Name(), typ.Complex().(object.RecordType).Name())
-	return p.Complex().(object.RecordType).Name() == typ.Complex().(object.RecordType).Name()
+	var compare func(x, a object.RecordType) bool
+	compare = func(x, a object.RecordType) bool {
+		switch {
+		case x.Name() == a.Name():
+			//	fmt.Println("eq")
+			return true //опасно сравнивать имена конеш
+		case x.BaseType() != nil:
+			//	fmt.Println("go base")
+			return compare(x.BaseType(), a)
+		default:
+			return false
+		}
+	}
+	x, a := p.Complex().(object.RecordType)
+	y, b := typ.Complex().(object.RecordType)
+	//fmt.Println("compare", p.Complex(), typ.Complex(), a, b, compare(x, y))
+	return a && b && compare(x, y)
 }
 
 func length(a object.Object, _a, _b interface{}) (ret int64) {

rt2/scope/std/scope.go

@@ -115,9 +115,9 @@ func (r *rec) init(n node.Node) {
 	r.x = make(map[scope.ID]interface{})
 }
 
-func (a *rec) set(k scope.ID, v interface{}) { fmt.Println(k); a.x[k] = v }
+func (a *rec) set(k scope.ID, v interface{}) { a.x[k] = v }
 
-func (a *rec) get(k scope.ID) interface{} { fmt.Println(k); return a.x[k] }
+func (a *rec) get(k scope.ID) interface{} { return a.x[k] }
 
 func nm() scope.Manager {
 	m := &manager{areas: list.New()}
@@ -158,7 +158,7 @@ func obj(o object.Object) (key scope.ID, val interface{}) {
 	switch x := o.(type) {
 	case object.ConstantObject, object.ProcedureObject, object.TypeObject:
 	case object.VariableObject, object.FieldObject:
-		fmt.Println(x.Name())
+		//fmt.Println(x.Name())
 		key = scope.ID{Name: x.Name()}
 		switch t := x.Complex().(type) {
 		case nil:
@@ -175,7 +175,7 @@ func obj(o object.Object) (key scope.ID, val interface{}) {
 			fmt.Println("unexpected", reflect.TypeOf(t))
 		}
 	case object.ParameterObject:
-		fmt.Println("'" + x.Name())
+		//fmt.Println("'" + x.Name())
 		key = scope.ID{Name: x.Name()}
 		val = &ref{link: o}
 	default:
@@ -198,26 +198,22 @@ func (m *manager) Allocate(n node.Node, final bool) {
 				case object.RecordType:
 					for rec := t; rec != nil; {
 						for x := rec.Link(); x != nil; x = x.Link() {
-							fmt.Println(o.Name(), ".", x.Name())
+							//fmt.Println(o.Name(), ".", x.Name())
 							alloc(v.(KVarea), x)
 						}
-						if rec.Base() != "" {
-							rec = mod.TypeByName(n, rec.Base()).(object.RecordType)
-						} else {
-							rec = nil
-						}
+						rec = rec.BaseType()
 					}
 				}
 			}
 		} else {
-			fmt.Println("nil allocated", reflect.TypeOf(o))
+			//fmt.Println("nil allocated", reflect.TypeOf(o))
 		}
 	}
 	for _, o := range mod.Objects[n] {
 		alloc(h, o)
 	}
 	m.areas.PushFront(h)
-	fmt.Println("allocate")
+	//fmt.Println("allocate")
 }
 
 func (m *manager) Initialize(n node.Node, o object.Object, _val node.Node) {
@@ -227,11 +223,11 @@ func (m *manager) Initialize(n node.Node, o object.Object, _val node.Node) {
 	assert.For(h.root == n, 21)
 	assert.For(!h.ready, 22)
 	val := _val
-	fmt.Println("initialize")
+	//fmt.Println("initialize")
 	for next := o; next != nil; next = next.Link() {
 		assert.For(val != nil, 40)
-		fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
-		fmt.Println(reflect.TypeOf(val))
+		//fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
+		//fmt.Println(reflect.TypeOf(val))
 		switch ov := val.(type) {
 		case node.ConstantNode:
 			switch next.(type) {
@@ -271,12 +267,12 @@ func (m *manager) Dispose(n node.Node) {
 		h := e.Value.(*area)
 		assert.For(h.root == n, 21)
 		m.areas.Remove(e)
-		fmt.Println("dispose")
+		//fmt.Println("dispose")
 	}
 }
 
 func (m *manager) Select(i scope.ID) interface{} {
-	fmt.Println("select", i)
+	//fmt.Println("select", i)
 	depth := 0
 	type result struct {
 		x interface{}
@@ -320,7 +316,7 @@ func (m *manager) Select(i scope.ID) interface{} {
 		}
 	}
 	assert.For(res != nil, 40)
-	fmt.Println(res.x)
+	//fmt.Println(res.x)
 	return res.x
 }
 
@@ -352,7 +348,7 @@ func (m *manager) Update(i scope.ID, val scope.ValueFor) {
 			old := x.get()
 			tmp := val(old)
 			assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
-			fmt.Println(tmp)
+			//fmt.Println(tmp)
 			x.set(tmp)
 			ret = x
 		case reference:
@@ -363,19 +359,19 @@ func (m *manager) Update(i scope.ID, val scope.ValueFor) {
 				old := x.get(*i.Index)
 				tmp := val(old)
 				assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
-				fmt.Println(tmp)
+				//fmt.Println(tmp)
 				x.set(*i.Index, tmp)
 			} else {
 				old := x.sel()
 				tmp := val(old)
 				assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
-				fmt.Println(tmp)
+				//fmt.Println(tmp)
 				x.upd(arrConv(tmp))
 			}
 			ret = x
 		case record:
 			if i.Path[depth] == "" {
-				fmt.Println(i, depth)
+				//fmt.Println(i, depth)
 				panic(0) //случай выбора всей записи целиком
 			} else {
 				z := x.getField(i.Path[depth])
@@ -414,7 +410,7 @@ func FindObjByName(mgr scope.Manager, name string) (ret object.Object) {
 		case *basic:
 			ret = x.(*basic).link
 		default:
-			fmt.Println("no such object")
+			//fmt.Println("no such object")
 		}
 	}
 	return ret

xev/converter.go

@@ -206,6 +206,11 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 			ret.SetLink(r.doObject(link))
 			assert.For(ret.Link() != nil, 40)
 		}
+		base := r.findLink(n, "base")
+		if base != nil {
+			ret.(object.RecordType).SetBase(r.doType(base))
+			assert.For(ret.(object.RecordType).BaseType() != nil, 41)
+		}
 	default:
 		panic(fmt.Sprintln("unknown form", n.Data.Typ.Form))
 	}