добавлен WHILE

cp/constant/nodeclass.go

@@ -15,4 +15,5 @@ const (
 	MONADIC
 	CONDITIONAL
 	IF
+	WHILE
 )

cp/constant/operation/operation.go

@@ -6,4 +6,5 @@ const (
 	PLUS Operation = iota
 	CONVERT
 	EQUAL
+	LESSER
 )

cp/node/class.go

@@ -80,6 +80,9 @@ type IfNode interface {
 	self() IfNode
 }
 
+type WhileNode interface {
+	self() WhileNode
+}
 type enterNode struct {
 	nodeFields
 	enter enter.Enter
@@ -180,3 +183,9 @@ type ifNode struct {
 }
 
 func (v *ifNode) self() IfNode { return v }
+
+type whileNode struct {
+	nodeFields
+}
+
+func (v *whileNode) self() WhileNode { return v }

cp/node/node.go

@@ -43,6 +43,8 @@ func New(class constant.Class) Node {
 		return new(conditionalNode)
 	case constant.IF:
 		return new(ifNode)
+	case constant.WHILE:
+		return new(whileNode)
 	default:
 		panic("no such class")
 	}

fw.go

@@ -15,12 +15,12 @@ func main() {
 	global := new(stdDomain)
 	modList := module.New()
 	global.ConnectTo(context.MOD, modList)
-	ret, err := modList.Load("XevDemo4")
+	ret, err := modList.Load("XevDemo5")
 	assert.For(ret != nil, 40)
 	assert.For(err == nil, 41)
 	{
 		domain := new(stdDomain)
-		global.ConnectTo("XevDemo4", domain)
+		global.ConnectTo("XevDemo5", domain)
 		root := frame.NewRoot()
 		domain.ConnectTo(context.STACK, root)
 		domain.ConnectTo(context.SCOPE, scope.New())

rt2/rules/if.go

@@ -34,9 +34,11 @@ func ifSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		last := fu.DataOf(f)[0].(node.Node)
 		done := fu.DataOf(f)[last].(bool)
 		fu.DataOf(f)[last] = nil
-		if done {
+		if done && last.Right() != nil {
 			fu.Push(fu.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/rules/op.go

@@ -42,6 +42,15 @@ func eq(_a interface{}, _b interface{}) bool {
 	var b int32 = int32Of(_b)
 	return a == b
 }
+
+func lss(_a interface{}, _b interface{}) bool {
+	assert.For(_a != nil, 20)
+	assert.For(_b != nil, 21)
+	var a int32 = int32Of(_a)
+	var b int32 = int32Of(_b)
+	return a < b
+}
+
 func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	var fu nodeframe.FrameUtils
 	n := fu.NodeOf(f).(node.MonadicNode)
@@ -86,6 +95,9 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case operation.EQUAL:
 			fu.DataOf(f.Parent())[n] = eq(fu.DataOf(f)[n.Left()], fu.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()])
+			return frame.End()
 		default:
 			panic("unknown operation")
 		}

rt2/rules/table.go

@@ -36,6 +36,8 @@ func prologue(n node.Node) frame.Sequence {
 		return ifSeq
 	case node.IfNode:
 		return ifExpr
+	case node.WhileNode:
+		return whileSeq
 	default:
 		panic(fmt.Sprintln("unknown node", reflect.TypeOf(n)))
 	}
@@ -44,7 +46,7 @@ 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.CallNode, node.ConditionalNode:
+	case node.AssignNode, node.CallNode, node.ConditionalNode, node.WhileNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			next := n.Link()
 			if next != nil {

rt2/rules/while.go

@@ -0,0 +1,46 @@
+package rules
+
+import (
+	"fmt"
+	"fw/cp/node"
+	"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)
+
+	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
+		if done && n.Right() != nil {
+			fu.Push(fu.New(n.Right()), f)
+			return cond, frame.LATER
+		} else if !done {
+			return frame.End()
+		} else if n.Right() == nil {
+			return frame.End()
+		} else {
+			panic("unexpected while seq")
+		}
+	}
+
+	cond = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+		switch n.Left().(type) {
+		case node.OperationNode:
+			fu.Push(fu.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()]
+				return next, frame.LATER
+			}
+			ret = frame.LATER
+			return seq, ret
+		default:
+			panic(fmt.Sprintf("unknown condition expression", reflect.TypeOf(n.Left())))
+		}
+	}
+	return cond, frame.NOW
+}

xev/converter.go

@@ -225,6 +225,8 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				ret.(node.OperationNode).SetOperation(operation.PLUS)
 			case "equal":
 				ret.(node.OperationNode).SetOperation(operation.EQUAL)
+			case "lesser":
+				ret.(node.OperationNode).SetOperation(operation.LESSER)
 			default:
 				panic("no such operation")
 			}
@@ -261,6 +263,8 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 			ret = node.New(constant.CONDITIONAL)
 		case "if":
 			ret = node.New(constant.IF)
+		case "while":
+			ret = node.New(constant.WHILE)
 		default:
 			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")