отладил динамические строки

fw.go

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

rt2/rules/assign.go

@@ -12,6 +12,7 @@ import (
 	"fw/rt2/frame"
 	"fw/rt2/scope"
 	"reflect"
+	"ypk/halt"
 )
 
 func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
@@ -54,7 +55,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		vleft := left.(scope.Variable)
-		switch l := a.Right().(type) {
+		switch r := a.Right().(type) {
 		case node.ConstantNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
@@ -85,18 +86,31 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.LATER
 		case node.IndexNode:
-			rightId = l.Adr()
-			rt2.Push(rt2.New(l), f)
+			rightId = r.Adr()
+			rt2.Push(rt2.New(r), f)
 			rt2.Assert(f, func(f frame.Frame) (bool, int) {
 				return rt2.ValueOf(f)[rightId] != nil, 62
 			})
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				right := rt2.ValueOf(f)[l.Adr()]
-				arr := sc.Select(l.Left().Object().Adr()).(scope.Array)
-				right = arr.Get(right)
-				vleft.Set(right)
-				return frame.End()
+				right := rt2.ValueOf(f)[r.Adr()]
+				switch z := r.Left().(type) {
+				case node.VariableNode, node.ParameterNode:
+					arr := sc.Select(z.Object().Adr()).(scope.Array)
+					right = arr.Get(right)
+					vleft.Set(right)
+					return frame.End()
+				case node.DerefNode:
+					return This(expectExpr(f, z, func(in ...IN) (out OUT) {
+						arr := rt2.ValueOf(f)[z.Adr()].(scope.Array)
+						right = arr.Get(right)
+						vleft.Set(right)
+						return End()
+					}))
+				default:
+					halt.As(100, reflect.TypeOf(z), z)
+				}
+				panic(0)
 			}
 			ret = frame.LATER
 		case node.ProcedureNode:
@@ -135,9 +149,23 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 				left = rt2.ValueOf(f)[l.Adr()]
-				arr := sc.Select(l.Left().Object().Adr()).(scope.Array)
-				left = arr.Get(left)
-				return right(f)
+				switch z := l.Left().(type) {
+				case node.VariableNode, node.ParameterNode:
+					arr := sc.Select(l.Left().Object().Adr()).(scope.Array)
+					left = arr.Get(left)
+					return right(f)
+				case node.DerefNode:
+					return This(expectExpr(f, z, func(in ...IN) (out OUT) {
+						arr := rt2.ValueOf(f)[z.Adr()].(scope.Array)
+						left = arr.Get(left)
+						out.do = Expose(right)
+						out.next = NOW
+						return
+					}))
+				default:
+					halt.As(100, reflect.TypeOf(z), z)
+				}
+				panic(0)
 			}
 			ret = frame.LATER
 		case node.DerefNode:
@@ -174,11 +202,30 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 		heap := f.Domain().Discover(context.HEAP).(scope.Manager).Target().(scope.HeapAllocator)
 		if a.Right() != nil {
-			seq, ret = This(expectExpr(f, a.Right(), func(...IN) OUT {
-				fmt.Println("NEW", rt2.ValueOf(f)[a.Right().Adr()], "here")
-				fn := heap.Allocate(a.Left(), rt2.ValueOf(f)[a.Right().Adr()])
-				sc.Update(a.Left().Object().Adr(), fn)
-				return End()
+			seq, ret = This(expectExpr(f, a.Right(), func(in ...IN) (out OUT) {
+				//fmt.Println("NEW", rt2.ValueOf(f)[a.Right().Adr()], "here")
+				switch z := a.Left().(type) {
+				case node.VariableNode:
+					fn := heap.Allocate(a.Left(), rt2.ValueOf(f)[a.Right().Adr()])
+					sc.Update(a.Left().Object().Adr(), fn)
+					return End()
+				case node.FieldNode:
+					fn := heap.Allocate(a.Left(), rt2.ValueOf(f)[a.Right().Adr()])
+					rt2.Push(rt2.New(z), in[0].frame)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[z.Adr()] != nil, 65
+					})
+					out.do = func(in ...IN) OUT {
+						field := rt2.ValueOf(in[0].frame)[z.Adr()].(scope.Variable)
+						field.Set(fn(nil))
+						return End()
+					}
+					out.next = LATER
+					return
+				default:
+					halt.As(100, reflect.TypeOf(z))
+				}
+				panic(0)
 			}))
 		} else {
 			//fmt.Println("NEW here")

rt2/rules/deref.go

@@ -18,9 +18,9 @@ func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	//fmt.Println("deref from ptr", n.Ptr())
 	if n.Ptr() {
-		switch l := n.Left().Object().(type) {
-		case object.ParameterObject, object.VariableObject:
-			sc.Select(l.Adr(), func(v scope.Value) {
+		switch l := n.Left().(type) {
+		case node.ParameterNode, node.VariableNode:
+			sc.Select(l.Object().Adr(), func(v scope.Value) {
 				ptr, ok := v.(scope.Pointer)
 				assert.For(ok, 60, reflect.TypeOf(v))
 				rt2.ValueOf(f.Parent())[n.Adr()] = ptr.Get()
@@ -31,6 +31,28 @@ func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				}
 			})
 			return seq, ret
+		case node.FieldNode, node.CallNode:
+			rt2.Push(rt2.New(l), f)
+			rt2.Assert(f, func(f frame.Frame) (bool, int) {
+				return rt2.ValueOf(f)[l.Adr()] != nil || rt2.RegOf(f)["RETURN"] != nil, 63
+			})
+			seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+				v := rt2.ValueOf(f)[l.Adr()]
+				if v == nil {
+					v = rt2.RegOf(f)["RETURN"].(scope.Value)
+				}
+				ptr, ok := v.(scope.Pointer)
+				assert.For(ok, 60, reflect.TypeOf(v))
+				rt2.ValueOf(f.Parent())[n.Adr()] = ptr.Get()
+				if scope.GoTypeFrom(ptr.Get()) == nil {
+					seq, ret = doTrap(f, traps.NILderef)
+				} else {
+					seq, ret = frame.End()
+				}
+				return frame.End()
+			}
+			ret = frame.LATER
+			return seq, ret
 		default:
 			halt.As(100, l.Adr(), reflect.TypeOf(l))
 		}

rt2/scope/modern/hp.go

@@ -98,7 +98,7 @@ func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
 		}
 	}
 	switch v := n.(type) {
-	case node.VariableNode:
+	case node.VariableNode, node.FieldNode:
 		switch t := v.Object().Complex().(type) {
 		case object.PointerType:
 			talloc(t)
@@ -107,7 +107,7 @@ func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
 			halt.As(100, reflect.TypeOf(t))
 		}
 	default:
-		halt.As(101, reflect.TypeOf(v))
+		halt.As(101, reflect.TypeOf(v), v)
 	}
 	assert.For(res != nil, 60)
 	runtime.SetFinalizer(res, fin)

rt2/scope/modern/val.go

@@ -48,8 +48,30 @@ type ptr struct {
 }
 
 type idx struct {
-	arr *arr
-	idx int
+	some scope.Array
+	idx  int
+}
+
+func (i *idx) link() object.Object {
+	switch a := i.some.(type) {
+	case *arr:
+		return a.link
+	case *dynarr:
+		return a.link
+	default:
+		panic(0)
+	}
+}
+
+func (i *idx) val() []interface{} {
+	switch a := i.some.(type) {
+	case *arr:
+		return a.val
+	case *dynarr:
+		return a.val
+	default:
+		panic(0)
+	}
 }
 
 func (r *rec) String() string {
@@ -189,7 +211,24 @@ func (a *arr) Get(id scope.Value) scope.Value {
 		if len(a.val) == 0 {
 			a.val = make([]interface{}, int(a.length))
 		}
-		return &idx{arr: a, idx: int(i)}
+		return &idx{some: a, idx: int(i)}
+	default:
+		halt.As(100, reflect.TypeOf(i))
+	}
+	panic(0)
+}
+
+//возвращает *idx
+func (a *dynarr) Get(id scope.Value) scope.Value {
+	switch i := id.(type) {
+	case *data:
+		return a.Get(i.val.(scope.Value))
+	case INTEGER:
+		assert.For(int(i) < len(a.val), 20)
+		if len(a.val) == 0 {
+			panic(0)
+		}
+		return &idx{some: a, idx: int(i)}
 	default:
 		halt.As(100, reflect.TypeOf(i))
 	}
@@ -197,7 +236,7 @@ func (a *arr) Get(id scope.Value) scope.Value {
 }
 
 func (i *idx) Id() cp.ID {
-	return i.arr.Id()
+	return i.some.Id()
 }
 
 func (i *idx) String() string {
@@ -205,18 +244,27 @@ func (i *idx) String() string {
 }
 
 func (i *idx) Set(v scope.Value) {
-	t := i.arr.link.Complex()
+	t := i.link().Complex()
 	switch x := v.(type) {
 	case *idx:
-		if x.arr.link.Complex().(object.ArrayType).Base() != object.COMPLEX {
-			i.arr.val[i.idx] = x.arr.val[x.idx]
+		var comp object.Type = object.NOTYPE
+		switch xt := x.link().Complex().(type) {
+		case object.ArrayType:
+			comp = xt.Base()
+		case object.DynArrayType:
+			comp = xt.Base()
+		default:
+			halt.As(100, xt)
+		}
+		if comp != object.COMPLEX {
+			i.val()[i.idx] = x.val()[x.idx]
 		} else {
-			switch z := x.arr.val[x.idx].(type) {
+			switch z := x.val()[x.idx].(type) {
 			case *arr:
 				t := z.link.Complex().(object.ArrayType).Base()
 				switch t {
 				case object.CHAR:
-					i.arr.val[i.idx].(*arr).Set(STRING(z.tryString()))
+					i.val()[i.idx].(*arr).Set(STRING(z.tryString()))
 				default:
 					halt.As(100, t)
 				}
@@ -227,26 +275,26 @@ func (i *idx) Set(v scope.Value) {
 	case *data:
 		i.Set(x.val.(scope.Value))
 	case CHAR:
-		i.arr.val[i.idx] = x
+		i.val()[i.idx] = x
 	case STRING:
 		_ = t.(object.ArrayType)
-		i.arr.val[i.idx].(*arr).Set(x)
+		i.val()[i.idx].(*arr).Set(x)
 	case REAL:
-		i.arr.val[i.idx] = x
+		i.val()[i.idx] = x
 	default:
 		halt.As(100, reflect.TypeOf(x), x, t)
 	}
 }
 
 func (i *idx) Get() scope.Value {
-	x := i.arr.val[i.idx]
+	x := i.val()[i.idx]
 	switch z := x.(type) {
 	case *arr:
 		return z
 	case CHAR:
 		return z
 	case nil:
-		b := i.arr.link.Complex().(object.ArrayType).Base()
+		b := i.link().Complex().(object.ArrayType).Base()
 		switch b {
 		case object.CHAR:
 			return CHAR(rune(0))
@@ -311,7 +359,7 @@ func (d *data) Set(v scope.Value) {
 		assert.For(t.Type() == object.PROCEDURE, 22)
 		d.val = x
 	case *idx:
-		d.val = x.arr.val[x.idx]
+		d.val = x.val()[x.idx]
 	case INTEGER:
 		switch d.link.Type() {
 		case object.INTEGER:
@@ -646,11 +694,11 @@ func gfrom(v scope.Value) interface{} {
 		}
 		panic(0)
 	case *idx:
-		switch n.arr.link.Complex().(object.ArrayType).Base() {
+		switch n.link().Complex().(object.ArrayType).Base() {
 		case object.CHAR:
 			return rune(n.Get().(CHAR))
 		default:
-			halt.As(100, n.arr.link.Complex().(object.ArrayType).Base())
+			halt.As(100, n.link().Complex().(object.ArrayType).Base())
 		}
 		panic(0)
 	case PTR: