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

cp/adr.go

@@ -1,12 +1,14 @@
 package cp
 
+type ID int
+
 type Id interface {
-	Adr(...int) int
+	Adr(...int) ID
 }
 
 var adr int = 0
 
-func SomeAdr() int {
+func SomeAdr() ID {
 	adr--
-	return adr
+	return ID(adr)
 }

cp/node/class.go

@@ -1,6 +1,7 @@
 package node
 
 import (
+	"fw/cp"
 	"fw/cp/constant"
 	"fw/cp/constant/enter"
 	"fw/cp/constant/operation"
@@ -90,13 +91,13 @@ func New(class constant.Class, id int) (ret Node) {
 type nodeFields struct {
 	left, right, link Node
 	obj               object.Object
-	adr               int
+	adr               cp.ID
 }
 
-func (nf *nodeFields) Adr(a ...int) int {
+func (nf *nodeFields) Adr(a ...int) cp.ID {
 	assert.For(len(a) <= 1, 20)
 	if len(a) == 1 {
-		nf.adr = a[0]
+		nf.adr = cp.ID(a[0])
 	}
 	return nf.adr
 }

cp/object/object.go

@@ -108,7 +108,7 @@ type objectFields struct {
 	link Object
 	comp ComplexType
 	ref  []Ref
-	adr  int
+	adr  cp.ID
 }
 
 func (of *objectFields) SetType(typ Type)         { of.typ = typ }
@@ -120,10 +120,10 @@ func (of *objectFields) SetLink(o Object)         { of.link = o }
 func (of *objectFields) SetComplex(t ComplexType) { of.comp = t }
 func (of *objectFields) Complex() ComplexType     { return of.comp }
 
-func (of *objectFields) Adr(a ...int) int {
+func (of *objectFields) Adr(a ...int) cp.ID {
 	assert.For(len(a) <= 1, 20)
 	if len(a) == 1 {
-		of.adr = a[0]
+		of.adr = cp.ID(a[0])
 	}
 	return of.adr
 }

cp/object/type.go

@@ -69,16 +69,16 @@ type ComplexType interface {
 
 type comp struct {
 	link Object
-	adr  int
+	adr  cp.ID
 }
 
 func (c *comp) Link() Object     { return c.link }
 func (c *comp) SetLink(o Object) { c.link = o }
 
-func (c *comp) Adr(a ...int) int {
+func (c *comp) Adr(a ...int) cp.ID {
 	assert.For(len(a) <= 1, 20)
 	if len(a) == 1 {
-		c.adr = a[0]
+		c.adr = cp.ID(a[0])
 	}
 	return c.adr
 }

fw.go

@@ -9,7 +9,8 @@ import (
 	rtmod "fw/rt2/module"
 	_ "fw/rt2/rules"
 	"fw/rt2/scope"
-	_ "fw/rt2/scope/std"
+	// "fw/rt2/scope/std"
+	_ "fw/rt2/scope/modern"
 	"time"
 	"ypk/assert"
 )
@@ -27,12 +28,12 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevTest0"
+		name = "XevDemo1"
 	}
 	global := &stdDomain{god: true}
 	modList := rtmod.New()
 	global.Attach(context.MOD, modList)
-	global.Attach(context.HEAP, scope.NewHeap())
+	global.Attach(context.HEAP, scope.New())
 	t0 := time.Now()
 	var init []*mod.Module
 	_, err := modList.Load(name, func(m *mod.Module) {

rt2/frame/frame.go

@@ -55,6 +55,7 @@ type Frame interface {
 
 //пользовательская функция, которую выполнит фрейм, может поставить на очередь выполнения себя или другую функцию
 type Sequence func(f Frame) (Sequence, WAIT)
+type Assert func(f Frame) (bool, int)
 
 func Tail(x WAIT) (seq Sequence) {
 	return func(f Frame) (Sequence, WAIT) { return nil, x }

rt2/frame/std/sf.go

@@ -34,7 +34,7 @@ func (f *RootFrame) PushFor(fr, parent frame.Frame) {
 	f.inner.PushFront(fr)
 	if parent == nil {
 		domain := f.Domain().(context.Factory).New()
-		domain.Attach(context.SCOPE, scope.NewStack())
+		domain.Attach(context.SCOPE, scope.New())
 		fr.Init(domain)
 	} else {
 		fr.Init(parent.Domain())

rt2/nodeframe/frame.go

@@ -2,10 +2,12 @@ package nodeframe
 
 import (
 	"fmt"
+	"fw/cp"
 	"fw/cp/node"
 	"fw/rt2/context"
 	"fw/rt2/decision"
 	"fw/rt2/frame"
+	"fw/rt2/scope"
 	"fw/utils"
 	"reflect"
 	"ypk/assert"
@@ -13,46 +15,58 @@ import (
 
 var count int64
 
-type FrameUtils struct{}
+type NodeFrameUtils struct{}
 
-func (fu FrameUtils) New(n node.Node) (f frame.Frame) {
+func (fu NodeFrameUtils) New(n node.Node) (f frame.Frame) {
 	assert.For(n != nil, 20)
 	f = new(nodeFrame)
 	f.(*nodeFrame).ir = n
 	f.(*nodeFrame).data = make(map[interface{}]interface{})
+	f.(*nodeFrame).value = make(map[cp.ID]scope.Value)
 	utils.PrintFrame("_", "NEW", reflect.TypeOf(n))
 	return f
 }
 
-func (fu FrameUtils) Push(f, p frame.Frame) {
+func (fu NodeFrameUtils) Push(f, p frame.Frame) {
 	assert.For(f != nil, 20)
 	pp, _ := p.(*nodeFrame)
 	pp.push(f)
 }
 
-func (fu FrameUtils) NodeOf(f frame.Frame) node.Node {
+func (fu NodeFrameUtils) NodeOf(f frame.Frame) node.Node {
 	ff, _ := f.(*nodeFrame)
 	assert.For(ff.ir != nil, 40)
 	return ff.ir
 }
 
-func (fu FrameUtils) DataOf(f frame.Frame) map[interface{}]interface{} {
+func (fu NodeFrameUtils) DataOf(f frame.Frame) map[interface{}]interface{} {
 	return f.(*nodeFrame).data
 }
 
-func (fu FrameUtils) ReplaceDomain(f frame.Frame, d context.Domain) {
+func (fu NodeFrameUtils) ValueOf(f frame.Frame) map[cp.ID]scope.Value {
+	return f.(*nodeFrame).value
+}
+
+func (fu NodeFrameUtils) ReplaceDomain(f frame.Frame, d context.Domain) {
 	ff := f.(*nodeFrame)
 	ff.domain = d
 }
 
+func (fu NodeFrameUtils) Assert(f frame.Frame, ok frame.Assert) {
+	ff := f.(*nodeFrame)
+	ff.assertion = ok
+}
+
 type nodeFrame struct {
-	root   frame.Stack
-	parent frame.Frame
-	ir     node.Node
-	seq    frame.Sequence
-	domain context.Domain
-	data   map[interface{}]interface{}
-	num    int64
+	root      frame.Stack
+	parent    frame.Frame
+	ir        node.Node
+	seq       frame.Sequence
+	assertion frame.Assert
+	domain    context.Domain
+	data      map[interface{}]interface{}
+	value     map[cp.ID]scope.Value
+	num       int64
 }
 
 func done(f frame.Frame) {
@@ -67,7 +81,7 @@ 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)
+	fmt.Println("data:", f.data, f.value)
 	if next != nil {
 		assert.For(ret != frame.STOP, 40)
 		f.seq = next
@@ -97,6 +111,15 @@ func (f *nodeFrame) OnPop() {
 	if f.seq != nil {
 		_, _ = f.seq(f)
 	}
+	if f.parent != nil {
+		ff, ok := f.parent.(*nodeFrame)
+		if ok && ff.assertion != nil {
+			ok, code := ff.assertion(ff)
+			if !ok {
+				panic(fmt.Sprintln("assert", code, "for", reflect.TypeOf(ff.ir)))
+			}
+		}
+	}
 }
 
 func (f *nodeFrame) push(n frame.Frame) {

rt2/rules/assign.go

@@ -10,23 +10,20 @@ import (
 	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 	"reflect"
 )
 
 func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f)
-	op := node.New(constant.DYADIC, cp.SomeAdr()).(node.OperationNode)
+	op := node.New(constant.DYADIC, int(cp.SomeAdr())).(node.OperationNode)
 	op.SetOperation(operation.PLUS)
 	op.SetLeft(n.Left())
 	op.SetRight(n.Right())
 	rt2.Push(rt2.New(op), f)
 	seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		sc.Update(scope.Designator(n.Left()), func(interface{}) interface{} {
-			return rt2.DataOf(f)[op]
-		})
+		sc.Update(n.Left().Adr(), nil) //scope.Simple(rt2.DataOf(f)[op]))
 		return frame.End()
 	}
 	ret = frame.LATER
@@ -35,16 +32,14 @@ func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 func decSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f)
-	op := node.New(constant.DYADIC, cp.SomeAdr()).(node.OperationNode)
+	op := node.New(constant.DYADIC, int(cp.SomeAdr())).(node.OperationNode)
 	op.SetOperation(operation.MINUS)
 	op.SetLeft(n.Left())
 	op.SetRight(n.Right())
 	rt2.Push(rt2.New(op), f)
 	seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		sc.Update(scope.Designator(n.Left()), func(interface{}) interface{} {
-			return rt2.DataOf(f)[op]
-		})
+		sc.Update(n.Left().Adr(), nil) //scope.Simple(rt2.DataOf(f)[op]))
 		return frame.End()
 	}
 	ret = frame.LATER
@@ -52,60 +47,56 @@ func decSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 }
 
 func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	a := fu.NodeOf(f)
+	a := rt2.NodeOf(f)
 
-	var leftId scope.ID
-	var rightId scope.ID
+	var leftId cp.ID
+	var rightId cp.ID
 
 	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		switch 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)
-				sc.Update(leftId, func(interface{}) interface{} {
-					return a.Right().(node.ConstantNode).Data()
-				})
+				sc.Update(leftId, sc.Provide(a.Right())) //scope.Simple(a.Right().(node.ConstantNode).Data()))
 				return frame.End()
 			}
 			ret = frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(leftId, func(interface{}) interface{} {
-					return sc.Select(scope.Designator(a.Right()))
-				})
+				sc.Update(leftId, scope.Simple(sc.Select(a.Right().Object().Adr())))
 				return frame.End()
 			}
 			ret = frame.NOW
 		case node.OperationNode, node.CallNode, node.DerefNode:
-			fu.Push(fu.New(a.Right()), f)
+			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
+			})
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(leftId, func(interface{}) interface{} {
-					return fu.DataOf(f)[a.Right()]
-				})
+				sc.Update(leftId, scope.Simple(rt2.ValueOf(f)[a.Right().Adr()]))
 				return frame.End()
 			}
 			ret = frame.LATER
 		case node.IndexNode:
-			rightId = scope.Designator(a.Right())
+			rightId = a.Right().Adr()
 			rt2.Push(rt2.New(a.Right()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				rightId.Index = new(int64)
-				*rightId.Index = int64(rt2.DataOf(f)[a.Right()].(int32))
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				sc.Update(leftId, func(interface{}) interface{} {
-					return sc.Select(rightId)
-				})
+				/*				rightId.Index = new(int64)
+								*rightId.Index = int64(rt2.DataOf(f)[a.Right()].(int32))
+								sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+								sc.Update(leftId, func(interface{}) interface{} {
+									return sc.Select(rightId)
+								}) */
 				return frame.End()
 			}
 			ret = frame.LATER
 		case node.ProcedureNode:
-			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			sc.Update(leftId, func(interface{}) interface{} {
+			//			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			/*sc.Update(leftId, func(interface{}) interface{} {
 				return a.Right().Object()
-			})
+			})*/
 			return frame.End()
 		default:
 			fmt.Println(reflect.TypeOf(a.Right()))
@@ -118,46 +109,46 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case statement.ASSIGN:
 		switch l := a.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
-			leftId = scope.Designator(a.Left())
+			leftId = a.Left().Object().Adr()
 			seq, ret = right(f)
 		case node.FieldNode:
 			switch l.Left().(type) {
 			case node.GuardNode:
 				rt2.Push(rt2.New(l.Left()), f)
 				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					x := rt2.DataOf(f)[l.Left()].(node.Node)
-					leftId = scope.Designator(a.Left(), x)
+					//					x := rt2.DataOf(f)[l.Left()].(node.Node)
+					//					leftId = scope.Designator(a.Left(), x)
 					fmt.Println(leftId)
 					return right(f)
 				}
 				ret = frame.LATER
 			case node.DerefNode:
-				rt2.DataOf(f)[l.Left()] = scope.ID{}
+				//				rt2.DataOf(f)[l.Left()] = scope.ID{}
 				rt2.Push(rt2.New(l.Left()), f)
 				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					leftId = rt2.DataOf(f)[l.Left()].(scope.ID)
-					leftId.Path = a.Left().Object().Name()
+					//					leftId = rt2.DataOf(f)[l.Left()].(scope.ID)
+					//					leftId.Path = a.Left().Object().Name()
 					return right(f)
 				}
 				ret = frame.LATER
 			default:
-				leftId = scope.Designator(a.Left())
+				//				leftId = scope.Designator(a.Left())
 				seq, ret = right(f)
 			}
 		case node.IndexNode:
-			leftId = scope.Designator(a.Left())
+			//			leftId = scope.Designator(a.Left())
 			rt2.Push(rt2.New(a.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				leftId.Index = new(int64)
-				*leftId.Index = int64(rt2.DataOf(f)[a.Left()].(int32))
+				/*				leftId.Index = new(int64)
+				*leftId.Index = int64(rt2.DataOf(f)[a.Left()].(int32))*/
 				return right(f)
 			}
 			ret = frame.LATER
 		case node.DerefNode:
-			rt2.DataOf(f)[a.Left()] = scope.ID{}
+			//			rt2.DataOf(f)[a.Left()] = scope.ID{}
 			rt2.Push(rt2.New(a.Left()), f)
 			seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-				leftId = rt2.DataOf(f)[a.Left()].(scope.ID)
+				//				leftId = rt2.DataOf(f)[a.Left()].(scope.ID)
 				return right(f)
 			}
 			ret = frame.LATER
@@ -180,17 +171,17 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			panic(fmt.Sprintln("wrong left", reflect.TypeOf(a.Left())))
 		}
 	case statement.NEW:
-		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		heap := scope.This(f.Domain().Discover(context.HEAP))
+		//		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+		//		heap := scope.This(f.Domain().Discover(context.HEAP))
 		if a.Right() != nil {
 			seq, ret = This(expectExpr(f, a.Right(), func(...IN) OUT {
 				fmt.Println("NEW", rt2.DataOf(f)[a.Right()], "here")
-				sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left(), rt2.DataOf(f)[a.Right()]))
+				//				sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left(), rt2.DataOf(f)[a.Right()]))
 				return End()
 			}))
 		} else {
 			fmt.Println("NEW here")
-			sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left()))
+			//			sc.Update(scope.Designator(a.Left()), heap.Target().(scope.HeapAllocator).Allocate(a.Left()))
 			return frame.End()
 		}
 	default:

rt2/rules/call.go

@@ -11,7 +11,6 @@ import (
 	"fw/rt2/context"
 	"fw/rt2/frame"
 	rt_mod "fw/rt2/module"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 	"ypk/assert"
 )
@@ -39,11 +38,11 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 		return
 	}
 	m := rt_mod.DomainModule(f.Domain())
-	cn := node.New(constant.CALL, cp.SomeAdr())
+	cn := node.New(constant.CALL, int(cp.SomeAdr()))
 	ol := m.NodeByObject(obj)
 	assert.For(len(ol) <= 1, 40)
 	cn.SetLeft(ol[0])
-	cc := node.New(constant.CONSTANT, cp.SomeAdr()).(node.ConstantNode)
+	cc := node.New(constant.CONSTANT, int(cp.SomeAdr())).(node.ConstantNode)
 	cc.SetData(data)
 	cn.SetRight(cc)
 	rt2.Push(rt2.New(cn), f)
@@ -51,7 +50,7 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 
 func process(f frame.Frame, par node.Node) {
 	assert.For(par != nil, 20)
-	sm := scope.This(f.Domain().Discover(context.SCOPE))
+	sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	switch par.(type) {
 	case node.ConstantNode:
 		msg := &Msg{}
@@ -82,24 +81,23 @@ func syscall(f frame.Frame) {
 }
 
 func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
+	n := rt2.NodeOf(f)
 
 	call := func(proc node.Node, d context.Domain) {
-		nf := fu.New(proc)
-		fu.Push(nf, f)
+		nf := rt2.New(proc)
+		rt2.Push(nf, f)
 		if d != nil {
-			fu.ReplaceDomain(nf, d)
+			rt2.ReplaceDomain(nf, d)
 		}
 		//передаем ссылку на цепочку значений параметров в данные фрейма входа в процедуру
 		if (n.Right() != nil) && (proc.Object() != nil) {
-			fu.DataOf(nf)[proc.Object()] = n.Right()
+			rt2.DataOf(nf)[proc.Object()] = n.Right()
 		} else {
 			//fmt.Println("no data for call")
 		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			var fu nodeframe.FrameUtils
-			fu.DataOf(f.Parent())[n] = fu.DataOf(f)[n.Left().Object()]
+			rt2.DataOf(f.Parent())[n] = rt2.DataOf(f)[n.Left().Object()]
+			rt2.ValueOf(f.Parent())[n.Adr()] = rt2.ValueOf(f)[n.Left().Object().Adr()]
 			return frame.End()
 		}
 		ret = frame.LATER
@@ -129,7 +127,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case node.VariableNode:
 		m := rt_mod.DomainModule(f.Domain())
 		sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-		obj := sc.Select(scope.Designator(n.Left()))
+		obj := sc.Select(n.Left().Adr())
 
 		if obj, ok := obj.(object.Object); ok {
 			proc := m.NodeByObject(obj)

rt2/rules/deref.go

@@ -2,6 +2,7 @@ package rules
 
 import (
 	"fmt"
+	"fw/cp"
 	"fw/cp/node"
 	"fw/rt2"
 	"fw/rt2/context"
@@ -15,16 +16,16 @@ func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	x := rt2.DataOf(f.Parent())[n]
 	fmt.Println("deref from ptr", n.(node.DerefNode).Ptr())
-	_, ok := x.(scope.ID)
+	_, ok := x.(cp.ID)
 	if ok {
-		rt2.DataOf(f.Parent())[n] = scope.Designator(n.Left())
+		//		rt2.DataOf(f.Parent())[n] = scope.Designator(n.Left())
 	} else {
 		for z := n.Left(); !ok && z != nil; {
 			switch z.(type) {
 			case node.DerefNode:
 				z = z.Left()
 			default:
-				data := sc.Select(scope.Designator(z))
+				data := sc.Select(z.Adr())
 				assert.For(data != nil, 40)
 				rt2.DataOf(f.Parent())[n] = data
 				ok = true

rt2/rules/enter.go

@@ -3,17 +3,16 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
 	"fw/rt2/module"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 )
 
 func enterSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
-	body := fu.NodeOf(f).Right()
+	n := rt2.NodeOf(f)
+	body := rt2.NodeOf(f).Right()
 	tail := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		if body == nil {
 			//случай пустого тела процедуры/секции BEGIN
@@ -22,19 +21,19 @@ func enterSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			//Вход в процедуру не несет значимых действий и просто заменяет себя в цепочке родителей на своего родителя
 			//При вызове фрейма с другим доменом это мешает, надо убрать
 			//Через DataOf(f.Parent()) может передаваться результат выполнения
-			//fu.Push(fu.New(body), f.Parent())
-			fu.Push(fu.New(body), f)
+			//rt2.Push(rt2.New(body), f.Parent())
+			rt2.Push(rt2.New(body), f)
 			return frame.Tail(frame.STOP), frame.LATER
 		} else {
 			//Особый случай, вход в модуль, секция BEGIN
-			fu.Push(fu.New(body), f)
+			rt2.Push(rt2.New(body), f)
 			fmt.Println("begin", module.DomainModule(f.Domain()).Name)
 			//Выход из модуля, секция CLOSE
 			next := n.Link()
 			if next != nil {
 				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 					fmt.Println("end", module.DomainModule(f.Domain()).Name)
-					f.Root().PushFor(fu.New(next), f)
+					f.Root().PushFor(rt2.New(next), f)
 					return frame.Tail(frame.STOP), frame.END
 				}
 			} else {
@@ -44,11 +43,11 @@ func enterSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 		}
 	}
-	sm := scope.This(f.Domain().Discover(context.SCOPE))
+	sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	//fmt.Println(n.Object())
 	if n.Object() != nil {
-		par, ok := fu.DataOf(f)[n.Object()].(node.Node)
-		//fmt.Println(fu.DataOf(f)[n.Object()])
+		par, ok := rt2.DataOf(f)[n.Object()].(node.Node)
+		//fmt.Println(rt2.DataOf(f)[n.Object()])
 		//fmt.Println(ok)
 		if ok {
 			sm.Target().(scope.ScopeAllocator).Allocate(n, false)

rt2/rules/expect.go

@@ -5,7 +5,7 @@ import (
 	"fw/cp/node"
 	"fw/rt2"
 	"fw/rt2/frame"
-	"fw/rt2/scope"
+	//	"fw/rt2/scope"
 	"reflect"
 	"ypk/assert"
 )
@@ -13,13 +13,13 @@ import (
 //функция вернет в данные родительского фрейма вычисленное значение expr
 func expectExpr(parent frame.Frame, expr node.Node, next Do) OUT {
 	assert.For(expr != nil, 20)
-	sm := rt2.ScopeOf(parent)
+	//	sm := rt2.ScopeOf(parent)
 	switch e := expr.(type) {
 	case node.ConstantNode:
 		rt2.DataOf(parent)[expr] = e.Data()
 		return OUT{do: next, next: NOW}
 	case node.VariableNode, node.ParameterNode:
-		rt2.DataOf(parent)[expr] = sm.Select(scope.Designator(expr))
+		//		rt2.DataOf(parent)[expr] = sm.Select(scope.Designator(expr))
 		return OUT{do: next, next: NOW}
 	case node.OperationNode, node.CallNode:
 		rt2.Push(rt2.New(expr), parent)
@@ -31,7 +31,7 @@ func expectExpr(parent frame.Frame, expr node.Node, next Do) OUT {
 		}
 		return OUT{do: wait, next: LATER}
 	case node.IndexNode:
-		id := scope.Designator(expr)
+		/*id := scope.Designator(expr)
 		rt2.Push(rt2.New(expr), parent)
 		wait := func(...IN) OUT {
 			if rt2.DataOf(parent)[expr] == nil {
@@ -43,7 +43,8 @@ func expectExpr(parent frame.Frame, expr node.Node, next Do) OUT {
 			}
 			return OUT{do: next, next: NOW}
 		}
-		return OUT{do: wait, next: LATER}
+		return OUT{do: wait, next: LATER}*/
+		return End()
 	case node.ProcedureNode:
 		rt2.DataOf(parent)[expr] = e.Object()
 		return OUT{do: next, next: NOW}

rt2/rules/guard.go

@@ -7,21 +7,21 @@ import (
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2"
-	"fw/rt2/context"
+	//	"fw/rt2/context"
 	"fw/rt2/frame"
-	"fw/rt2/scope"
+	//	"fw/rt2/scope"
 	"reflect"
 )
 
 func guardSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	sc := scope.This(f.Domain().Discover(context.SCOPE))
+	//	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	n := rt2.NodeOf(f).(node.GuardNode)
 	var obj object.Object
 	switch l := n.Left().(type) {
 	case node.VariableNode:
 		obj = l.Object()
 	case node.ParameterNode:
-		obj = sc.Select(scope.Designator(l)).(object.Object)
+		//		obj = sc.Select(scope.Designator(l)).(object.Object)
 	default:
 		panic(fmt.Sprintln("unsupported left", reflect.TypeOf(l)))
 	}
@@ -29,8 +29,8 @@ func guardSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		rt2.DataOf(f.Parent())[n] = n.Left()
 		return frame.End()
 	} else {
-		trap := node.New(constant.TRAP, cp.SomeAdr()).(node.TrapNode)
-		code := node.New(constant.CONSTANT, cp.SomeAdr()).(node.ConstantNode)
+		trap := node.New(constant.TRAP, int(cp.SomeAdr())).(node.TrapNode)
+		code := node.New(constant.CONSTANT, int(cp.SomeAdr())).(node.ConstantNode)
 		code.SetData(0)
 		trap.SetLeft(code)
 		rt2.Push(rt2.New(trap), f)

rt2/rules/if.go

@@ -3,19 +3,18 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"reflect"
 )
 
 func ifExpr(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
+	n := rt2.NodeOf(f)
 	switch n.Left().(type) {
 	case node.OperationNode:
-		fu.Push(fu.New(n.Left()), f)
+		rt2.Push(rt2.New(n.Left()), f)
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			fu.DataOf(f.Parent())[n] = fu.DataOf(f)[n.Left()]
+			rt2.DataOf(f.Parent())[n] = rt2.DataOf(f)[n.Left()]
 			return frame.End()
 		}
 		ret = frame.LATER
@@ -26,25 +25,24 @@ func ifExpr(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 }
 
 func ifSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
-	fu.DataOf(f)[0] = n.Left() //if
-	fu.Push(fu.New(n.Left()), f)
+	n := rt2.NodeOf(f)
+	rt2.DataOf(f)[0] = n.Left() //if
+	rt2.Push(rt2.New(n.Left()), f)
 	seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-		last := fu.DataOf(f)[0].(node.Node)
-		done := fu.DataOf(f)[last].(bool)
-		fu.DataOf(f)[last] = nil
+		last := rt2.DataOf(f)[0].(node.Node)
+		done := rt2.DataOf(f)[last].(bool)
+		rt2.DataOf(f)[last] = nil
 		if done && last.Right() != nil {
-			fu.Push(fu.New(last.Right()), f)
+			rt2.Push(rt2.New(last.Right()), f)
 			return frame.Tail(frame.STOP), frame.LATER
 		} else if last.Right() == nil {
 			return frame.End()
 		} else if last.Link() != nil { //elsif
-			fu.DataOf(f)[0] = last.Link()
-			fu.Push(fu.New(last.Link()), f)
+			rt2.DataOf(f)[0] = last.Link()
+			rt2.Push(rt2.New(last.Link()), f)
 			return seq, frame.LATER
 		} else if n.Right() != nil { //else
-			fu.Push(fu.New(n.Right()), f)
+			rt2.Push(rt2.New(n.Right()), f)
 			return frame.Tail(frame.STOP), frame.LATER
 		} else if n.Right() == nil {
 			return frame.End()

rt2/rules/index.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"fw/cp/node"
 	"fw/rt2"
-	"fw/rt2/context"
+	//	"fw/rt2/context"
 	"fw/rt2/frame"
-	"fw/rt2/scope"
+	//	"fw/rt2/scope"
 	"reflect"
 )
 
@@ -22,8 +22,8 @@ func indexSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		ret = frame.NOW
 	case node.VariableNode:
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			rt2.DataOf(f.Parent())[i] = sc.Select(scope.Designator(i.Right()))
+			//			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			//			rt2.DataOf(f.Parent())[i] = sc.Select(scope.Designator(i.Right()))
 			return frame.End()
 		}
 		ret = frame.NOW

rt2/rules/op.go

@@ -8,7 +8,6 @@ import (
 	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 	"math"
 	"math/big"
@@ -128,14 +127,6 @@ func in(_a interface{}, _b interface{}) bool {
 	return a == b
 }
 
-func sum(_a interface{}, _b interface{}) interface{} {
-	assert.For(_a != nil, 20)
-	assert.For(_b != nil, 21)
-	var a int32 = int32Of(_a)
-	var b int32 = int32Of(_b)
-	return a + b
-}
-
 func sub(_a interface{}, _b interface{}) interface{} {
 	assert.For(_a != nil, 20)
 	assert.For(_b != nil, 21)
@@ -293,31 +284,30 @@ func bits(_a interface{}) interface{} {
 }
 
 func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
 	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-	n := fu.NodeOf(f).(node.MonadicNode)
+	n := rt2.NodeOf(f).(node.MonadicNode)
 
 	op := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-		n := fu.NodeOf(f)
+		n := rt2.NodeOf(f)
 		switch n.(node.OperationNode).Operation() {
 		case operation.NOT:
-			fu.DataOf(f.Parent())[n] = not(fu.DataOf(f)[n.Left()])
+			rt2.DataOf(f.Parent())[n] = not(rt2.DataOf(f)[n.Left()])
 			return frame.End()
 		case operation.IS:
-			x := sc.Select(scope.Designator(n.Left())).(object.Object)
-			fu.DataOf(f.Parent())[n] = is(x, n.Object())
+			/*	x := sc.Select(scope.Designator(n.Left())).(object.Object)
+				rt2.DataOf(f.Parent())[n] = is(x, n.Object())*/
 			return frame.End()
 		case operation.ABS:
-			fu.DataOf(f.Parent())[n] = abs(fu.DataOf(f)[n.Left()])
+			rt2.DataOf(f.Parent())[n] = abs(rt2.DataOf(f)[n.Left()])
 			return frame.End()
 		case operation.ODD:
-			fu.DataOf(f.Parent())[n] = odd(fu.DataOf(f)[n.Left()])
+			rt2.DataOf(f.Parent())[n] = odd(rt2.DataOf(f)[n.Left()])
 			return frame.End()
 		case operation.CAP:
-			fu.DataOf(f.Parent())[n] = cap_char(fu.DataOf(f)[n.Left()])
+			rt2.DataOf(f.Parent())[n] = cap_char(rt2.DataOf(f)[n.Left()])
 			return frame.End()
 		case operation.BITS:
-			fu.DataOf(f.Parent())[n] = bits(fu.DataOf(f)[n.Left()])
+			rt2.DataOf(f.Parent())[n] = bits(rt2.DataOf(f)[n.Left()])
 			return frame.End()
 		default:
 			panic("no such op")
@@ -332,25 +322,25 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			case object.INTEGER:
 				switch v := x.(type) {
 				case int8:
-					fu.DataOf(f.Parent())[n] = int32(x.(int8))
+					rt2.DataOf(f.Parent())[n] = int32(x.(int8))
 				case *big.Int:
-					fu.DataOf(f.Parent())[n] = int32(v.Int64())
+					rt2.DataOf(f.Parent())[n] = int32(v.Int64())
 				case int32:
-					fu.DataOf(f.Parent())[n] = v
+					rt2.DataOf(f.Parent())[n] = v
 				default:
 					panic(fmt.Sprintln("ooops", reflect.TypeOf(x)))
 				}
 			case object.SET:
 				switch v := x.(type) {
 				case int32:
-					fu.DataOf(f.Parent())[n] = big.NewInt(int64(v))
+					rt2.DataOf(f.Parent())[n] = big.NewInt(int64(v))
 				default:
 					panic(fmt.Sprintln("ooops", reflect.TypeOf(x)))
 				}
 			case object.REAL:
 				switch v := x.(type) {
 				case int32:
-					fu.DataOf(f.Parent())[n] = float64(v)
+					rt2.DataOf(f.Parent())[n] = float64(v)
 				default:
 					panic(fmt.Sprintln("ooops", reflect.TypeOf(x)))
 				}
@@ -360,9 +350,9 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		}
 		switch n.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
-			x := sc.Select(scope.Designator(n.Left()))
+			x := sc.Select(n.Left().Object().Adr())
 			assert.For(x != nil, 40)
-			conv(x)
+			conv(scope.ValueFrom(x))
 			return frame.End()
 		case node.OperationNode:
 			return This(expectExpr(f, n.Left(), func(...IN) OUT {
@@ -375,18 +365,18 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case operation.NOT:
 		switch n.Left().(type) {
 		case node.ConstantNode:
-			fu.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
+			rt2.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
 			return op, frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
+				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				//				rt2.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
 				return op, frame.NOW
 			}
 			ret = frame.NOW
 			return seq, ret
 		case node.OperationNode, node.DerefNode:
-			fu.Push(fu.New(n.Left()), f)
+			rt2.Push(rt2.New(n.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return op, frame.NOW
 			}
@@ -394,8 +384,8 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return seq, ret
 		case node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
+				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				//				rt2.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
 				return op, frame.NOW
 			}
 			ret = frame.NOW
@@ -424,67 +414,67 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 }
 
 func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
+	sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 
 	op := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-		n := fu.NodeOf(f).(node.OperationNode)
+		n := rt2.NodeOf(f).(node.OperationNode)
 		switch n.Operation() {
 		case operation.PLUS:
-			fu.DataOf(f.Parent())[n] = sum(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Sum(rt2.ValueOf(f)[n.Left().Adr()], rt2.ValueOf(f)[n.Right().Adr()])
 			return frame.End()
 		case operation.MINUS:
-			fu.DataOf(f.Parent())[n] = sub(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = sub(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.EQUAL:
-			fu.DataOf(f.Parent())[n] = eq(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = eq(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.LESSER:
-			fu.DataOf(f.Parent())[n] = lss(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = lss(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.LESS_EQUAL:
-			fu.DataOf(f.Parent())[n] = leq(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = leq(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.LEN:
-			fu.DataOf(f.Parent())[n] = length(n.Left().Object(), fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = length(n.Left().Object(), rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.NOT_EQUAL:
-			fu.DataOf(f.Parent())[n] = neq(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = neq(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.GREATER:
-			fu.DataOf(f.Parent())[n] = gtr(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = gtr(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.MAX:
-			fu.DataOf(f.Parent())[n] = max(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = max(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.MIN:
-			fu.DataOf(f.Parent())[n] = min(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = min(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.DIV:
-			fu.DataOf(f.Parent())[n] = div(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = div(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.MOD:
-			fu.DataOf(f.Parent())[n] = mod(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = mod(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.TIMES:
-			fu.DataOf(f.Parent())[n] = times(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = times(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.SLASH:
-			fu.DataOf(f.Parent())[n] = slash(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = slash(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.IN:
-			fu.DataOf(f.Parent())[n] = in(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = in(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.ASH:
-			fu.DataOf(f.Parent())[n] = ash(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = ash(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.AND:
-			fu.DataOf(f.Parent())[n] = and(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = and(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.OR:
-			fu.DataOf(f.Parent())[n] = or(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = or(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		case operation.GREAT_EQUAL:
-			fu.DataOf(f.Parent())[n] = geq(fu.DataOf(f)[n.Left()], fu.DataOf(f)[n.Right()])
+			rt2.DataOf(f.Parent())[n] = geq(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
 			return frame.End()
 		default:
 			panic(fmt.Sprintln("unknown operation", n.(node.OperationNode).Operation()))
@@ -492,23 +482,20 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	}
 
 	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-		n := fu.NodeOf(f)
+		n := rt2.NodeOf(f)
 		switch n.Right().(type) {
 		case node.ConstantNode:
-			fu.DataOf(f)[n.Right()] = n.Right().(node.ConstantNode).Data()
+			rt2.ValueOf(f)[n.Right().Adr()] = sc.Provide(n.Right())(nil)
 			return op, frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Right()] = sc.Select(scope.Designator(n.Right()))
-				//fmt.Println(n.Right().Object(), reflect.TypeOf(n.Right().Object()))
-				assert.For(fu.DataOf(f)[n.Right()] != nil, 60)
+				rt2.ValueOf(f)[n.Right().Adr()] = sc.Select(n.Right().Object().Adr())
 				return op, frame.NOW
 			}
 			ret = frame.NOW
 			return seq, ret
 		case node.OperationNode, node.DerefNode:
-			fu.Push(fu.New(n.Right()), f)
+			rt2.Push(rt2.New(n.Right()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return op, frame.NOW
 			}
@@ -516,8 +503,8 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return seq, ret
 		case node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Right()] = sc.Select(scope.Designator(n.Right()))
+				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				//				rt2.DataOf(f)[n.Right()] = sc.Select(scope.Designator(n.Right()))
 				return op, frame.NOW
 			}
 			ret = frame.NOW
@@ -529,21 +516,20 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	}
 
 	left := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-		n := fu.NodeOf(f)
+		n := rt2.NodeOf(f)
 		switch n.Left().(type) {
 		case node.ConstantNode:
-			fu.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
+			rt2.ValueOf(f)[n.Left().Adr()] = sc.Provide(n.Left())(nil)
 			return right, frame.NOW
 		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
+				rt2.ValueOf(f)[n.Left().Adr()] = sc.Select(n.Left().Object().Adr())
 				return right, frame.NOW
 			}
 			ret = frame.NOW
 			return seq, ret
 		case node.OperationNode, node.DerefNode, node.RangeNode:
-			fu.Push(fu.New(n.Left()), f)
+			rt2.Push(rt2.New(n.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				return right, frame.NOW
 			}
@@ -551,8 +537,8 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return seq, ret
 		case node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
+				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				//				rt2.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
 				return right, frame.NOW
 			}
 			ret = frame.NOW

rt2/rules/repeat.go

@@ -3,22 +3,21 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"reflect"
 )
 
 func repeatSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
+	n := rt2.NodeOf(f)
 
-	fu.DataOf(f)[n.Right()] = false
+	rt2.DataOf(f)[n.Right()] = false
 	var cond func(f frame.Frame) (frame.Sequence, frame.WAIT)
 	next := func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-		done := fu.DataOf(f)[n.Right()].(bool)
-		fu.DataOf(f)[n.Right()] = nil
+		done := rt2.DataOf(f)[n.Right()].(bool)
+		rt2.DataOf(f)[n.Right()] = nil
 		if !done && n.Left() != nil {
-			fu.Push(fu.New(n.Left()), f)
+			rt2.Push(rt2.New(n.Left()), f)
 			return cond, frame.LATER
 		} else if done {
 			return frame.End()
@@ -32,9 +31,9 @@ func repeatSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	cond = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 		switch n.Right().(type) {
 		case node.OperationNode:
-			fu.Push(fu.New(n.Right()), f)
+			rt2.Push(rt2.New(n.Right()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				fu.DataOf(f.Parent())[n] = fu.DataOf(f)[n.Right()]
+				rt2.DataOf(f.Parent())[n] = rt2.DataOf(f)[n.Right()]
 				return next, frame.LATER
 			}
 			ret = frame.LATER

rt2/rules/return.go

@@ -3,36 +3,37 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 	"reflect"
 )
 
 func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	a := fu.NodeOf(f)
+	a := rt2.NodeOf(f)
 
 	left := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		switch a.Left().(type) {
 		case node.ConstantNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				fu.DataOf(f.Parent())[a.Object()] = a.Left().(node.ConstantNode).Data()
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				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()
 			}
 			ret = frame.NOW
 		case node.VariableNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				fu.DataOf(f.Parent())[a.Object()] = sc.Select(scope.Designator(a.Left()))
+				rt2.ValueOf(f.Parent())[a.Object().Adr()] = sc.Select(a.Left().Object().Adr())
 				return frame.End()
 			}
 			ret = frame.NOW
 		case node.OperationNode, node.CallNode:
-			fu.Push(fu.New(a.Left()), f)
+			rt2.Push(rt2.New(a.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				fu.DataOf(f.Parent())[a.Object()] = fu.DataOf(f)[a.Left()]
+				rt2.ValueOf(f.Parent())[a.Object().Adr()] = rt2.ValueOf(f)[a.Left().Adr()]
 				return frame.End()
 			}
 			ret = frame.LATER

rt2/rules/table.go

@@ -11,7 +11,6 @@ import (
 	"fw/rt2/frame"
 	"fw/rt2/frame/std"
 	rt_module "fw/rt2/module"
-	"fw/rt2/nodeframe"
 	"fw/rt2/scope"
 	"fw/utils"
 	"reflect"
@@ -99,7 +98,6 @@ func prologue(n node.Node) frame.Sequence {
 }
 
 func epilogue(n node.Node) frame.Sequence {
-	var fu nodeframe.FrameUtils
 	switch n.(type) {
 	case node.AssignNode, node.InitNode, node.CallNode, node.ConditionalNode, node.WhileNode,
 		node.RepeatNode, node.ExitNode, node.WithNode, node.CaseNode, node.CompNode:
@@ -108,14 +106,14 @@ func epilogue(n node.Node) frame.Sequence {
 			//fmt.Println("from", reflect.TypeOf(n))
 			//fmt.Println("next", reflect.TypeOf(next))
 			if next != nil {
-				f.Root().PushFor(fu.New(next), f.Parent())
+				f.Root().PushFor(rt2.New(next), f.Parent())
 			}
 			return frame.End()
 		}
 	case node.EnterNode:
 		return func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			fmt.Println(rt_module.DomainModule(f.Domain()).Name)
-			sm := scope.This(f.Domain().Discover(context.SCOPE))
+			sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
 			sm.Target().(scope.ScopeAllocator).Dispose(n)
 			//возвращаем результаты вызова функции
 			if f.Parent() != nil {

rt2/rules/while.go

@@ -3,21 +3,20 @@ package rules
 import (
 	"fmt"
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 	"reflect"
 )
 
 func whileSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
+	n := rt2.NodeOf(f)
 
 	var cond func(f frame.Frame) (frame.Sequence, frame.WAIT)
 	next := func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-		done := fu.DataOf(f)[n.Left()].(bool)
-		fu.DataOf(f)[n.Left()] = nil
+		done := rt2.DataOf(f)[n.Left()].(bool)
+		rt2.DataOf(f)[n.Left()] = nil
 		if done && n.Right() != nil {
-			fu.Push(fu.New(n.Right()), f)
+			rt2.Push(rt2.New(n.Right()), f)
 			return cond, frame.LATER
 		} else if !done {
 			return frame.End()
@@ -31,9 +30,9 @@ func whileSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	cond = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 		switch n.Left().(type) {
 		case node.OperationNode:
-			fu.Push(fu.New(n.Left()), f)
+			rt2.Push(rt2.New(n.Left()), f)
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				fu.DataOf(f.Parent())[n] = fu.DataOf(f)[n.Left()]
+				rt2.DataOf(f.Parent())[n] = rt2.DataOf(f)[n.Left()]
 				return next, frame.LATER
 			}
 			ret = frame.LATER

rt2/rules/with.go

@@ -2,30 +2,29 @@ package rules
 
 import (
 	"fw/cp/node"
+	"fw/rt2"
 	"fw/rt2/frame"
-	"fw/rt2/nodeframe"
 )
 
 func withSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	var fu nodeframe.FrameUtils
-	n := fu.NodeOf(f)
-	fu.DataOf(f)[0] = n.Left() //if
-	fu.Push(fu.New(n.Left()), f)
+	n := rt2.NodeOf(f)
+	rt2.DataOf(f)[0] = n.Left() //if
+	rt2.Push(rt2.New(n.Left()), f)
 	seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-		last := fu.DataOf(f)[0].(node.Node)
-		done := fu.DataOf(f)[last].(bool)
-		fu.DataOf(f)[last] = nil
+		last := rt2.DataOf(f)[0].(node.Node)
+		done := rt2.DataOf(f)[last].(bool)
+		rt2.DataOf(f)[last] = nil
 		if done && last.Right() != nil {
-			fu.Push(fu.New(last.Right()), f)
+			rt2.Push(rt2.New(last.Right()), f)
 			return frame.Tail(frame.STOP), frame.LATER
 		} else if last.Right() == nil {
 			return frame.End()
 		} else if last.Link() != nil { //elsif
-			fu.DataOf(f)[0] = last.Link()
-			fu.Push(fu.New(last.Link()), f)
+			rt2.DataOf(f)[0] = last.Link()
+			rt2.Push(rt2.New(last.Link()), f)
 			return seq, frame.LATER
 		} else if n.Right() != nil { //else
-			fu.Push(fu.New(n.Right()), f)
+			rt2.Push(rt2.New(n.Right()), f)
 			return frame.Tail(frame.STOP), frame.LATER
 		} else if n.Right() == nil {
 			return frame.End()

rt2/scope/area.go

@@ -1,39 +1,13 @@
 package scope
 
 import (
+	"fw/cp"
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2/context"
 	"fw/rt2/frame"
-	"strconv"
 )
 
-type ID struct {
-	Name  string
-	Path  string
-	Index *int64
-	Ref   *int
-}
-
-func (i ID) String() string {
-	if i.Name != "" {
-		ret := i.Name
-		if i.Ref != nil {
-			ret = ret + strconv.Itoa(*i.Ref)
-		}
-		if i.Path != "" {
-			ret = ret + "." + i.Path
-		}
-		if i.Index != nil {
-			ret = ret + "[" + strconv.FormatInt(*i.Index, 10) + "]"
-		}
-
-		return ret
-	} else {
-		return "<empty id>"
-	}
-}
-
 type PARAM struct {
 	Objects object.Object
 	Values  node.Node
@@ -45,9 +19,10 @@ type PARAM struct {
 // pk, 20150112, инициализация параметров теперь происходит как и обычный frame.Sequence, с использованием стека
 type Manager interface {
 	context.ContextAware
-	Update(id ID, val ValueFor)
-	Select(id ID) interface{}
+	Update(id cp.ID, val ValueFor)
+	Select(id cp.ID) Value
 	Target(...Allocator) Allocator
+	Provide(interface{}) ValueFor
 	String() string
 }
 
@@ -66,15 +41,6 @@ type HeapAllocator interface {
 	Dispose(n node.Node)
 }
 
-//средство обновления значения
-type ValueFor func(in interface{}) (out interface{})
-
-var Designator func(n ...node.Node) ID
 var FindObjByName func(m Manager, name string) object.Object
 
-func This(i interface{}) Manager {
-	return i.(Manager)
-}
-
-var NewStack func() Manager
-var NewHeap func() Manager
+var New func() Manager

rt2/scope/data.go

@@ -0,0 +1,40 @@
+package scope
+
+import (
+	"fw/cp"
+)
+
+type Operations interface {
+	Sum(Value, Value) Value
+}
+
+type Value interface {
+	String() string
+}
+
+type Constant interface {
+	Value
+}
+
+type Variable interface {
+	Id() cp.ID
+	Set(Value)
+	Value
+}
+
+type Ref interface {
+	Value
+}
+
+//средство обновления значенияx
+type ValueFor func(in Value) (out Value)
+
+func Simple(v Value) ValueFor {
+	return func(Value) Value {
+		return v
+	}
+}
+
+var ValueFrom func(v Value) Value
+
+var Ops Operations

rt2/scope/modern/ms.go

@@ -0,0 +1,244 @@
+package modern
+
+import (
+	"fmt"
+	"fw/cp"
+	cpm "fw/cp/module"
+	"fw/cp/node"
+	"fw/cp/object"
+	"fw/rt2/context"
+	"fw/rt2/frame"
+	rtm "fw/rt2/module"
+	"fw/rt2/scope"
+	"reflect"
+	"ypk/assert"
+	"ypk/halt"
+)
+
+type level struct {
+	k     map[cp.ID]int
+	v     map[int]scope.Variable
+	r     map[int]scope.Ref
+	next  int
+	ready bool
+}
+
+type area struct {
+	d    context.Domain
+	data []*level
+}
+
+type salloc struct {
+	area *area
+}
+
+type ref struct {
+	id   cp.ID
+	link object.Object
+}
+
+func (r *ref) String() string {
+	return fmt.Sprint(r.link.Name(), "@", r.id)
+}
+
+func newRef(x object.Object) *ref {
+	return &ref{link: x}
+}
+
+func (a *area) allocate(mod *cpm.Module, ol []object.Object, r bool) {
+	l := &level{next: 1, ready: r,
+		k: make(map[cp.ID]int),
+		v: make(map[int]scope.Variable),
+		r: make(map[int]scope.Ref)}
+	a.data = append(a.data, l)
+	for _, o := range ol {
+		fmt.Println(reflect.TypeOf(o))
+		imp := mod.ImportOf(o)
+		if imp == "" {
+			switch x := o.(type) {
+			case object.VariableObject:
+				switch o.Complex().(type) {
+				case nil:
+					l.v[l.next] = NewData(x)
+					l.k[x.Adr()] = l.next
+					l.next++
+				case object.PointerType:
+					fmt.Println("pointer")
+				}
+			case object.ConstantObject, object.ProcedureObject:
+				//do nothing
+			case object.ParameterObject:
+				l.r[l.next] = newRef(x)
+				l.k[x.Adr()] = l.next
+				l.next++
+			default:
+				halt.As(20, reflect.TypeOf(x))
+			}
+		}
+	}
+}
+
+func (a *area) top() *level {
+	if len(a.data) > 0 {
+		return a.data[len(a.data)-1]
+	}
+	return nil
+}
+
+func (a *area) Provide(x interface{}) scope.ValueFor {
+	return func(scope.Value) scope.Value {
+		switch z := x.(type) {
+		case node.ConstantNode:
+			return NewConst(z)
+		}
+		panic(0)
+	}
+}
+
+func (a *salloc) Allocate(n node.Node, final bool) {
+	fmt.Println("ALLOCATE")
+	mod := rtm.DomainModule(a.area.d)
+	a.area.allocate(mod, mod.Objects[n], final)
+}
+
+func (a *salloc) Dispose(n node.Node) {
+	x := a.area.data
+	a.area.data = nil
+	for i := 0; i < len(x)-1; i++ {
+		a.area.data = append(a.area.data, x[i])
+	}
+}
+
+func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, ret frame.WAIT) {
+	fmt.Println("INITIALIZE")
+	l := a.area.top()
+	assert.For(l != nil && !l.ready, 20)
+	val := par.Values
+	f := par.Frame
+	end := func(frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+		l.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() {
+		switch o := next.(type) {
+		case object.VariableObject:
+			switch nv := val.(type) {
+			case node.ConstantNode:
+				v := NewConst(nv)
+				l.v[l.k[o.Adr()]].Set(v)
+			case node.VariableNode:
+				v := a.area.Select(nv.Adr())
+				l.v[l.k[o.Adr()]].Set(v)
+			default:
+				halt.As(40, reflect.TypeOf(nv))
+			}
+		case object.ParameterObject:
+			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, id: nv.Object().Adr()}
+			default:
+				halt.As(40, reflect.TypeOf(nv))
+			}
+		default:
+			halt.As(40, reflect.TypeOf(o))
+		}
+		val = val.Link()
+	}
+	return seq, ret
+}
+
+func (a *area) Update(id cp.ID, fval scope.ValueFor) {
+	fmt.Println("UPDATE", id)
+	var upd func(x int, id cp.ID)
+	var k int
+	upd = func(x int, id cp.ID) {
+		for i := x - 1; i >= 0 && k == 0; i-- {
+			l := a.data[i]
+			if l.ready {
+				k = l.k[id]
+				if k != 0 {
+					v := a.data[i].v[k]
+					if v == nil { //ref?
+						r := l.r[k]
+						if r != nil {
+							upd(i, r.(*ref).id)
+							break
+						}
+					} else {
+						v.Set(fval(a.data[i].v[k]))
+					}
+				}
+			}
+		}
+	}
+	k = 0
+	upd(len(a.data), id)
+	assert.For(k != 0, 60)
+}
+func (a *area) Select(id cp.ID) (ret scope.Value) {
+	fmt.Println("SELECT", id)
+	var sel func(x int, id cp.ID)
+	sel = func(x int, id cp.ID) {
+		for i := x - 1; i >= 0 && ret == nil; i-- {
+			l := a.data[i]
+			k := 0
+			if l.ready {
+				k = l.k[id]
+				if k != 0 {
+					ret = l.v[k]
+					if ret == nil { //ref?
+						r := l.r[k]
+						if r != nil {
+							sel(i, r.(*ref).id)
+							break
+						}
+					}
+				}
+			}
+		}
+	}
+	sel(len(a.data), id)
+	assert.For(ret != nil, 60)
+	return ret
+}
+
+func (a *area) Target(...scope.Allocator) scope.Allocator { return &salloc{area: a} }
+func (a *area) String() (ret string) {
+	for _, l := range a.data {
+		ret = fmt.Sprintln(ret, l)
+	}
+	return ret
+}
+
+func (l *level) String() (ret string) {
+	for k, v := range l.k {
+		ret = fmt.Sprint(ret, "@", k, v, l.v[v])
+		if l.v[v] == nil {
+			ret = fmt.Sprintln(ret, l.r[v])
+		} else {
+			ret = fmt.Sprintln(ret)
+		}
+	}
+	return ret
+}
+
+func (a *area) Init(d context.Domain) { a.d = d }
+
+func (a *area) Domain() context.Domain { return a.d }
+
+func (a *area) Handle(msg interface{}) {}
+
+func nn() scope.Manager {
+	return &area{}
+}
+
+func init() {
+	scope.New = nn
+}

rt2/scope/modern/val.go

@@ -0,0 +1,197 @@
+package modern
+
+import (
+	"fmt"
+	"fw/cp"
+	"fw/cp/node"
+	"fw/cp/object"
+	"fw/rt2/scope"
+	"math/big"
+	"reflect"
+	"ypk/assert"
+	"ypk/halt"
+)
+
+type data struct {
+	link object.Object
+	val  interface{}
+}
+
+func (x *data) Id() cp.ID {
+	return 0
+}
+
+func (d *data) Set(v scope.Value) {
+	fmt.Println("set data")
+	switch x := v.(type) {
+	case *data:
+		assert.For(d.link.Type() == x.link.Type(), 20)
+		d.val = x.val
+	case INTEGER:
+		switch d.link.Type() {
+		case object.INTEGER:
+			d.val = x
+		case object.LONGINT:
+			d.val = LONGINT(x)
+		default:
+			halt.As(20, d.link.Type())
+		}
+	case BOOLEAN:
+		assert.For(d.link.Type() == object.BOOLEAN, 20)
+		d.val = x
+	case SHORTCHAR:
+		assert.For(d.link.Type() == object.SHORTCHAR, 20)
+		d.val = x
+	case CHAR:
+		assert.For(d.link.Type() == object.CHAR, 20)
+		d.val = x
+	case SHORTINT:
+		assert.For(d.link.Type() == object.SHORTINT, 20)
+		d.val = x
+	case LONGINT:
+		assert.For(d.link.Type() == object.LONGINT, 20)
+		d.val = x
+	case BYTE:
+		assert.For(d.link.Type() == object.BYTE, 20)
+		d.val = x
+	case SET:
+		assert.For(d.link.Type() == object.SET, 20)
+		d.val = x
+	case REAL:
+		assert.For(d.link.Type() == object.REAL, 20)
+		d.val = x
+	case SHORTREAL:
+		assert.For(d.link.Type() == object.SHORTREAL, 20)
+		d.val = x
+	default:
+		panic(fmt.Sprintln(reflect.TypeOf(x)))
+	}
+}
+
+func (d *data) String() string {
+	return fmt.Sprint(d.link.Name(), "=", d.val)
+}
+
+type INTEGER int32
+type BOOLEAN bool
+type BYTE int8
+type SHORTINT int16
+type LONGINT int64
+type SET struct {
+	bits *big.Int
+}
+type CHAR rune
+type REAL float64
+type SHORTREAL float32
+type SHORTCHAR rune
+
+func (x SHORTCHAR) String() string { return fmt.Sprint(rune(x)) }
+func (x SHORTREAL) String() string { return fmt.Sprint(float32(x)) }
+func (x REAL) String() string      { return fmt.Sprint(float64(x)) }
+func (x CHAR) String() string      { return fmt.Sprint(rune(x)) }
+func (x SET) String() string       { return fmt.Sprint(x.bits) }
+func (x LONGINT) String() string   { return fmt.Sprint(int64(x)) }
+func (x SHORTINT) String() string  { return fmt.Sprint(int16(x)) }
+func (x BYTE) String() string      { return fmt.Sprint(int8(x)) }
+func (x INTEGER) String() string   { return fmt.Sprint(int32(x)) }
+func (x BOOLEAN) String() string   { return fmt.Sprint(bool(x)) }
+
+func NewData(o object.Object) (ret scope.Variable) {
+	switch o.Type() {
+	case object.INTEGER:
+		ret = &data{link: o, val: INTEGER(0)}
+	case object.BOOLEAN:
+		ret = &data{link: o, val: BOOLEAN(false)}
+	case object.BYTE:
+		ret = &data{link: o, val: BYTE(0)}
+	case object.CHAR:
+		ret = &data{link: o, val: CHAR(0)}
+	case object.LONGINT:
+		ret = &data{link: o, val: LONGINT(0)}
+	case object.SHORTINT:
+		ret = &data{link: o, val: SHORTINT(0)}
+	case object.SET:
+		ret = &data{link: o, val: SET{bits: big.NewInt(0)}}
+	case object.REAL:
+		ret = &data{link: o, val: REAL(0)}
+	case object.SHORTREAL:
+		ret = &data{link: o, val: SHORTREAL(0)}
+	case object.SHORTCHAR:
+		ret = &data{link: o, val: SHORTCHAR(0)}
+	default:
+		panic(fmt.Sprintln("unsupported type", o.Type()))
+	}
+	return ret
+}
+
+func NewConst(n node.Node) scope.Value {
+	switch x := n.(type) {
+	case node.ConstantNode:
+		switch x.Type() {
+		case object.INTEGER:
+			return INTEGER(x.Data().(int32))
+		case object.REAL:
+			return REAL(x.Data().(float64))
+		case object.BOOLEAN:
+			return BOOLEAN(x.Data().(bool))
+		case object.SHORTCHAR:
+			return SHORTCHAR(x.Data().(rune))
+		case object.LONGINT:
+			return LONGINT(x.Data().(int64))
+		case object.SHORTINT:
+			return SHORTINT(x.Data().(int16))
+		case object.SHORTREAL:
+			return SHORTREAL(x.Data().(float32))
+		case object.BYTE:
+			return BYTE(x.Data().(int8))
+		case object.SET:
+			return SET{bits: x.Data().(*big.Int)}
+		case object.CHAR:
+			return CHAR(x.Data().(rune))
+		default:
+			panic(fmt.Sprintln(x.Type()))
+		}
+	}
+	panic(0)
+}
+
+func vfrom(v scope.Value) scope.Value {
+	switch n := v.(type) {
+	case *data:
+		switch n.link.Type() {
+		case object.INTEGER:
+			return n.val.(INTEGER)
+		default:
+			halt.As(100, n.link.Type())
+		}
+	case INTEGER:
+		return n
+	default:
+		halt.As(100, reflect.TypeOf(n))
+	}
+	return nil
+}
+
+type ops struct{}
+
+func (o *ops) Sum(a, b scope.Value) scope.Value {
+	switch x := a.(type) {
+	case *data:
+		return o.Sum(vfrom(a), b)
+	case INTEGER:
+		switch y := b.(type) {
+		case *data:
+			return o.Sum(x, vfrom(b))
+		case INTEGER:
+			return INTEGER(int32(x) + int32(y))
+		}
+	default:
+		panic(fmt.Sprintln(reflect.TypeOf(x)))
+	}
+	panic(0)
+}
+
+func init() {
+	scope.ValueFrom = vfrom
+	scope.Ops = &ops{}
+}

rt2/scope/std/heap.go

@@ -35,6 +35,7 @@ func (h *heap) String() (ret string) {
 	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) {

rt2/utils.go

@@ -1,6 +1,7 @@
 package rt2
 
 import (
+	"fw/cp"
 	"fw/cp/node"
 	"fw/rt2/context"
 	"fw/rt2/frame"
@@ -8,12 +9,15 @@ import (
 	"fw/rt2/scope"
 )
 
-var utils nodeframe.FrameUtils
+var utils nodeframe.NodeFrameUtils
 
 func DataOf(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)
 }
+func ReplaceDomain(f frame.Frame, d context.Domain) { utils.ReplaceDomain(f, d) }
+func Assert(f frame.Frame, ok frame.Assert)         { utils.Assert(f, ok) }