продолжается переезд на новый механизм стека/кучи, обновлены примеры после багфиска в генераторе дампов Xev

cp/object/object.go

@@ -35,7 +35,7 @@ type Object interface {
 }
 
 type Ref interface {
-	Object() Object
+	Adr(...int) cp.ID
 }
 
 type VariableObject interface {
@@ -132,7 +132,7 @@ func (of *objectFields) SetRef(n Ref) {
 	assert.For(n != nil, 20)
 	exists := func() bool {
 		for _, v := range of.ref {
-			if v == n {
+			if v.Adr() == n.Adr() {
 				return true
 			}
 		}

cp/object/type.go

@@ -10,7 +10,8 @@ import (
 type Type int
 
 const (
-	INTEGER Type = iota
+	NOTYPE Type = iota
+	INTEGER
 	SHORTINT
 	LONGINT
 	BYTE
@@ -22,7 +23,6 @@ const (
 	SET
 	PROCEDURE
 	//фиктивные типы
-	NOTYPE
 	COMPLEX
 	STRING
 	SHORTSTRING
@@ -56,6 +56,10 @@ func (t Type) String() string {
 		return "COMPLEX"
 	case PROCEDURE:
 		return "PROCEDURE"
+	case STRING:
+		return "STRING"
+	case SHORTSTRING:
+		return "SHORTSTRING"
 	default:
 		return fmt.Sprint("looks like new type here", int(t))
 	}

rt2/rules/assign.go

@@ -93,10 +93,8 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.LATER
 		case node.ProcedureNode:
-			//			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-			/*sc.Update(leftId, func(interface{}) interface{} {
-				return a.Right().Object()
-			})*/
+			sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+			sc.Update(leftId, sc.Provide(a.Right().Object()))
 			return frame.End()
 		default:
 			fmt.Println(reflect.TypeOf(a.Right()))

rt2/rules/call.go

@@ -44,6 +44,7 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 	cn.SetLeft(ol[0])
 	cc := node.New(constant.CONSTANT, int(cp.SomeAdr())).(node.ConstantNode)
 	cc.SetData(data)
+	cc.SetType(object.SHORTSTRING)
 	cn.SetRight(cc)
 	rt2.Push(rt2.New(cn), f)
 }
@@ -127,7 +128,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(n.Left().Adr())
+		obj := scope.GoTypeFrom(sc.Select(n.Left().Object().Adr()))
 
 		if obj, ok := obj.(object.Object); ok {
 			proc := m.NodeByObject(obj)

rt2/rules/deref.go

@@ -2,22 +2,33 @@ package rules
 
 import (
 	"fmt"
-	"fw/cp"
+	//	"fw/cp"
 	"fw/cp/node"
+	"fw/cp/object"
 	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
 	"fw/rt2/scope"
-	"ypk/assert"
+	"reflect"
+	//"ypk/assert"
+	"ypk/halt"
 )
 
 func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-	n := rt2.NodeOf(f)
+	n := rt2.NodeOf(f).(node.DerefNode)
 	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.(cp.ID)
-	if ok {
+	fmt.Println("deref from ptr", n.Ptr())
+	if n.Ptr() {
+
+	} else {
+		switch l := n.Left().Object().(type) {
+		case object.ParameterObject:
+			rt2.ValueOf(f.Parent())[n.Adr()] = sc.Select(l.Adr())
+		default:
+			halt.As(100, l.Adr(), reflect.TypeOf(l))
+		}
+	}
+	/* if ok {
 		//		rt2.DataOf(f.Parent())[n] = scope.Designator(n.Left())
 	} else {
 		for z := n.Left(); !ok && z != nil; {
@@ -31,6 +42,6 @@ func derefSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				ok = true
 			}
 		}
-	}
+	} */
 	return frame.End()
 }

rt2/rules/op.go

@@ -13,7 +13,6 @@ import (
 	"math/big"
 	"reflect"
 	"strings"
-	"unicode/utf8"
 	"ypk/assert"
 )
 
@@ -217,40 +216,6 @@ func is(p object.Object, typ object.ComplexType) bool {
 	return a && b && compare(x, y)
 }
 
-func length(a object.Object, _a, _b interface{}) (ret int64) {
-	//assert.For(a != nil, 20)
-	assert.For(_b != nil, 21)
-	var b int32 = int32Of(_b)
-	assert.For(b == 0, 22)
-	if a != nil {
-		assert.For(a.Type() == object.COMPLEX, 23)
-		switch typ := a.Complex().(type) {
-		case object.ArrayType:
-			ret = typ.Len()
-		case object.DynArrayType:
-			switch _a.(type) {
-			case string:
-				ret = int64(utf8.RuneCountInString(_a.(string)))
-			default:
-				ret = 0
-				fmt.Sprintln("unsupported", reflect.TypeOf(_a))
-			}
-		default:
-			panic(fmt.Sprintln("unsupported", reflect.TypeOf(a.Complex())))
-		}
-	} else {
-		switch _a.(type) {
-		case string:
-			ret = int64(utf8.RuneCountInString(_a.(string)))
-		case []interface{}:
-			ret = int64(len(_a.([]interface{})))
-		default:
-			panic(fmt.Sprintln("unsupported", reflect.TypeOf(_a)))
-		}
-	}
-	return ret
-}
-
 func abs(_a interface{}) interface{} {
 	assert.For(_a != nil, 20)
 	var a int32 = int32Of(_a)
@@ -429,7 +394,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Leq(rt2.ValueOf(f)[n.Left().Adr()], rt2.ValueOf(f)[n.Right().Adr()])
 			return frame.End()
 		case operation.LEN:
-			rt2.DataOf(f.Parent())[n] = length(n.Left().Object(), rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
+			rt2.ValueOf(f.Parent())[n.Adr()] = scope.Ops.Len(n.Left().Object(), rt2.ValueOf(f)[n.Left().Adr()], rt2.ValueOf(f)[n.Right().Adr()])
 			return frame.End()
 		case operation.NOT_EQUAL:
 			rt2.DataOf(f.Parent())[n] = neq(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])

rt2/scope/data.go

@@ -14,6 +14,7 @@ type Operations interface {
 	Leq(Value, Value) Value
 
 	Conv(Value, object.Type) Value
+	Len(object.Object, Value, Value) Value
 }
 
 type Value interface {

rt2/scope/modern/ms.go

@@ -3,6 +3,7 @@ package modern
 import (
 	"fmt"
 	"fw/cp"
+	"fw/cp/constant/enter"
 	cpm "fw/cp/module"
 	"fw/cp/node"
 	"fw/cp/object"
@@ -45,32 +46,63 @@ func newRef(x object.Object) *ref {
 	return &ref{link: x}
 }
 
-func (a *area) allocate(mod *cpm.Module, ol []object.Object, r bool) {
+func (a *area) allocate(mod *cpm.Module, n node.EnterNode, r bool) {
+	ol := mod.Objects[n]
 	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)
+	skip := make(map[cp.ID]object.Object) //для процедурных типов в общей куче могут валяться переменные, скипаем их
+	tl := mod.Types[n]
+	for _, t := range tl {
+		switch x := t.(type) {
+		case object.BasicType:
+			for link := x.Link(); link != nil; link = link.Link() {
+				skip[link.Adr()] = link
+			}
+		}
+	}
 	for _, o := range ol {
-		fmt.Println(reflect.TypeOf(o))
 		imp := mod.ImportOf(o)
-		if imp == "" {
+		fmt.Println(reflect.TypeOf(o), o.Adr())
+		if imp == "" && skip[o.Adr()] == nil {
+			fmt.Println(l.next)
 			switch x := o.(type) {
 			case object.VariableObject:
-				switch o.Complex().(type) {
+				switch t := o.Complex().(type) {
 				case nil:
 					l.v[l.next] = NewData(x)
 					l.k[x.Adr()] = l.next
 					l.next++
+				case object.BasicType:
+					l.v[l.next] = NewData(x)
+					l.k[x.Adr()] = l.next
+					l.next++
+				case object.ArrayType:
+					l.v[l.next] = NewData(x)
+					l.k[x.Adr()] = l.next
+					l.next++
+				case object.DynArrayType:
+					l.v[l.next] = NewData(x)
+					l.k[x.Adr()] = l.next
+					l.next++
 				case object.PointerType:
 					fmt.Println("pointer")
+				default:
+					halt.As(20, reflect.TypeOf(t))
 				}
-			case object.ConstantObject, object.ProcedureObject:
+
+			case object.ConstantObject:
+				//do nothing
+			case object.ProcedureObject:
 				//do nothing
 			case object.ParameterObject:
-				l.r[l.next] = newRef(x)
-				l.k[x.Adr()] = l.next
-				l.next++
+				if n.Enter() == enter.PROCEDURE {
+					l.r[l.next] = newRef(x)
+					l.k[x.Adr()] = l.next
+					l.next++
+				}
 			default:
 				halt.As(20, reflect.TypeOf(x))
 			}
@@ -90,6 +122,10 @@ func (a *area) Provide(x interface{}) scope.ValueFor {
 		switch z := x.(type) {
 		case node.ConstantNode:
 			return NewConst(z)
+		case object.ProcedureObject:
+			return NewProc(z)
+		default:
+			halt.As(100, reflect.TypeOf(z))
 		}
 		panic(0)
 	}
@@ -98,7 +134,7 @@ func (a *area) Provide(x interface{}) scope.ValueFor {
 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)
+	a.area.allocate(mod, n.(node.EnterNode), final)
 }
 
 func (a *salloc) Dispose(n node.Node) {
@@ -143,6 +179,18 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			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()}
+			case node.ConstantNode: //array :) заменяем ссылку на переменную
+				old := l.r[l.k[o.Adr()]].(*ref)
+				l.r[l.k[o.Adr()]] = nil
+				data := NewConst(nv)
+				switch data.(type) {
+				case STRING, SHORTSTRING:
+					val := &dynarr{link: old.link}
+					val.Set(data)
+					l.v[l.k[o.Adr()]] = val
+				default:
+					halt.As(100, reflect.TypeOf(data))
+				}
 			default:
 				halt.As(40, reflect.TypeOf(nv))
 			}
@@ -235,10 +283,33 @@ 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)
+	a, ok := mgr.(*area)
+	assert.For(ok, 20)
+	assert.For(name != "", 21)
+	for i := len(a.data) - 1; i >= 0 && ret == nil; i-- {
+		l := a.data[i]
+		for _, v := range l.v {
+			switch vv := v.(type) {
+			case *data:
+				fmt.Println(vv.link.Name())
+				if vv.link.Name() == name {
+					ret = vv.link
+				}
+			default:
+				fmt.Println(reflect.TypeOf(vv))
+			}
+		}
+	}
+	return ret
+}
+
 func nn() scope.Manager {
 	return &area{}
 }
 
 func init() {
 	scope.New = nn
+	scope.FindObjByName = fn
 }

rt2/scope/modern/val.go

@@ -17,8 +17,99 @@ type data struct {
 	val  interface{}
 }
 
+type arr struct {
+	link   object.Object
+	val    []interface{}
+	length int64
+}
+
+type dynarr struct {
+	link object.Object
+	val  []interface{}
+}
+
+type proc struct {
+	link object.Object
+}
+
+func (p *proc) String() string {
+	return fmt.Sprint(p.link.Adr(), p.link.Name())
+}
+
 func (x *data) Id() cp.ID {
-	return 0
+	return x.link.Adr()
+}
+
+func (x *arr) Id() cp.ID {
+	return x.link.Adr()
+}
+
+func (x *dynarr) Id() cp.ID {
+	return x.link.Adr()
+}
+
+func (a *arr) Set(v scope.Value) {
+	switch x := v.(type) {
+	case STRING:
+		v := make([]interface{}, int(a.length))
+		for i := 0; i < int(a.length) && i < len(x); i++ {
+			v[i] = CHAR(x[i])
+		}
+		a.val = v
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+}
+
+func (a *dynarr) Set(v scope.Value) {
+	switch x := v.(type) {
+	case *arr:
+		a.val = x.val
+	case STRING:
+		v := make([]interface{}, len(x))
+		for i := 0; i < len(x); i++ {
+			v[i] = CHAR(x[i])
+		}
+		a.val = v
+	case SHORTSTRING:
+		v := make([]interface{}, len(x))
+		for i := 0; i < len(x); i++ {
+			v[i] = SHORTCHAR(x[i])
+		}
+		a.val = v
+	default:
+		halt.As(100, reflect.TypeOf(x))
+	}
+}
+
+func (a *arr) String() (ret string) {
+	ret = fmt.Sprint("array", "[", a.length, "]")
+	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {
+		switch x := a.val[i].(type) {
+		case CHAR:
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		case SHORTCHAR:
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		default:
+			halt.As(100, reflect.TypeOf(x))
+		}
+	}
+	return ret
+}
+
+func (a *dynarr) String() (ret string) {
+	ret = fmt.Sprint("dyn array")
+	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {
+		switch x := a.val[i].(type) {
+		case CHAR:
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		case SHORTCHAR:
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		default:
+			halt.As(100, reflect.TypeOf(x))
+		}
+	}
+	return ret
 }
 
 func (d *data) Set(v scope.Value) {
@@ -27,6 +118,12 @@ func (d *data) Set(v scope.Value) {
 	case *data:
 		assert.For(d.link.Type() == x.link.Type(), 20)
 		d.val = x.val
+	case *proc:
+		assert.For(d.link.Type() == object.COMPLEX, 20)
+		t, ok := d.link.Complex().(object.BasicType)
+		assert.For(ok, 21, reflect.TypeOf(d.link.Complex()))
+		assert.For(t.Type() == object.PROCEDURE, 22)
+		d.val = x
 	case INTEGER:
 		switch d.link.Type() {
 		case object.INTEGER:
@@ -84,17 +181,21 @@ type CHAR rune
 type REAL float64
 type SHORTREAL float32
 type SHORTCHAR rune
+type STRING string
+type SHORTSTRING string
 
-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 (x SHORTSTRING) String() string { return string(x) }
+func (x STRING) String() string      { return string(x) }
+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() {
@@ -118,6 +219,23 @@ func NewData(o object.Object) (ret scope.Variable) {
 		ret = &data{link: o, val: SHORTREAL(0)}
 	case object.SHORTCHAR:
 		ret = &data{link: o, val: SHORTCHAR(0)}
+	case object.COMPLEX:
+		switch t := o.Complex().(type) {
+		case object.BasicType:
+			switch t.Type() {
+			case object.PROCEDURE:
+				ret = &data{link: o, val: nil}
+			default:
+				halt.As(100, t.Type())
+			}
+		case object.ArrayType:
+			ret = &arr{link: o, length: t.Len()}
+		case object.DynArrayType:
+			ret = &dynarr{link: o}
+		default:
+			halt.As(100, reflect.TypeOf(t))
+
+		}
 	default:
 		panic(fmt.Sprintln("unsupported type", o.Type()))
 	}
@@ -136,6 +254,12 @@ func fromg(x interface{}) scope.Value {
 	panic(100)
 }
 
+func NewProc(o object.Object) scope.Value {
+	p, ok := o.(object.ProcedureObject)
+	assert.For(ok, 20, reflect.TypeOf(o))
+	return &proc{link: p}
+}
+
 func NewConst(n node.Node) scope.Value {
 	switch x := n.(type) {
 	case node.ConstantNode:
@@ -160,6 +284,10 @@ func NewConst(n node.Node) scope.Value {
 			return SET{bits: x.Data().(*big.Int)}
 		case object.CHAR:
 			return CHAR(x.Data().(rune))
+		case object.STRING:
+			return STRING(x.Data().(string))
+		case object.SHORTSTRING:
+			return SHORTSTRING(x.Data().(string))
 		default:
 			panic(fmt.Sprintln(x.Type()))
 		}
@@ -189,7 +317,13 @@ func vfrom(v scope.Value) scope.Value {
 func gfrom(v scope.Value) interface{} {
 	switch n := v.(type) {
 	case *data:
-		return gfrom(n.val.(scope.Value))
+		if n.val == nil {
+			return nil
+		} else {
+			return gfrom(n.val.(scope.Value))
+		}
+	case *proc:
+		return n.link
 	case INTEGER:
 		return int32(n)
 	case BOOLEAN:
@@ -252,6 +386,45 @@ func (o *ops) Sub(a, b scope.Value) scope.Value {
 	panic(0)
 
 }
+
+func (o *ops) Len(a object.Object, _a, _b scope.Value) (ret scope.Value) {
+	//assert.For(a != nil, 20)
+	assert.For(_b != nil, 21)
+	var b int32 = gfrom(_b).(int32)
+	assert.For(b == 0, 22)
+	if a != nil {
+		assert.For(a.Type() == object.COMPLEX, 23)
+		switch typ := a.Complex().(type) {
+		case object.ArrayType:
+			ret = INTEGER(int32(typ.Len()))
+		case object.DynArrayType:
+			switch t := _a.(type) {
+			//case string:
+			//	ret = int64(utf8.RuneCountInString(_a.(string)))
+			default:
+				ret = INTEGER(0)
+				fmt.Sprintln("unsupported", reflect.TypeOf(t))
+			}
+		default:
+			panic(fmt.Sprintln("unsupported", reflect.TypeOf(a.Complex())))
+		}
+	} else {
+		switch a := _a.(type) {
+		//		case string:
+		//			ret = int64(utf8.RuneCountInString(_a.(string)))
+		//		case []interface{}:
+		//			ret = int64(len(_a.([]interface{})))
+		case *arr:
+			ret = INTEGER(int32(a.length))
+		case *dynarr:
+			ret = INTEGER(int32(len(a.val)))
+		default:
+			panic(fmt.Sprintln("unsupported", reflect.TypeOf(a)))
+		}
+	}
+	return ret
+}
+
 func (o *ops) Conv(a scope.Value, typ object.Type) scope.Value {
 	switch typ {
 	case object.INTEGER:

xev/converter.go

@@ -198,6 +198,7 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				if link != nil {
 					t.SetLink(r.doObject(link))
 					assert.For(t.Link() != nil, 40)
+					t.Link().SetRef(t)
 				}
 				ret = t
 			case "CHAR", "SHORTCHAR", "INTEGER", "LONGINT", "BYTE",
@@ -243,6 +244,7 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 			if link != nil {
 				ret.SetLink(r.doObject(link))
 				assert.For(ret.Link() != nil, 40)
+				ret.Link().SetRef(ret)
 			}
 			base := r.findLink(n, "base")
 			if base != nil {
@@ -305,6 +307,7 @@ func (r *Result) doObject(n *Node) (ret object.Object) {
 		link := r.findLink(n, "link")
 		if link != nil {
 			ret.SetLink(r.doObject(link))
+			ret.Link().SetRef(ret)
 			if ret.Link() == nil {
 				panic("error in object")
 			}