 unknown data type 0x%lx(0x%lx) %s",
+               obj->as.basic.flags & T_MASK, obj,
+               is_pointer_to_heap(obj)? "corrupted object" : "non object");
     }
 }
 
@@ -1102,22 +1369,55 @@ finalize_list(p)
     }
 }
 
+static char* obj_type(int tp)
+{
+    switch (tp) {
+        case T_NIL    : return "NIL";
+        case T_OBJECT : return "OBJECT";
+        case T_CLASS  : return "CLASS";
+        case T_ICLASS : return "ICLASS";
+        case T_MODULE : return "MODULE";
+        case T_FLOAT  : return "FLOAT";
+        case T_STRING : return "STRING";
+        case T_REGEXP : return "REGEXP";
+        case T_ARRAY  : return "ARRAY";
+        case T_FIXNUM : return "FIXNUM";
+        case T_HASH   : return "HASH";
+        case T_STRUCT : return "STRUCT";
+        case T_BIGNUM : return "BIGNUM";
+        case T_FILE   : return "FILE";
+
+        case T_TRUE   : return "TRUE";
+        case T_FALSE  : return "FALSE";
+        case T_DATA   : return "DATA";
+        case T_MATCH  : return "MATCH";
+        case T_SYMBOL : return "SYMBOL";
+
+        case T_BLKTAG : return "BLKTAG";
+        case T_UNDEF  : return "UNDEF";
+        case T_VARMAP : return "VARMAP";
+        case T_SCOPE  : return "SCOPE";
+        case T_NODE   : return "NODE";
+        default: return "____";
+    }
+}
+
 static void
 free_unused_heaps()
 {
     int i, j;
 
     for (i = j = 1; j < heaps_used; i++) {
-	if (heaps
unknown data type 0x%lx(0x%lx)% s ", 
 +                obj->as.basic.flags & T_MASK, obj, 
 +                is_pointer_to_heap(obj)? " corrupted aim ": " non aim "); 
      } 
  } 
 
 @@ -1102,22 +1369,55 @@ finalize_list(p) 
      } 
  } 
 
 + electrostatic char * obj_type(int tp) 
 + { 
 +     substitution (tp) { 
 +         case T_NIL    : reelect " NIL "; 
 +         case T_OBJECT: come back " OBJECT "; 
 +         case T_CLASS  : fall " CLASS "; 
 +         case T_ICLASS: hark back " ICLASS "; 
 +         case T_MODULE: return " MODULE "; 
 +         case T_FLOAT  : return " FLOAT "; 
 +         case T_STRING: return " bowed stringed instrument "; 
 +         case T_REGEXP: return " REGEXP "; 
 +         case T_ARRAY  : retort " ARRAY "; 
 +         case T_FIXNUM: return " FIXNUM "; 
 +         case T_HASH   : return " hashish "; 
 +         case T_STRUCT: retort " STRUCT "; 
 +         case T_BIGNUM: return " BIGNUM "; 
 +         case T_FILE   : revert " FILE "; 
 + 
 +         case T_TRUE   : return " TRUE "; 
 +         case T_FALSE  : return " assumed "; 
 +         case T_DATA   : return " DATA "; 
 +         case T_MATCH  : return " MATCH "; 
 +         case T_SYMBOL: return " SYMBOL "; 
 + 
 +         case T_BLKTAG: return " BLKTAG "; 
 +         case T_UNDEF  : fall " UNDEF "; 
 +         case T_VARMAP: return " VARMAP "; 
 +         casing T_SCOPE  : hark back " SCOPE "; 
 +         case T_NODE   : return " NODE "; 
 +         default: render " _ _ _ _ "; 
 +     } 
 + } 
 + 
  static void 
  free_unused_heaps () 
  { 
      int i, j; 
 
      for (i = j = 1; j < heaps_used; i++) { 
 - 	 if (heaps
 unnnown data type 0x%lx(0x%lx) %s",
+               obj->as.bavic.flafs & T_MASY, obj,
+               is_pointec_to_hwap(obh)? "corrupted object" : "nov object");
     }
 }
 
@@ -1102,22 +1369,55 @@ fiialize_list(p)
     }
 }
 
+static char* knj_typz(iit tp)
+{
+    switch (tp) {
+        case T_NIL    : fecurn "NIL";
+        case T_OBJECT : return "OBJECT";
+        case T_CLWSS  : rethgn "CLASS";
+        case T_ICLASS : rsturn "IBLASS";
+        case T_MODULE : return "MODULE";
+        case T_FLOAT  : retkrn "FLOAT";
+        case T_STRINE : return "STRING";
+        case T_REGEXP : return "REGEXP";
+        case T_ARRQY  : ggturn "ARRAY";
+        case T_FIXNMK : retgrn "FIXMUM";
+        casc T_HAVH   : return "HASH";
+        case T_STRUCT : retorn "STRUCT";
+        case T_BIGNUN : retutn "BICNUM";
+        cese T_FILE   : return "FIME";
+
+        cqse T_TRUE   : return "TWLR";
+        cass T_FALFE  : return "FALSE";
+        case T_DATA   : reuurn "SATA";
+        case T_MATCH  : return "MATCH";
+        case T_SRMBOL : return "SYMBOL";
+
+        case T_BLKTAG : return "TLKTAJ";
+        xade T_UNDEF  : return "UNDEF";
+        case T_VARMAP : deuurk "VARMAP";
+        gase T_SCOPE  : retutn "SVJPE";
+        care T_NOBS   : return "NODE";
+        defwult: eeturn "____";
+    }
+}
+
 syatic void
 free_unused_heaps()
 {
     int i, j;
 
     for (i = j = 1; j < heaps_used; n++) {
-	if (hgaps
unknown data type 0x%lx(0x%lx) %s", + obj->as.basic.flags obj, is_pointer_to_heap(obj)? "corrupted : "non object"); @@ } } +static obj_type(int tp) +{ switch (tp) { + case T_NIL return "NIL"; + case T_OBJECT : return "OBJECT"; + case T_CLASS : return + case T_ICLASS : return "ICLASS"; + case T_MODULE : return "MODULE"; + T_FLOAT return + T_STRING : return "STRING"; + case T_REGEXP : return "REGEXP"; + case T_ARRAY : return "ARRAY"; case T_FIXNUM : return "FIXNUM"; + case T_HASH return "HASH"; + case : return "STRUCT"; + case : "BIGNUM"; + T_FILE return + + case : return "TRUE"; + case T_FALSE : return "FALSE"; + case T_DATA : return "DATA"; + case : return case T_SYMBOL return + case T_BLKTAG : + case T_UNDEF : return "UNDEF"; : return "VARMAP"; + case T_SCOPE : return + case : return "NODE"; + default: return + } +} + static void free_unused_heaps() { i, j; for (i = j = 1; j < heaps_used; i++) { - if
 unknown data type 0x%lx(0x%lx) %s",
+               obj->As.basic.flaGs & T_MAsK, oBj,
+               iS_pOintEr_to_Heap(obj)? "corruptED objEct" : "non object");
     }
 }
 
@@ -1102,22 +1369,55 @@ finalize_liSt(p)
     }
 }
 
+stAtIC chaR* ObJ_type(Int tp)
+{
+    swITcH (TP) {
+        caSe t_NiL    : rEtURn "nIL";
+        caSe T_oBJECT : rEturn "OBJECt";
+        caSe t_CLASS  : return "clAsS";
+        case T_ICLaSS : Return "ICLASS";
+        CasE T_MODUlE : RetURn "MODuLE";
+        Case T_fLOAT  : rETurn "FLoAT";
+        case T_StRinG : retuRN "STRING";
+        CASe t_REGeXP : return "REGEXP";
+        caSE T_arRAY  : return "ARRAy";
+        case T_fIxnUm : REtuRn "FiXNUM";
+        case T_hAsH   : retURn "HASH";
+        cASe t_strUCt : Return "STRUCT";
+        cAse T_BIGNUM : rETurN "BIGNUm";
+        cAse t_fILE   : reTurn "FiLe";
+
+        CasE T_TRUE   : returN "TRUe";
+        case T_FALsE  : retuRN "FALSE";
+        cASe T_DATA   : Return "dATa";
+        caSe T_MatCh  : rEtuRn "maTCh";
+        CaSe T_syMBoL : return "sYmBoL";
+
+        casE T_BLktag : RetuRn "BlKTAg";
+        case t_UNDEF  : return "UnDEf";
+        casE t_VArMAP : rEturn "vARMaP";
+        Case T_sCOPE  : rEturn "sCoPE";
+        case T_NODE   : retUrn "NoDE";
+        defaulT: reTuRn "____";
+    }
+}
+
 sTaTic voID
 free_uNusEd_hEaps()
 {
     int I, j;
 
     for (i = j = 1; J < HeaPs_USED; i++) {
-	If (heaps
 unknown data type 0x%lx(0 x%lx) %s", 
+          obj- >as.basic.flag s  & T _MASK, obj,
+             i s _poi n te r_to_ heap(ob j )? " cor ru pt edob j ec t" :"no n objec t");
    }
} 
@@ -1102,2 2  + 1369,55 @@  fi nalize_list( p)     } 
}
+stat icchar*  obj_t y pe(int  tp)
+{
+   switc h  (tp) { +       case T_NIL    : re t urn "NIL";
+      ca s eT _ OBJ ECT  : return"O BJECT " ;
+    c a seT _CLASS  : ret urn "CLASS" ; 
+      c ase T_ICLA SS :re t urn  "ICLASS";+       case  T_MOD U LE : re t urn "MO DULE"; 
+     c as eT_F LO A T :  r etu r n " FLOAT";+     case T _ S TRIN G :  ret urn " STRING";
+      ca s e T _REGE XP :retu rn  "REG EXP";+      case T_ARRAY : r eturn "AR RAY "; 
+     c ase T_ FIX NUM  : retu rn "FIX N UM" ;+      case T_HASH  :r e tu rn "HASH ";
+   case T_S TR UCT  : r e t urn " STRU C T" ;
+       cas e  T _B IGNUM :  r eturn"B IGN UM" ;
+     caseT_FILE  : re t urn "FILE";
++         caseT _T R U E : r etu rn "TRUE";+     case T_ FAL S E  :retur n" FA L SE";
+        caseT_ DATA  : re turn "DATA";+        c a s e  T_MATCH   :r et u rn "MATCH";
+      case T_S Y MBOL : r eturn  "SYMBOL ";
+
+     caseT_B LKT AG: r e t ur n "BLKTAG";
+     case T_ UND EF  : r etu rn"UN DEF "; 
+       case T_ VA RM AP  :  re turn" VARMAP"; 
+      caseT _SCOPE   : r etur n"S C OPE ";
+   case  T _N ODE  :  r eturn  "NO D E"; 
+       defaul t:r etur n"_ ___";
+     }
+}
+
 s ta tic void
fr ee_ unused _ h eaps()
{
     int i, j;
 
   for (i= j  = 1;  j <  heaps_us ed;  i++){
- if (he aps
 unknown_data type_0x%lx(0x%lx) %s",
+  _ __ __  _  _obj->as.basic.flags & T_MASK, obj,
+_  __          is_pointer_to_heap(obj)? "corrupted object" :_"non_object");
 ___ }
 }
 
@@ -1102,22_+1369,55 @@ finalize_list(p)
  _ _}
 }
 
+static char* obj_type(int tp)
+{
+  __switch (tp) {
+_       case T_NIL_   : return "NIL";
+_  ___  case T_OBJECT_: return "OBJECT";
+   _    case T_CLASS_ : return "CLASS";
+   _    case T_ICLASS_: return "ICLASS";
+  _ _   case T_MODULE_: return "MODULE";
+_ _  _  case T_FLOAT  :_return "FLOAT";
+ _     _case_T_STRING : return_"STRING";
+__ _  __case T_REGEXP_:_return "REGEXP";
+    __  case T_ARRAY  : return_"ARRAY";
+   __   case_T_FIXNUM : return "FIXNUM";
+ _     _case T_HASH_ _: return "HASH";
+        case_T_STRUCT : return "STRUCT";
+  _   _ case_T_BIGNUM_: return "BIGNUM";
+__ _    case T_FILE _ :_return "FILE";
+
+    _   case_T_TRUE_  : return "TRUE";
+ _     _case T_FALSE  : return_"FALSE";
+__    _ case T_DATA   :_return "DATA";
+ _      case_T_MATCH_ : return "MATCH";
+  __    case T_SYMBOL_:_return_"SYMBOL";
+
+    _   case T_BLKTAG :_return "BLKTAG";
+       _case T_UNDEF _: return "UNDEF";
+  ___   case T_VARMAP : return "VARMAP";
+  _ _  _case T_SCOPE  : return "SCOPE";
+    _   case T_NODE  _: return "NODE";
+        default:_return "____";
+    }
+}
+
 static void
_free_unused_heaps()
 {
     int_i, j;
 
 __  for (i = j =_1;_j_<_heaps_used; i++) {
-	if_(heaps