добавил и отладил работу итератора и прохода по итератору

cp/object/type.go

@@ -26,6 +26,7 @@ const (
 	COMPLEX
 	STRING
 	SHORTSTRING
+	NIL
 )
 
 func (t Type) String() string {
@@ -60,6 +61,8 @@ func (t Type) String() string {
 		return "STRING"
 	case SHORTSTRING:
 		return "SHORTSTRING"
+	case NIL:
+		return "NIL"
 	default:
 		return fmt.Sprint("looks like new type here", int(t))
 	}

fw.go

@@ -10,17 +10,22 @@ import (
 	_ "fw/rt2/rules"
 	"fw/rt2/scope"
 	_ "fw/rt2/scope/modern"
+	"fw/utils"
 	"time"
 	"ypk/assert"
 )
 
 var name string
+var heap scope.Manager
 
 func init() {
 	flag.StringVar(&name, "i", "", "-i name.ext")
 }
 
 func close() {
+	utils.PrintFrame("____")
+	utils.PrintFrame(heap)
+	utils.PrintFrame("^^^^")
 	fmt.Println("closed")
 }
 
@@ -33,7 +38,8 @@ func main() {
 	global.global = global
 	modList := rtmod.New()
 	global.Attach(context.MOD, modList)
-	global.Attach(context.HEAP, scope.New(context.HEAP))
+	heap = scope.New(context.HEAP)
+	global.Attach(context.HEAP, heap)
 	t0 := time.Now()
 	var init []*mod.Module
 	_, err := modList.Load(name, func(m *mod.Module) {

rt2/nodeframe/frame.go

@@ -72,8 +72,8 @@ type nodeFrame struct {
 func done(f frame.Frame) {
 	utils.PrintFrame("____")
 	utils.PrintFrame(f.Domain().Discover(context.SCOPE))
-	utils.PrintFrame("--")
-	utils.PrintFrame(f.Domain().Discover(context.HEAP))
+	//	utils.PrintFrame("--")
+	//	utils.PrintFrame(f.Domain().Discover(context.HEAP))
 	utils.PrintFrame("^^^^")
 }
 
@@ -99,7 +99,7 @@ func (f *nodeFrame) Do() frame.WAIT {
 func (f *nodeFrame) onPush() {
 	f.num = count
 	count++
-	assert.For(count < 15, 40)
+	//	assert.For(count < 15, 40)
 	utils.PrintFrame("_", "PUSH", reflect.TypeOf(f.ir))
 	f.seq = decision.PrologueFor(f.ir)
 }

rt2/rules/assign.go

@@ -69,7 +69,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return frame.End()
 			}
 			ret = frame.NOW
-		case node.OperationNode, node.CallNode, node.DerefNode:
+		case node.OperationNode, node.CallNode, node.DerefNode, node.FieldNode:
 			rt2.Push(rt2.New(a.Right()), f)
 			rt2.Assert(f, func(f frame.Frame) (bool, int) {
 				return rt2.ValueOf(f)[a.Right().Adr()] != nil, 61
@@ -177,7 +177,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return End()
 			}))
 		} else {
-			fmt.Println("NEW here")
+			//fmt.Println("NEW here")
 			fn := heap.Allocate(a.Left())
 			sc.Update(a.Left().Object().Adr(), fn)
 			return frame.End()

rt2/rules/call.go

@@ -61,7 +61,7 @@ func process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
 			if err := json.Unmarshal([]byte(val), msg); err == nil {
 				switch msg.Type {
 				case "log":
-					fmt.Println(msg.Data)
+					fmt.Print(msg.Data)
 					callHandler(f, scope.FindObjByName(sm, "go_handler"), `{"type":"log"}`)
 				default:
 					panic(40)

rt2/rules/table.go

@@ -10,7 +10,7 @@ import (
 	"fw/rt2/decision"
 	"fw/rt2/frame"
 	"fw/rt2/frame/std"
-	rt_module "fw/rt2/module"
+	//	rt_module "fw/rt2/module"
 	"fw/rt2/scope"
 	"fw/utils"
 	"reflect"
@@ -114,7 +114,7 @@ func epilogue(n node.Node) frame.Sequence {
 		}
 	case node.EnterNode:
 		return func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			fmt.Println(rt_module.DomainModule(f.Domain()).Name)
+			//fmt.Println(rt_module.DomainModule(f.Domain()).Name)
 			sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
 			sm.Target().(scope.ScopeAllocator).Dispose(n)
 			//возвращаем результаты вызова функции
@@ -228,7 +228,7 @@ func run(global context.Domain, init []*module.Module) {
 		t0 := time.Now()
 		for x := frame.NOW; x == frame.NOW; x = root.Do() {
 			utils.PrintFrame("STEP", i)
-			assert.For(i < 1000, 40)
+			//assert.For(i < 1000, 40)
 			i++
 		}
 		t1 := time.Now()

rt2/scope/modern/ms.go

@@ -191,13 +191,13 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 	ret = frame.NOW
 	var sm scope.Manager
 	for next := par.Objects; next != nil; next = next.Link() {
+		global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
 		mod := rtm.ModuleOfNode(f.Domain(), val)
 		if mod != nil {
-			global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
 			//fmt.Println(mod.Name)
 			global = global.Discover(mod.Name).(context.Domain)
 			sm = global.Discover(context.SCOPE).(scope.Manager)
-		} else {
+		} else { //для фиктивных узлов, которые созданы рантаймом, типа INC/DEC
 			sm = a.area
 		}
 		switch o := next.(type) {
@@ -209,6 +209,19 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			case node.VariableNode:
 				v := sm.Select(nv.Object().Adr())
 				l.v[l.k[o.Adr()]].Set(v)
+			case node.FieldNode:
+				nf := rt2.New(nv)
+				rt2.Push(nf, f)
+				rt2.Assert(f, func(f frame.Frame) (bool, int) {
+					return rt2.ValueOf(f)[nv.Adr()] != nil, 60
+				})
+				rt2.ReplaceDomain(nf, global)
+				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+					v := rt2.ValueOf(f)[nv.Adr()]
+					l.v[l.k[o.Adr()]].Set(v)
+					return end, frame.NOW
+				}
+				ret = frame.LATER
 			default:
 				halt.As(40, reflect.TypeOf(nv))
 			}

rt2/scope/modern/val.go

@@ -474,6 +474,8 @@ func newConst(n node.Node) scope.Value {
 			return STRING(x.Data().(string))
 		case object.SHORTSTRING:
 			return SHORTSTRING(x.Data().(string))
+		case object.NIL:
+			return NIL
 		default:
 			panic(fmt.Sprintln(x.Type()))
 		}
@@ -1214,6 +1216,14 @@ func (o *ops) Neq(a, b scope.Value) scope.Value {
 			return o.Neq(a, vfrom(b))
 		default:
 			switch x := a.(type) {
+			case *ptr:
+				switch y := b.(type) {
+				case PTR:
+					assert.For(y == NIL, 40)
+					return BOOLEAN(x.val != nil && x.val.id != 0)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			case INTEGER:
 				switch y := b.(type) {
 				case INTEGER:

utils/debug.go

@@ -14,12 +14,12 @@ func PrintFrame(x ...interface{}) {
 
 func PrintScope(x ...interface{}) {
 	if debugScope {
-		fmt.Println(x[0], x[1])
+		fmt.Println(x...)
 	}
 }
 
 func PrintTrap(x ...interface{}) {
 	if debugTrap {
-		fmt.Println(x[0], x[1])
+		fmt.Println(x...)
 	}
 }

xev/converter.go

@@ -166,6 +166,8 @@ func convertData(typ string, val string, conv convertable) {
 		conv.SetData(val)
 	case "":
 		conv.SetType(object.NOTYPE)
+	case "NIL":
+		conv.SetType(object.NIL)
 	default:
 		panic(fmt.Sprintln("no such constant type", typ))
 	}