добавлена инициализация параметров значениями, монадные операции, RETURN, пока не все корректные

cp/constant/nodeclass.go

@@ -10,4 +10,7 @@ const (
 	CONSTANT
 	CALL
 	PROCEDURE
+	PARAMETER
+	RETURN
+	MONADIC
 )

cp/constant/operation/operation.go

@@ -4,4 +4,5 @@ type Operation int
 
 const (
 	PLUS Operation = iota
+	CONVERT
 )

cp/node/class.go

@@ -29,112 +29,134 @@ type ConstantNode interface {
 
 // Self-designator for empty interfaces
 type AssignNode interface {
-	Self() AssignNode
+	self() AssignNode
 	SetStatement(statement.Statement)
 	Statement() statement.Statement
 	Node
 }
 
 type VariableNode interface {
-	Self() VariableNode
+	self() VariableNode
 	Node
 }
 
 type CallNode interface {
-	Self() CallNode
+	self() CallNode
 	Node
 }
 
 type ProcedureNode interface {
-	Self() ProcedureNode
+	self() ProcedureNode
 	Node
 }
 
-type enterNode struct {
-	nodeFields
-	enter enter.Enter
+type ParameterNode interface {
+	Node
+	self() ParameterNode
 }
 
-func (e *enterNode) SetEnter(enter enter.Enter) {
-	e.enter = enter
+type ReturnNode interface {
+	Node
+	self() ReturnNode
 }
 
-func (e *enterNode) Enter() enter.Enter {
-	return e.enter
+type DyadicNode interface {
+	OperationNode
+	self() DyadicNode
 }
 
+type MonadicNode interface {
+	OperationNode
+	SetType(typ object.Type)
+	Type() object.Type
+	self() MonadicNode
+}
+
+type enterNode struct {
+	nodeFields
+	enter enter.Enter
+}
+
+func (e *enterNode) SetEnter(enter enter.Enter) { e.enter = enter }
+func (e *enterNode) Enter() enter.Enter         { return e.enter }
+
 type constantNode struct {
 	nodeFields
 	typ  object.Type
 	data interface{}
 }
 
-func (c *constantNode) SetType(t object.Type) {
-	c.typ = t
-}
+func (c *constantNode) SetType(t object.Type) { c.typ = t }
 
-func (c *constantNode) SetData(data interface{}) {
-	c.data = data
-}
+func (c *constantNode) SetData(data interface{}) { c.data = data }
 
-func (c *constantNode) Data() interface{} {
-	return c.data
-}
+func (c *constantNode) Data() interface{} { return c.data }
 
-func (c *constantNode) Type() object.Type {
-	return c.typ
-}
+func (c *constantNode) Type() object.Type { return c.typ }
 
 type dyadicNode struct {
 	nodeFields
 	operation operation.Operation
 }
 
-func (d *dyadicNode) SetOperation(op operation.Operation) {
-	d.operation = op
-}
+func (d *dyadicNode) SetOperation(op operation.Operation) { d.operation = op }
 
-func (d *dyadicNode) Operation() operation.Operation {
-	return d.operation
-}
+func (d *dyadicNode) Operation() operation.Operation { return d.operation }
+
+func (d *dyadicNode) self() DyadicNode { return d }
 
 type assignNode struct {
 	nodeFields
 	stat statement.Statement
 }
 
-func (a *assignNode) Self() AssignNode {
-	return a
-}
+func (a *assignNode) self() AssignNode { return a }
 
-func (a *assignNode) SetStatement(s statement.Statement) {
-	a.stat = s
-}
+func (a *assignNode) SetStatement(s statement.Statement) { a.stat = s }
 
-func (a *assignNode) Statement() statement.Statement {
-	return a.stat
-}
+func (a *assignNode) Statement() statement.Statement { return a.stat }
 
 type variableNode struct {
 	nodeFields
 }
 
-func (v *variableNode) Self() VariableNode {
-	return v
-}
+func (v *variableNode) self() VariableNode { return v }
 
 type callNode struct {
 	nodeFields
 }
 
-func (v *callNode) Self() CallNode {
-	return v
-}
+func (v *callNode) self() CallNode { return v }
 
 type procedureNode struct {
 	nodeFields
 }
 
-func (v *procedureNode) Self() ProcedureNode {
-	return v
+func (v *procedureNode) self() ProcedureNode { return v }
+
+type parameterNode struct {
+	nodeFields
 }
+
+func (v *parameterNode) self() ParameterNode { return v }
+
+type returnNode struct {
+	nodeFields
+}
+
+func (v *returnNode) self() ReturnNode { return v }
+
+type monadicNode struct {
+	nodeFields
+	operation operation.Operation
+	typ       object.Type
+}
+
+func (v *monadicNode) self() MonadicNode { return v }
+
+func (v *monadicNode) SetOperation(op operation.Operation) { v.operation = op }
+
+func (v *monadicNode) Operation() operation.Operation { return v.operation }
+
+func (v *monadicNode) SetType(t object.Type) { v.typ = t }
+func (v *monadicNode) Type() object.Type     { return v.typ }

cp/node/node.go

@@ -33,6 +33,12 @@ func New(class constant.Class) Node {
 		return new(callNode)
 	case constant.PROCEDURE:
 		return new(procedureNode)
+	case constant.PARAMETER:
+		return new(parameterNode)
+	case constant.RETURN:
+		return new(returnNode)
+	case constant.MONADIC:
+		return new(monadicNode)
 	default:
 		panic("no such class")
 	}

cp/object/object.go

@@ -8,6 +8,7 @@ const (
 	VARIABLE
 	LOCAL_PROCEDURE
 	CONSTANT
+	PARAMETER
 )
 
 const (
@@ -28,6 +29,9 @@ type Object interface {
 	SetName(name string)
 	SetType(typ Type)
 	Type() Type
+	Link() Object
+	SetLink(o Object)
+	Name() string
 }
 
 type VariableObject interface {
@@ -41,6 +45,10 @@ type ConstantObject interface {
 	Data() interface{}
 }
 
+type ParameterObject interface {
+	Object
+}
+
 func New(mode Mode) Object {
 	switch mode {
 	case HEAD:
@@ -51,6 +59,8 @@ func New(mode Mode) Object {
 		return new(localProcedureObject)
 	case CONSTANT:
 		return new(constantObject)
+	case PARAMETER:
+		return new(parameterObject)
 	default:
 		panic("no such object mode")
 	}
@@ -59,19 +69,15 @@ func New(mode Mode) Object {
 type objectFields struct {
 	name string
 	typ  Type
+	link Object
 }
 
-func (of *objectFields) SetType(typ Type) {
-	of.typ = typ
-}
-
-func (of *objectFields) SetName(name string) {
-	of.name = name
-}
-
-func (of *objectFields) Type() Type {
-	return of.typ
-}
+func (of *objectFields) SetType(typ Type)    { of.typ = typ }
+func (of *objectFields) SetName(name string) { of.name = name }
+func (of *objectFields) Name() string        { return of.name }
+func (of *objectFields) Type() Type          { return of.typ }
+func (of *objectFields) Link() Object        { return of.link }
+func (of *objectFields) SetLink(o Object)    { of.link = o }
 
 type variableObject struct {
 	objectFields
@@ -97,3 +103,36 @@ func (o *constantObject) SetData(x interface{}) {
 }
 
 func (o *constantObject) Data() interface{} { return o.val }
+
+type parameterObject struct {
+	objectFields
+}
+
+func (t Type) String() string {
+	switch t {
+	case NOTYPE:
+		return "NO TYPE"
+	case INTEGER:
+		return "INTEGER"
+	case SHORTINT:
+		return "SHORTINT"
+	case LONGINT:
+		return "LONGINT"
+	case BYTE:
+		return "BYTE"
+	case BOOLEAN:
+		return "BOOLEAN"
+	case SHORTREAL:
+		return "SHORTREAL"
+	case REAL:
+		return "REAL"
+	case CHAR:
+		return "CHAR"
+	case SHORTCHAR:
+		return "SHORTCHAR"
+	case SET:
+		return "SET"
+	default:
+		panic("looks like new type here")
+	}
+}

rt2/nodeframe/frame.go

@@ -2,18 +2,24 @@ package nodeframe
 
 import (
 	"cp/node"
+	"fmt"
+	"reflect"
 	"rt2/context"
 	"rt2/decision"
 	"rt2/frame"
 	"ypk/assert"
 )
 
+var count int64
+
 type FrameUtils struct{}
 
 func (fu FrameUtils) New(n node.Node) (f frame.Frame) {
 	assert.For(n != nil, 20)
 	f = new(nodeFrame)
 	f.(*nodeFrame).ir = n
+	f.(*nodeFrame).num = count
+	count++
 	return f
 }
 
@@ -43,11 +49,13 @@ type nodeFrame struct {
 	seq    frame.Sequence
 	domain context.Domain
 	data   map[interface{}]interface{}
+	num    int64
 }
 
 func (f *nodeFrame) Do() frame.WAIT {
 	assert.For(f.seq != nil, 20)
 	next, ret := f.seq(f)
+	fmt.Println(f.num, ret, reflect.TypeOf(f.ir))
 	if next != nil {
 		assert.For(ret != frame.STOP, 40)
 		f.seq = next

rt2/rules/assign.go

@@ -3,6 +3,8 @@ package rules
 import (
 	"cp/node"
 	"cp/statement"
+	"fmt"
+	"reflect"
 	"rt2/context"
 	"rt2/frame"
 	"rt2/nodeframe"
@@ -12,46 +14,53 @@ import (
 func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	var fu nodeframe.FrameUtils
 	a := fu.NodeOf(f)
+
+	right := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+		switch a.Right().(type) {
+		case node.ConstantNode:
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				sc.Update(a.Left().Object(), func(interface{}) interface{} {
+					return a.Right().(node.ConstantNode).Data()
+				})
+				return frame.End()
+			}
+			ret = frame.DO
+		case node.VariableNode:
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				sc.Update(a.Left().Object(), func(interface{}) interface{} {
+					return sc.Select(a.Right().Object())
+				})
+				return frame.End()
+			}
+			ret = frame.DO
+		case node.OperationNode, node.CallNode:
+			fu.Push(fu.New(a.Right()), f)
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
+				sc.Update(a.Left().Object(), func(interface{}) interface{} {
+					return fu.DataOf(f)[a.Right()]
+				})
+				return frame.End()
+			}
+			ret = frame.SKIP
+		default:
+			fmt.Println(reflect.TypeOf(a.Right()))
+			panic("wrong right")
+		}
+		return seq, ret
+	}
 	switch a.(node.AssignNode).Statement() {
 	case statement.ASSIGN:
 		m := new(frame.SetDataMsg)
 		m.Data = make(map[interface{}]interface{})
 		f.(context.ContextAware).Handle(m)
 		switch a.Left().(type) {
-		case node.VariableNode:
-			switch a.Right().(type) {
-			case node.ConstantNode:
-				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-					sc.Update(a.Left().Object(), func(interface{}) interface{} {
-						return a.Right().(node.ConstantNode).Data()
-					})
-					return frame.End()
-				}
-				ret = frame.DO
-			case node.VariableNode:
-				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-					sc.Update(a.Left().Object(), func(interface{}) interface{} {
-						return sc.Select(a.Right().Object())
-					})
-					return frame.End()
-				}
-				ret = frame.DO
-			case node.OperationNode:
-				fu.Push(fu.New(a.Right()), f)
-				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-					sc.Update(a.Left().Object(), func(interface{}) interface{} {
-						return fu.DataOf(f)[a.Right()]
-					})
-					return frame.End()
-				}
-				ret = frame.SKIP
-			default:
-				panic("wrong right")
-			}
+		case node.VariableNode, node.ParameterNode:
+			seq, ret = right(f)
 		default:
+			fmt.Println(reflect.TypeOf(a.Left()))
 			panic("wrong left")
 		}
 	default:

rt2/rules/call.go

@@ -2,11 +2,20 @@ package rules
 
 import (
 	"cp/node"
+	"rt2/context"
 	"rt2/frame"
 	mod "rt2/module"
 	"rt2/nodeframe"
 )
 
+/**
+Для CallNode
+	.Left() указывает на процедуру
+	.Left().Object() указывает на список внутренних объектов, в т.ч. переменных
+	.Object() указывает первый элемент из списка входных параметров/переменных,
+	то же что и.Left().Object().Link(), далее .Link() указывает на следующие за ним входные параметры
+	.Right() указывает на узлы, которые передаются в параметры
+*/
 func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	var fu nodeframe.FrameUtils
 	n := fu.NodeOf(f)
@@ -14,7 +23,16 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	case node.ProcedureNode:
 		m := mod.DomainModule(f.Domain())
 		proc := m.NodeByObject(n.Left().Object())
-		f.Root().Push(fu.New(proc))
+		nf := fu.New(proc)
+		f.Root().Push(nf)
+		//передаем ссылку на цепочку значений параметров в данные фрейма входа в процедуру
+		if (n.Right() != nil) && (proc.Object() != nil) {
+			dd := make(map[interface{}]interface{})
+			dd[proc.Object()] = n.Right()
+			m := new(frame.SetDataMsg)
+			m.Data = dd
+			nf.(context.ContextAware).Handle(m)
+		}
 		seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			return frame.End()
 		}

rt2/rules/op.go

@@ -9,10 +9,11 @@ import (
 	"rt2/frame"
 	"rt2/nodeframe"
 	"rt2/scope"
+	"ypk/assert"
 )
 
 func int32Of(x interface{}) (a int32) {
-	fmt.Println(reflect.TypeOf(x))
+	//fmt.Println(reflect.TypeOf(x))
 	switch x.(type) {
 	case *int32:
 		z := *x.(*int32)
@@ -20,7 +21,7 @@ func int32Of(x interface{}) (a int32) {
 	case int32:
 		a = x.(int32)
 	default:
-		panic("unsupported type")
+		panic(fmt.Sprintln("unsupported type", reflect.TypeOf(x)))
 	}
 	return a
 }
@@ -31,7 +32,11 @@ func sum(_a interface{}, _b interface{}) interface{} {
 	return a + b
 }
 
-func opSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+	return frame.End()
+}
+
+func dopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	var fu nodeframe.FrameUtils
 
 	m := new(frame.SetDataMsg)
@@ -55,15 +60,25 @@ func opSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		case node.ConstantNode:
 			fu.DataOf(f)[n.Right()] = n.Right().(node.ConstantNode).Data()
 			return op, frame.DO
-		case node.VariableNode:
+		case node.VariableNode, node.ParameterNode:
 			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
 				fu.DataOf(f)[n.Right()] = sc.Select(n.Right().Object())
+				//fmt.Println(n.Right().Object(), reflect.TypeOf(n.Right().Object()))
+				assert.For(fu.DataOf(f)[n.Right()] != nil, 60)
 				return op, frame.DO
 			}
 			ret = frame.DO
 			return seq, ret
+		case node.OperationNode:
+			fu.Push(fu.New(n.Right()), f)
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				return frame.End()
+			}
+			ret = frame.SKIP
+			return seq, ret
 		default:
+			fmt.Println(reflect.TypeOf(n.Right()))
 			panic("wrong right")
 		}
 	}
@@ -74,7 +89,7 @@ func opSeq(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.DO
-		case node.VariableNode:
+		case node.VariableNode, node.ParameterNode:
 			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())
@@ -82,10 +97,17 @@ func opSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.DO
 			return seq, ret
+		case node.OperationNode:
+			fu.Push(fu.New(n.Left()), f)
+			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+				return frame.End()
+			}
+			ret = frame.SKIP
+			return seq, ret
 		default:
+			fmt.Println(reflect.TypeOf(n.Left()))
 			panic("wrong left")
 		}
 	}
-
 	return left, frame.DO
 }

rt2/rules/return.go

@@ -0,0 +1,9 @@
+package rules
+
+import (
+	"rt2/frame"
+)
+
+func returnSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
+	return frame.End()
+}

rt2/rules/table.go

@@ -15,25 +15,40 @@ import (
 
 func prologue(n node.Node) frame.Sequence {
 	var fu nodeframe.FrameUtils
-	fmt.Println(reflect.TypeOf(n))
+	//fmt.Println(reflect.TypeOf(n))
 	switch n.(type) {
 	case node.EnterNode:
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-			node := fu.NodeOf(f).Right()
-			assert.For(node != nil, 40)
+			body := fu.NodeOf(f).Right()
+			assert.For(body != nil, 40)
 			sm := scope.This(f.Domain().Discover(context.SCOPE))
 			sm.Allocate(n)
-			f.Root().Push(fu.New(node))
+			if n.Object() != nil {
+				par, ok := fu.DataOf(f)[n.Object()].(node.Node)
+				if ok {
+					sm.Initialize(n, n.Object().Link(), par)
+				}
+			}
+			f.Root().Push(fu.New(body))
 			return frame.Tail(frame.STOP), frame.SKIP
 		}
 	case node.AssignNode:
 		return assignSeq
 	case node.OperationNode:
-		return opSeq
+		switch n.(type) {
+		case node.DyadicNode:
+			return dopSeq
+		case node.MonadicNode:
+			return mopSeq
+		default:
+			panic("no such op")
+		}
 	case node.CallNode:
 		return callSeq
+	case node.ReturnNode:
+		return returnSeq
 	default:
-		panic("unknown node")
+		panic(fmt.Sprintln("unknown node", reflect.TypeOf(n)))
 	}
 }
 
@@ -56,6 +71,9 @@ func epilogue(n node.Node) frame.Sequence {
 		}
 	case node.OperationNode:
 		return nil //do nothing
+	case node.ReturnNode:
+		fmt.Println("return")
+		return nil
 	default:
 		fmt.Println(reflect.TypeOf(n))
 		panic("unhandled epilogue")

rt2/scope/area.go

@@ -13,6 +13,7 @@ type Manager interface {
 	Select(o object.Object) interface{}
 	Allocate(n node.Node)
 	Dispose(n node.Node)
+	Initialize(n node.Node, o object.Object, val node.Node)
 }
 
 //средство обновления значения

rt2/scope/stdScope.go

@@ -25,14 +25,16 @@ type manager struct {
 	areas *list.List
 }
 
-type heapObj struct {
+type area struct {
 	heap map[object.Object]interface{}
 	root node.Node
 }
 
 type undefined struct{}
+type param struct{}
 
 var undef *undefined = new(undefined)
+var par *param = new(param)
 
 func (m *manager) init() *manager {
 	m.areas = list.New()
@@ -41,24 +43,56 @@ func (m *manager) init() *manager {
 
 func (m *manager) Allocate(n node.Node) {
 	mod := rt_mod.DomainModule(m.Domain())
-	h := new(heapObj)
+	h := new(area)
 	h.heap = make(map[object.Object]interface{})
 	h.root = n
 	for _, o := range mod.Objects[n] {
-		fmt.Println(reflect.TypeOf(o))
+		//fmt.Println(reflect.TypeOf(o))
 		switch o.(type) {
 		case object.VariableObject:
 			h.heap[o] = undef
+		case object.ParameterObject:
+			h.heap[o] = par
 		}
 	}
 	m.areas.PushFront(h)
 	fmt.Println("allocate", len(h.heap), "obj")
 }
 
+func (m *manager) set(a *area, o object.Object, val node.Node) {
+	switch val.(type) {
+	case node.ConstantNode:
+		m.Update(o, func(old interface{}) interface{} {
+			return val.(node.ConstantNode).Data()
+		})
+	case node.VariableNode, node.ParameterNode:
+		m.Update(o, func(old interface{}) interface{} {
+			return m.Select(val.Object())
+		})
+	default:
+		panic("unknown value")
+	}
+}
+
+func (m *manager) Initialize(n node.Node, o object.Object, _val node.Node) {
+	e := m.areas.Front()
+	assert.For(e != nil, 20)
+	h := e.Value.(*area)
+	assert.For(h.root == n, 21)
+	val := _val
+	for next := o; next != nil; next = next.Link() {
+		assert.For(val != nil, 40)
+		fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
+		fmt.Println(reflect.TypeOf(val))
+		m.set(h, next, val)
+		val = val.Link()
+	}
+}
+
 func (m *manager) Dispose(n node.Node) {
 	e := m.areas.Front()
 	assert.For(e != nil, 20)
-	h := e.Value.(*heapObj)
+	h := e.Value.(*area)
 	assert.For(h.root == n, 21)
 	m.areas.Remove(e)
 	fmt.Println("dispose")
@@ -67,12 +101,14 @@ func (m *manager) Dispose(n node.Node) {
 func (m *manager) Select(o object.Object) (ret interface{}) {
 	assert.For(o != nil, 20)
 	for e := m.areas.Front(); (e != nil) && (ret == nil); e = e.Next() {
-		h := e.Value.(*heapObj)
+		h := e.Value.(*area)
 		ret = h.heap[o]
 	}
 	assert.For(ret != nil, 40)
 	if ret == undef {
 		ret = nil
+	} else if ret == par {
+		panic("")
 	}
 	return ret
 }
@@ -80,9 +116,9 @@ func (m *manager) Select(o object.Object) (ret interface{}) {
 func (m *manager) Update(o object.Object, val Value) {
 	assert.For(o != nil, 20)
 	assert.For(val != nil, 21)
-	var x *heapObj
+	var x *area
 	for e := m.areas.Front(); (e != nil) && (x == nil); e = e.Next() {
-		h := e.Value.(*heapObj)
+		h := e.Value.(*area)
 		if h.heap[o] != nil {
 			x = h
 		}

xev/converter.go

@@ -49,6 +49,40 @@ type convertable interface {
 	SetType(t object.Type)
 }
 
+type typed interface {
+	SetType(t object.Type)
+}
+
+func initType(typ string, conv typed) {
+	assert.For(conv != nil, 20)
+	switch typ {
+	case "INTEGER":
+		conv.SetType(object.INTEGER)
+	case "SHORTINT":
+		conv.SetType(object.SHORTINT)
+	case "LONGINT":
+		conv.SetType(object.LONGINT)
+	case "BYTE":
+		conv.SetType(object.BYTE)
+	case "CHAR":
+		conv.SetType(object.CHAR)
+	case "SHORTCHAR":
+		conv.SetType(object.SHORTCHAR)
+	case "REAL":
+		conv.SetType(object.REAL)
+	case "SHORTREAL":
+		conv.SetType(object.SHORTREAL)
+	case "SET":
+		conv.SetType(object.SET)
+	case "BOOLEAN":
+		conv.SetType(object.BOOLEAN)
+	case "":
+		conv.SetType(object.NOTYPE)
+	default:
+		panic("no such constant type")
+	}
+}
+
 func convertData(typ string, val string, conv convertable) {
 	assert.For(conv != nil, 20)
 	switch typ {
@@ -92,7 +126,7 @@ func convertData(typ string, val string, conv convertable) {
 		conv.SetData(float32(x))
 	case "SET":
 		conv.SetType(object.SET)
-		x, _ := strconv.ParseInt(val, 16, 32)
+		x, _ := strconv.ParseInt(val, 2, 32)
 		conv.SetData(big.NewInt(x))
 	case "BOOLEAN":
 		conv.SetType(object.BOOLEAN)
@@ -123,19 +157,33 @@ func (r *Result) buildObject(n *Node) object.Object {
 			ret = object.New(object.HEAD)
 		case "variable":
 			ret = object.New(object.VARIABLE)
+			initType(n.Data.Obj.Typ, ret.(object.VariableObject))
 		case "local procedure":
 			ret = object.New(object.LOCAL_PROCEDURE)
 		case "constant":
 			ret = object.New(object.CONSTANT)
 			convertData(n.Data.Obj.Typ, n.Data.Obj.Value, ret.(object.ConstantObject))
-			fmt.Println(n.Data.Obj.Name, " ", ret.(object.ConstantObject).Data())
+			//fmt.Println(n.Data.Obj.Name, " ", ret.(object.ConstantObject).Data())
+		case "parameter":
+			ret = object.New(object.PARAMETER)
+			initType(n.Data.Obj.Typ, ret.(object.ParameterObject))
 		default:
+			fmt.Println(n.Data.Obj.Mode)
 			panic("no such object mode")
 		}
 	}
 	if ret != nil {
 		objectMap[n.Id] = ret
 		ret.SetName(n.Data.Obj.Name)
+
+		link := r.findLink(n, "link")
+		if link != nil {
+			ret.SetLink(r.buildObject(link))
+			if ret.Link() == nil {
+				panic("error in object")
+			}
+		}
+
 	}
 	return ret
 }
@@ -181,7 +229,7 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 		case "constant":
 			ret = node.New(constant.CONSTANT)
 			convertData(n.Data.Nod.Typ, n.Data.Nod.Value, ret.(node.ConstantNode))
-			fmt.Println(ret.(node.ConstantNode).Data())
+			//fmt.Println(ret.(node.ConstantNode).Data())
 		case "assign":
 			ret = node.New(constant.ASSIGN)
 			switch n.Data.Nod.Statement {
@@ -194,7 +242,21 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 			ret = node.New(constant.CALL)
 		case "procedure":
 			ret = node.New(constant.PROCEDURE)
+		case "parameter":
+			ret = node.New(constant.PARAMETER)
+		case "return":
+			ret = node.New(constant.RETURN)
+		case "monadic":
+			ret = node.New(constant.MONADIC)
+			switch n.Data.Nod.Operation {
+			case "convert":
+				ret.(node.OperationNode).SetOperation(operation.CONVERT)
+				initType(n.Data.Nod.Typ, ret.(node.MonadicNode))
+			default:
+				panic("no such operation")
+			}
 		default:
+			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")
 		}
 	}

xev/loader.go

@@ -3,10 +3,10 @@ package xev
 import "encoding/xml"
 
 type CptObject struct {
-	Name  string `xml:"urn:bbcb:component:dev:cpt name,attr"`
-	Mode  string `xml:"urn:bbcb:component:dev:cpt mode,attr"`
-	Typ   string `xml:"urn:bbcb:component:dev:cpt type,attr"`
-	Leaf  bool   `xml:"urn:bbcb:component:dev:cpt leaf,attr"`
+	Name string `xml:"urn:bbcb:component:dev:cpt name,attr"`
+	Mode string `xml:"urn:bbcb:component:dev:cpt mode,attr"`
+	Typ  string `xml:"urn:bbcb:component:dev:cpt type,attr"`
+	//	Leaf  bool   `xml:"urn:bbcb:component:dev:cpt leaf,attr"`
 	Value string `xml:",chardata"`
 }