исправил очередную ошибку в генераторе дампов, поэтому обновил компиляты

исправил ошибку в инициализации
работаю над парсером json

fw.go

@@ -24,11 +24,11 @@ func init() {
 }
 
 func close() {
+	utils.Debug(false)
 	utils.PrintFrame("____")
 	utils.PrintFrame(heap)
 	utils.PrintFrame("^^^^")
 	log.Println("closed")
-	//fmt.Println(heap)
 }
 
 func main() {

rt2/frame/std/sf.go

@@ -2,10 +2,10 @@ package std
 
 import (
 	"container/list"
-	"fmt"
 	"fw/rt2/context"
 	"fw/rt2/frame"
 	"fw/rt2/scope"
+	"fw/utils"
 	"reflect"
 	"ypk/assert"
 	"ypk/halt"
@@ -110,7 +110,7 @@ func (f *RootFrame) Do() (res frame.WAIT) {
 			} else if wait == frame.NOW {
 			} else if wait == frame.WRONG {
 				trapped = true
-				fmt.Println("it's a trap")
+				utils.PrintTrap("it's a trap")
 				break
 				//panic("something wrong") do nothing, it's a trap
 			} else if wait == frame.STOP {
@@ -137,7 +137,9 @@ func (f *RootFrame) ForEach(run func(x frame.Frame) bool) {
 	e := f.inner.Front()
 	ok := true
 	for (e != nil) && ok {
-		ok = run(e.Value.(frame.Frame))
+		if e.Value != nil {
+			ok = run(e.Value.(frame.Frame))
+		}
 		e = e.Next()
 	}
 }

rt2/nodeframe/frame.go

@@ -34,9 +34,13 @@ func (fu NodeFrameUtils) Push(f, p frame.Frame) {
 }
 
 func (fu NodeFrameUtils) NodeOf(f frame.Frame) node.Node {
-	ff, _ := f.(*nodeFrame)
-	assert.For(ff.ir != nil, 40)
-	return ff.ir
+	ff, ok := f.(*nodeFrame)
+	if ok {
+		assert.For(ff.ir != nil, 40)
+		return ff.ir
+	} else {
+		return nil
+	}
 }
 
 func (fu NodeFrameUtils) DataOf(f frame.Frame) map[interface{}]interface{} {
@@ -88,7 +92,23 @@ func (f *nodeFrame) Do() frame.WAIT {
 	} else {
 		assert.For(ret == frame.STOP || ret == frame.WRONG, 41)
 		if ret == frame.WRONG {
-			fmt.Println("stopped by signal")
+			var fu NodeFrameUtils
+			utils.PrintTrap()
+			utils.PrintTrap("something WRONG")
+			utils.PrintTrap(f.Domain().Discover(context.SCOPE))
+			depth := 10
+			f.root.ForEach(func(old frame.Frame) bool {
+				n := fu.NodeOf(old)
+				if n != nil {
+					utils.PrintTrap(reflect.TypeOf(n), n.Adr())
+					utils.PrintTrap("data: ", fu.DataOf(old), "value: ", fu.ValueOf(old))
+				} else {
+					utils.PrintTrap(reflect.TypeOf(old))
+				}
+				depth--
+				return depth != 0
+			})
+			utils.PrintTrap(f.Domain().Discover(context.HEAP))
 		}
 
 	}

rt2/rules/call.go

@@ -8,6 +8,7 @@ import (
 	cpm "fw/cp/module"
 	"fw/cp/node"
 	"fw/cp/object"
+	"fw/cp/traps"
 	"fw/rt2"
 	"fw/rt2/context"
 	"fw/rt2/frame"
@@ -233,7 +234,11 @@ func callSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 						dm   context.Domain
 					)
 					v := rt2.ValueOf(f)[n.Right().Adr()]
-					_, c := scope.Ops.TypeOf(v)
+					t, c := scope.Ops.TypeOf(v)
+					if c == nil {
+						return thisTrap(f, traps.Default)
+					}
+					assert.For(c != nil, 40, n.Right().Adr(), v, t)
 					x := ml.NewTypeCalc()
 					x.ConnectTo(c)
 					for _, ml := range x.MethodList() {

rt2/rules/field.go

@@ -1,7 +1,6 @@
 package rules
 
 import (
-	"fmt"
 	"reflect"
 )
 
@@ -27,7 +26,7 @@ func fieldSeq(in ...IN) (out OUT) {
 	case node.VariableNode, node.ParameterNode:
 		sc.Select(l.Object().Adr(), func(v scope.Value) {
 			rt2.ValueOf(f.Parent())[n.Adr()] = v.(scope.Record).Get(n.Object().Adr())
-			fmt.Println(n.Object().Adr())
+			//fmt.Println(n.Object().Adr())
 		})
 		out = End()
 	case node.FieldNode, node.DerefNode:

rt2/rules/op.go

@@ -106,15 +106,8 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			}
 			ret = frame.LATER
 			return seq, ret
-		case node.FieldNode:
-			seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-				//				sc := f.Domain().Discover(context.SCOPE).(scope.Manager)
-				//				rt2.DataOf(f)[n.Left()] = sc.Select(scope.Designator(n.Left()))
-				panic(0)
-				return op, frame.NOW
-			}
-			ret = frame.NOW
-			return seq, ret
+		case node.CallNode, node.FieldNode:
+			return This(expectExpr(f, n.Left(), Expose(op)))
 		default:
 			fmt.Println(reflect.TypeOf(n.Left()))
 			panic("wrong left")

rt2/rules/table.go

@@ -74,7 +74,7 @@ func prologue(n node.Node) frame.Sequence {
 		return func(f frame.Frame) (frame.Sequence, frame.WAIT) {
 			switch code := next.Left().(type) {
 			case node.ConstantNode:
-				utils.PrintTrap("TRAP:", traps.This(code.Data()))
+				log.Println("TRAP:", traps.This(code.Data()))
 				return frame.Tail(frame.WRONG), frame.NOW
 			default:
 				panic(fmt.Sprintln("unsupported code", reflect.TypeOf(code)))

rt2/rules/trap.go

@@ -17,3 +17,11 @@ func doTrap(f frame.Frame, err traps.TRAP) (frame.Sequence, frame.WAIT) {
 	rt2.Push(rt2.New(trap), f)
 	return frame.Tail(frame.STOP), frame.LATER
 }
+
+func thisTrap(f frame.Frame, err traps.TRAP) (out OUT) {
+	out.do = Expose(func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+		return doTrap(f, err)
+	})
+	out.next = LATER
+	return
+}

rt2/scope/modern/hp.go

@@ -77,7 +77,7 @@ func (h *halloc) Allocate(n node.Node, par ...interface{}) scope.ValueFor {
 			fake := object.New(object.VARIABLE, cp.Some())
 			fake.SetComplex(bt)
 			fake.SetType(object.COMPLEX)
-			fake.SetName("{}")
+			fake.SetName("{" + n.Object().Name() + "}")
 			l.alloc(h.area.d, mod, nil, append(ol, fake), skip)
 			res = &ptrValue{scope: h.area, id: fake.Adr(), link: n.Object()}
 		case object.DynArrayType:

rt2/scope/modern/ms.go

@@ -19,6 +19,7 @@ import (
 )
 
 type level struct {
+	root   node.Node
 	k      map[cp.ID]int
 	v      map[int]scope.Variable
 	r      map[int]scope.Ref
@@ -88,6 +89,7 @@ func (a *area) Provide(x interface{}) scope.ValueFor {
 
 //var alloc func(*level, []object.Object, map[cp.ID]interface{})
 func (l *level) alloc(d context.Domain, mod *cpm.Module, root node.Node, ol []object.Object, skip map[cp.ID]interface{}) {
+	l.root = root
 	ml := d.Discover(context.UNIVERSE).(context.Domain).Discover(context.MOD).(rtm.List)
 	for _, o := range ol {
 		imp := mod.ImportOf(o)
@@ -113,11 +115,12 @@ func (l *level) alloc(d context.Domain, mod *cpm.Module, root node.Node, ol []ob
 					l.l[l.next] = nl
 					l.k[x.Adr()] = l.next
 					fl := make([]object.Object, 0)
+					//fmt.Println("-------")
 					for rec := t; rec != nil; {
 						for x := rec.Link(); x != nil; x = x.Link() {
-							//fmt.Println(o.Name(), ".", x.Name(), x.Adr())
 							switch x.(type) {
 							case object.FieldObject:
+								//fmt.Println(o.Name(), ".", x.Name(), x.Adr())
 								fl = append(fl, x)
 							case object.ParameterObject, object.ProcedureObject, object.VariableObject:
 								//do nothing
@@ -222,13 +225,13 @@ func (a *salloc) Dispose(n node.Node) {
 	}
 }
 
-func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, ret frame.WAIT) {
+func (a *salloc) Initialize(n node.Node, par scope.PARAM) (frame.Sequence, frame.WAIT) {
 	utils.PrintScope("INITIALIZE")
 	l := a.area.top()
 	assert.For(l != nil && !l.ready, 20)
 	val := par.Values
 	f := par.Frame
-	end := func(frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+	tail := func(frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		l.ready = true
 		if par.Tail != nil {
 			return par.Tail(f)
@@ -236,152 +239,160 @@ func (a *salloc) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence, r
 			return frame.End()
 		}
 	}
-	seq = end
-	ret = frame.NOW
-	var sm scope.Manager
-	for next := par.Objects; next != nil; next = next.Link() {
-		global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
-		mod := rtm.ModuleOfNode(f.Domain(), val)
-		//mod := rtm.ModuleOfNode(f.Domain(), val.Object())
-		if mod != nil {
-			//fmt.Println(mod.Name)
-			global = global.Discover(mod.Name).(context.Domain)
-			sm = global.Discover(context.SCOPE).(scope.Manager)
-		} else { //для фиктивных узлов, которые созданы рантаймом, типа INC/DEC
-			sm = a.area
-		}
-		switch o := next.(type) {
-		case object.VariableObject:
-			switch nv := val.(type) {
-			case node.ConstantNode:
-				v := newConst(nv)
-				l.v[l.k[o.Adr()]].Set(v)
-			case node.VariableNode, node.ParameterNode:
-				if nv.Object().Imp() != "" {
-					md := rtm.ModuleDomain(f.Domain(), nv.Object().Imp())
-					sm = md.Discover(context.SCOPE).(scope.Manager)
-				}
-				v := sm.Select(rtm.MapImportObject(f.Domain(), nv.Object()).Adr())
-				l.v[l.k[o.Adr()]].Set(v)
-			case node.OperationNode:
-				nf := rt2.New(nv)
-				rt2.Push(nf, f)
-				rt2.Assert(f, func(f frame.Frame) (bool, int) {
-					return rt2.ValueOf(f)[nv.Adr()] != nil, 59
-				})
-				rt2.ReplaceDomain(nf, global)
-				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					v := rt2.ValueOf(f)[nv.Adr()]
+	var nxt frame.Sequence
+	var next object.Object = par.Objects
+	nxt = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+		seq = nxt
+		ret = frame.NOW
+		var sm scope.Manager
+		if next == nil {
+			return tail, frame.LATER
+		} else {
+			global := f.Domain().Discover(context.UNIVERSE).(context.Domain)
+			mod := rtm.ModuleOfNode(f.Domain(), val)
+			//mod := rtm.ModuleOfNode(f.Domain(), val.Object())
+			if mod != nil {
+				//fmt.Println(mod.Name)
+				global = global.Discover(mod.Name).(context.Domain)
+				sm = global.Discover(context.SCOPE).(scope.Manager)
+			} else { //для фиктивных узлов, которые созданы рантаймом, типа INC/DEC
+				sm = a.area
+			}
+			switch o := next.(type) {
+			case object.VariableObject:
+				switch nv := val.(type) {
+				case node.ConstantNode:
+					v := newConst(nv)
 					l.v[l.k[o.Adr()]].Set(v)
-					return end, frame.NOW
-				}
-				ret = frame.LATER
-			case node.FieldNode, node.DerefNode, node.CallNode:
-				nf := rt2.New(nv)
-				rt2.Push(nf, f)
-				rt2.ReplaceDomain(nf, global)
-				rt2.Assert(f, func(f frame.Frame) (bool, int) {
-					return rt2.ValueOf(f)[nv.Adr()] != nil || rt2.RegOf(f)["RETURN"] != nil, 60
-				})
-				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					v := rt2.ValueOf(f)[nv.Adr()]
-					if v == nil {
-						v, _ = rt2.RegOf(f)["RETURN"].(scope.Value)
+				case node.VariableNode, node.ParameterNode:
+					if nv.Object().Imp() != "" {
+						md := rtm.ModuleDomain(f.Domain(), nv.Object().Imp())
+						sm = md.Discover(context.SCOPE).(scope.Manager)
 					}
-					assert.For(v != nil, 40)
-					l.v[l.k[o.Adr()]].Set(v)
-					return end, frame.NOW
-				}
-				ret = frame.LATER
-			case node.IndexNode:
-				nf := rt2.New(nv)
-				rt2.Push(nf, f)
-				rt2.ReplaceDomain(nf, global)
-				rt2.Assert(f, func(f frame.Frame) (bool, int) {
-					return rt2.ValueOf(f)[nv.Adr()] != nil, 64
-				})
-				seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
-					sc := global.Discover(context.SCOPE).(scope.Manager)
-					left := rt2.ValueOf(f)[nv.Adr()]
-					arr := sc.Select(nv.Left().Object().Adr()).(scope.Array)
-					v := arr.Get(left)
+					v := sm.Select(rtm.MapImportObject(f.Domain(), nv.Object()).Adr())
 					l.v[l.k[o.Adr()]].Set(v)
-					return end, frame.NOW
-				}
-				ret = frame.LATER
-			default:
-				halt.As(40, reflect.TypeOf(nv))
-			}
-		case object.ParameterObject:
-			switch nv := val.(type) {
-			case node.VariableNode, node.ParameterNode:
-				old := l.r[l.k[o.Adr()]].(*ref)
-				l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: sm, id: nv.Object().Adr()}
-			case node.FieldNode:
-				nf := rt2.New(nv)
-				rt2.Push(nf, f)
-				rt2.ReplaceDomain(nf, global)
-				rt2.Assert(f, func(f frame.Frame) (bool, int) {
-					return rt2.ValueOf(f)[nv.Adr()] != nil, 60
-				})
-				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					v := rt2.ValueOf(f)[nv.Adr()]
-					assert.For(v != nil, 40)
-					//old := l.r[l.k[o.Adr()]].(*ref)
-					l.v[l.k[o.Adr()]] = v.(scope.Variable)
-					l.r[l.k[o.Adr()]] = nil
-					return end, frame.NOW
-				}
-				ret = frame.LATER
-			case node.ConstantNode: //array :) заменяем ссылку на переменную
-				old := l.r[l.k[o.Adr()]].(*ref)
-				l.r[l.k[o.Adr()]] = nil
-				data := newConst(nv)
-				switch data.(type) {
-				case STRING, SHORTSTRING:
-					val := &dynarr{link: old.link}
-					val.Set(data)
-					l.v[l.k[o.Adr()]] = val
+				case node.OperationNode:
+					nf := rt2.New(nv)
+					rt2.Push(nf, f)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[nv.Adr()] != nil, 59
+					})
+					rt2.ReplaceDomain(nf, global)
+					seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+						v := rt2.ValueOf(f)[nv.Adr()]
+						l.v[l.k[o.Adr()]].Set(v)
+						return nxt, frame.NOW
+					}
+					ret = frame.LATER
+				case node.FieldNode, node.DerefNode, node.CallNode:
+					nf := rt2.New(nv)
+					rt2.Push(nf, f)
+					rt2.ReplaceDomain(nf, global)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[nv.Adr()] != nil || rt2.RegOf(f)["RETURN"] != nil, 60
+					})
+					seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+						v := rt2.ValueOf(f)[nv.Adr()]
+						if v == nil {
+							v, _ = rt2.RegOf(f)["RETURN"].(scope.Value)
+						}
+						assert.For(v != nil, 40)
+						l.v[l.k[o.Adr()]].Set(v)
+						return nxt, frame.NOW
+					}
+					ret = frame.LATER
+				case node.IndexNode:
+					nf := rt2.New(nv)
+					rt2.Push(nf, f)
+					rt2.ReplaceDomain(nf, global)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[nv.Adr()] != nil, 64
+					})
+					seq = func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+						sc := global.Discover(context.SCOPE).(scope.Manager)
+						left := rt2.ValueOf(f)[nv.Adr()]
+						arr := sc.Select(nv.Left().Object().Adr()).(scope.Array)
+						v := arr.Get(left)
+						l.v[l.k[o.Adr()]].Set(v)
+						return nxt, frame.NOW
+					}
+					ret = frame.LATER
 				default:
-					halt.As(100, reflect.TypeOf(data))
+					halt.As(40, reflect.TypeOf(nv))
 				}
-			case node.DerefNode:
-				rt2.Push(rt2.New(nv), f)
-				rt2.Assert(f, func(f frame.Frame) (bool, int) {
-					return rt2.ValueOf(f)[nv.Adr()] != nil, 61
-				})
-				dn := next
-				old := l.r[l.k[dn.Adr()]].(*ref)
-				seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-					switch dn.(type) {
-					case object.VariableObject, object.ParameterObject:
-						l.r[l.k[dn.Adr()]] = nil
-						data := rt2.ValueOf(f)[nv.Adr()]
-						switch deref := data.(type) {
-						case STRING, SHORTSTRING:
-							val := &dynarr{link: old.link}
-							val.Set(deref)
-							l.v[l.k[dn.Adr()]] = val
-						case *rec:
-							l.v[l.k[dn.Adr()]] = deref
+			case object.ParameterObject:
+				switch nv := val.(type) {
+				case node.VariableNode, node.ParameterNode:
+					old := l.r[l.k[o.Adr()]].(*ref)
+					l.r[l.k[o.Adr()]] = &ref{link: old.link, sc: sm, id: nv.Object().Adr()}
+				case node.FieldNode:
+					nf := rt2.New(nv)
+					rt2.Push(nf, f)
+					rt2.ReplaceDomain(nf, global)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[nv.Adr()] != nil, 60
+					})
+					seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+						v := rt2.ValueOf(f)[nv.Adr()]
+						assert.For(v != nil, 40)
+						//old := l.r[l.k[o.Adr()]].(*ref)
+						l.v[l.k[o.Adr()]] = v.(scope.Variable)
+						l.r[l.k[o.Adr()]] = nil
+						return nxt, frame.NOW
+					}
+					ret = frame.LATER
+				case node.ConstantNode: //array :) заменяем ссылку на переменную
+					old := l.r[l.k[o.Adr()]].(*ref)
+					l.r[l.k[o.Adr()]] = nil
+					data := newConst(nv)
+					switch data.(type) {
+					case STRING, SHORTSTRING:
+						val := &dynarr{link: old.link}
+						val.Set(data)
+						l.v[l.k[o.Adr()]] = val
+					default:
+						halt.As(100, reflect.TypeOf(data))
+					}
+				case node.DerefNode:
+					rt2.Push(rt2.New(nv), f)
+					rt2.Assert(f, func(f frame.Frame) (bool, int) {
+						return rt2.ValueOf(f)[nv.Adr()] != nil, 61
+					})
+					dn := next
+					old := l.r[l.k[dn.Adr()]].(*ref)
+					seq = func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+						switch dn.(type) {
+						case object.VariableObject, object.ParameterObject:
+							l.r[l.k[dn.Adr()]] = nil
+							data := rt2.ValueOf(f)[nv.Adr()]
+							switch deref := data.(type) {
+							case STRING, SHORTSTRING:
+								val := &dynarr{link: old.link}
+								val.Set(deref)
+								l.v[l.k[dn.Adr()]] = val
+							case *rec:
+								l.v[l.k[dn.Adr()]] = deref
+							default:
+								halt.As(100, reflect.TypeOf(data))
+							}
 						default:
-							halt.As(100, reflect.TypeOf(data))
+							panic(fmt.Sprintln("unknown value", reflect.TypeOf(next)))
 						}
-					default:
-						panic(fmt.Sprintln("unknown value", reflect.TypeOf(next)))
+						return nxt, frame.NOW
 					}
-					return end, frame.NOW
+					ret = frame.LATER
+				default:
+					halt.As(40, reflect.TypeOf(nv))
 				}
-				ret = frame.LATER
 			default:
-				halt.As(40, reflect.TypeOf(nv))
+				halt.As(40, reflect.TypeOf(o))
 			}
-		default:
-			halt.As(40, reflect.TypeOf(o))
+			val = val.Link()
+			next = next.Link()
 		}
-		val = val.Link()
+		return
 	}
-	return seq, ret
+	return nxt, frame.NOW
 }
 
 func (a *salloc) Join(m scope.Manager) { a.area = m.(*area) }
@@ -480,6 +491,9 @@ func (a *area) String() (ret string) {
 }
 
 func (l *level) String() (ret string) {
+	if l.root != nil {
+		ret = fmt.Sprintln(ret, "scope of node", l.root.Adr())
+	}
 	for k, v := range l.k {
 		ret = fmt.Sprint(ret, "@", k, v, l.v[v])
 		if l.v[v] == nil {

rt2/scope/modern/val.go

@@ -5,6 +5,7 @@ import (
 	"fw/cp"
 	"fw/cp/node"
 	"fw/cp/object"
+	//	rtm "fw/rt2/module"
 	"fw/rt2/scope"
 	"fw/utils"
 	"math"
@@ -100,6 +101,7 @@ func (r *rec) Set(v scope.Value) {
 func (r *rec) Get(id cp.ID) scope.Value {
 	k := r.l.k[id]
 	if r.l.v[k] == nil { //ref
+		fmt.Println(r.Id(), id)
 		assert.For(r.l.r[k] != nil, 20, id, k)
 		return r.l.r[k]
 	} else {
@@ -1282,7 +1284,12 @@ func (o *ops) Is(a scope.Value, typ object.ComplexType) scope.Value {
 					return false
 				}
 			case object.PointerType:
-				return false
+				if a.Base() != nil {
+					return compare(x, a.Base())
+				} else {
+					fmt.Println("here")
+					return false
+				}
 			default:
 				halt.As(100, reflect.TypeOf(a))
 			}
@@ -1311,12 +1318,17 @@ func (o *ops) Is(a scope.Value, typ object.ComplexType) scope.Value {
 	case *rec:
 		z, a := x.link.Complex().(object.RecordType)
 		y, b := typ.(object.RecordType)
-		//fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
+		//fmt.Println("compare rec", x.link.Complex(), typ, a, b, a && b && compare(z, y))
 		return BOOLEAN(a && b && compare(z, y))
 	case *ptr:
 		z, a := x.link.Complex().(object.PointerType)
+		if val := x.Get(); z.Name() == "ANYPTR" && val != NIL {
+			t, c := o.TypeOf(val)
+			assert.For(t == object.COMPLEX, 40)
+			z, a = c.(object.RecordType)
+		}
 		y, b := typ.(object.PointerType)
-		//fmt.Println("compare", x.link.Complex(), typ, a, b, a && b && compare(z, y))
+		//fmt.Println("compare ptr", z, typ, a, b, a && b && compare(z, y))
 		return BOOLEAN(a && b && compare(z, y))
 	default:
 		halt.As(100, reflect.TypeOf(x))
@@ -1758,8 +1770,11 @@ func (o *ops) Geq(a, b scope.Value) scope.Value {
 func (o *ops) TypeOf(x scope.Value) (object.Type, object.ComplexType) {
 	switch v := x.(type) {
 	case *ptr:
+		//assert.For(v.val != nil, 20, v.Id())
 		if v.val != nil {
 			return v.val.link.Type(), v.val.link.Complex()
+		} else {
+			//return v.link.Type(), v.link.Complex()
 		}
 	case *rec:
 		return v.link.Type(), v.link.Complex()