добился выполнения методов, и работоспособности NEW

cp/object/type.go

@@ -2,6 +2,7 @@ package object
 
 import (
 	"fmt"
+	"reflect"
 )
 
 type Type int
@@ -164,6 +165,7 @@ type ptr struct {
 }
 
 func NewPointerType(n string) PointerType {
+	fmt.Println("new ptr type", n)
 	return &ptr{name: n}
 }
 
@@ -171,6 +173,7 @@ func (p *ptr) Name() string { return p.name }
 func (p *ptr) Base(x ...ComplexType) ComplexType {
 	if len(x) == 1 {
 		p.basetyp = x[0]
+		fmt.Println("pbasetyp", p.basetyp, reflect.TypeOf(p.basetyp))
 	} else if len(x) > 1 {
 		panic("there can be only one")
 	}

fw.go

@@ -27,7 +27,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevDemo19"
+		name = "XevDemo20"
 	}
 	global := &stdDomain{god: true}
 	modList := module.New()

rt2/nodeframe/frame.go

@@ -71,6 +71,7 @@ func (f *nodeFrame) Do() frame.WAIT {
 func (f *nodeFrame) onPush() {
 	f.num = count
 	count++
+	assert.For(count < 10, 40)
 	utils.PrintFrame("_", "PUSH", reflect.TypeOf(f.ir))
 	f.seq = decision.PrologueFor(f.ir)
 }

rt2/rules/assign.go

@@ -130,6 +130,15 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 					return right(f)
 				}
 				ret = frame.LATER
+			case node.DerefNode:
+				rt2.DataOf(f)[l.Left()] = scope.ID{}
+				rt2.Push(rt2.New(l.Left()), f)
+				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+					leftId = rt2.DataOf(f)[l.Left()].(scope.ID)
+					leftId.Path = a.Left().Object().Name()
+					return right(f)
+				}
+				ret = frame.LATER
 			default:
 				leftId = scope.Designator(a.Left())
 				seq, ret = right(f)
@@ -143,6 +152,14 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return right(f)
 			}
 			ret = frame.LATER
+		case node.DerefNode:
+			rt2.DataOf(f)[a.Left()] = scope.ID{}
+			rt2.Push(rt2.New(a.Left()), f)
+			seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+				leftId = rt2.DataOf(f)[a.Left()].(scope.ID)
+				return right(f)
+			}
+			ret = frame.LATER
 		default:
 			fmt.Println(reflect.TypeOf(a.Left()))
 			panic("wrong left")
@@ -162,16 +179,16 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			panic(fmt.Sprintln("wrong left", reflect.TypeOf(a.Left())))
 		}
 	case statement.NEW:
+		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+		heap := scope.This(f.Domain().Discover(context.HEAP))
 		if a.Right() != nil {
 			seq, ret = This(expectExpr(f, a.Right(), func(...IN) OUT {
-				fmt.Println(rt2.DataOf(f)[a.Right()])
-				panic(fmt.Sprintln("NEW here"))
+				fmt.Println("NEW", rt2.DataOf(f)[a.Right()], "here")
+				sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left(), rt2.DataOf(f)[a.Right()]))
 				return End()
 			}))
 		} else {
 			fmt.Println("NEW here")
-			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			heap := scope.This(f.Domain().Discover(context.HEAP))
 			sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left()))
 			return frame.End()
 		}

rt2/rules/call.go

@@ -99,11 +99,17 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		ret = frame.LATER
 	}
 
-	switch n.Left().(type) {
+	switch p := n.Left().(type) {
 	case node.ProcedureNode:
 		m := rt_mod.DomainModule(f.Domain())
-		proc := m.NodeByObject(n.Left().Object())
-		call(proc)
+		if p.Super() {
+			fmt.Println("supercall, stop for now")
+			seq = Propose(Tail(STOP))
+			ret = frame.NOW
+		} else {
+			proc := m.NodeByObject(n.Left().Object())
+			call(proc)
+		}
 	case node.VariableNode:
 		m := rt_mod.DomainModule(f.Domain())
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)

rt2/rules/deref.go

@@ -14,8 +14,13 @@ func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f)
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	fmt.Println("deref from ptr", n.(node.DerefNode).Ptr())
-	data := sc.Select(scope.Designator(n.Left()))
-	assert.For(data != nil, 40)
-	rt2.DataOf(f.Parent())[n] = data
+	_, ok := rt2.DataOf(f.Parent())[n].(scope.ID)
+	if ok {
+		rt2.DataOf(f.Parent())[n] = scope.Designator(n.Left())
+	} else {
+		data := sc.Select(scope.Designator(n.Left()))
+		assert.For(data != nil, 40)
+		rt2.DataOf(f.Parent())[n] = data
+	}
 	return frame.End()
 }

rt2/scope/area.go

@@ -18,15 +18,16 @@ type ID struct {
 func (i ID) String() string {
 	if i.Name != "" {
 		ret := i.Name
+		if i.Ref != nil {
+			ret = ret + strconv.Itoa(*i.Ref)
+		}
 		if i.Path != "" {
 			ret = ret + "." + i.Path
 		}
 		if i.Index != nil {
 			ret = ret + "[" + strconv.FormatInt(*i.Index, 10) + "]"
 		}
-		if i.Ref != nil {
-			ret = ret + strconv.Itoa(*i.Ref)
-		}
+
 		return ret
 	} else {
 		return "<empty id>"
@@ -60,7 +61,7 @@ type ScopeAllocator interface {
 
 type HeapAllocator interface {
 	Allocator
-	Allocate(n node.Node) ValueFor //указатель лежит в скоупе процедуры/модуля, а рекорд - в куче, поэтому нужно после создания экземпляра обновить указатель
+	Allocate(n node.Node, par ...interface{}) ValueFor //указатель лежит в скоупе процедуры/модуля, а рекорд - в куче, поэтому нужно после создания экземпляра обновить указатель
 	Dispose(n node.Node)
 }
 

rt2/scope/std/heap.go

@@ -29,31 +29,55 @@ func nh() scope.Manager {
 	return &heap{data: &area{ready: true, root: nil, x: make(map[scope.ID]interface{})}}
 }
 
-func (h *heap) Allocate(n node.Node) scope.ValueFor {
+func (h *heap) Allocate(n node.Node, par ...interface{}) (ret scope.ValueFor) {
+	var talloc func(t object.PointerType) (oid scope.ID)
+	talloc = func(t object.PointerType) (oid scope.ID) {
+		switch bt := t.Base().(type) {
+		case object.RecordType:
+			fake := object.New(object.VARIABLE)
+			fake.SetComplex(bt)
+			fake.SetType(object.COMPLEX)
+			fake.SetName("@")
+			r := &rec{link: fake}
+			oid = scope.ID{Name: "@"}
+			oid.Ref = new(int)
+			*oid.Ref = h.next
+			od := &desc{link: fake}
+			od.ID = oid
+			fake.SetRef(od)
+			alloc(nil, h.data, oid, r)
+		case object.DynArrayType:
+			assert.For(len(par) > 0, 20)
+			p := int64(par[0].(int32))
+			fake := object.New(object.VARIABLE)
+			fake.SetComplex(bt)
+			fake.SetType(object.COMPLEX)
+			fake.SetName("@")
+			r := &arr{link: fake, par: p}
+			oid = scope.ID{Name: "@"}
+			oid.Ref = new(int)
+			*oid.Ref = h.next
+			od := &desc{link: fake}
+			od.ID = oid
+			fake.SetRef(od)
+			alloc(nil, h.data, oid, r)
+		case object.ArrayType:
+			panic(0)
+		case object.PointerType:
+			oid = talloc(bt)
+		default:
+			panic(fmt.Sprintln("cannot allocate", reflect.TypeOf(bt)))
+		}
+		return oid
+	}
 	switch v := n.(type) {
 	case node.VariableNode:
 		switch t := v.Object().Complex().(type) {
 		case object.PointerType:
 			h.next++
-			switch bt := t.Base().(type) {
-			case object.RecordType:
-				fake := object.New(object.VARIABLE)
-				fake.SetComplex(bt)
-				fake.SetType(object.COMPLEX)
-				fake.SetName("@")
-				r := &rec{link: fake}
-				oid := scope.ID{Name: "@"}
-				oid.Ref = new(int)
-				*oid.Ref = h.next
-				od := &desc{link: fake}
-				od.ID = oid
-				fake.SetRef(od)
-				alloc(nil, h.data, oid, r)
-				return func(interface{}) interface{} {
-					return oid
-				}
-			default:
-				panic(fmt.Sprintln("cannot allocate", reflect.TypeOf(t)))
+			oid := talloc(t)
+			return func(interface{}) interface{} {
+				return oid
 			}
 		default:
 			panic(fmt.Sprintln("unsupported type", reflect.TypeOf(t)))
@@ -91,6 +115,21 @@ func (h *heap) Update(i scope.ID, val scope.ValueFor) {
 				z := x.getField(i.Path)
 				ret = upd(z)
 			}
+		case array:
+			if i.Index != nil {
+				old := x.get(*i.Index)
+				tmp := val(old)
+				assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
+				//fmt.Println(tmp)
+				x.set(*i.Index, tmp)
+			} else {
+				old := x.sel()
+				tmp := val(old)
+				assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
+				//fmt.Println(tmp)
+				x.upd(arrConv(tmp))
+			}
+			ret = x
 		default:
 			panic(0)
 		}

rt2/scope/std/scope.go

@@ -435,8 +435,10 @@ func (m *manager) Update(i scope.ID, val scope.ValueFor) {
 				switch id := tmp.(type) {
 				case scope.ID:
 					x.id(id)
+				case object.VariableObject:
+					x.id(odesign(id))
 				default:
-					panic("only id for nil pointer")
+					panic(fmt.Sprintln("only id for nil pointer", reflect.TypeOf(id)))
 				}
 			case x.id().Ref != nil && *x.id().Ref != 0: //это указатель на объект в куче
 				i.Name = x.id().Name