заработала первая реальная процедура IntToString

cp/node/class.go

@@ -1,6 +1,7 @@
 package node
 
 import (
+	"fmt"
 	"fw/cp"
 	"fw/cp/constant"
 	"fw/cp/constant/enter"
@@ -157,6 +158,10 @@ func (d *dyadicNode) Operation() operation.Operation { return d.operation }
 
 func (d *dyadicNode) self() DyadicNode { return d }
 
+func (d *dyadicNode) String() string {
+	return fmt.Sprintln("dyadic ", d.Adr(), d.operation)
+}
+
 type assignNode struct {
 	nodeFields
 	stat statement.Statement
@@ -228,6 +233,10 @@ func (v *monadicNode) Complex(x ...object.ComplexType) object.ComplexType {
 	return v.comp
 }
 
+func (v *monadicNode) String() string {
+	return fmt.Sprintln("monadic ", v.Adr(), v.operation)
+}
+
 type conditionalNode struct {
 	nodeFields
 }

rt2/scope/modern/ms.go

@@ -41,10 +41,15 @@ type ref struct {
 	scope.Ref
 	id   cp.ID
 	link object.Object
+	sc   scope.Manager
 }
 
 func (r *ref) String() string {
-	return fmt.Sprint(r.link.Name(), "@", r.id)
+	var m string
+	if r.sc != nil {
+		m = rtm.DomainModule(r.sc.Domain()).Name
+	}
+	return fmt.Sprint(m, " ", r.link.Name(), "@", r.id)
 }
 
 func newRef(x object.Object) *ref {
@@ -136,9 +141,8 @@ func (l *level) alloc(mod *cpm.Module, root node.Node, ol []object.Object, skip
 }
 
 func (a *salloc) Allocate(n node.Node, final bool) {
-	fmt.Println("ALLOCATE")
 	mod := rtm.DomainModule(a.area.d)
-
+	fmt.Println("ALLOCATE FOR", mod.Name, n.Adr())
 	tl := mod.Types[n]
 	skip := make(map[cp.ID]interface{}) //для процедурных типов в общей куче могут валяться переменные, скипаем их
 	for _, t := range tl {
@@ -185,6 +189,10 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 	seq = end
 	ret = frame.NOW
 	for next := par.Objects; next != nil; next = next.Link() {
+		mod := rtm.ModuleOfNode(f.Domain(), val)
+		global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
+		global = global.Discover(mod.Name).(context.Domain)
+		ar := global.Discover(context.SCOPE).(scope.Manager)
 		switch o := next.(type) {
 		case object.VariableObject:
 			switch nv := val.(type) {
@@ -192,7 +200,7 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 				v := newConst(nv)
 				l.v[l.k[o.Adr()]].Set(v)
 			case node.VariableNode:
-				v := a.area.Select(nv.Object().Adr())
+				v := ar.Select(nv.Object().Adr())
 				l.v[l.k[o.Adr()]].Set(v)
 			default:
 				halt.As(40, reflect.TypeOf(nv))
@@ -201,7 +209,7 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			switch nv := val.(type) {
 			case node.VariableNode:
 				old := l.r[l.k[o.Adr()]].(*ref)
-				l.r[l.k[o.Adr()]] = &ref{link: old.link, id: nv.Object().Adr()}
+				l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: ar, id: nv.Object().Adr()}
 			case node.ConstantNode: //array :) заменяем ссылку на переменную
 				old := l.r[l.k[o.Adr()]].(*ref)
 				l.r[l.k[o.Adr()]] = nil
@@ -257,10 +265,10 @@ func (a *salloc) Join(m scope.Manager) { a.area = m.(*area) }
 
 func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 	assert.For(id != 0, 20)
-	fmt.Println("UPDATE", id)
 	var upd func(x int, id cp.ID)
 	var k int
 	upd = func(x int, id cp.ID) {
+		fmt.Println("UPDATE", id)
 		for i := x - 1; i >= 0 && k == 0; i-- {
 			l := a.data[i]
 			if l.ready {
@@ -270,7 +278,13 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 					if v == nil { //ref?
 						r := l.r[k]
 						if r != nil {
-							upd(i, r.(*ref).id)
+							fmt.Println("ref")
+							if r.(*ref).sc == a {
+								upd(i, r.(*ref).id)
+							} else {
+								k = -1
+								r.(*ref).sc.Update(r.(*ref).id, fval)
+							}
 							break
 						}
 					} else {
@@ -286,9 +300,9 @@ func (a *area) Update(id cp.ID, fval scope.ValueFor) {
 }
 
 func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
-	fmt.Println("SELECT", id)
 	var sel func(x int, id cp.ID)
 	sel = func(x int, id cp.ID) {
+		fmt.Println("SELECT", id)
 		for i := x - 1; i >= 0 && ret == nil; i-- {
 			l := a.data[i]
 			k := 0
@@ -302,7 +316,12 @@ func (a *area) Select(id cp.ID, val ...scope.ValueOf) (ret scope.Value) {
 							if l.l[k] != nil { //rec
 								panic(0)
 							} else {
-								sel(i, r.(*ref).id)
+								fmt.Println("ref")
+								if r.(*ref).sc == a {
+									sel(i, r.(*ref).id)
+								} else {
+									ret = r.(*ref).sc.Select(r.(*ref).id)
+								}
 							}
 							break
 						}

rt2/scope/modern/val.go

@@ -91,13 +91,19 @@ func (x *dynarr) Id() cp.ID { return x.link.Adr() }
 func (a *arr) Set(v scope.Value) {
 	switch x := v.(type) {
 	case *arr:
-		a.Set(STRING(x.String()))
+		a.Set(STRING(x.tryString()))
 	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
+	case SHORTSTRING:
+		v := make([]interface{}, int(a.length))
+		for i := 0; i < int(a.length) && i < len(x); i++ {
+			v[i] = SHORTCHAR(x[i])
+		}
+		a.val = v
 	default:
 		halt.As(100, reflect.TypeOf(x))
 	}
@@ -128,6 +134,26 @@ func (a *dynarr) Set(v scope.Value) {
 	}
 }
 
+func (a *arr) tryString() (ret string) {
+	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {
+		switch x := a.val[i].(type) {
+		case CHAR:
+			if int(x) == 0 {
+				break
+			}
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		case SHORTCHAR:
+			if int(x) == 0 {
+				break
+			}
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		default:
+			halt.As(100, reflect.TypeOf(x))
+		}
+	}
+	return ret
+}
+
 func (a *arr) String() (ret string) {
 	ret = fmt.Sprint("array", "[", a.length, "]")
 	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {
@@ -172,6 +198,8 @@ func (i *idx) Set(v scope.Value) {
 	switch x := v.(type) {
 	case *idx:
 		i.arr.val[i.idx] = x.arr.val[x.idx]
+	case *data:
+		i.Set(x.val.(scope.Value))
 	case CHAR:
 		i.arr.val[i.idx] = x
 	default:
@@ -179,6 +207,26 @@ func (i *idx) Set(v scope.Value) {
 	}
 }
 
+func (a *dynarr) tryString() (ret string) {
+	for i := 0; i < len(a.val) && a.val[i] != nil; i++ {
+		switch x := a.val[i].(type) {
+		case CHAR:
+			if int(x) == 0 {
+				break
+			}
+			ret = fmt.Sprint(ret, string([]rune{rune(x)}))
+		case SHORTCHAR:
+			if int(x) == 0 {
+				break
+			}
+			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++ {
@@ -209,6 +257,8 @@ func (d *data) Set(v scope.Value) {
 		assert.For(ok, 21, reflect.TypeOf(d.link.Complex()))
 		assert.For(t.Type() == object.PROCEDURE, 22)
 		d.val = x
+	case *idx:
+		d.val = x.arr.val[x.idx]
 	case INTEGER:
 		switch d.link.Type() {
 		case object.INTEGER:
@@ -446,6 +496,8 @@ func vfrom(v scope.Value) scope.Value {
 			return n.val.(BOOLEAN)
 		case object.REAL:
 			return n.val.(REAL)
+		case object.LONGINT:
+			return n.val.(LONGINT)
 		default:
 			halt.As(100, n.link.Type())
 		}
@@ -471,7 +523,7 @@ func gfrom(v scope.Value) interface{} {
 		switch n.link.Complex().(object.DynArrayType).Base() {
 		case object.SHORTCHAR:
 			if n.val != nil {
-				return n.String()
+				return n.tryString()
 			} else {
 				return ""
 			}
@@ -479,6 +531,18 @@ func gfrom(v scope.Value) interface{} {
 			halt.As(100, n.link.Complex().(object.DynArrayType).Base())
 		}
 		panic(0)
+	case *arr:
+		switch n.link.Complex().(object.ArrayType).Base() {
+		case object.SHORTCHAR:
+			if n.val != nil {
+				return n.tryString()
+			} else {
+				return ""
+			}
+		default:
+			halt.As(100, n.link.Complex().(object.ArrayType).Base())
+		}
+		panic(0)
 	case INTEGER:
 		return int32(n)
 	case BOOLEAN:
@@ -522,14 +586,14 @@ func (o *ops) Sum(a, b scope.Value) scope.Value {
 				case *arr:
 					switch {
 					case x.link.Type() == y.link.Type() && x.link.Complex().(object.ArrayType).Base() == object.CHAR:
-						return STRING(x.String() + y.String())
+						return STRING(x.tryString() + y.tryString())
 					default:
 						halt.As(100, x.link.Type(), y.link.Type())
 					}
 				case STRING:
 					switch {
 					case x.link.Complex().(object.ArrayType).Base() == object.CHAR:
-						return STRING(x.String() + string(y))
+						return STRING(x.tryString() + string(y))
 					default:
 						halt.As(100, x.link.Type())
 					}
@@ -541,7 +605,7 @@ func (o *ops) Sum(a, b scope.Value) scope.Value {
 				case STRING:
 					switch {
 					case x.link.Complex().(object.DynArrayType).Base() == object.CHAR:
-						return STRING(x.String() + string(y))
+						return STRING(x.tryString() + string(y))
 					default:
 						halt.As(100, x.link.Type())
 					}
@@ -562,6 +626,13 @@ func (o *ops) Sum(a, b scope.Value) scope.Value {
 				default:
 					halt.As(100, reflect.TypeOf(y))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					return LONGINT(x + y)
+				default:
+					halt.As(100, reflect.TypeOf(y))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -772,6 +843,13 @@ func (o *ops) Div(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					return LONGINT(x / y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -797,6 +875,13 @@ func (o *ops) Mod(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					return LONGINT(x % y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -874,11 +959,10 @@ func (o *ops) Len(a object.Object, _a, _b scope.Value) (ret scope.Value) {
 			ret = INTEGER(int32(typ.Len()))
 		case object.DynArrayType:
 			switch t := _a.(type) {
-			//case string:
-			//	ret = int64(utf8.RuneCountInString(_a.(string)))
+			case *arr:
+				ret = INTEGER(t.length)
 			default:
-				ret = INTEGER(0)
-				fmt.Sprintln("unsupported", reflect.TypeOf(t))
+				halt.As(100, "unsupported", reflect.TypeOf(t))
 			}
 		default:
 			panic(fmt.Sprintln("unsupported", reflect.TypeOf(a.Complex())))
@@ -991,6 +1075,15 @@ func (o *ops) Conv(a scope.Value, typ object.Type, comp ...object.ComplexType) s
 		default:
 			halt.As(100, reflect.TypeOf(x))
 		}
+	case object.CHAR:
+		switch x := a.(type) {
+		case *data:
+			return o.Conv(vfrom(x), typ)
+		case LONGINT:
+			return CHAR(rune(x))
+		default:
+			halt.As(100, reflect.TypeOf(x))
+		}
 	case object.NOTYPE:
 		assert.For(len(comp) > 0, 20)
 		switch t := comp[0].(type) {
@@ -999,7 +1092,9 @@ func (o *ops) Conv(a scope.Value, typ object.Type, comp ...object.ComplexType) s
 			case object.SHORTSTRING:
 				switch x := a.(type) {
 				case *dynarr:
-					return SHORTSTRING(x.String())
+					return SHORTSTRING(x.tryString())
+				case *arr:
+					return SHORTSTRING(x.tryString())
 				default:
 					halt.As(100, reflect.TypeOf(x))
 				}
@@ -1091,6 +1186,13 @@ func (o *ops) Eq(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					return BOOLEAN(x == y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -1116,6 +1218,13 @@ func (o *ops) Neq(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					return BOOLEAN(x != y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}
@@ -1141,6 +1250,14 @@ func (o *ops) Lss(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case LONGINT:
+				switch y := b.(type) {
+				case LONGINT:
+					fmt.Println("LESSER", x, y, BOOLEAN(x < y))
+					return BOOLEAN(x < y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}

xev/converter.go

@@ -238,8 +238,10 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 			switch n.Data.Typ.Base {
 			case "CHAR":
 				ret = object.NewArrayType(object.CHAR, int64(n.Data.Typ.Par), n.Id)
+			case "SHORTCHAR":
+				ret = object.NewArrayType(object.SHORTCHAR, int64(n.Data.Typ.Par), n.Id)
 			default:
-				panic(fmt.Sprintln("unknown array type", n.Data.Typ.Typ))
+				panic(fmt.Sprintln("unknown array type", n.Data.Typ.Base))
 			}
 		case "RECORD":
 			switch n.Data.Typ.Base {