добавлен модуль Math, для него потребовался аналог FPU - инжектированная процедура go_math

rt2/rules/call.go

@@ -54,7 +54,7 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 	rt2.Push(rt2.New(cn), f)
 }
 
-func process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
+func go_process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
 	assert.For(par != nil, 20)
 	sm := f.Domain().Discover(context.SCOPE).(scope.Manager)
 	do := func(val string) {
@@ -114,9 +114,20 @@ func process(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
 	panic(0)
 }
 
+func go_math(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT) {
+	assert.For(par != nil, 20)
+	switch p := par.(type) {
+
+	default:
+		halt.As(100, reflect.TypeOf(p))
+	}
+	panic(126)
+}
+
 func init() {
 	sys = make(map[string]func(f frame.Frame, par node.Node) (frame.Sequence, frame.WAIT))
-	sys["go_process"] = process
+	sys["go_process"] = go_process
+	sys["go_math"] = go_math
 }
 
 func syscall(f frame.Frame) (frame.Sequence, frame.WAIT) {
@@ -235,7 +246,7 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		} else {
 			name := n.Left().Object().Name()
 			switch {
-			case name == "go_process":
+			case sys[name] != nil:
 				return syscall(f)
 			default:
 				panic(fmt.Sprintln("unknown sysproc variable", name))

rt2/rules/op.go

@@ -79,7 +79,7 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			assert.For(x != nil, 40)
 			conv(scope.ValueFrom(x))
 			return frame.End()
-		case node.OperationNode, node.DerefNode:
+		case node.OperationNode, node.DerefNode, node.CallNode:
 			return This(expectExpr(f, n.Left(), func(...IN) OUT {
 				conv(rt2.ValueOf(f)[n.Left().Adr()])
 				return End()

rt2/scope/modern/val.go

@@ -229,6 +229,8 @@ func (i *idx) Set(v scope.Value) {
 	case STRING:
 		_ = t.(object.ArrayType)
 		i.arr.val[i.idx].(*arr).Set(x)
+	case REAL:
+		i.arr.val[i.idx] = x
 	default:
 		halt.As(100, reflect.TypeOf(x), x, t)
 	}
@@ -1032,6 +1034,13 @@ func (o *ops) Mult(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case REAL:
+				switch y := b.(type) {
+				case REAL:
+					return REAL(x * y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			case SET:
 				switch y := b.(type) {
 				case SET:
@@ -1504,6 +1513,13 @@ func (o *ops) Gtr(a, b scope.Value) scope.Value {
 				default:
 					panic(fmt.Sprintln(reflect.TypeOf(y)))
 				}
+			case REAL:
+				switch y := b.(type) {
+				case REAL:
+					return BOOLEAN(x > y)
+				default:
+					panic(fmt.Sprintln(reflect.TypeOf(y)))
+				}
 			default:
 				panic(fmt.Sprintln(reflect.TypeOf(x)))
 			}

xev/converter.go

@@ -234,8 +234,10 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				ret = object.NewDynArrayType(object.BYTE, n.Id)
 			case "SHORTCHAR":
 				ret = object.NewDynArrayType(object.SHORTCHAR, n.Id)
+			case "REAL":
+				ret = object.NewDynArrayType(object.REAL, n.Id)
 			default:
-				panic(fmt.Sprintln("unknown dyn type", n.Data.Typ.Typ))
+				panic(fmt.Sprintln("unknown dyn type", n.Data.Typ.Base, n.Data.Typ.Typ))
 			}
 		case "ARRAY":
 			switch n.Data.Typ.Base {
@@ -243,6 +245,8 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				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)
+			case "REAL":
+				ret = object.NewArrayType(object.REAL, int64(n.Data.Typ.Par), n.Id)
 			case "COMPLEX":
 				ret = object.NewArrayType(object.COMPLEX, int64(n.Data.Typ.Par), n.Id)
 				base := r.findLink(n, "base")