home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTDBUG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  6.2 KB  |  223 lines
  1. /*
  2.  *    c-tree debug help
  3.  *
  4.  *    This program is the CONFIDENTIAL and PROPRIETARY property 
  5.  *    of FairCom(R) Corporation. Any unauthorized use, reproduction or
  6.  *    transfer of this program is strictly prohibited.
  7.  *
  8.  *      Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989 FairCom Corporation
  9.  *    (Subject to limited distribution and
  10.  *     restricted disclosure only.)
  11.  *    *** ALL RIGHTS RESERVED ***
  12.  *
  13.  *    4006 West Broadway
  14.  *    Columbia, MO 65203
  15.  *
  16.  *
  17.  *    c-tree(R)    Version 4.3
  18.  *            Release C
  19.  *            February 7, 1989 17:30
  20.  *
  21.  */
  22.  
  23. #include "ctstdr.h"        /* standard i/o header         */
  24. #include "ctoptn.h"        /* c-tree configuration options */
  25. #include "cterrc.h"        /* c-tree error codes        */
  26. #include "ctstrc.h"        /* c-tree data structures    */
  27. #include "ctvrec.h"        /* variable length header    */
  28. #include "ctgvar.h"        /* global variable definitions    */
  29.  
  30. CTFILE   *tstfnm();
  31. TREEBUFF *getnod();
  32. COUNT     uerr(),getvhdr();
  33.  
  34. CTFILE   *ctnum,*htnum;
  35. TREEBUFF *buf;
  36. VHDR      vrhdr;
  37.  
  38. COUNT prthdr(filno)
  39. COUNT        filno;
  40. {
  41.     if ((ctnum = tstfnm(filno)) == NULL) {
  42.         printf("\nfile number %d is not active (error %d)\n",
  43.             filno,uerr_cod);
  44.         return(uerr_cod);
  45.     }
  46.     if (ct_key != ct_dat || ct_key != ct_vat) {
  47.         printf(
  48. "\npointers to base of file control structures are clobbered.\n");
  49.         return(-1);
  50.     }
  51.  
  52. printf("\nheader info for file #%d  [%s]:\n",filno,ctnum->flname);
  53. printf("\n    configuration version: %6xx\t           index root ptr: %lxx", 
  54.     ctnum->verson,  ctnum->root);    
  55. printf("\n                node size: %6u \t           node stack ptr: %lxx", 
  56.     ctnum->recsiz,  ctnum->nodstk);  
  57. printf("\n       data record length: %6u \t         extend file size: %u",  
  58.     ctnum->reclen,  ctnum->extsiz);
  59. printf("\n max values per leaf node: %6d \t  max values per non-leaf: %d",
  60.     ctnum->maxkvl,  ctnum->maxkvn);
  61. printf("\n  max bytes per leaf node: %6d \t   max bytes per non-leaf: %d",  
  62.     ctnum->maxkbl,  ctnum->maxkbn);  
  63. printf("\n                file mode: %6d \t               key length: %d",  
  64.     ctnum->flmode,  ctnum->length);  
  65. printf("\n                file type: %6d \t  # of additional members: %d",  
  66.     ctnum->clstyp,  ctnum->nmem);    
  67. printf("\n              update flag: %6xx\t      index member number: %d",  
  68.     ctnum->updflg,  ctnum->kmem);    
  69. #ifdef CT_ANSI
  70. printf("\n                 key type: %6d \t                   stream: %p",
  71. #else
  72. printf("\n                 key type: %6d \t          file descriptor: %d",  
  73. #endif
  74.     ctnum->ktype,   ctnum->fd);      
  75. printf("\n           duplicate flag: %6d \t          lru age counter: %u",  
  76.     ctnum->autodup, ctnum->usecnt);  
  77. printf("\n      # of active entries: %6ld \t         current node ptr: %lxx", 
  78.     ctnum->nument,  ctnum->retnod);  
  79. printf("\n         delete stack ptr: %6lxx\t  current element in node: %d",  
  80.     ctnum->delstk,  ctnum->retelm);  
  81. printf("\n           last byte used: %6lxx\t            serial number: %lxx",  
  82.     ctnum->numrec + 1L,  ctnum->sernum);  
  83. printf("\n       last physical byte: %6lxx\t              file number: %d",  
  84.     ctnum->phyrec + 1L,  ctnum->filnum);  
  85.  
  86.        return(NO_ERROR);
  87. }
  88.  
  89. COUNT prtnod(filno,nodex)
  90. COUNT        filno;
  91. LONG               nodex;
  92. {
  93.     LONG  bytoff;
  94.     COUNT i,j,k;
  95.     TEXT *tp,*sp,ch;
  96.  
  97. #ifdef FLOATKEY
  98.     float  fv;
  99.     double dv;
  100. #endif
  101.  
  102.     LONG  drnpnt(),nodpnt();
  103.     TEXT *valpnt();
  104.  
  105.     if ((ctnum = tstfnm(filno)) == NULL) {
  106.         printf("\nfile number %d is not active (error %d)\n",
  107.             filno,uerr_cod);
  108.         return(uerr_cod);
  109.     }
  110.  
  111.     htnum = ctnum - ctnum->kmem;
  112.  
  113.     if (htnum->clstyp != IDX_CLOSE && htnum->clstyp != VAT_CLOSE) {
  114.         printf("\nFile %s does not have c-tree nodes.\n",
  115.             htnum->flname);
  116.         return(uerr(RMOD_ERR));
  117.     }
  118.  
  119.     if ((htnum->numrec + 1L) < (nodex + htnum->recsiz) || nodex <
  120.         htnum->recsiz || (htnum->clstyp == IDX_CLOSE && 
  121.         (nodex % htnum->recsiz) != 0) || (htnum->clstyp == VAT_CLOSE &&
  122.         (getvhdr(htnum,nodex,&vrhdr) || vrhdr.recmrk != VNOD_FLAG))) {
  123.         printf("\nNode Position %lxx is not a legal offset for a node.\n",
  124.             nodex);
  125.         return(-1);
  126.     }
  127.  
  128.     if ((buf = getnod(nodex,ctnum)) == NULL) {
  129.         printf("\nCould not get node %lxx (error %d).\n",nodex,
  130.             uerr_cod);
  131.         return(uerr_cod);
  132.     }
  133.  
  134.     if (buf->nkv < 0 || (buf->nkv > buf->maxkv && !buf->ktipe) ||
  135.         buf->nkb > buf->maxb) {
  136.         printf(
  137. "\nBadly formed node. Be sure that offset %lxx corresponds to a node.\n",
  138. nodex);
  139.         return(-2);
  140.     }
  141.  
  142.     printf("\n\nNODE: %lxx\n",nodex);
  143.     if (buf->leaf == LEAF)
  144.         printf("\n\tpredecessor node: %lxx",buf->predsr);
  145.     printf("\n\t  successor node: %lxx",buf->sucesr);
  146.     printf("\n\t    # of entries: %d",buf->nkv);
  147.     printf("\n\t      # of bytes: %u",buf->nkb);
  148.     printf("\n\t       leaf flag: %d (0 => non-leaf / 1 => leaf)",buf->leaf);
  149.     printf("\n\t        member #: %d",buf->bmem);
  150.     printf("\n\n\telement  offset   key value");
  151.  
  152.     for (i = 0; i++ < buf->nkv; ) {
  153.         tp = sp = valpnt(buf,i);
  154.         if (buf->leaf == LEAF)
  155.             bytoff = drnpnt(buf,i);
  156.         else
  157.             bytoff = nodpnt(buf,i);
  158.         printf("\n\t  %3d    %6lxx  ",i,bytoff);
  159.         
  160.         if (buf->confg == DUPLEAF)
  161.             k = buf->klen - 4;
  162.         else
  163.             k = buf->klen;
  164.  
  165.         for (j = 0; j++ < k; )
  166.             printf("%2x",0x00ff & *tp++);
  167.         printf("\n\t                  ");
  168.         for (j = 0, tp = sp; j++ < k; ) {
  169.             ch = *tp++;
  170.             if (ch < ' ' || ch > '~')
  171.                 ch = '.';
  172.             printf(" %c",ch);
  173.         }
  174. #ifdef FLOATKEY
  175.         j = NO;
  176.         if (ctnum->ktype == SFLOATKEY) {
  177.             cpybuf(&fv,sp,sizeof(float));
  178. #ifdef UNIFRMAT
  179.             revobj(&fv,sizeof(float));
  180. #endif
  181.             dv = fv;
  182.             j  = YES;
  183.         } else if (ctnum->ktype == DFLOATKEY) {
  184.             cpybuf(&dv,sp,sizeof(double));
  185. #ifdef UNIFRMAT
  186.             revobj(&dv,sizeof(double));
  187. #endif
  188.             j  = YES;
  189.         }
  190.         if (j)
  191.             printf("\n\t                   %e",dv);
  192. #endif
  193.  
  194.     }
  195.     return(NO_ERROR);
  196. }        
  197.  
  198. COUNT chkidx(filno)
  199. COUNT        filno;
  200. {
  201.     COUNT retval;
  202.     LONG  nodpos;
  203.  
  204.     if ((retval = prthdr(filno)) != NO_ERROR)
  205.         return(retval);
  206.  
  207.     printf(
  208. "\n\nNote that internal error 231 is caused by attempting to examine a node");
  209.     printf(
  210. "\nwhich belongs to a different member (than implied by the key number).");
  211.  
  212.     do {
  213.         printf("\n\nEnter node position (in hex): ");
  214.         scanf("%lx",&nodpos);
  215.         if (nodpos != 0L)
  216.             prtnod(filno,nodpos);
  217.     } while (nodpos);
  218.  
  219.     return(NO_ERROR);
  220. }
  221.  
  222. /* end of ctdbug.c */
  223.