обработка типа RECORD, demo7

cp/constant/nodeclass.go

@@ -20,4 +20,5 @@ const (
 	EXIT
 	LOOP
 	DEREF
+	FIELD
 )

cp/node/class.go

@@ -8,6 +8,12 @@ import (
 	"fw/cp/statement"
 )
 
+const INIT constant.Class = -1
+
+type InitNode interface {
+	Node
+}
+
 func New(class constant.Class) Node {
 	switch class {
 	case constant.ENTER:
@@ -44,6 +50,10 @@ func New(class constant.Class) Node {
 		return new(loopNode)
 	case constant.DEREF:
 		return new(derefNode)
+	case constant.FIELD:
+		return new(fieldNode)
+	case INIT:
+		return new(initNode)
 	default:
 		panic("no such class")
 	}
@@ -200,3 +210,15 @@ type derefNode struct {
 }
 
 func (v *derefNode) self() DerefNode { return v }
+
+type fieldNode struct {
+	nodeFields
+}
+
+func (v *fieldNode) self() FieldNode { return v }
+
+type initNode struct {
+	nodeFields
+}
+
+func (v *initNode) self() InitNode { return v }

cp/node/node.go

@@ -118,3 +118,8 @@ type DerefNode interface {
 	self() DerefNode
 	Node
 }
+
+type FieldNode interface {
+	self() FieldNode
+	Node
+}

cp/object/object.go

@@ -9,6 +9,7 @@ const (
 	EXTERNAL_PROC
 	CONSTANT
 	PARAMETER
+	FIELD
 )
 
 type Object interface {
@@ -38,6 +39,11 @@ type ParameterObject interface {
 	self() ParameterObject
 }
 
+type FieldObject interface {
+	Object
+	self() FieldObject
+}
+
 func New(mode Mode) Object {
 	switch mode {
 	case HEAD:
@@ -52,6 +58,8 @@ func New(mode Mode) Object {
 		return new(parameterObject)
 	case EXTERNAL_PROC:
 		return new(externalProcedureObject)
+	case FIELD:
+		return new(fieldObject)
 	default:
 		panic("no such object mode")
 	}
@@ -107,3 +115,9 @@ type parameterObject struct {
 }
 
 func (v *parameterObject) self() ParameterObject { return v }
+
+type fieldObject struct {
+	objectFields
+}
+
+func (v *fieldObject) self() FieldObject { return v }

cp/object/type.go

@@ -123,3 +123,11 @@ type arr struct {
 
 func (a *arr) Base() Type { return a.base }
 func (a *arr) Len() int64 { return a.length }
+
+type rec struct {
+	comp
+}
+
+func NewRecordType() RecordType {
+	return &rec{}
+}

fw.go

@@ -22,7 +22,7 @@ func init() {
 func main() {
 	flag.Parse()
 	if name == "" {
-		name = "XevDemo6"
+		name = "XevDemo7"
 	}
 	global := new(stdDomain)
 	modList := module.New()

rt2/rules/assign.go

@@ -81,7 +81,7 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	switch a.(node.AssignNode).Statement() {
 	case statement.ASSIGN:
 		switch a.Left().(type) {
-		case node.VariableNode, node.ParameterNode:
+		case node.VariableNode, node.ParameterNode, node.FieldNode:
 			seq, ret = right(f)
 		default:
 			fmt.Println(reflect.TypeOf(a.Left()))

rt2/rules/op.go

@@ -196,7 +196,7 @@ func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.ConstantNode:
 			fu.DataOf(f)[n.Left()] = n.Left().(node.ConstantNode).Data()
 			return right, frame.NOW
-		case node.VariableNode, node.ParameterNode:
+		case node.VariableNode, node.ParameterNode, node.FieldNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 				fu.DataOf(f)[n.Left()] = sc.Select(n.Left().Object())

rt2/rules/table.go

@@ -46,6 +46,8 @@ func prologue(n node.Node) frame.Sequence {
 		return exitSeq
 	case node.DerefNode:
 		return derefSeq
+	case node.InitNode:
+		return frame.Tail(frame.STOP)
 	default:
 		panic(fmt.Sprintln("unknown node", reflect.TypeOf(n)))
 	}
@@ -54,7 +56,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, node.WhileNode, node.RepeatNode, node.ExitNode:
+	case node.AssignNode, node.InitNode, node.CallNode, node.ConditionalNode, node.WhileNode, node.RepeatNode, node.ExitNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			next := n.Link()
 			if next != nil {

rt2/scope/stdScope.go

@@ -89,10 +89,12 @@ func (m *manager) Allocate(n node.Node) {
 	for _, o := range mod.Objects[n] {
 		//fmt.Println(reflect.TypeOf(o))
 		switch o.(type) {
-		case object.VariableObject:
+		case object.VariableObject, object.FieldObject:
 			h.heap[o] = &direct{data: def}
 		case object.ParameterObject:
 			h.heap[o] = &indirect{mgr: m}
+		default:
+			panic(fmt.Sprintln("wrong object type", reflect.TypeOf(o)))
 		}
 	}
 	m.areas.PushFront(h)
@@ -103,7 +105,7 @@ func (m *manager) set(a *area, o object.Object, val node.Node) {
 	switch val.(type) {
 	case node.ConstantNode:
 		switch o.(type) {
-		case object.VariableObject:
+		case object.VariableObject, object.FieldObject:
 			m.Update(o, func(old interface{}) interface{} {
 				return val.(node.ConstantNode).Data()
 			})
@@ -115,9 +117,9 @@ func (m *manager) set(a *area, o object.Object, val node.Node) {
 		default:
 			panic("unknown value")
 		}
-	case node.VariableNode, node.ParameterNode:
+	case node.VariableNode, node.ParameterNode, node.FieldNode:
 		switch o.(type) {
-		case object.VariableObject:
+		case object.VariableObject, object.FieldObject:
 			m.Update(o, func(old interface{}) interface{} {
 				return m.Select(val.Object())
 			})

xev/converter.go

@@ -190,6 +190,14 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 		default:
 			panic(fmt.Sprintln("unknown type", n.Data.Typ.Typ))
 		}
+	case "RECORD":
+		switch n.Data.Typ.Base {
+		case "NOTYP":
+			n := object.NewRecordType()
+			ret = n
+		default:
+			panic("unknown record base")
+		}
 	default:
 		panic(fmt.Sprintln("unknown form", n.Data.Typ.Form))
 	}
@@ -218,6 +226,9 @@ func (r *Result) doObject(n *Node) object.Object {
 		case "parameter":
 			ret = object.New(object.PARAMETER)
 			initType(n.Data.Obj.Typ, ret.(object.ParameterObject))
+		case "field":
+			ret = object.New(object.FIELD)
+			initType(n.Data.Obj.Typ, ret.(object.FieldObject))
 		default:
 			fmt.Println(n.Data.Obj.Mode)
 			panic("no such object mode")
@@ -349,6 +360,10 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 			ret = node.New(constant.EXIT)
 		case "dereferencing":
 			ret = node.New(constant.DEREF)
+		case "field":
+			ret = node.New(constant.FIELD)
+		case "init":
+			ret = node.New(node.INIT)
 		default:
 			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")