убрал логирование

cp/object/type.go

@@ -3,7 +3,6 @@ package object
 import (
 	"fmt"
 	"fw/cp"
-	"reflect"
 	"ypk/assert"
 )
 
@@ -198,7 +197,7 @@ type ptr struct {
 }
 
 func NewPointerType(n string) PointerType {
-	fmt.Println("new ptr type", n)
+	//fmt.Println("new ptr type", n)
 	return &ptr{name: n}
 }
 
@@ -206,7 +205,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))
+		//fmt.Println("pbasetyp", p.basetyp, reflect.TypeOf(p.basetyp))
 	} else if len(x) > 1 {
 		panic("there can be only one")
 	}

rt2/rules/call.go

@@ -143,7 +143,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		} else {
 			if imp := m.ImportOf(n.Left().Object()); imp == "" {
 				proc := m.NodeByObject(n.Left().Object())
-				fmt.Println(len(proc), len(n.Left().Object().Ref()))
+				//fmt.Println(len(proc), len(n.Left().Object().Ref()))
 				call(proc[0], nil)
 			} else {
 				m := ml.Loaded(imp)

rt2/scope/modern/hp.go

@@ -18,7 +18,7 @@ type halloc struct {
 }
 
 func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
-	fmt.Println("HEAP ALLOCATE")
+	//fmt.Println("HEAP ALLOCATE")
 	mod := rtm.ModuleOfNode(h.area.d, n)
 	if h.area.data == nil {
 		h.area.data = append(h.area.data, newlvl())

rt2/scope/modern/ms.go

@@ -194,7 +194,7 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 		mod := rtm.ModuleOfNode(f.Domain(), val)
 		if mod != nil {
 			global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
-			fmt.Println(mod.Name)
+			//fmt.Println(mod.Name)
 			global = global.Discover(mod.Name).(context.Domain)
 			sm = global.Discover(context.SCOPE).(scope.Manager)
 		} else {

rt2/scope/modern/val.go

@@ -195,7 +195,7 @@ func (i *idx) String() string {
 }
 
 func (i *idx) Set(v scope.Value) {
-	fmt.Println(i, len(i.arr.val))
+	//fmt.Println(i, len(i.arr.val))
 	switch x := v.(type) {
 	case *idx:
 		i.arr.val[i.idx] = x.arr.val[x.idx]
@@ -1032,12 +1032,12 @@ func (o *ops) Is(a scope.Value, typ object.ComplexType) scope.Value {
 	case *rec:
 		z, a := x.link.Complex().(object.RecordType)
 		y, b := typ.(object.RecordType)
-		fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
+		//fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
 		return BOOLEAN(a && b && compare(z, y))
 	case *ptr:
 		z, a := x.link.Complex().(object.PointerType)
 		y, b := typ.(object.PointerType)
-		fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
+		//fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
 		return BOOLEAN(a && b && compare(z, y))
 	default:
 		halt.As(100, reflect.TypeOf(x))

rt2/scope/std/heap.go

@@ -1,194 +0,0 @@
-package std
-
-import (
-	"fmt"
-	"fw/cp"
-	"fw/cp/node"
-	"fw/cp/object"
-	"fw/rt2/context"
-	"fw/rt2/scope"
-	"reflect"
-	"ypk/assert"
-)
-
-type heap struct {
-	d    context.Domain
-	data *area
-	next int
-}
-
-type desc struct {
-	scope.ID
-	link object.Object
-}
-
-func (d *desc) Object() object.Object {
-	return d.link
-}
-
-func nh() scope.Manager {
-	return &heap{data: &area{ready: true, root: nil, x: make(map[scope.ID]interface{})}}
-}
-
-func (h *heap) String() (ret string) {
-	ret = fmt.Sprintln("HEAP")
-	ret = fmt.Sprintln(ret, h.data)
-	return fmt.Sprint(ret, "END")
-}
-
-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, cp.SomeAdr())
-			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)
-			var p int64
-			switch x := par[0].(type) {
-			case int64:
-				p = x
-			case int32:
-				p = int64(x)
-			default:
-				panic("mistyped parameter")
-			}
-			fake := object.New(object.VARIABLE, cp.SomeAdr())
-			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++
-			oid := talloc(t)
-			return func(interface{}) interface{} {
-				return oid
-			}
-		default:
-			panic(fmt.Sprintln("unsupported type", reflect.TypeOf(t)))
-		}
-	default:
-		panic(fmt.Sprintln("unsupported node", reflect.TypeOf(v)))
-	}
-}
-
-func (h *heap) Dispose(n node.Node) {
-}
-
-func (h *heap) Target(...scope.Allocator) scope.Allocator {
-	return h
-}
-
-func (h *heap) Update(i scope.ID, val scope.ValueFor) {
-	fmt.Println("update", i)
-	var upd func(x interface{}) (ret interface{})
-	upd = func(x interface{}) (ret interface{}) {
-		fmt.Println(reflect.TypeOf(x))
-		switch x := x.(type) {
-		case value:
-			old := x.get()
-			tmp := val(old)
-			assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
-			//fmt.Println(tmp)
-			x.set(tmp)
-			ret = x
-		case record:
-			if i.Path == "" {
-				//fmt.Println(i, depth)
-				panic(0) //случай выбора всей записи целиком
-			} else {
-				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)
-		}
-		return ret
-	}
-	upd(h.data.get(i))
-}
-
-func (h *heap) Select(i scope.ID) interface{} {
-	fmt.Println("heap select", i)
-	type result struct {
-		x interface{}
-	}
-	var res *result
-	var sel func(interface{}) *result
-	sel = func(x interface{}) (ret *result) {
-		fmt.Println(x)
-		switch x := x.(type) {
-		case record:
-			if i.Path == "" {
-				ret = &result{x: x.(*rec).link}
-			} else {
-				z := x.getField(i.Path)
-				ret = sel(z)
-			}
-		case array:
-			if i.Index != nil {
-				ret = &result{x: x.get(*i.Index)}
-			} else {
-				ret = &result{x: x.sel()}
-			}
-		default:
-			panic(0)
-		}
-		return ret
-	}
-	res = sel(h.data.get(i))
-	assert.For(res != nil, 40)
-	//fmt.Println(res.x)
-	return res.x
-}
-
-func (h *heap) Init(d context.Domain) { h.d = d }
-
-func (h *heap) Domain() context.Domain { return h.d }
-
-func (h *heap) Handle(msg interface{}) {}

rt2/scope/std/scope.go

@@ -1,549 +0,0 @@
-package std
-
-import (
-	"container/list"
-	"fmt"
-	"fw/cp/node"
-	"fw/cp/object"
-	"fw/rt2"
-	"fw/rt2/context"
-	"fw/rt2/frame"
-	rt_mod "fw/rt2/module"
-	"fw/rt2/scope"
-	"reflect"
-	"runtime"
-	"ypk/assert"
-)
-
-type manager struct {
-	d     context.Domain
-	areas *list.List
-}
-
-type KVarea interface {
-	set(scope.ID, interface{})
-	get(scope.ID) interface{}
-	String() string
-}
-
-type area struct {
-	root  node.Node
-	x     map[scope.ID]interface{}
-	ready bool
-}
-
-func area_fin(a interface{}) {
-	fmt.Println("scope cleared")
-}
-
-func (a *area) set(k scope.ID, v interface{}) {
-	key := scope.ID{Name: k.Name}
-	fmt.Println(k, key)
-	a.x[key] = v
-}
-
-func (a *area) get(k scope.ID) interface{} {
-	key := scope.ID{Name: k.Name}
-	return a.x[key]
-}
-
-func (a *area) String() (ret string) {
-	ret = fmt.Sprintln("AREA")
-	for k, v := range a.x {
-		ret = fmt.Sprintln(ret, "key:", k, "type:", reflect.TypeOf(v), "value:", v)
-	}
-	return fmt.Sprint(ret, "END")
-}
-
-type value interface {
-	set(x interface{})
-	get() interface{}
-}
-
-type reference interface {
-	id(...scope.ID) scope.ID
-}
-
-type array interface {
-	set(i int64, x interface{})
-	get(i int64) interface{}
-	upd(x []interface{})
-	sel() []interface{}
-}
-
-type basic struct {
-	link object.Object
-	data interface{}
-}
-
-type record interface {
-	setField(field string, x interface{})
-	getField(field string) interface{}
-	init(root node.Node)
-}
-
-func (b *basic) set(i interface{}) { b.data = i }
-
-func (b *basic) get() interface{} { return b.data }
-
-type ref struct {
-	link object.Object
-	ref  scope.ID
-}
-
-func (r *ref) id(x ...scope.ID) scope.ID {
-	if len(x) == 1 {
-		r.ref = x[0]
-	} else if len(x) > 1 {
-		panic("there can be only one")
-	}
-	return r.ref
-}
-
-type arr struct {
-	link object.Object
-	par  int64
-	data []interface{}
-}
-
-func (a *arr) get(i int64) interface{} {
-	if len(a.data) == 0 {
-		a.data = make([]interface{}, a.par)
-	}
-	return a.data[i]
-}
-
-func (a *arr) set(i int64, x interface{}) {
-	if len(a.data) == 0 {
-		a.data = make([]interface{}, a.par)
-	}
-	a.data[i] = x
-}
-
-func (a *arr) sel() []interface{} { return a.data }
-
-func (a *arr) upd(x []interface{}) { a.data = x }
-
-type rec struct {
-	link object.Object
-	root node.Node
-	x    map[scope.ID]interface{}
-}
-
-func (r *rec) setField(f string, x interface{}) { r.set(scope.ID{Name: f}, x) }
-
-func (r *rec) getField(f string) interface{} { return r.get(scope.ID{Name: f}) }
-
-func (r *rec) init(n node.Node) {
-	r.root = n
-	r.x = make(map[scope.ID]interface{})
-}
-
-func (a *rec) set(k scope.ID, v interface{}) { a.x[k] = v }
-
-func (a *rec) get(k scope.ID) interface{} { return a.x[k] }
-
-func (a *rec) String() (ret string) {
-	ret = fmt.Sprintln("RECORD")
-	for k, v := range a.x {
-		ret = fmt.Sprintln(ret, "key:", k, "value:", v)
-	}
-	return fmt.Sprint(ret, "END")
-}
-
-func nm() scope.Manager {
-	m := &manager{areas: list.New()}
-	return m
-}
-
-func (m *manager) String() (ret string) {
-	ret = fmt.Sprintln("SCOPE")
-	i := 0
-	for s := m.areas.Back(); s != nil; s = s.Prev() {
-		a := s.Value.(*area)
-		ret = fmt.Sprintln(ret, i, a)
-		i++
-	}
-	return fmt.Sprint(ret, "END")
-}
-
-func init() {
-	scope.NewStack = nm
-	scope.Designator = design
-	scope.FindObjByName = FindObjByName
-
-	scope.NewHeap = nh
-}
-
-func design(n ...node.Node) (id scope.ID) {
-	switch x := n[0].(type) {
-	case node.VariableNode, node.ParameterNode:
-		id = scope.ID{Name: x.Object().Name()}
-	case node.FieldNode:
-		fmt.Println(x.Object().Name())
-		if len(n) == 1 {
-			id = scope.ID{Name: x.Left().Object().Name(), Path: x.Object().Name()}
-		} else if n[1] != nil {
-			id = scope.ID{Name: n[1].Object().Name(), Path: x.Object().Name()}
-		} else {
-			panic("wrong params")
-		}
-	case node.IndexNode:
-		id = scope.ID{Name: x.Left().Object().Name()}
-	default:
-		panic(fmt.Sprintln("unsupported", reflect.TypeOf(x)))
-	}
-	return id
-}
-
-func odesign(o object.Object) (id scope.ID) {
-	switch x := o.(type) {
-	case object.VariableObject, object.ParameterObject:
-		switch x.Name() {
-		case "@":
-			id = scope.ID{Name: "@", Ref: new(int)}
-			*id.Ref = *x.Ref()[0].(*desc).Ref
-		default:
-			id = scope.ID{Name: x.Name()}
-		}
-	default:
-		panic(fmt.Sprintln("unsupported", reflect.TypeOf(o)))
-	}
-	return id
-}
-
-func obj(o object.Object) (key scope.ID, val interface{}) {
-	switch x := o.(type) {
-	case object.ConstantObject, object.ProcedureObject, object.TypeObject:
-	case object.VariableObject, object.FieldObject:
-		//fmt.Println(x.Name())
-		key = scope.ID{Name: x.Name()}
-		switch t := x.Complex().(type) {
-		case nil:
-			val = &basic{link: o}
-		case object.BasicType:
-			val = &basic{link: o}
-		case object.ArrayType:
-			val = &arr{link: o, par: t.Len()}
-		case object.DynArrayType:
-			val = &arr{link: o}
-		case object.RecordType:
-			val = &rec{link: o}
-		case object.PointerType:
-			val = &ref{link: o, ref: scope.ID{Ref: new(int)}}
-		default:
-			fmt.Println("unexpected", reflect.TypeOf(t))
-		}
-	case object.ParameterObject:
-		//fmt.Println("'" + x.Name())
-		key = scope.ID{Name: x.Name()}
-		val = &ref{link: o}
-	default:
-		fmt.Println(reflect.TypeOf(o))
-	}
-	return key, val
-}
-
-func alloc(root node.Node, h KVarea, k scope.ID, v interface{}) {
-	h.set(k, v)
-	switch rv := v.(type) {
-	case record:
-		rv.init(root)
-		o := rv.(*rec).link
-		switch t := o.Complex().(type) {
-		case object.RecordType:
-			for rec := t; rec != nil; {
-				for x := rec.Link(); x != nil; x = x.Link() {
-					//fmt.Println(o.Name(), ".", x.Name())
-					k, f := obj(x)
-					alloc(root, v.(KVarea), k, f)
-				}
-				rec = rec.BaseType()
-			}
-		}
-	}
-}
-
-func (m *manager) Target(...scope.Allocator) scope.Allocator {
-	return m
-}
-
-func (m *manager) Allocate(n node.Node, final bool) {
-	h := &area{ready: final, root: n, x: make(map[scope.ID]interface{})}
-	runtime.SetFinalizer(h, area_fin)
-	mod := rt_mod.DomainModule(m.Domain())
-	for _, o := range mod.Objects[n] {
-		k, v := obj(o)
-		if v != nil {
-			//fmt.Println(k, v)
-			alloc(n, h, k, v)
-		}
-	}
-	m.areas.PushFront(h)
-	fmt.Println("allocate")
-}
-
-func (m *manager) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, ret frame.WAIT) {
-	e := m.areas.Front()
-	assert.For(e != nil, 20)
-	h := e.Value.(*area)
-	assert.For(h.root == n, 21)
-	assert.For(!h.ready, 22)
-	val := par.Values
-	fmt.Println("initialize")
-	f := par.Frame
-	end := func(frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-		h.ready = true
-		if par.Tail != nil {
-			return par.Tail(f)
-		} else {
-			return frame.End()
-		}
-	}
-	seq = end
-	ret = frame.NOW
-	for next := par.Objects; next != nil; next = next.Link() {
-		assert.For(val != nil, 40)
-		fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
-		fmt.Println(reflect.TypeOf(val))
-		switch ov := val.(type) {
-		case node.ConstantNode:
-			switch next.(type) {
-			case object.VariableObject:
-				m.Update(odesign(next), func(old interface{}) interface{} {
-					return ov.Data()
-				})
-			case object.ParameterObject:
-				k, v := scope.ID{Name: next.Name()}, &basic{link: next}
-				h.set(k, v)
-				m.Update(odesign(next), func(old interface{}) interface{} {
-					return ov.Data()
-				})
-			default:
-				panic("unknown value")
-			}
-		case node.VariableNode, node.ParameterNode:
-			switch next.(type) {
-			case object.VariableObject:
-				m.Update(odesign(next), func(old interface{}) interface{} {
-					return m.Select(odesign(ov.Object()))
-				})
-			case object.ParameterObject:
-				h.get(scope.ID{Name: next.Name()}).(*ref).ref = design(ov)
-			default:
-				panic("unknown value")
-			}
-		case node.DerefNode:
-			rt2.Push(rt2.New(ov), f)
-			dn := next
-			seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-				fmt.Println(rt2.DataOf(f)[ov])
-				switch dn.(type) {
-				case object.VariableObject:
-					m.Update(odesign(dn), func(old interface{}) interface{} {
-						return rt2.DataOf(f)[ov]
-					})
-				case object.ParameterObject:
-					h.get(scope.ID{Name: dn.Name()}).(*ref).ref = odesign(rt2.DataOf(f)[ov].(object.Object))
-					fmt.Println("got param", odesign(rt2.DataOf(f)[ov].(object.Object)))
-				default:
-					panic(fmt.Sprintln("unknown value", reflect.TypeOf(next)))
-				}
-				return end, frame.NOW
-			}
-			ret = frame.LATER
-		default:
-			panic(fmt.Sprintln("unknown value", reflect.TypeOf(val)))
-		}
-		val = val.Link()
-	}
-	return seq, ret
-}
-
-func (m *manager) Dispose(n node.Node) {
-	e := m.areas.Front()
-	if e != nil {
-		h := e.Value.(*area)
-		assert.For(h.root == n, 21)
-		m.areas.Remove(e)
-		fmt.Println("dispose")
-	}
-}
-
-func (m *manager) Select(i scope.ID) interface{} {
-	type result struct {
-		x interface{}
-	}
-	var res *result
-	var sel func(interface{}) *result
-	fmt.Println("select", i)
-	sel = func(x interface{}) (ret *result) {
-		switch x := x.(type) {
-		case value:
-			ret = &result{x: x.get()}
-		case reference:
-			i = x.id()
-			fmt.Println("ref!", i)
-			ret = nil
-		case array:
-			if i.Index != nil {
-				ret = &result{x: x.get(*i.Index)}
-			} else {
-				ret = &result{x: x.sel()}
-			}
-		case record:
-			if i.Path == "" {
-				ret = &result{x: x.(*rec).link}
-			} else {
-				z := x.getField(i.Path)
-				ret = sel(z)
-			}
-		case nil:
-			if i.Name == "@" {
-				fmt.Println("ptr")
-				if hm := m.Domain().Discover(context.HEAP).(scope.Manager); hm != nil {
-					ret = &result{x: hm.Select(i)}
-				} else {
-					panic(0)
-				}
-			}
-		default:
-			panic(0)
-		}
-		return ret
-	}
-	for e := m.areas.Front(); (e != nil) && (res == nil); e = e.Next() {
-		h := e.Value.(*area)
-		if h.ready {
-			res = sel(h.get(i))
-		}
-	}
-	assert.For(res != nil, 40)
-	//fmt.Println(res.x)
-	return res.x
-}
-
-func arrConv(x interface{}) []interface{} {
-	switch a := x.(type) {
-	case string:
-		s := []rune(a)
-		ret := make([]interface{}, 0)
-		for i := 0; i < len(s); i++ {
-			ret = append(ret, s[i])
-		}
-		return ret
-	case []interface{}:
-		return a
-	case int32:
-		fmt.Println("not an array")
-		return []interface{}{rune(0)}
-	default:
-		panic(fmt.Sprintln("unsupported", reflect.TypeOf(x)))
-	}
-}
-
-func (m *manager) Update(i scope.ID, val scope.ValueFor) {
-	assert.For(val != nil, 21)
-	fmt.Println("update", i)
-	var x interface{}
-	var upd func(x interface{}) (ret interface{})
-	upd = func(x interface{}) (ret interface{}) {
-		fmt.Println(reflect.TypeOf(x))
-		switch x := x.(type) {
-		case value:
-			old := x.get()
-			tmp := val(old)
-			assert.For(tmp != nil, 40) //если устанавливают значение NIL, значит делают что-то неверно
-			//fmt.Println(tmp)
-			x.set(tmp)
-			ret = x
-		case reference:
-			fmt.Println(x.id())
-			switch {
-			case x.id().Ref != nil && *x.id().Ref == 0: //это нулевой указатель
-				tmp := val(nil)
-				ret = x
-				switch id := tmp.(type) {
-				case scope.ID:
-					x.id(id)
-				case object.VariableObject:
-					x.id(odesign(id))
-				default:
-					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
-				i.Ref = x.id().Ref
-				ret = nil
-			default: //это параметр процедуры
-				i.Name = x.id().Name
-				ret = nil
-			}
-		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
-		case record:
-			if i.Path == "" {
-				//fmt.Println(i, depth)
-				panic(0) //случай выбора всей записи целиком
-			} else {
-				z := x.getField(i.Path)
-				ret = upd(z)
-			}
-		case nil:
-			if i.Name == "@" {
-				fmt.Println("ptr")
-				if hm := m.Domain().Discover(context.HEAP).(scope.Manager); hm != nil {
-					hm.Update(i, val)
-					ret = hm
-				} else {
-					panic(0)
-				}
-			} else {
-				ret = x
-			}
-		default:
-			panic(fmt.Sprintln("unhandled", reflect.TypeOf(x)))
-		}
-		return ret
-	}
-	for e := m.areas.Front(); (e != nil) && (x == nil); e = e.Next() {
-		h := e.Value.(*area)
-		x = upd(h.get(i))
-	}
-	assert.For(x != nil, 40)
-}
-
-func (m *manager) Init(d context.Domain) { m.d = d }
-
-func (m *manager) Domain() context.Domain { return m.d }
-
-func (m *manager) Handle(msg interface{}) {}
-
-func FindObjByName(mgr scope.Manager, name string) (ret object.Object) {
-	assert.For(name != "", 20)
-	m := mgr.(*manager)
-	for e := m.areas.Front(); (e != nil) && (ret == nil); e = e.Next() {
-		h := e.Value.(*area)
-		x := h.get(scope.ID{Name: name})
-		switch x.(type) {
-		case *basic:
-			ret = x.(*basic).link
-		default:
-			//fmt.Println("no such object")
-		}
-	}
-	return ret
-}

xev/converter.go

@@ -590,7 +590,7 @@ func buildMod(r *Result) *module.Module {
 
 func DoAST(r *Result) (mod *module.Module) {
 	mod = buildMod(r)
-	fmt.Println(len(mod.Nodes), len(mod.Objects))
+	//fmt.Println(len(mod.Nodes), len(mod.Objects))
 	reset()
 	return mod
 }