разбор полей рекорда

cp/module/module.go

@@ -10,6 +10,22 @@ type Module struct {
 	Enter   node.Node
 	Objects map[node.Node][]object.Object
 	Nodes   []node.Node
+	Types   map[node.Node][]object.ComplexType
+}
+
+type named interface {
+	Name() string
+}
+
+func (m *Module) TypeByName(scope node.Node, name string) (ret object.ComplexType) {
+	assert.For(name != "", 20)
+	for _, typ := range m.Types[scope] {
+		if v, ok := typ.(named); ok && v.Name() == name {
+			ret = typ
+			break
+		}
+	}
+	return ret
 }
 
 func (m *Module) NodeByObject(obj object.Object) (ret node.Node) {

cp/node/class.go

@@ -12,6 +12,7 @@ const INIT constant.Class = -1
 
 type InitNode interface {
 	Node
+	self() InitNode
 }
 
 func New(class constant.Class) Node {

cp/object/object.go

@@ -44,6 +44,11 @@ type FieldObject interface {
 	self() FieldObject
 }
 
+type ProcedureObject interface {
+	Object
+	self() ProcedureObject
+}
+
 func New(mode Mode) Object {
 	switch mode {
 	case HEAD:
@@ -93,11 +98,14 @@ type localProcedureObject struct {
 	objectFields
 }
 
+func (p *localProcedureObject) self() ProcedureObject { return p }
+
 type externalProcedureObject struct {
 	objectFields
 }
 
-func (v *variableObject) self() VariableObject { return v }
+func (p *externalProcedureObject) self() ProcedureObject { return p }
+func (v *variableObject) self() VariableObject           { return v }
 
 type constantObject struct {
 	objectFields

cp/object/type.go

@@ -86,6 +86,8 @@ type DynArrayType interface {
 
 type RecordType interface {
 	ComplexType
+	Base() string
+	Name() string
 }
 
 func NewBasicType(t Type) BasicType {
@@ -126,8 +128,15 @@ func (a *arr) Len() int64 { return a.length }
 
 type rec struct {
 	comp
+	name, base string
 }
 
-func NewRecordType() RecordType {
-	return &rec{}
+func (r *rec) Name() string { return r.name }
+func (r *rec) Base() string { return r.base }
+func NewRecordType(n string, par ...string) RecordType {
+	if len(par) == 0 {
+		return &rec{name: n}
+	} else {
+		return &rec{name: n, base: par[0]}
+	}
 }

rt2/nodeframe/frame.go

@@ -19,7 +19,7 @@ func (fu FrameUtils) New(n node.Node) (f frame.Frame) {
 	f = new(nodeFrame)
 	f.(*nodeFrame).ir = n
 	f.(*nodeFrame).data = make(map[interface{}]interface{})
-	utils.Println("_", "NEW", reflect.TypeOf(n))
+	//utils.Println("_", "NEW", reflect.TypeOf(n))
 	return f
 }
 

rt2/rules/assign.go

@@ -23,7 +23,7 @@ func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	rt2.Utils.Push(rt2.Utils.New(op), f)
 	seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		sc.Update(n.Left().Object(), func(interface{}) interface{} {
+		sc.UpdateObj(n.Left().Object(), func(interface{}) interface{} {
 			return rt2.Utils.DataOf(f)[op]
 		})
 		return frame.End()
@@ -41,7 +41,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.ConstantNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(a.Left().Object(), func(interface{}) interface{} {
+				sc.UpdateObj(a.Left().Object(), func(interface{}) interface{} {
 					return a.Right().(node.ConstantNode).Data()
 				})
 				return frame.End()
@@ -50,8 +50,8 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.VariableNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(a.Left().Object(), func(interface{}) interface{} {
-					return sc.Select(a.Right().Object())
+				sc.UpdateObj(a.Left().Object(), func(interface{}) interface{} {
+					return sc.SelectObj(a.Right().Object())
 				})
 				return frame.End()
 			}
@@ -60,7 +60,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			fu.Push(fu.New(a.Right()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(a.Left().Object(), func(interface{}) interface{} {
+				sc.UpdateObj(a.Left().Object(), func(interface{}) interface{} {
 					return fu.DataOf(f)[a.Right()]
 				})
 				return frame.End()
@@ -68,7 +68,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			ret = frame.LATER
 		case node.ProcedureNode:
 			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			sc.Update(a.Left().Object(), func(interface{}) interface{} {
+			sc.UpdateObj(a.Left().Object(), func(interface{}) interface{} {
 				return a.Right().Object()
 			})
 			return frame.End()
@@ -81,7 +81,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	switch a.(node.AssignNode).Statement() {
 	case statement.ASSIGN:
 		switch a.Left().(type) {
-		case node.VariableNode, node.ParameterNode, node.FieldNode:
+		case node.VariableNode, node.ParameterNode:
 			seq, ret = right(f)
 		default:
 			fmt.Println(reflect.TypeOf(a.Left()))

rt2/rules/call.go

@@ -88,6 +88,8 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		//передаем ссылку на цепочку значений параметров в данные фрейма входа в процедуру
 		if (n.Right() != nil) && (proc.Object() != nil) {
 			fu.DataOf(nf)[proc.Object()] = n.Right()
+		} else {
+			//fmt.Println("no data for call")
 		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			var fu nodeframe.FrameUtils
@@ -105,7 +107,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case node.VariableNode:
 		m := mod.DomainModule(f.Domain())
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		obj := sc.Select(n.Left().Object())
+		obj := sc.SelectObj(n.Left().Object())
 
 		if obj, ok := obj.(object.Object); ok {
 			proc := m.NodeByObject(obj)

rt2/rules/deref.go

@@ -10,6 +10,6 @@ import (
 func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.Utils.NodeOf(f)
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-	rt2.Utils.DataOf(f.Parent())[n] = sc.Select(n.Left().Object())
+	rt2.Utils.DataOf(f.Parent())[n] = sc.SelectObj(n.Left().Object())
 	return frame.End()
 }

rt2/rules/enter.go

@@ -1,6 +1,7 @@
 package rules
 
 import (
+	"fmt"
 	"fw/cp/node"
 	"fw/rt2/context"
 	"fw/rt2/frame"
@@ -16,8 +17,11 @@ func enterSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	assert.For(body != nil, 40)
 	sm := scope.This(f.Domain().Discover(context.SCOPE))
 	sm.Allocate(n)
+	fmt.Println(n.Object())
 	if n.Object() != nil {
 		par, ok := fu.DataOf(f)[n.Object()].(node.Node)
+		//fmt.Println(fu.DataOf(f)[n.Object()])
+		//fmt.Println(ok)
 		if ok {
 			sm.Initialize(n, n.Object().Link(), par)
 		}

rt2/rules/op.go

@@ -108,7 +108,7 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 		switch n.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
-			x := sc.Select(n.Left().Object())
+			x := sc.SelectObj(n.Left().Object())
 			assert.For(x != nil, 40)
 			switch n.Type() {
 			case object.INTEGER:
@@ -170,7 +170,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Right()] = sc.Select(n.Right().Object())
+				fu.DataOf(f)[n.Right()] = sc.SelectObj(n.Right().Object())
 				//fmt.Println(n.Right().Object(), reflect.TypeOf(n.Right().Object()))
 				assert.For(fu.DataOf(f)[n.Right()] != nil, 60)
 				return op, frame.NOW
@@ -199,7 +199,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.VariableNode, node.ParameterNode, node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Left()] = sc.Select(n.Left().Object())
+				fu.DataOf(f)[n.Left()] = sc.SelectObj(n.Left().Object())
 				return right, frame.NOW
 			}
 			ret = frame.NOW

rt2/rules/return.go

@@ -25,7 +25,7 @@ func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
 		case node.VariableNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f.Parent())[a.Object()] = sc.Select(a.Left().Object())
+				fu.DataOf(f.Parent())[a.Object()] = sc.SelectObj(a.Left().Object())
 				return frame.End()
 			}
 			ret = frame.NOW

rt2/rules/table.go

@@ -59,6 +59,8 @@ func epilogue(n node.Node) frame.Sequence {
 	case node.AssignNode, node.InitNode, node.CallNode, node.ConditionalNode, node.WhileNode, node.RepeatNode, node.ExitNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			next := n.Link()
+			//fmt.Println("from", reflect.TypeOf(n))
+			//fmt.Println("next", reflect.TypeOf(next))
 			if next != nil {
 				f.Root().PushFor(fu.New(next), f.Parent())
 			}

rt2/scope/area.go

@@ -9,8 +9,10 @@ import (
 //менеджер зон видимости, зоны видимости динамические, создаются в момент входа в EnterNode
 type Manager interface {
 	context.ContextAware
-	Update(o object.Object, val ValueFor)
-	Select(o object.Object) interface{}
+	UpdateObj(o object.Object, val ValueFor)
+	SelectObj(o object.Object) interface{}
+	UpdateNode(n node.Node, val ValueFor)
+	SelectNode(n node.Node) interface{}
 	FindObjByName(name string) object.Object
 	Allocate(n node.Node)
 	Dispose(n node.Node)

rt2/scope/stdScope.go

@@ -66,14 +66,14 @@ func (v *direct) Get() interface{} { return v.data }
 func (v *indirect) Set(x interface{}) {
 	assert.For(x != nil, 20)
 	assert.For(v.ref != nil, 21)
-	v.mgr.Update(v.ref, func(old interface{}) interface{} {
+	v.mgr.UpdateObj(v.ref, func(old interface{}) interface{} {
 		return x
 	})
 }
 
 func (v *indirect) Get() interface{} {
 	assert.For(v.ref != nil, 20)
-	return v.mgr.Select(v.ref)
+	return v.mgr.SelectObj(v.ref)
 }
 
 func (m *manager) init() *manager {
@@ -89,12 +89,31 @@ func (m *manager) Allocate(n node.Node) {
 	for _, o := range mod.Objects[n] {
 		//fmt.Println(reflect.TypeOf(o))
 		switch o.(type) {
-		case object.VariableObject, object.FieldObject:
-			h.heap[o] = &direct{data: def}
+		case object.VariableObject:
+			switch o.(object.VariableObject).Type() {
+			case object.COMPLEX:
+				switch o.(object.VariableObject).Complex().(type) {
+				case object.RecordType:
+					for rec := o.(object.VariableObject).Complex().(object.RecordType); rec != nil; {
+						for x := rec.Link(); x != nil; x = x.Link() {
+							fmt.Println(o.Name(), ".", x.Name())
+						}
+						if rec.Base() != "" {
+							rec = mod.TypeByName(n, rec.Base()).(object.RecordType)
+						} else {
+							rec = nil
+						}
+					}
+				default:
+					h.heap[o] = &direct{data: def}
+				}
+			default:
+				h.heap[o] = &direct{data: def}
+			}
 		case object.ParameterObject:
 			h.heap[o] = &indirect{mgr: m}
 		default:
-			panic(fmt.Sprintln("wrong object type", reflect.TypeOf(o)))
+			fmt.Println("wrong object type", reflect.TypeOf(o))
 		}
 	}
 	m.areas.PushFront(h)
@@ -105,8 +124,8 @@ func (m *manager) set(a *area, o object.Object, val node.Node) {
 	switch val.(type) {
 	case node.ConstantNode:
 		switch o.(type) {
-		case object.VariableObject, object.FieldObject:
-			m.Update(o, func(old interface{}) interface{} {
+		case object.VariableObject:
+			m.UpdateObj(o, func(old interface{}) interface{} {
 				return val.(node.ConstantNode).Data()
 			})
 		case object.ParameterObject:
@@ -119,9 +138,9 @@ func (m *manager) set(a *area, o object.Object, val node.Node) {
 		}
 	case node.VariableNode, node.ParameterNode, node.FieldNode:
 		switch o.(type) {
-		case object.VariableObject, object.FieldObject:
-			m.Update(o, func(old interface{}) interface{} {
-				return m.Select(val.Object())
+		case object.VariableObject:
+			m.UpdateObj(o, func(old interface{}) interface{} {
+				return m.SelectObj(val.Object())
 			})
 		case object.ParameterObject:
 			a.heap[o].(*indirect).ref = val.Object()
@@ -169,7 +188,7 @@ func (m *manager) FindObjByName(name string) (ret object.Object) {
 	return ret
 }
 
-func (m *manager) Select(o object.Object) (ret interface{}) {
+func (m *manager) SelectObj(o object.Object) (ret interface{}) {
 	assert.For(o != nil, 20)
 	for e := m.areas.Front(); (e != nil) && (ret == nil); e = e.Next() {
 		h := e.Value.(*area)
@@ -183,7 +202,7 @@ func (m *manager) Select(o object.Object) (ret interface{}) {
 	return ret
 }
 
-func (m *manager) Update(o object.Object, val ValueFor) {
+func (m *manager) UpdateObj(o object.Object, val ValueFor) {
 	assert.For(o != nil, 20)
 	assert.For(val != nil, 21)
 	var x *area
@@ -203,6 +222,13 @@ func (m *manager) Update(o object.Object, val ValueFor) {
 	x.heap[o].Set(tmp)
 }
 
+func (m *manager) SelectNode(n node.Node) interface{} {
+	return nil
+}
+
+func (m *manager) UpdateNode(n node.Node, val ValueFor) {
+
+}
 func (m *manager) Init(d context.Domain) {
 	m.d = d
 }

xev/converter.go

@@ -193,10 +193,16 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 	case "RECORD":
 		switch n.Data.Typ.Base {
 		case "NOTYP":
-			n := object.NewRecordType()
+			n := object.NewRecordType(n.Data.Typ.Name)
 			ret = n
 		default:
-			panic("unknown record base")
+			n := object.NewRecordType(n.Data.Typ.Name, n.Data.Typ.Base)
+			ret = n
+		}
+		link := r.findLink(n, "link")
+		if link != nil {
+			ret.SetLink(r.doObject(link))
+			assert.For(ret.Link() != nil, 40)
 		}
 	default:
 		panic(fmt.Sprintln("unknown form", n.Data.Typ.Form))
@@ -257,25 +263,28 @@ func (r *Result) doObject(n *Node) object.Object {
 	return ret
 }
 
-func (r *Result) buildScope(list []Node) []object.Object {
+func (r *Result) buildScope(list []Node) (ro []object.Object, rt []object.ComplexType) {
 	assert.For(list != nil, 20)
-	ret := make([]object.Object, 0)
+	ro = make([]object.Object, 0)
+	rt = make([]object.ComplexType, 0)
 	for i := range list {
 		switch {
 		case list[i].Data.Obj != nil:
 			obj := r.doObject(&list[i])
 			if obj != nil {
-				ret = append(ret, obj)
+				ro = append(ro, obj)
 			}
 		case list[i].Data.Typ != nil:
-			_ = r.doType(&list[i])
+			typ := r.doType(&list[i])
+			if typ != nil {
+				rt = append(rt, typ)
+			}
 		default:
 			panic("no such object type")
 		}
 
 	}
-
-	return ret
+	return ro, rt
 }
 
 func (r *Result) buildNode(n *Node) (ret node.Node) {
@@ -405,14 +414,16 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 	return ret
 }
 
-func buildMod(r *Result) (nodeList []node.Node, scopeList map[node.Node][]object.Object, root node.Node) {
+func buildMod(r *Result) (nodeList []node.Node, scopeList map[node.Node][]object.Object, typeList map[node.Node][]object.ComplexType, root node.Node) {
 	scopes := make(map[string][]object.Object, 0)
+	types := make(map[string][]object.ComplexType, 0)
 	for i := range r.GraphList {
 		if r.GraphList[i].CptScope != "" {
-			scopes[r.GraphList[i].CptScope] = r.buildScope(r.GraphList[i].NodeList)
+			scopes[r.GraphList[i].CptScope], types[r.GraphList[i].CptScope] = r.buildScope(r.GraphList[i].NodeList)
 		}
 	}
 	scopeList = make(map[node.Node][]object.Object, 0)
+	typeList = make(map[node.Node][]object.ComplexType, 0)
 	for i := range r.GraphList {
 		if r.GraphList[i].CptProc != "" {
 			nodeList = make([]node.Node, 0)
@@ -423,20 +434,23 @@ func buildMod(r *Result) (nodeList []node.Node, scopeList map[node.Node][]object
 				if scopes[node.Id] != nil {
 					scopeList[ret] = scopes[node.Id]
 				}
+				if types[node.Id] != nil {
+					typeList[ret] = types[node.Id]
+				}
 				if (node.Data.Nod.Class == "enter") && (node.Data.Nod.Enter == "module") {
 					root = ret
 				}
 			}
 		}
 	}
-	return nodeList, scopeList, root
+	return nodeList, scopeList, typeList, root
 }
 
 func DoAST(r *Result) (mod *module.Module) {
 	nodeMap = make(map[string]node.Node)
 	objectMap = make(map[string]object.Object)
 	mod = new(module.Module)
-	mod.Nodes, mod.Objects, mod.Enter = buildMod(r)
+	mod.Nodes, mod.Objects, mod.Types, mod.Enter = buildMod(r)
 	fmt.Println(len(mod.Nodes), len(mod.Objects))
 	nodeMap = nil
 	objectMap = nil

xev/loader.go

@@ -7,6 +7,7 @@ type CptType struct {
 	Typ  string `xml:"urn:bbcb:component:dev:cpt type,attr"`
 	Base string `xml:"urn:bbcb:component:dev:cpt base,attr"`
 	Par  int    `xml:"urn:bbcb:component:dev:cpt par,attr"`
+	Name string `xml:"urn:bbcb:component:dev:cpt name,attr"`
 }
 
 type CptObject struct {