почистил логгирование, убрал баг из Demo6

rt2/nodeframe/frame.go

@@ -70,18 +70,18 @@ type nodeFrame struct {
 }
 
 func done(f frame.Frame) {
-	fmt.Println("____")
-	fmt.Println(f.Domain().Discover(context.SCOPE))
-	fmt.Println("--")
-	fmt.Println(f.Domain().Discover(context.HEAP))
-	fmt.Println("^^^^")
+	utils.PrintFrame("____")
+	utils.PrintFrame(f.Domain().Discover(context.SCOPE))
+	utils.PrintFrame("--")
+	utils.PrintFrame(f.Domain().Discover(context.HEAP))
+	utils.PrintFrame("^^^^")
 }
 
 func (f *nodeFrame) Do() frame.WAIT {
 	assert.For(f.seq != nil, 20)
 	next, ret := f.seq(f)
 	utils.PrintFrame(f.num, ret, reflect.TypeOf(f.ir), f.ir)
-	fmt.Println("data:", f.data, f.value)
+	utils.PrintFrame("data:", f.data, f.value)
 	if next != nil {
 		assert.For(ret != frame.STOP, 40)
 		f.seq = next
@@ -118,7 +118,7 @@ func (f *nodeFrame) OnPop() {
 			if !ok {
 				panic(fmt.Sprintln("assert", code, "for", reflect.TypeOf(ff.ir)))
 			} else {
-				fmt.Println("assert passed", code, "for", reflect.TypeOf(ff.ir))
+				utils.PrintFrame("assert passed", code, "for", reflect.TypeOf(ff.ir))
 			}
 			ff.assertion = nil
 		}

rt2/rules/call.go

@@ -12,6 +12,7 @@ import (
 	"fw/rt2/frame"
 	rt_mod "fw/rt2/module"
 	"fw/rt2/scope"
+	"fw/utils"
 	"reflect"
 	"ypk/assert"
 	"ypk/halt"
@@ -148,7 +149,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				m := ml.Loaded(imp)
 				proc := m.ObjectByName(m.Enter, n.Left().Object().Name())
 				nl := m.NodeByObject(proc)
-				fmt.Println("foreign call", len(nl))
+				utils.PrintFrame("foreign call", len(nl))
 				call(nl[0], f.Domain().Discover(context.UNIVERSE).(context.Domain).Discover(imp).(context.Domain))
 			}
 		}

rt2/rules/deref.go

@@ -1,8 +1,6 @@
 package rules
 
 import (
-	"fmt"
-	//	"fw/cp"
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2"
@@ -17,7 +15,7 @@ import (
 func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f).(node.DerefNode)
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-	fmt.Println("deref from ptr", n.Ptr())
+	//fmt.Println("deref from ptr", n.Ptr())
 	if n.Ptr() {
 		switch l := n.Left().Object().(type) {
 		case object.ParameterObject, object.VariableObject:

rt2/rules/op.go

@@ -87,7 +87,8 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case operation.NOT:
 		switch n.Left().(type) {
 		case node.ConstantNode:
-			rt2.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
+			//			rt2.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
+			panic(0)
 			return op, frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {

rt2/rules/return.go

@@ -18,7 +18,7 @@ func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
 		case node.ConstantNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				rt2.DataOf(f.Parent())[a.Object()] = a.Left().(node.ConstantNode).Data()
+				//rt2.DataOf(f.Parent())[a.Object()] = a.Left().(node.ConstantNode).Data()
 				rt2.ValueOf(f.Parent())[a.Object().Adr()] = sc.Provide(a.Left())(nil)
 				return frame.End()
 			}

rt2/rules/table.go

@@ -179,7 +179,7 @@ func (f *flow) Do() (ret frame.WAIT) {
 			}
 		}
 	}
-	fmt.Println(">", ret)
+	utils.PrintFrame(">", ret)
 	return ret
 }
 
@@ -217,7 +217,7 @@ func run(global context.Domain, init []*module.Module) {
 		global.Attach(context.STACK, root)
 		for i := len(init) - 1; i >= 0; i-- {
 			ret := init[i]
-			fmt.Println("queue", ret.Name)
+			utils.PrintScope("queue", ret.Name)
 			nf = rt2.New(ret.Enter)
 			root.PushFor(nf, nil)
 			ff = append(ff, nf)
@@ -227,7 +227,7 @@ func run(global context.Domain, init []*module.Module) {
 		i := 0
 		t0 := time.Now()
 		for x := frame.NOW; x == frame.NOW; x = root.Do() {
-			fmt.Println("STEP", i)
+			utils.PrintFrame("STEP", i)
 			assert.For(i < 1000, 40)
 			i++
 		}

rt2/scope/modern/ms.go

@@ -12,6 +12,7 @@ import (
 	"fw/rt2/frame"
 	rtm "fw/rt2/module"
 	"fw/rt2/scope"
+	"fw/utils"
 	"reflect"
 	"ypk/assert"
 	"ypk/halt"
@@ -89,10 +90,10 @@ func (a *area) Provide(x interface{}) scope.ValueFor {
 func (l *level) alloc(mod *cpm.Module, root node.Node, ol []object.Object, skip map[cp.ID]interface{}) {
 	for _, o := range ol {
 		imp := mod.ImportOf(o)
-		fmt.Println(reflect.TypeOf(o), o.Adr())
+		utils.PrintScope(reflect.TypeOf(o), o.Adr())
 		_, field := o.(object.FieldObject)
 		if imp == "" && (skip[o.Adr()] == nil || (field && l.nested)) {
-			fmt.Println("next", l.next)
+			utils.PrintScope("next", l.next)
 			switch x := o.(type) {
 			case object.VariableObject, object.FieldObject:
 				switch t := o.Complex().(type) {
@@ -142,7 +143,7 @@ func (l *level) alloc(mod *cpm.Module, root node.Node, ol []object.Object, skip
 
 func (a *salloc) Allocate(n node.Node, final bool) {
 	mod := rtm.DomainModule(a.area.d)
-	fmt.Println("ALLOCATE FOR", mod.Name, n.Adr())
+	utils.PrintScope("ALLOCATE FOR", mod.Name, n.Adr())
 	tl := mod.Types[n]
 	skip := make(map[cp.ID]interface{}) //для процедурных типов в общей куче могут валяться переменные, скипаем их
 	for _, t := range tl {
@@ -173,7 +174,7 @@ func (a *salloc) Dispose(n node.Node) {
 }
 
 func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, ret frame.WAIT) {
-	fmt.Println("INITIALIZE")
+	utils.PrintScope("INITIALIZE")
 	l := a.area.top()
 	assert.For(l != nil && !l.ready, 20)
 	val := par.Values
@@ -188,11 +189,17 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 	}
 	seq = end
 	ret = frame.NOW
+	var sm scope.Manager
 	for next := par.Objects; next != nil; next = next.Link() {
 		mod := rtm.ModuleOfNode(f.Domain(), val)
-		global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
-		global = global.Discover(mod.Name).(context.Domain)
-		ar := global.Discover(context.SCOPE).(scope.Manager)
+		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 {
+			sm = a.area
+		}
 		switch o := next.(type) {
 		case object.VariableObject:
 			switch nv := val.(type) {
@@ -200,7 +207,7 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 				v := newConst(nv)
 				l.v[l.k[o.Adr()]].Set(v)
 			case node.VariableNode:
-				v := ar.Select(nv.Object().Adr())
+				v := sm.Select(nv.Object().Adr())
 				l.v[l.k[o.Adr()]].Set(v)
 			default:
 				halt.As(40, reflect.TypeOf(nv))
@@ -209,7 +216,7 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			switch nv := val.(type) {
 			case node.VariableNode:
 				old := l.r[l.k[o.Adr()]].(*ref)
-				l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: ar, id: nv.Object().Adr()}
+				l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: sm, id: nv.Object().Adr()}
 			case node.ConstantNode: //array :) заменяем ссылку на переменную
 				old := l.r[l.k[o.Adr()]].(*ref)
 				l.r[l.k[o.Adr()]] = nil
@@ -268,7 +275,7 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 	var upd func(x int, id cp.ID)
 	var k int
 	upd = func(x int, id cp.ID) {
-		fmt.Println("UPDATE", id)
+		utils.PrintScope("UPDATE", id)
 		for i := x - 1; i >= 0 && k == 0; i-- {
 			l := a.data[i]
 			if l.ready {
@@ -278,7 +285,7 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 					if v == nil { //ref?
 						r := l.r[k]
 						if r != nil {
-							fmt.Println("ref")
+							utils.PrintScope("ref")
 							if r.(*ref).sc == a {
 								upd(i, r.(*ref).id)
 							} else {
@@ -302,7 +309,7 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
 	var sel func(x int, id cp.ID)
 	sel = func(x int, id cp.ID) {
-		fmt.Println("SELECT", id)
+		utils.PrintScope("SELECT", id)
 		for i := x - 1; i >= 0 && ret == nil; i-- {
 			l := a.data[i]
 			k := 0
@@ -316,7 +323,7 @@ func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
 							if l.l[k] != nil { //rec
 								panic(0)
 							} else {
-								fmt.Println("ref")
+								utils.PrintScope("ref")
 								if r.(*ref).sc == a {
 									sel(i, r.(*ref).id)
 								} else {
@@ -378,7 +385,7 @@ func (a *area) Domain() context.Domain { return a.d }
 func (a *area) Handle(msg interface{}) {}
 
 func fn(mgr scope.Manager, name string) (ret object.Object) {
-	fmt.Println("FIND", name)
+	utils.PrintScope("FIND", name)
 	a, ok := mgr.(*area)
 	assert.For(ok, 20)
 	assert.For(name != "", 21)
@@ -387,12 +394,12 @@ func fn(mgr scope.Manager, name string) (ret object.Object) {
 		for _, v := range l.v {
 			switch vv := v.(type) {
 			case *data:
-				fmt.Println(vv.link.Name())
+				utils.PrintScope(vv.link.Name())
 				if vv.link.Name() == name {
 					ret = vv.link
 				}
 			default:
-				fmt.Println(reflect.TypeOf(vv))
+				utils.PrintScope(reflect.TypeOf(vv))
 			}
 		}
 	}

rt2/scope/modern/val.go

@@ -6,6 +6,7 @@ import (
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2/scope"
+	"fw/utils"
 	"math"
 	"math/big"
 	"reflect"
@@ -243,7 +244,7 @@ func (a *dynarr) String() (ret string) {
 }
 
 func (d *data) Set(v scope.Value) {
-	fmt.Println("set data")
+	utils.PrintScope("set data")
 	switch x := v.(type) {
 	case *data:
 		if d.link.Type() == x.link.Type() {
@@ -961,6 +962,8 @@ func (o *ops) Len(a object.Object, _a, _b scope.Value) (ret scope.Value) {
 			switch t := _a.(type) {
 			case *arr:
 				ret = INTEGER(t.length)
+			case *dynarr:
+				ret = INTEGER(len(t.val))
 			default:
 				halt.As(100, "unsupported", reflect.TypeOf(t))
 			}
@@ -1253,7 +1256,6 @@ func (o *ops) Lss(a, b scope.Value) scope.Value {
 			case LONGINT:
 				switch y := b.(type) {
 				case LONGINT:
-					fmt.Println("LESSER", x, y, BOOLEAN(x < y))
 					return BOOLEAN(x < y)
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))

rt2/utils.go

@@ -1,27 +1,22 @@
 package rt2
 
 import (
-	"fmt"
 	"fw/cp"
 	"fw/cp/node"
 	"fw/rt2/context"
 	"fw/rt2/frame"
 	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
-	"reflect"
 )
 
 var utils nodeframe.NodeFrameUtils
 
-func DataOf(f frame.Frame) map[interface{}]interface{} { panic(100) }
-func RegOf(f frame.Frame) map[interface{}]interface{}  { return utils.DataOf(f) }
-func ValueOf(f frame.Frame) map[cp.ID]scope.Value {
-	fmt.Println("getval ", reflect.TypeOf(NodeOf(f)))
-	return utils.ValueOf(f)
-}
-func NodeOf(f frame.Frame) node.Node { return utils.NodeOf(f) }
-func Push(f, p frame.Frame)          { utils.Push(f, p) }
-func New(n node.Node) frame.Frame    { return utils.New(n) }
+//func DataOf(f frame.Frame) map[interface{}]interface{} { panic(100) }
+func RegOf(f frame.Frame) map[interface{}]interface{} { return utils.DataOf(f) }
+func ValueOf(f frame.Frame) map[cp.ID]scope.Value     { return utils.ValueOf(f) }
+func NodeOf(f frame.Frame) node.Node                  { return utils.NodeOf(f) }
+func Push(f, p frame.Frame)                           { utils.Push(f, p) }
+func New(n node.Node) frame.Frame                     { return utils.New(n) }
 func ScopeOf(f frame.Frame) scope.Manager {
 	return f.Domain().Discover(context.SCOPE).(scope.Manager)
 }

utils/debug.go

@@ -2,8 +2,8 @@ package utils
 
 import "fmt"
 
-var debugFrame = true
-var debugScope = true
+var debugFrame = false
+var debugScope = false
 var debugTrap = true
 
 func PrintFrame(x ...interface{}) {

xev/converter.go

@@ -550,7 +550,7 @@ func buildMod(r *Result) *module.Module {
 				this.mod = g.CptProc
 			}
 			this.scopes[sc], this.types[sc] = r.buildScope(g.NodeList)
-			fmt.Println(sc, len(this.scopes[sc]), len(this.types[sc]))
+			//fmt.Println(sc, len(this.scopes[sc]), len(this.types[sc]))
 		}
 	}
 	//временные структуры перегоняем в рабочие
@@ -582,7 +582,7 @@ func buildMod(r *Result) *module.Module {
 	for k, v := range scopes {
 		if k < 0 {
 			impList[v.mod] = module.Import{Objects: v.scopes[k], Name: v.mod}
-			fmt.Println("типы не учтены", len(v.types[k]))
+			//fmt.Println("типы не учтены", len(v.types[k]))
 		}
 	}
 	return &module.Module{Nodes: nodeList, Objects: scopeList, Types: typeList, Enter: root, Imports: impList}