добавил тесты

cp/adr.go

@@ -0,0 +1,12 @@
+package cp
+
+type Id interface {
+	Adr(...int) int
+}
+
+var adr int = 0
+
+func SomeAdr() int {
+	adr--
+	return adr
+}

cp/node/class.go

@@ -6,6 +6,7 @@ import (
 	"fw/cp/constant/operation"
 	"fw/cp/constant/statement"
 	"fw/cp/object"
+	"ypk/assert"
 )
 
 const INIT constant.Class = -1
@@ -21,72 +22,83 @@ type CompNode interface {
 	self() CompNode
 }
 
-func New(class constant.Class) Node {
+func New(class constant.Class, id int) (ret Node) {
 	switch class {
 	case constant.ENTER:
-		return new(enterNode)
+		ret = new(enterNode)
 	case constant.ASSIGN:
-		return new(assignNode)
+		ret = new(assignNode)
 	case constant.VARIABLE:
-		return new(variableNode)
+		ret = new(variableNode)
 	case constant.DYADIC:
-		return new(dyadicNode)
+		ret = new(dyadicNode)
 	case constant.CONSTANT:
-		return new(constantNode)
+		ret = new(constantNode)
 	case constant.CALL:
-		return new(callNode)
+		ret = new(callNode)
 	case constant.PROCEDURE:
-		return new(procedureNode)
+		ret = new(procedureNode)
 	case constant.PARAMETER:
-		return new(parameterNode)
+		ret = new(parameterNode)
 	case constant.RETURN:
-		return new(returnNode)
+		ret = new(returnNode)
 	case constant.MONADIC:
-		return new(monadicNode)
+		ret = new(monadicNode)
 	case constant.CONDITIONAL:
-		return new(conditionalNode)
+		ret = new(conditionalNode)
 	case constant.IF:
-		return new(ifNode)
+		ret = new(ifNode)
 	case constant.REPEAT:
-		return new(repeatNode)
+		ret = new(repeatNode)
 	case constant.WHILE:
-		return new(whileNode)
+		ret = new(whileNode)
 	case constant.EXIT:
-		return new(exitNode)
+		ret = new(exitNode)
 	case constant.LOOP:
-		return new(loopNode)
+		ret = new(loopNode)
 	case constant.DEREF:
-		return new(derefNode)
+		ret = new(derefNode)
 	case constant.FIELD:
-		return new(fieldNode)
+		ret = new(fieldNode)
 	case INIT:
-		return new(initNode)
+		ret = new(initNode)
 	case constant.INDEX:
-		return new(indexNode)
+		ret = new(indexNode)
 	case constant.TRAP:
-		return new(trapNode)
+		ret = new(trapNode)
 	case constant.WITH:
-		return new(withNode)
+		ret = new(withNode)
 	case constant.GUARD:
-		return new(guardNode)
+		ret = new(guardNode)
 	case constant.CASE:
-		return new(caseNode)
+		ret = new(caseNode)
 	case constant.ELSE:
-		return new(elseNode)
+		ret = new(elseNode)
 	case constant.DO:
-		return new(doNode)
+		ret = new(doNode)
 	case constant.RANGE:
-		return new(rangeNode)
+		ret = new(rangeNode)
 	case COMPOUND:
-		return new(compNode)
+		ret = new(compNode)
 	default:
 		panic("no such class")
 	}
+	ret.Adr(id)
+	return ret
 }
 
 type nodeFields struct {
 	left, right, link Node
 	obj               object.Object
+	adr               int
+}
+
+func (nf *nodeFields) Adr(a ...int) int {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		nf.adr = a[0]
+	}
+	return nf.adr
 }
 
 func (nf *nodeFields) SetLeft(n Node) { nf.left = n }

cp/node/node.go

@@ -1,6 +1,7 @@
 package node
 
 import (
+	"fw/cp"
 	"fw/cp/constant/enter"
 	"fw/cp/constant/operation"
 	"fw/cp/constant/statement"
@@ -17,6 +18,8 @@ type Node interface {
 	Right() Node
 	Link() Node
 	Object() object.Object
+
+	cp.Id
 }
 
 type EnterNode interface {

cp/object/object.go

@@ -1,6 +1,7 @@
 package object
 
 import (
+	"fw/cp"
 	"ypk/assert"
 )
 
@@ -30,6 +31,7 @@ type Object interface {
 	Name() string
 	SetRef(n Ref)
 	Ref() []Ref
+	cp.Id
 }
 
 type Ref interface {
@@ -71,31 +73,33 @@ type Module interface {
 	self() Module
 }
 
-func New(mode Mode) Object {
+func New(mode Mode, id int) (ret Object) {
 	switch mode {
 	case HEAD:
-		return new(headObject)
+		ret = new(headObject)
 	case VARIABLE:
-		return new(variableObject)
+		ret = new(variableObject)
 	case LOCAL_PROC:
-		return new(localProcedureObject)
+		ret = new(localProcedureObject)
 	case CONSTANT:
-		return new(constantObject)
+		ret = new(constantObject)
 	case PARAMETER:
-		return new(parameterObject)
+		ret = new(parameterObject)
 	case EXTERNAL_PROC:
-		return new(externalProcedureObject)
+		ret = new(externalProcedureObject)
 	case TYPE_PROC:
-		return new(typeProcedureObject)
+		ret = new(typeProcedureObject)
 	case FIELD:
-		return new(fieldObject)
+		ret = new(fieldObject)
 	case TYPE:
-		return new(typeObject)
+		ret = new(typeObject)
 	case MODULE:
-		return new(mod)
+		ret = new(mod)
 	default:
 		panic("no such object mode")
 	}
+	ret.Adr(id)
+	return ret
 }
 
 type objectFields struct {
@@ -104,6 +108,7 @@ type objectFields struct {
 	link Object
 	comp ComplexType
 	ref  []Ref
+	adr  int
 }
 
 func (of *objectFields) SetType(typ Type)         { of.typ = typ }
@@ -115,6 +120,14 @@ func (of *objectFields) SetLink(o Object)         { of.link = o }
 func (of *objectFields) SetComplex(t ComplexType) { of.comp = t }
 func (of *objectFields) Complex() ComplexType     { return of.comp }
 
+func (of *objectFields) Adr(a ...int) int {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		of.adr = a[0]
+	}
+	return of.adr
+}
+
 func (of *objectFields) SetRef(n Ref) {
 	assert.For(n != nil, 20)
 	exists := func() bool {

cp/object/type.go

@@ -2,7 +2,9 @@ package object
 
 import (
 	"fmt"
+	"fw/cp"
 	"reflect"
+	"ypk/assert"
 )
 
 type Type int
@@ -62,15 +64,25 @@ func (t Type) String() string {
 type ComplexType interface {
 	Link() Object
 	SetLink(o Object)
+	cp.Id
 }
 
 type comp struct {
 	link Object
+	adr  int
 }
 
 func (c *comp) Link() Object     { return c.link }
 func (c *comp) SetLink(o Object) { c.link = o }
 
+func (c *comp) Adr(a ...int) int {
+	assert.For(len(a) <= 1, 20)
+	if len(a) == 1 {
+		c.adr = a[0]
+	}
+	return c.adr
+}
+
 type BasicType interface {
 	ComplexType
 	Type() Type
@@ -101,8 +113,9 @@ type RecordType interface {
 	Name() string
 }
 
-func NewBasicType(t Type) BasicType {
+func NewBasicType(t Type, id int) BasicType {
 	x := &basic{typ: t}
+	x.Adr(id)
 	return x
 }
 
@@ -113,8 +126,10 @@ type basic struct {
 
 func (b *basic) Type() Type { return b.typ }
 
-func NewDynArrayType(b Type) DynArrayType {
-	return &dyn{base: b}
+func NewDynArrayType(b Type, id int) (ret DynArrayType) {
+	ret = &dyn{base: b}
+	ret.Adr(id)
+	return ret
 }
 
 type dyn struct {
@@ -124,8 +139,10 @@ type dyn struct {
 
 func (d *dyn) Base() Type { return d.base }
 
-func NewArrayType(b Type, len int64) ArrayType {
-	return &arr{base: b, length: len}
+func NewArrayType(b Type, len int64, id int) (ret ArrayType) {
+	ret = &arr{base: b, length: len}
+	ret.Adr(id)
+	return ret
 }
 
 type arr struct {
@@ -145,12 +162,16 @@ type rec struct {
 
 func (r *rec) Name() string { return r.name }
 func (r *rec) Base() string { return r.base }
-func NewRecordType(n string, par ...string) RecordType {
+
+func NewRecordType(n string, id int, par ...string) (ret RecordType) {
 	if len(par) == 0 {
-		return &rec{}
+		ret = &rec{}
+		ret.Adr(id)
 	} else {
-		return &rec{name: n, base: par[0]}
+		ret = &rec{name: n, base: par[0]}
+		ret.Adr(id)
 	}
+	return ret
 }
 
 func (r *rec) BaseType() RecordType { return r.basetyp }

fw_test.bat

@@ -1,57 +1,11 @@
 @echo off 
-fw -i=XevDemo0 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo1 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo2 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo3 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo4 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo5 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo6 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo7 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo8 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo9 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo10 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo11 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo12 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo13 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo14 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo15 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo16 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo17 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo18 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo19 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo20 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo21 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevDemo22 > .out
-IF ERRORLEVEL 1 GOTO err
-fw -i=XevTest0 > .out
+fw -i=%1
 IF ERRORLEVEL 1 GOTO err
 
 GOTO ok
 :err
-echo FAILED
+echo FAILED %1
 pause
 
 :ok
-del .out
+exit

fw_test_all.bat

@@ -0,0 +1,26 @@
+@echo off 
+start fw_test XevDemo0
+start fw_test XevDemo1
+start fw_test XevDemo2
+start fw_test XevDemo3
+start fw_test XevDemo4
+start fw_test XevDemo5
+start fw_test XevDemo6
+start fw_test XevDemo7
+start fw_test XevDemo8
+start fw_test XevDemo9
+start fw_test XevDemo10
+start fw_test XevDemo11
+start fw_test XevDemo12
+start fw_test XevDemo13
+start fw_test XevDemo14
+start fw_test XevDemo15
+start fw_test XevDemo16
+start fw_test XevDemo17
+start fw_test XevDemo18
+start fw_test XevDemo19
+start fw_test XevDemo20
+start fw_test XevDemo21
+start fw_test XevDemo22
+
+start fw_test XevTest0

rt2/rules/assign.go

@@ -2,6 +2,7 @@ package rules
 
 import (
 	"fmt"
+	"fw/cp"
 	"fw/cp/constant"
 	"fw/cp/constant/operation"
 	"fw/cp/constant/statement"
@@ -16,7 +17,7 @@ import (
 
 func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f)
-	op := node.New(constant.DYADIC).(node.OperationNode)
+	op := node.New(constant.DYADIC, cp.SomeAdr()).(node.OperationNode)
 	op.SetOperation(operation.PLUS)
 	op.SetLeft(n.Left())
 	op.SetRight(n.Right())
@@ -34,7 +35,7 @@ func incSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 
 func decSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 	n := rt2.NodeOf(f)
-	op := node.New(constant.DYADIC).(node.OperationNode)
+	op := node.New(constant.DYADIC, cp.SomeAdr()).(node.OperationNode)
 	op.SetOperation(operation.MINUS)
 	op.SetLeft(n.Left())
 	op.SetRight(n.Right())

rt2/rules/call.go

@@ -3,6 +3,7 @@ package rules
 import (
 	"encoding/json"
 	"fmt"
+	"fw/cp"
 	"fw/cp/constant"
 	"fw/cp/node"
 	"fw/cp/object"
@@ -38,11 +39,11 @@ func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 		return
 	}
 	m := rt_mod.DomainModule(f.Domain())
-	cn := node.New(constant.CALL)
+	cn := node.New(constant.CALL, cp.SomeAdr())
 	ol := m.NodeByObject(obj)
 	assert.For(len(ol) <= 1, 40)
 	cn.SetLeft(ol[0])
-	cc := node.New(constant.CONSTANT).(node.ConstantNode)
+	cc := node.New(constant.CONSTANT, cp.SomeAdr()).(node.ConstantNode)
 	cc.SetData(data)
 	cn.SetRight(cc)
 	rt2.Push(rt2.New(cn), f)

rt2/rules/guard.go

@@ -2,6 +2,7 @@ package rules
 
 import (
 	"fmt"
+	"fw/cp"
 	"fw/cp/constant"
 	"fw/cp/node"
 	"fw/cp/object"
@@ -28,8 +29,8 @@ func guardSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		rt2.DataOf(f.Parent())[n] = n.Left()
 		return frame.End()
 	} else {
-		trap := node.New(constant.TRAP).(node.TrapNode)
-		code := node.New(constant.CONSTANT).(node.ConstantNode)
+		trap := node.New(constant.TRAP, cp.SomeAdr()).(node.TrapNode)
+		code := node.New(constant.CONSTANT, cp.SomeAdr()).(node.ConstantNode)
 		code.SetData(0)
 		trap.SetLeft(code)
 		rt2.Push(rt2.New(trap), f)

rt2/scope/std/heap.go

@@ -2,6 +2,7 @@ package std
 
 import (
 	"fmt"
+	"fw/cp"
 	"fw/cp/node"
 	"fw/cp/object"
 	"fw/rt2/context"
@@ -39,7 +40,7 @@ func (h *heap) Allocate(n node.Node, par ...interface{}) (ret scope.ValueFor) {
 	talloc = func(t object.PointerType) (oid scope.ID) {
 		switch bt := t.Base().(type) {
 		case object.RecordType:
-			fake := object.New(object.VARIABLE)
+			fake := object.New(object.VARIABLE, cp.SomeAdr())
 			fake.SetComplex(bt)
 			fake.SetType(object.COMPLEX)
 			fake.SetName("@")
@@ -62,7 +63,7 @@ func (h *heap) Allocate(n node.Node, par ...interface{}) (ret scope.ValueFor) {
 			default:
 				panic("mistyped parameter")
 			}
-			fake := object.New(object.VARIABLE)
+			fake := object.New(object.VARIABLE, cp.SomeAdr())
 			fake.SetComplex(bt)
 			fake.SetType(object.COMPLEX)
 			fake.SetName("@")

xev/converter.go

@@ -193,7 +193,7 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 		case "BASIC":
 			switch n.Data.Typ.Typ {
 			case "PROCEDURE":
-				t := object.NewBasicType(object.PROCEDURE)
+				t := object.NewBasicType(object.PROCEDURE, n.Id)
 				link := r.findLink(n, "link")
 				if link != nil {
 					t.SetLink(r.doObject(link))
@@ -217,33 +217,27 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 		case "DYNAMIC":
 			switch n.Data.Typ.Base {
 			case "CHAR":
-				n := object.NewDynArrayType(object.CHAR)
-				ret = n
+				ret = object.NewDynArrayType(object.CHAR, n.Id)
 			case "BYTE":
-				n := object.NewDynArrayType(object.BYTE)
-				ret = n
+				ret = object.NewDynArrayType(object.BYTE, n.Id)
 			case "SHORTCHAR":
-				n := object.NewDynArrayType(object.SHORTCHAR)
-				ret = n
+				ret = object.NewDynArrayType(object.SHORTCHAR, n.Id)
 			default:
 				panic(fmt.Sprintln("unknown dyn type", n.Data.Typ.Typ))
 			}
 		case "ARRAY":
 			switch n.Data.Typ.Base {
 			case "CHAR":
-				n := object.NewArrayType(object.CHAR, int64(n.Data.Typ.Par))
-				ret = n
+				ret = object.NewArrayType(object.CHAR, int64(n.Data.Typ.Par), n.Id)
 			default:
 				panic(fmt.Sprintln("unknown array type", n.Data.Typ.Typ))
 			}
 		case "RECORD":
 			switch n.Data.Typ.Base {
 			case "NOTYP":
-				n := object.NewRecordType(n.Data.Typ.Name)
-				ret = n
+				ret = object.NewRecordType(n.Data.Typ.Name, n.Id)
 			default:
-				n := object.NewRecordType(n.Data.Typ.Name, n.Data.Typ.Base)
-				ret = n
+				ret = object.NewRecordType(n.Data.Typ.Name, n.Id, n.Data.Typ.Base)
 			}
 			link := r.findLink(n, "link")
 			if link != nil {
@@ -272,33 +266,33 @@ func (r *Result) doObject(n *Node) (ret object.Object) {
 	if ret == nil {
 		switch n.Data.Obj.Mode {
 		case "head":
-			ret = object.New(object.HEAD)
+			ret = object.New(object.HEAD, n.Id)
 		case "variable":
-			ret = object.New(object.VARIABLE)
+			ret = object.New(object.VARIABLE, n.Id)
 			initType(n.Data.Obj.Typ, ret.(object.VariableObject))
 		case "local procedure":
-			ret = object.New(object.LOCAL_PROC)
+			ret = object.New(object.LOCAL_PROC, n.Id)
 			ret.SetType(object.PROCEDURE)
 		case "external procedure":
-			ret = object.New(object.EXTERNAL_PROC)
+			ret = object.New(object.EXTERNAL_PROC, n.Id)
 			ret.SetType(object.PROCEDURE)
 		case "type procedure":
-			ret = object.New(object.TYPE_PROC)
+			ret = object.New(object.TYPE_PROC, n.Id)
 			ret.SetType(object.PROCEDURE)
 		case "constant":
-			ret = object.New(object.CONSTANT)
+			ret = object.New(object.CONSTANT, n.Id)
 			convertData(n.Data.Obj.Typ, n.Data.Obj.Value, ret.(object.ConstantObject))
 			//fmt.Println(n.Data.Obj.Name, " ", ret.(object.ConstantObject).Data())
 		case "parameter":
-			ret = object.New(object.PARAMETER)
+			ret = object.New(object.PARAMETER, n.Id)
 			initType(n.Data.Obj.Typ, ret.(object.ParameterObject))
 		case "field":
-			ret = object.New(object.FIELD)
+			ret = object.New(object.FIELD, n.Id)
 			initType(n.Data.Obj.Typ, ret.(object.FieldObject))
 		case "type":
-			ret = object.New(object.TYPE)
+			ret = object.New(object.TYPE, n.Id)
 		case "module":
-			ret = object.New(object.MODULE)
+			ret = object.New(object.MODULE, n.Id)
 		default:
 			fmt.Println(n.Data.Obj.Mode)
 			panic("no such object mode")
@@ -364,7 +358,7 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 	if ret == nil {
 		switch n.Data.Nod.Class {
 		case "enter":
-			ret = node.New(constant.ENTER)
+			ret = node.New(constant.ENTER, n.Id)
 			switch n.Data.Nod.Enter {
 			case "module":
 				ret.(node.EnterNode).SetEnter(enter.MODULE)
@@ -374,12 +368,12 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				panic("no such enter type")
 			}
 		case "variable":
-			ret = node.New(constant.VARIABLE)
+			ret = node.New(constant.VARIABLE, n.Id)
 		case "dyadic":
-			ret = node.New(constant.DYADIC)
+			ret = node.New(constant.DYADIC, n.Id)
 			ret.(node.OperationNode).SetOperation(operation.This(n.Data.Nod.Operation))
 		case "constant":
-			ret = node.New(constant.CONSTANT)
+			ret = node.New(constant.CONSTANT, n.Id)
 			convertData(n.Data.Nod.Typ, n.Data.Nod.Value, ret.(node.ConstantNode))
 			//fmt.Println(ret.(node.ConstantNode).Data())
 			x := ret.(node.ConstantNode)
@@ -392,20 +386,20 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				x.SetMax(val)
 			}
 		case "assign":
-			ret = node.New(constant.ASSIGN)
+			ret = node.New(constant.ASSIGN, n.Id)
 			ret.(node.AssignNode).SetStatement(statement.This(n.Data.Nod.Statement))
 		case "call":
-			ret = node.New(constant.CALL)
+			ret = node.New(constant.CALL, n.Id)
 		case "procedure":
-			ret = node.New(constant.PROCEDURE)
+			ret = node.New(constant.PROCEDURE, n.Id)
 			proc = ret.(node.ProcedureNode)
 			proc.Super(n.Data.Nod.Proc)
 		case "parameter":
-			ret = node.New(constant.PARAMETER)
+			ret = node.New(constant.PARAMETER, n.Id)
 		case "return":
-			ret = node.New(constant.RETURN)
+			ret = node.New(constant.RETURN, n.Id)
 		case "monadic":
-			ret = node.New(constant.MONADIC)
+			ret = node.New(constant.MONADIC, n.Id)
 			ret.(node.OperationNode).SetOperation(operation.This(n.Data.Nod.Operation))
 			switch n.Data.Nod.Operation {
 			case "CONV":
@@ -413,32 +407,32 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				initType(n.Data.Nod.Typ, ret.(node.MonadicNode))
 			}
 		case "conditional":
-			ret = node.New(constant.CONDITIONAL)
+			ret = node.New(constant.CONDITIONAL, n.Id)
 		case "if":
-			ret = node.New(constant.IF)
+			ret = node.New(constant.IF, n.Id)
 		case "while":
-			ret = node.New(constant.WHILE)
+			ret = node.New(constant.WHILE, n.Id)
 		case "repeat":
-			ret = node.New(constant.REPEAT)
+			ret = node.New(constant.REPEAT, n.Id)
 		case "loop":
-			ret = node.New(constant.LOOP)
+			ret = node.New(constant.LOOP, n.Id)
 		case "exit":
-			ret = node.New(constant.EXIT)
+			ret = node.New(constant.EXIT, n.Id)
 		case "dereferencing":
-			ret = node.New(constant.DEREF)
+			ret = node.New(constant.DEREF, n.Id)
 			ret.(node.DerefNode).Ptr(n.Data.Nod.From)
 		case "field":
-			ret = node.New(constant.FIELD)
+			ret = node.New(constant.FIELD, n.Id)
 		case "init":
-			ret = node.New(node.INIT)
+			ret = node.New(node.INIT, n.Id)
 		case "index":
-			ret = node.New(constant.INDEX)
+			ret = node.New(constant.INDEX, n.Id)
 		case "trap":
-			ret = node.New(constant.TRAP)
+			ret = node.New(constant.TRAP, n.Id)
 		case "with":
-			ret = node.New(constant.WITH)
+			ret = node.New(constant.WITH, n.Id)
 		case "guard":
-			ret = node.New(constant.GUARD)
+			ret = node.New(constant.GUARD, n.Id)
 			typ := r.findLink(n, "type")
 			if typ != nil {
 				ret.(node.GuardNode).SetType(r.doType(typ))
@@ -447,9 +441,9 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				}
 			}
 		case "case":
-			ret = node.New(constant.CASE)
+			ret = node.New(constant.CASE, n.Id)
 		case "else":
-			ret = node.New(constant.ELSE)
+			ret = node.New(constant.ELSE, n.Id)
 			x := ret.(node.ElseNode)
 			if n.Data.Nod.Min != nil {
 				val, _ := strconv.Atoi(n.Data.Nod.Min.X)
@@ -460,11 +454,11 @@ func (r *Result) buildNode(n *Node) (ret node.Node) {
 				x.Max(val)
 			}
 		case "do":
-			ret = node.New(constant.DO)
+			ret = node.New(constant.DO, n.Id)
 		case "range":
-			ret = node.New(constant.RANGE)
+			ret = node.New(constant.RANGE, n.Id)
 		case "compound":
-			ret = node.New(node.COMPOUND)
+			ret = node.New(node.COMPOUND, n.Id)
 		default:
 			fmt.Println(n.Data.Nod.Class)
 			panic("no such node type")