поддержка охраны типа, исправлены ошибки

cp/constant/nodeclass.go

@@ -24,4 +24,5 @@ const (
 	INDEX
 	TRAP
 	WITH
+	GUARD
 )

cp/node/class.go

@@ -61,6 +61,8 @@ func New(class constant.Class) Node {
 		return new(trapNode)
 	case constant.WITH:
 		return new(withNode)
+	case constant.GUARD:
+		return new(guardNode)
 	default:
 		panic("no such class")
 	}
@@ -247,3 +249,12 @@ type withNode struct {
 }
 
 func (v *withNode) self() WithNode { return v }
+
+type guardNode struct {
+	nodeFields
+	typ object.ComplexType
+}
+
+func (v *guardNode) self() GuardNode              { return v }
+func (v *guardNode) SetType(t object.ComplexType) { v.typ = t }
+func (v *guardNode) Type() object.ComplexType     { return v.typ }

cp/node/node.go

@@ -138,3 +138,10 @@ type WithNode interface {
 	self() WithNode
 	Node
 }
+
+type GuardNode interface {
+	self() GuardNode
+	Node
+	Type() object.ComplexType
+	SetType(object.ComplexType)
+}

fw.go

@@ -26,7 +26,7 @@ func close() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevDemo12"
+		name = "XevDemo11"
 	}
 	global := new(stdDomain)
 	modList := module.New()

fw_test.bat

@@ -25,6 +25,8 @@ fw -i=XevDemo11
 IF ERRORLEVEL 1 GOTO err
 fw -i=XevDemo12
 IF ERRORLEVEL 1 GOTO err
+fw -i=XevDemo13
+IF ERRORLEVEL 1 GOTO err
 
 GOTO ok
 :err

rt2/rules/assign.go

@@ -97,13 +97,25 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 	switch a.(node.AssignNode).Statement() {
 	case statement.ASSIGN:
-		switch a.Left().(type) {
+		switch l := a.Left().(type) {
 		case node.VariableNode, node.ParameterNode:
 			leftId = scope.Designator(a.Left())
 			seq, ret = right(f)
 		case node.FieldNode:
-			leftId = scope.Designator(a.Left())
-			seq, ret = right(f)
+			switch l.Left().(type) {
+			case node.GuardNode:
+				rt2.Utils.Push(rt2.Utils.New(l.Left()), f)
+				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+					x := rt2.Utils.DataOf(f)[l.Left()].(node.Node)
+					leftId = scope.Designator(a.Left(), x)
+					fmt.Println(leftId)
+					return right(f)
+				}
+				ret = frame.LATER
+			default:
+				leftId = scope.Designator(a.Left())
+				seq, ret = right(f)
+			}
 		case node.IndexNode:
 			leftId = scope.Designator(a.Left())
 			rt2.Utils.Push(rt2.Utils.New(a.Left()), f)

rt2/rules/guard.go

@@ -0,0 +1,38 @@
+package rules
+
+import (
+	"fmt"
+	"fw/cp/constant"
+	"fw/cp/node"
+	"fw/cp/object"
+	"fw/rt2"
+	"fw/rt2/context"
+	"fw/rt2/frame"
+	"fw/rt2/scope"
+	"reflect"
+)
+
+func guardSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+	sc := scope.This(f.Domain().Discover(context.SCOPE))
+	n := rt2.Utils.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)
+	default:
+		panic(fmt.Sprintln("unsupported left", reflect.TypeOf(l)))
+	}
+	if is(obj, n.Type()) {
+		rt2.Utils.DataOf(f.Parent())[n] = n.Left()
+		return frame.End()
+	} else {
+		trap := node.New(constant.TRAP).(node.TrapNode)
+		code := node.New(constant.CONSTANT).(node.ConstantNode)
+		code.SetData(0)
+		trap.SetLeft(code)
+		rt2.Utils.Push(rt2.Utils.New(trap), f)
+		return frame.Tail(frame.STOP), frame.LATER
+	}
+}

rt2/rules/op.go

@@ -95,7 +95,7 @@ func not(_a interface{}) bool {
 	return !a
 }
 
-func is(p, typ object.Object) bool {
+func is(p object.Object, typ object.ComplexType) bool {
 	var compare func(x, a object.RecordType) bool
 	compare = func(x, a object.RecordType) bool {
 		switch {
@@ -110,8 +110,8 @@ func is(p, typ object.Object) bool {
 		}
 	}
 	x, a := p.Complex().(object.RecordType)
-	y, b := typ.Complex().(object.RecordType)
-	//fmt.Println("compare", p.Complex(), typ.Complex(), a, b, compare(x, y))
+	y, b := typ.(object.RecordType)
+	fmt.Println("compare", p.Complex(), typ, a, b, a && b && compare(x, y))
 	return a && b && compare(x, y)
 }
 

rt2/rules/table.go

@@ -63,6 +63,8 @@ func prologue(n node.Node) frame.Sequence {
 		}
 	case node.WithNode:
 		return withSeq
+	case node.GuardNode:
+		return guardSeq
 	default:
 		panic(fmt.Sprintln("unknown node", reflect.TypeOf(n)))
 	}
@@ -88,7 +90,8 @@ func epilogue(n node.Node) frame.Sequence {
 			sm.Dispose(n)
 			return frame.End()
 		}
-	case node.OperationNode, node.ReturnNode, node.IfNode, node.LoopNode, node.DerefNode, node.IndexNode, node.TrapNode:
+	case node.OperationNode, node.ReturnNode, node.IfNode, node.LoopNode,
+		node.DerefNode, node.IndexNode, node.TrapNode, node.GuardNode:
 		return nil
 	default:
 		fmt.Println(reflect.TypeOf(n))

rt2/scope/area.go

@@ -43,7 +43,7 @@ type Manager interface {
 //средство обновления значения
 type ValueFor func(in interface{}) (out interface{})
 
-var Designator func(n node.Node) ID
+var Designator func(n ...node.Node) ID
 var FindObjByName func(m Manager, name string) object.Object
 
 func This(i interface{}) Manager {

rt2/scope/std/scope.go

@@ -130,12 +130,18 @@ func init() {
 	scope.FindObjByName = FindObjByName
 }
 
-func design(n node.Node) (id scope.ID) {
-	switch x := n.(type) {
+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:
-		id = scope.ID{Name: x.Left().Object().Name(), Path: [scope.DEPTH]string{x.Object().Name()}}
+		if len(n) == 1 {
+			id = scope.ID{Name: x.Left().Object().Name(), Path: [scope.DEPTH]string{x.Object().Name()}}
+		} else if n[1] != nil {
+			id = scope.ID{Name: n[1].Object().Name(), Path: [scope.DEPTH]string{x.Object().Name()}}
+		} else {
+			panic("wrong params")
+		}
 	case node.IndexNode:
 		id = scope.ID{Name: x.Left().Object().Name()}
 	default:

xev/converter.go

@@ -401,6 +401,15 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 			ret = node.New(constant.TRAP)
 		case "with":
 			ret = node.New(constant.WITH)
+		case "guard":
+			ret = node.New(constant.GUARD)
+			typ := r.findLink(n, "type")
+			if typ != nil {
+				ret.(node.GuardNode).SetType(r.doType(typ))
+				if ret.(node.GuardNode).Type() == nil {
+					panic("error in node")
+				}
+			}
 		default:
 			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")
@@ -438,6 +447,7 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 		} else {
 			assert.For(proc == nil, 60) //у процедуры просто не может не быть объекта
 		}
+
 	}
 	return ret
 }