переписал дерево данных на стандартных списках голанга, чтоб побыстрее было, добрался до нормальных тестов, а они падают

cp/module/module.go

@@ -102,8 +102,10 @@ func (m *Module) NodeByObject(obj object.Object) (ret []node.Node) {
 	assert.For(obj != nil, 20)
 	for i := 0; (i < len(m.Nodes)) && (ret == nil); i++ {
 		node := m.Nodes[i]
-		if node.Object() == obj {
-			ret = append(ret, node)
+		if node.Object() != nil {
+			if node.Object().Adr(0, 0) == obj.Adr() {
+				ret = append(ret, node)
+			}
 		}
 	}
 	return ret

fw.go

@@ -36,8 +36,8 @@ func main() {
 	flag.Parse()
 	utils.Debug(debug)
 	if name == "" {
-		name = "XevDemo13"
-		utils.Debug(true)
+		name = "Start"
+		utils.Debug(false)
 	}
 	global := &stdDomain{god: true}
 	global.global = global

rt2/rules2/wrap/data/items/items.go

@@ -1,17 +1,9 @@
 package items
 
 import (
-	"container/list"
-	"fmt"
-	"fw/utils"
 	"ypk/assert"
-	"ypk/halt"
 )
 
-type Opts int
-
-const INIT Opts = iota
-
 type ID struct {
 	In   Data
 	This Key
@@ -19,6 +11,7 @@ type ID struct {
 
 type Key interface {
 	EqualTo(Key) int
+	Hash() int
 }
 
 type Value interface {
@@ -38,7 +31,7 @@ type Item interface {
 
 type Data interface {
 	Set(Key, Item)
-	Get(Key, ...Opts) Item
+	Get(Key) Item
 	Remove(Key)
 
 	Hold(Key)
@@ -51,148 +44,87 @@ type Data interface {
 	Begin()
 	End()
 	Drop()
-	Check(...Opts)
 }
 
 func New() Data {
-	return &data{x: list.New(), check: true}
+	return &tree{root: make([]*node, 0)}
 }
 
-type dummy struct {
-	k Key
+type tree struct {
+	root []*node
 }
 
-func (d *dummy) String() string {
-	return fmt.Sprint(d.k)
+type node struct {
+	data map[int]Value
 }
 
-type data struct {
-	x     *list.List
-	check bool
+func (t *tree) Begin() {
+	n := &node{data: make(map[int]Value)}
+	t.root = append(t.root, n)
 }
 
-func (d *data) find(k Key, from *list.Element) (ret Value, elem *list.Element) {
-	if from == nil {
-		from = d.x.Front()
-	}
-	for x := from; x != nil && ret == nil; x = x.Next() {
-		if v, ok := x.Value.(Value); ok {
-			if z := v.KeyOf().EqualTo(k); z == 0 {
-				ret = v
-			}
-		}
+func (t *tree) top() (ret *node) {
+	if len(t.root) > 0 {
+		ret = t.root[len(t.root)-1]
 	}
 	return
 }
 
-func (d *data) Exists(k Key) bool {
-	r, _ := d.find(k, nil)
-	return r != nil
+func (t *tree) End() {
+	var this *node
+	if len(t.root) > 0 {
+		this = t.root[len(t.root)-1]
+	}
+	assert.For(this != nil, 20)
 }
 
-func (d *data) Set(k Key, v Item) {
-	assert.For(v != nil, 20)
-	assert.For(v.KeyOf() == nil, 21)
-	x, _ := d.find(k, nil)
-	if x == nil {
-		v.KeyOf(k)
-		d.x.PushFront(v)
-	} else {
-		halt.As(123)
+func (t *tree) Drop() {
+	tmp := make([]*node, 0)
+	for i := 0; i < len(t.root)-1; i++ {
+		tmp = append(tmp, t.root[i])
 	}
+	t.root = tmp
 }
 
-func (d *data) ForEach(f func(Value) bool) {
-	ok := false
-	for x := d.x.Front(); x != nil && !ok; {
-		if v, da := x.Value.(Value); da {
-			ok = f(v)
-		}
-		x = x.Next()
-	}
+func (t *tree) Set(k Key, i Item) {
+	assert.For(i != nil, 20)
+	x := t.top()
+	x.data[k.Hash()] = i
+	i.KeyOf(k)
 }
 
-func (d *data) Get(k Key, opts ...Opts) (ret Item) {
-	if len(opts) == 0 {
-		d.Check()
-	} else {
-		switch opts[0] {
-		case INIT: //do nothing
-		default:
-			halt.As(100, fmt.Sprint(opts))
-		}
-	}
-	for x, e := d.find(k, nil); x != nil && ret == nil; {
-		switch v := x.(type) {
-		case nil: //do nothing
+func (t *tree) Get(k Key) (ret Item) {
+	for i := len(t.root) - 1; i >= 0 && ret == nil; i-- {
+		tmp := t.root[i].data[k.Hash()]
+		switch this := tmp.(type) {
 		case Item:
-			ret = v
+			ret = tmp.(Item)
 		case Link:
-			to := v.To()
-			if to.In == d {
-				x, e = d.find(to.This, e)
-			} else {
-				ret = to.In.Get(to.This, opts...)
-			}
+			ret = this.To().In.Get(this.To().This)
 		}
 	}
-	assert.For(ret != nil, 60, k)
 	return
 }
 
-func (d *data) Remove(key Key) {
-	ok := false
-	for x := d.x.Front(); x != nil && !ok; x = x.Next() {
-		switch v := x.Value.(type) {
-		case Value:
-			if v.KeyOf().EqualTo(key) == 0 {
-				d.x.Remove(x)
-				ok = true
-			}
+func (t *tree) Remove(k Key) {
+	var tmp Value
+	for i := len(t.root) - 1; i >= 0 && tmp != nil; i-- {
+		tmp = t.root[i].data[k.Hash()]
+		if tmp != nil {
+			delete(t.root[i].data, k.Hash())
 		}
 	}
 }
 
-func (d *data) Hold(key Key) {
-	assert.For(key != nil, 20)
-	d.x.PushFront(&dummy{k: key})
+type dummy struct {
+	k Key
 }
 
-func (d *data) Link(key Key, to ID) {
-	assert.For(key != nil, 20)
-	var this *list.Element
-	for x := d.x.Front(); x != nil && this == nil; {
-		if _, ok := x.Value.(*dummy); ok {
-			this = x
-		}
-		x = x.Next()
-		if x != nil {
-			if _, ok := x.Value.(*limit); ok {
-				x = nil
-			}
-		}
-	}
-	assert.For(this != nil, 60)
-	this.Value = &link{k: key, id: to}
-}
+func (d *dummy) KeyOf(...Key) Key { return d.k }
 
-func (d *data) Put(key Key, item Item) {
-	assert.For(key != nil, 20)
-	var this *list.Element
-	for x := d.x.Front(); x != nil && this == nil; {
-		if _, ok := x.Value.(*dummy); ok {
-			this = x
-		}
-		x = x.Next()
-		if x != nil {
-			if _, ok := x.Value.(*limit); ok {
-				x = nil
-			}
-		}
-	}
-	assert.For(this != nil, 60)
-	this.Value = item
-	item.KeyOf(key)
+func (t *tree) Hold(key Key) {
+	n := t.top()
+	n.data[key.Hash()] = &dummy{k: key}
 }
 
 type link struct {
@@ -214,55 +146,28 @@ func (l *link) To(id ...ID) ID {
 	return l.id
 }
 
-func NewLink(to ID) Link {
-	return &link{id: to}
+func (t *tree) Link(key Key, to ID) {
+	l := &link{k: key, id: to}
+	n := t.top()
+	n.data[key.Hash()] = l
 }
 
-type limit struct{}
-type limit_key struct{}
-
-func (l *limit_key) EqualTo(Key) int { return -1 }
-func (l *limit) KeyOf(...Key) Key    { return &limit_key{} }
-
-func (d *data) Check(o ...Opts) {
-	if len(o) == 1 {
-		d.check = false
-	}
-	t := d.x.Front()
-	if d.check && t != nil {
-		_, ok := t.Value.(*limit)
-		assert.For(ok, 30, "data not ready")
-	}
-}
-
-func (d *data) Begin() {
-	utils.PrintScope("BEGIN")
-	d.Check()
+func (t *tree) Put(k Key, i Item) {
+	t.Set(k, i)
 }
 
-func (d *data) End() {
-	utils.PrintScope("END")
-	for x := d.x.Front(); x != nil; {
-		d, ok := x.Value.(*dummy)
-		assert.For(!ok, 40, "missing value for item ", d)
-		x = x.Next()
-		if x != nil {
-			if _, ok := x.Value.(*limit); ok {
-				x = nil
-			}
-		}
+func (t *tree) Exists(k Key) (ret bool) {
+	for i := len(t.root) - 1; i >= 0 && !ret; i-- {
+		ret = t.root[i].data[k.Hash()] != nil
 	}
-	d.x.PushFront(&limit{})
+	return
 }
-func (d *data) Drop() {
-	d.Check()
-	for x := d.x.Front(); x != nil; {
-		d.x.Remove(x)
-		x = d.x.Front()
-		if x != nil {
-			if _, ok := x.Value.(*limit); ok {
-				x = nil
-			}
+
+func (t *tree) ForEach(f func(Value) bool) {
+	ok := false
+	for i := len(t.root) - 1; i >= 0 && !ok; i-- {
+		for _, v := range t.root[i].data {
+			ok = f(v)
 		}
 	}
 }

rt2/rules2/wrap/data/stack.go

@@ -44,6 +44,10 @@ func (k *key) String() string {
 	return fmt.Sprint(k.id)
 }
 
+func (k *key) Hash() int {
+	return int(k.id)
+}
+
 func (k *key) EqualTo(to items.Key) int {
 	kk, ok := to.(*key)
 	if ok && kk.id == k.id {
@@ -81,11 +85,7 @@ func (i *item) Value() scope.Value {
 
 func (a *area) Select(this cp.ID, val scope.ValueOf) {
 	utils.PrintScope("SELECT", this)
-	opts := make([]items.Opts, 0)
-	if a.unsafe {
-		opts = append(opts, items.INIT)
-	}
-	d, ok := a.il.Get(&key{id: this}, opts...).(*item)
+	d, ok := a.il.Get(&key{id: this}).(*item)
 	assert.For(ok, 20, this)
 	val(d.Value())
 }
@@ -317,7 +317,7 @@ func (a *salloc) proper_init(root node.Node, _val node.Node, _par object.Object,
 		switch par.(type) {
 		case object.VariableObject:
 			out = eval.GetExpression(in, link, val, func(in eval.IN) eval.OUT {
-				it := a.area.il.Get(&key{id: par.Adr()}, items.INIT).(*item)
+				it := a.area.il.Get(&key{id: par.Adr()}).(*item)
 				v := it.Value().(scope.Variable)
 				val := rt2.ValueOf(in.Frame)[eval.KeyOf(in, link)]
 				v.Set(val)
@@ -420,7 +420,7 @@ func nn(role string) scope.Manager {
 		return &area{all: &salloc{}, il: items.New()}
 	case context.HEAP:
 		ret := &area{all: &halloc{}, il: items.New(), unsafe: true}
-		ret.il.Check(items.INIT)
+		ret.il.Begin()
 		return ret
 	default:
 		panic(0)

rt2/rules2/wrap/eval/call.go

@@ -86,10 +86,10 @@ func go_math(in IN, par node.Node) OUT {
 		EXP  = 3.0
 	)
 	assert.For(par != nil, 20)
-	sm := rt2.CallScope(in.Frame)
 	res := math.NaN()
 	switch p := par.(type) {
 	case node.VariableNode:
+		sm := rt2.ScopeFor(in.Frame, p.Object().Adr())
 		sm.Select(p.Object().Adr(), func(val scope.Value) {
 			rv, ok := scope.GoTypeFrom(val).([]float64)
 			assert.For(ok && (len(rv) > 1), 100, rv)

rt2/rules2/wrap/eval/stmt.go

@@ -365,12 +365,14 @@ func doCall(in IN) (out OUT) {
 	}
 
 	switch p := c.Left().(type) {
+	case node.EnterNode:
+		call(p, nil)
 	case node.ProcedureNode:
 		m := rtm.DomainModule(in.Frame.Domain())
 		ml := in.Frame.Domain().Global().Discover(context.MOD).(rtm.List)
 		switch p.Object().Mode() {
 		case object.LOCAL_PROC, object.EXTERNAL_PROC:
-			if imp := p.Object().Imp(); imp == "" || imp == m.Name {
+			if imp := p.Object().Imp(); imp == "" {
 				proc := m.NodeByObject(p.Object())
 				assert.For(proc != nil, 40, m.Name, imp, p.Object().Imp(), p.Object().Adr(0, 0), p.Object().Name())
 				call(proc[0], nil)

rt2/utils.go

@@ -35,6 +35,7 @@ func ScopeFor(f frame.Frame, id cp.ID, fn ...scope.ValueOf) (ret scope.Manager)
 	mr := f.Domain().Global().Discover(context.SCOPE).(scope.Manager)
 	cr := f.Domain().Global().Discover(context.CALL).(scope.Manager)
 	hr := f.Domain().Global().Discover(context.HEAP).(scope.Manager)
+
 	switch {
 	case mr.Exists(id):
 		ret = mr

xev/cmds.go

@@ -4,7 +4,6 @@ import (
 	"archive/zip"
 	"fw/cp/module"
 	"io"
-	"log"
 	"path/filepath"
 	"ypk/assert"
 )
@@ -12,7 +11,7 @@ import (
 const CODE = "code"
 
 func Load(path, name string) (ret *module.Module) {
-	log.Println(path + ` ` + name)
+	//log.Println(path + ` ` + name)
 	//var data []byte
 	var rd io.Reader
 	r, err := zip.OpenReader(filepath.Join(path, CODE, name))