home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / DEBUG.C < prev    next >
Text File  |  1996-03-29  |  28KB  |  916 lines
  1. /*****************************************************************************/
  2. /* File:                                             IBM INTERNAL USE ONLY   */
  3. /*   debug.c                                                              822*/
  4. /*                                                                           */
  5. /* Description:                                                              */
  6. /*                                                                           */
  7. /*  Miscellaneous debugging routines.                                        */
  8. /*                                                                           */
  9. /* History:                                                                  */
  10. /*                                                                           */
  11. /*   05/04/93 Created.                                                       */
  12. /*                                                                           */
  13. /*...Release 1.04 (04/30/93)                                                 */
  14. /*...                                                                        */
  15. /*...                                                                        */
  16. /*****************************************************************************/
  17.  
  18. /*****************************************************************************/
  19. /* Includes.                                                                 */
  20. /*****************************************************************************/
  21. #include "all.h"
  22.  
  23. void DumpModuleLoadTable( UINT *pModuleLoadTable )
  24. {
  25.  MODULE_LOAD_ENTRY *p;
  26.  OBJTABLEENTRY     *q = NULL;
  27.  char              *cp;
  28.  UINT               NumModuleEntries;
  29.  int                NumObjectsInTable;
  30.  
  31.  FILE *dmp;
  32.  
  33.  
  34.  if( pModuleLoadTable == NULL )
  35.   return;
  36.  
  37.  dmp = fopen("log.dat","a");
  38.  
  39.  
  40.  NumModuleEntries = *pModuleLoadTable++;
  41.  fprintf(dmp,"\nNum of Modules  =%d\n",NumModuleEntries);
  42.  
  43.  p = (MODULE_LOAD_ENTRY*)pModuleLoadTable;
  44.  for(; NumModuleEntries > 0; NumModuleEntries--,p = (MODULE_LOAD_ENTRY*)q)
  45.  {
  46.   fprintf(dmp,"\nLengthofMteEntry=%d",p->LengthOfMteEntry);
  47.   fprintf(dmp,"\n             mte=%d",p->mte);
  48.   fprintf(dmp,"\nModuleNameLength=%d",p->ModuleNameLength);
  49.   if( p->ModuleNameLength==1 )
  50.    fprintf(dmp,"\n      ModuleName=%s","freed module");
  51.   else
  52.    fprintf(dmp,"\n      ModuleName=%s",p->ModuleName);
  53.  
  54.   cp = (char *)p + sizeof(MODULE_LOAD_ENTRY) - 1 + p->ModuleNameLength;
  55.   q  = (OBJTABLEENTRY*)cp;
  56.  
  57.   NumObjectsInTable = *(int*)q;
  58.   fprintf(dmp,"\nNumObjectsInTable=%d",NumObjectsInTable);
  59.  
  60.   q = (OBJTABLEENTRY*)((cp=(char*)q)+4);
  61.   for( ; NumObjectsInTable > 0; NumObjectsInTable--,q++)
  62.   {
  63.    fprintf(dmp,"\nObjNum=%d ",q->ObjNum);
  64.    fprintf(dmp,"ObjLoadAddr=%#8x ",q->ObjLoadAddr);
  65.    fprintf(dmp,"Sel:Off=%04x:%-04x ",q->ObjLoadSel, q->ObjLoadOff);
  66.    fprintf(dmp,"ObjLoadSize=%#8x  ",q->ObjLoadSize);
  67.    fprintf(dmp,"ObjType=%d  ",q->ObjType);
  68.    fprintf(dmp,"ObjBitness=%d  ",q->ObjBitness);
  69.   }
  70.   fprintf(dmp,"\n");
  71.  }
  72.  fflush(dmp);
  73.  fclose(dmp);
  74. }
  75.  
  76. void DumpMteTable( void *p )
  77. {
  78.  MTE_TABLE_ENTRY *pMteTable = (MTE_TABLE_ENTRY *)p;
  79.  MTE_TABLE_ENTRY *pMteTableEntry;
  80.  FILE *dmp;
  81.  ULONG thismte,lastmte;
  82.  
  83.  if( p == NULL )
  84.   return;
  85.  
  86.  dmp = fopen("log.dat","a");
  87.  
  88.  pMteTableEntry = pMteTable ;
  89.  lastmte = pMteTableEntry->mte;
  90.  
  91.  for( ;
  92.       pMteTable &&
  93.       ( (thismte=pMteTableEntry->mte) != ENDOFTABLE);
  94.       pMteTableEntry++ )
  95.  {
  96.   if( thismte != lastmte )
  97.   {
  98.    fprintf(dmp,"\n");
  99.    lastmte = thismte;
  100.   }
  101.   fprintf(dmp,"\nmte=%-#6x ",pMteTableEntry->mte);
  102.   fprintf(dmp,"Objnum=%-2d ",pMteTableEntry->ObjNum);
  103.   fprintf(dmp,"LoadAddr=%-#8x",pMteTableEntry->LoadAddr);
  104.  }
  105.  fflush(dmp);
  106.  fclose(dmp);
  107. }
  108.  
  109. void DumpPubRec16( void *pPubRec16 )
  110. {
  111.  FILE *dmp;
  112.  
  113.  PUBREC16 *p = (PUBREC16*)pPubRec16;
  114.  
  115.  USHORT ObjNum = p->Pub16Addr.RawAddr.ObjNum;
  116.  USHORT Offset = p->Pub16Addr.RawAddr.Offset;
  117.  USHORT Typeid = p->Typeid;
  118.  UCHAR  Namelen= p->Namelen;
  119.  char   pubname[256];
  120.  
  121.  memset(pubname,0,sizeof(pubname));
  122.  memcpy(pubname, &p->Namelen+1,Namelen);
  123.  
  124.  
  125.  dmp = fopen("log.dat","a");
  126.  fprintf(dmp,"\n %04x:%04x",ObjNum,Offset);
  127.  fprintf(dmp," %04x",Typeid);
  128.  fprintf(dmp," %s",pubname);
  129.  
  130.  fflush(dmp);
  131.  fclose(dmp);
  132. }
  133. /*****************************************************************************/
  134. /* Dump the object tables attached to the pdf structures.                    */
  135. /*                                                                           */
  136. /*                                                                           */
  137. /*****************************************************************************/
  138.  
  139. extern PROCESS_NODE *pnode;
  140.  
  141. void DumpObjectTable( DEBFILE *pdf )
  142. {
  143.  OBJTABLEENTRY     *q = NULL;
  144.  int                NumObjectsInTable;
  145.  
  146.  FILE *dmp;
  147.  dmp = fopen("log.dat","a");
  148.  
  149.  q  = (OBJTABLEENTRY*)pdf->CodeObjs;
  150.  
  151.  NumObjectsInTable = *(int*)q;
  152.  fprintf(dmp,"\nModuleName=%s",pdf->DebFilePtr->fn);
  153.  fprintf(dmp,"\nNumObjectsInTable=%d",NumObjectsInTable);
  154.  
  155.  q = (OBJTABLEENTRY*)( (char*)q + 4 );
  156.  for( ; NumObjectsInTable > 0; NumObjectsInTable--,q++)
  157.  {
  158.   fprintf(dmp,"\nObjNum=%d ",q->ObjNum);
  159.   fprintf(dmp,"ObjLoadAddr=%#8x ",q->ObjLoadAddr);
  160.   fprintf(dmp,"ObjLoadSize=%#8x  ",q->ObjLoadSize);
  161.   fprintf(dmp,"ObjType=%d  ",q->ObjType);
  162.   fprintf(dmp,"ObjBitness=%d  ",q->ObjBitness);
  163.  }
  164.  fprintf(dmp,"\n");
  165.  
  166.  fflush(dmp);
  167.  fclose(dmp);
  168. }
  169.  
  170.  
  171.  
  172. static UCHAR  AlreadyOpen=0;
  173.  
  174. /*****************************************************************************/
  175. /* Dump the unwind tables.                                                   */
  176. /*                                                                           */
  177. /*                                                                           */
  178. /*****************************************************************************/
  179. extern uint          NActFrames;
  180. extern uchar         ActCSAtrs[];       /* 0=>16-bit frame 1=>32-bit      107*/
  181. extern uint          ActFrames[];       /* value of frame pointer (bp)       */
  182. extern uint          ActFaddrs[];       /* value of return "EIP" on stack 107*/
  183. extern uint          ActFlines[MAXAFRAMES][2]; /* mid, lno for ActFaddrs  107*/
  184. extern SCOPE         ActScopes[];       /* (mid,ssproc) for ...              */
  185.  
  186. void DumpUnwindTables( void )
  187. {
  188.  int n;
  189.  
  190.  FILE *dmp;
  191.  
  192.   if( AlreadyOpen )
  193.     dmp = fopen("log.dat","a");
  194.   else
  195.   {
  196.     dmp = fopen("log.dat","w");
  197.     AlreadyOpen = 1;
  198.   }
  199.  for( n=0; n< NActFrames; n++)
  200.  {
  201.   fprintf(dmp,"\nActCSAtrs[%2d]=%#4x ",n,ActCSAtrs[n]);
  202.   fprintf(dmp,"\nActFrames[%2d]=%#8x ",n,ActFrames[n]);
  203.   fprintf(dmp,"\nActFaddrs[%2d]=%#8x ",n,ActFaddrs[n]);
  204.   fprintf(dmp,"\nActFrames[%2d]/mid=%3d ",n,ActFlines[n][0]);
  205.   fprintf(dmp,"\nActFrames[%2d]/lno=%3d ",n,ActFlines[n][1]);
  206.   fprintf(dmp,"\nActScopes[%2d]=%#8x ",n,ActScopes[n]);
  207.   fprintf(dmp,"\n");
  208.  }
  209.  fflush(dmp);
  210.  fclose(dmp);
  211. }
  212.  
  213.  
  214. /*****************************************************************************/
  215. /* Dump the instruction cache                                                */
  216. /*                                                                           */
  217. /*                                                                           */
  218. /*****************************************************************************/
  219. void DumpCache( INSTR *icache)
  220. {
  221.  int n=0;
  222.  
  223.  
  224.  FILE *dmp;
  225.  dmp = fopen("log.dat","a");
  226.  while( icache[n].instaddr != ENDOFCACHE )
  227.  {
  228. /*fprintf(dmp,"\n%4d instaddr=%#8x ",n, icache[n].instaddr);fflush(0);*/
  229.    printf(    "\n%4d instaddr=%#8x ",n, icache[n].instaddr);fflush(0);
  230.   n++;
  231.  }
  232.  fflush(dmp);
  233.  fclose(dmp);
  234. }
  235.  
  236. void DumpSourceLineCache( UINT  *SourceLineCache)
  237. {
  238.  int n=0;
  239.  
  240.  
  241.  FILE *dmp;
  242.  dmp = fopen("logx.dat","a");
  243.  while( SourceLineCache[n] != ENDOFTABLE )
  244.  {
  245.   fprintf(dmp,"\n%6d lno=%d ",n,SourceLineCache[n]);fflush(0);
  246.   n++;
  247.  }
  248.  fflush(dmp);
  249.  fclose(dmp);
  250. }
  251.  
  252. /*****************************************************************************/
  253. /* Dump break points.                                                        */
  254. /*                                                                           */
  255. /*****************************************************************************/
  256. void DumpBrks( BRK *p)
  257. {
  258.  uchar *q;
  259.  uint nbytes;
  260.  
  261.  FILE *dmp;
  262.  dmp = fopen("log.dat","a");
  263.  
  264.  fprintf(dmp,"\n\n");
  265.  for( ;p;p=p->next )
  266.  {
  267.   fprintf(dmp,"\nbrkat=%#8x ",p->brkat);
  268.   q=Getnbytes(p->brkat,1,&nbytes);
  269.   fprintf(dmp,"opcode=%2x ",*q);
  270.  }
  271.  fflush(dmp);
  272.  fclose(dmp);
  273. }
  274.  
  275. void DumpModuleStructure( void *mptr )
  276. {
  277.  
  278.  FILE *dmp;
  279.  MODULE *p  = (MODULE *)mptr;
  280.  CSECT  *pc = p->pCsects;
  281.  
  282.  dmp = fopen("log.dat","a");
  283.  fprintf(dmp,"\n mid=%d",p->mid);
  284. #if 0
  285.  fprintf(dmp,"\n Filename       =%08x",p->FileName);
  286.  fprintf(dmp,"\n Publics        =%08x",p->Publics);
  287.  fprintf(dmp,"\n PubLen         =%08x",p->PubLen);
  288.  fprintf(dmp,"\n TypeDefs       =%08x",p->TypeDefs);
  289.  fprintf(dmp,"\n TypeLen        =%08x",p->TypeLen);
  290.  fprintf(dmp,"\n Symbols        =%08x",p->Symbols);
  291.  fprintf(dmp,"\n Symlen         =%08x",p->SymLen);
  292.  fprintf(dmp,"\n LineNums       =%08x",p->LineNums);
  293.  fprintf(dmp,"\n LineNumsLen    =%08x",p->LineNumsLen);
  294.  fprintf(dmp,"\n Format/Pubs    =%d",p->DbgFormatFlags.Pubs);
  295.  fprintf(dmp,"\n Format/Syms    =%d",p->DbgFormatFlags.Syms);
  296.  fprintf(dmp,"\n Format/Lins    =%d",p->DbgFormatFlags.Lins);
  297.  fprintf(dmp,"\n Format/Typs    =%d",p->DbgFormatFlags.Typs);
  298.  fprintf(dmp,"\n");
  299. #endif
  300.  while(pc)
  301.  {
  302.   fprintf(dmp,"\n");
  303.   fprintf(dmp,"\n      Segnum      =%10d", pc->SegNum     );
  304.   fprintf(dmp,"\n      SegFlatAddr =%10x", pc->SegFlatAddr);
  305.   fprintf(dmp,"\n      CsectLo     =%10x", pc->CsectLo    );
  306.   fprintf(dmp,"\n      CsectHi     =%10x", pc->CsectHi    );
  307.   fprintf(dmp,"\n      CsectSize   =%10x", pc->CsectSize  );
  308.   fprintf(dmp,"\n      NumEntries  =%10d", pc->NumEntries );
  309.   fprintf(dmp,"\n");
  310.  
  311.   pc = pc->next;
  312.  }
  313.  
  314.  fflush(dmp);
  315.  fclose(dmp);
  316.  
  317. }
  318.  
  319. void DumpCsectMap( MODULE* pm, CSECTMAP *pmap, int type )
  320. {
  321.  
  322.  FILE     *dmp;
  323.  CSECT    *pCsect;
  324.  CSECTMAP *pc;
  325.  void     *pf;
  326.  
  327.  dmp = fopen("log.dat","a");
  328.  fprintf(dmp,"\n mid=%d",pm->mid);
  329.  for( pCsect = pm->pCsects; pCsect != NULL; pCsect=pCsect->next )
  330.  {
  331.   fprintf(dmp,"\n");
  332.   fprintf(dmp,"\n     Segnum      =%10d", pCsect->SegNum     );
  333.   fprintf(dmp,"\n     SegFlatAddr =%10x", pCsect->SegFlatAddr);
  334.   fprintf(dmp,"\n     CsectLo     =%10x", pCsect->CsectLo    );
  335.   fprintf(dmp,"\n     CsectHi     =%10x", pCsect->CsectHi    );
  336.   fprintf(dmp,"\n     CsectSize   =%10x", pCsect->CsectSize  );
  337.   fprintf(dmp,"\n     NumEntries  =%10d", pCsect->NumEntries );
  338.   pc = pmap;
  339.   while(pc)
  340.   {
  341.    if( pc->pCsect == pCsect )
  342.    {
  343.     pf = pc->pFirstEntry;
  344.     switch( type )
  345.     {
  346.      case TYPE10B_HL04:
  347.      {
  348.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_HL04*)pf)->NumEntries);
  349.       fprintf(dmp,"\n      SegmentNumber =%10d", ((FIRST_ENTRY_HL04*)pf)->SegNum    );
  350.       fprintf(dmp,"\n      BaseOffset    =%10x", ((FIRST_ENTRY_HL04*)pf)->BaseOffset);
  351.       fprintf(dmp,"\n");
  352.      }
  353.      break;
  354.  
  355.      case TYPE10B_HL03:
  356.      {
  357.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_HL03*)pf)->NumEntries);
  358.       fprintf(dmp,"\n      SegmentNumber =%10d", ((FIRST_ENTRY_HL03*)pf)->SegNum    );
  359.       fprintf(dmp,"\n");
  360.      }
  361.      break;
  362.  
  363.      case TYPE10B_HL01:
  364.      {
  365.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_HL01*)pf)->NumEntries);
  366.       fprintf(dmp,"\n");
  367.      }
  368.      break;
  369.  
  370.      case TYPE109_16:
  371.      {
  372.       UCHAR *pFileName = pc->pFirstEntry;
  373.  
  374.  
  375.       pf = pFileName + *pFileName + 1;
  376.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_109_16*)pf)->NumEntries);
  377.       fprintf(dmp,"\n      SegmentNumber =%10d", ((FIRST_ENTRY_109_16*)pf)->SegNum    );
  378.       fprintf(dmp,"\n");
  379.      }
  380.      break;
  381.  
  382.      case TYPE109_32:
  383.      {
  384.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_109_32*)pf)->NumEntries);
  385.       fprintf(dmp,"\n      SegmentNumber =%10d", ((FIRST_ENTRY_109_32*)pf)->SegNum    );
  386.       fprintf(dmp,"\n");
  387.      }
  388.      break;
  389.  
  390.      case TYPE105:
  391.      {
  392.       UCHAR *pFileName = pc->pFirstEntry;
  393.  
  394.  
  395.       pf = pFileName + *pFileName + 1;
  396.       fprintf(dmp,"\n      NumEntries    =%10d", ((FIRST_ENTRY_105*)pf)->NumEntries);
  397.       fprintf(dmp,"\n      sfi           =%10d", pc->mssfi);
  398.       fprintf(dmp,"\n");
  399.      }
  400.      break;
  401.     }
  402.    }
  403.    pc = pc->next;
  404.   }
  405.  }
  406.  fflush(dmp);
  407.  fclose(dmp);
  408.  
  409. }
  410.  
  411. void DumpAfileStructure( void *fp   )
  412. {
  413.  FILE *dmp;
  414.  
  415.  AFILE *p = (AFILE *)fp;
  416.  
  417.   if( AlreadyOpen )
  418.     dmp = fopen("log.dat","a");
  419.   else
  420.   {
  421.     dmp = fopen("log.dat","w");
  422.     AlreadyOpen = 1;
  423.   }
  424.  fprintf(dmp,"\n mid            =%d",  p->mid);
  425.  fprintf(dmp,"\n Tlines         =%d",  p->Tlines);
  426.  fprintf(dmp,"\n Nlines         =%d",  p->Nlines );
  427.  fprintf(dmp,"\n Nbias          =%d",  p->Nbias);
  428.  fprintf(dmp,"\n topline        =%d",  p->topline);
  429.  fprintf(dmp,"\n csrline        =%d",  p->csrline);
  430.  fprintf(dmp,"\n hotline        =%d",  p->hotline);
  431.  fprintf(dmp,"\n hotaddr        =%08x",p->hotaddr);
  432.  fprintf(dmp,"\n skipcols       =%d",  p->skipcols);
  433.  fprintf(dmp,"\n Nshown         =%d",  p->Nshown);
  434.  fprintf(dmp,"\n topoff         =%08x",p->topoff);
  435.  fprintf(dmp,"\n csr.col        =%d",  p->csr.col);
  436.  fprintf(dmp,"\n csr.row        =%d",  p->csr.row);
  437.  fprintf(dmp,"\n");
  438.  fflush(dmp);
  439.  fclose(dmp);
  440. }
  441.  
  442. void DumpINSTRStructure( void *pinstr )
  443. {
  444.  FILE *dmp;
  445.  
  446.  INSTR *p = (INSTR *)pinstr;
  447.  
  448.   if( AlreadyOpen )
  449.     dmp = fopen("log.dat","a");
  450.   else
  451.   {
  452.     dmp = fopen("log.dat","w");
  453.     AlreadyOpen = 1;
  454.     fprintf(dmp,"\n");
  455.     fprintf(dmp,"instaddr  ");
  456.     fprintf(dmp,"len       ");
  457.     fprintf(dmp,"mod_type  ");
  458.     fprintf(dmp,"type      ");
  459.     fprintf(dmp,"opsize    ");
  460.     fprintf(dmp,"reg       ");
  461.     fprintf(dmp,"offset    ");
  462.     fprintf(dmp,"seg       ");
  463.     fprintf(dmp,"base      ");
  464.     fprintf(dmp,"index     ");
  465.     fprintf(dmp,"scale     ");
  466.   }
  467.  
  468.  fprintf(dmp,"\n");
  469.  fprintf(dmp,"%-10x",  p->instaddr );
  470.  fprintf(dmp,"%-10d",  p->len      );
  471.  fprintf(dmp,"%-10d",  p->mod_type );
  472.  fprintf(dmp,"%-10d",  p->type     );
  473.  fprintf(dmp,"%-10d",  p->OpSize   );
  474.  fprintf(dmp,"%-10d",  p->reg      );
  475.  fprintf(dmp,"%-10x",  p->offset   );
  476.  fprintf(dmp,"%-10d",  p->seg      );
  477.  fprintf(dmp,"%-10d",  p->base     );
  478.  fprintf(dmp,"%-10d",  p->index    );
  479.  fprintf(dmp,"%-10d",  p->scale    );
  480.  fflush(dmp);
  481.  fclose(dmp);
  482. }
  483.  
  484. void DumpTSTATEStructure( void *ptstate )
  485. {
  486.  FILE *dmp;
  487.  
  488.  TSTATE *p = (TSTATE *)ptstate;
  489.  
  490.   if( AlreadyOpen )
  491.     dmp = fopen("log.dat","a");
  492.   else
  493.   {
  494.     dmp = fopen("log.dat","w");
  495.     AlreadyOpen = 1;
  496.     fprintf(dmp,"\n");
  497.     fprintf(dmp,"DbgState  ");
  498.     fprintf(dmp,"ThdState  ");
  499.     fprintf(dmp,"Priority  ");
  500.     fprintf(dmp,"tid       ");
  501.   }
  502.  
  503.  fprintf(dmp,"\n");
  504.  fprintf(dmp,"%-10x",  p->ts.DebugState );
  505.  fprintf(dmp,"%-10d",  p->ts.ThreadState  );
  506.  fprintf(dmp,"%-10d",  p->ts.Priority );
  507.  fprintf(dmp,"%-10d",  p->tid      );
  508.  fflush(dmp);
  509.  fclose(dmp);
  510. }
  511.  
  512. void DumpString( void *cp   )
  513. {
  514.  FILE *dmp;
  515.  
  516.  
  517.   if( AlreadyOpen )
  518.     dmp = fopen("log.dat","a");
  519.   else
  520.   {
  521.     dmp = fopen("log.dat","w");
  522.     AlreadyOpen = 1;
  523.   }
  524.  fprintf(dmp,"\n %s", cp);
  525.  fflush(dmp);
  526.  fclose(dmp);
  527. }
  528.  
  529. #if 0
  530. void DumpFILE( void *fp )
  531. {
  532.  FILE *dmp;
  533.  
  534.  FILE *p = (FILE *)fp;
  535.  
  536.   if( AlreadyOpen )
  537.     dmp = fopen("logx.dat","a");
  538.   else
  539.   {
  540.     dmp = fopen("logx.dat","w");
  541.     AlreadyOpen = 1;
  542.     fprintf(dmp,"\n");
  543.     fprintf(dmp,"bufPtr    ");
  544.     fprintf(dmp,"count     ");
  545.     fprintf(dmp,"userFlags ");
  546.     fprintf(dmp,"bufLen    ");
  547.     fprintf(dmp,"ungetCount");
  548.     fprintf(dmp,"tempStore ");
  549.     fprintf(dmp,"ungetbf[0]");
  550.     fprintf(dmp,"ungetbf[1]");
  551.     fprintf(dmp,"lastOp    ");
  552.     fprintf(dmp,"filler    ");
  553.   }
  554.  
  555.  fprintf(dmp,"\n");
  556.  fprintf(dmp,"%-10p",  p->bufPtr   );
  557.  fprintf(dmp,"%-10d",  p->count    );
  558.  fprintf(dmp,"%-10x",  p->userFlags);
  559.  fprintf(dmp,"%-10d",  p->bufLen   );
  560.  fprintf(dmp,"%-10d",  p->ungetCount);
  561.  fprintf(dmp,"%-10d",  p->tempStore);
  562.  fprintf(dmp,"%-10d",  p->ungetBuf[0]);
  563.  fprintf(dmp,"%-10d",  p->ungetBuf[1]);
  564.  fprintf(dmp,"%-10d",  p->lastOp   );
  565.  fprintf(dmp,"%-10d",  p->filler   );
  566.  fflush(dmp);
  567.  fclose(dmp);
  568. }
  569. void DumpEntryList( void *p,int type )
  570. {
  571.   FILE *dmp;
  572.   extern ULONG __pFirstAllocMem;
  573.   extern ULONG __pLastAllocMem;
  574.   extern ULONG __pFirstFree;
  575.   ULONG pu = (ULONG)p;
  576.   ULONG *pe = (ULONG*)0x1e0000;
  577.  
  578.  
  579.   if( AlreadyOpen )
  580.     dmp = fopen("logx.dat","a");
  581.   else
  582.   {
  583.     dmp = fopen("logx.dat","w");
  584.     AlreadyOpen = 1;
  585.     fprintf(dmp,"\n");
  586.     fprintf(dmp,"type            ");
  587.     fprintf(dmp,"pFirstFree      ");
  588.     fprintf(dmp,"pLastAllocMem   ");
  589.     fprintf(dmp,"pFirstAllocMem  ");
  590.   }
  591.  
  592.  fprintf(dmp,"\n");
  593.  if( type == 1 )
  594.   fprintf(dmp,"alloc(%-9x)",pu);
  595.  else
  596.   fprintf(dmp,"free (%-9x)",pu);
  597.  
  598.  fprintf(dmp,"%-16x",__pFirstFree    );
  599.  fprintf(dmp,"%-16x",__pLastAllocMem );
  600.  fprintf(dmp,"%-16x",__pFirstAllocMem);
  601.  
  602.  for(;;)
  603.  {
  604.   fprintf(dmp,"\n");
  605.        fprintf(dmp,"%-010x",pe   );
  606.        fprintf(dmp,"%-010x",*pe );
  607.   pe++;fprintf(dmp,"%-010x",*pe );
  608.   pe++;fprintf(dmp,"%-010x",*pe );
  609.   pe++;fprintf(dmp,"%-010x",*pe );
  610.   if( *pe == 0 )
  611.    break;
  612.   pe++;
  613.  }
  614.  
  615.  fprintf(dmp,"\n");
  616.  fflush(dmp);
  617.  fclose(dmp);
  618. }
  619. /*---------------------------------------------------------------------*/
  620.  
  621. typedef struct
  622. {
  623.  int   msgnum;
  624.  char *msg;
  625. }ESPQ_MSG;
  626.  
  627. static ESPQ_MSG  EspMsg[] =
  628. {
  629.  ESP_QMSG_END_SESSION    , "Esp_Qmsg_End_Session"    ,
  630.  ESP_QMSG_NEW_SESSION    , "Esp_Qmsg_New_Session"    ,
  631.  ESP_QMSG_CTRL_BREAK     , "Esp_Qmsg_Ctrl_Break"     ,
  632.  ESP_QMSG_DISCONNECT     , "Esp_Qmsg_Disconnect"     ,
  633.  ESP_QMSG_CONNECT_REQUEST, "Esp_Qmsg_Connect_Request",
  634.  ESP_QMSG_QUE_TERM       , "Esp_Qmsg_Que_Term"       ,
  635.  ESP_QMSG_ERROR          , "Esp_Qmsg_Error"          ,
  636.  ESP_QMSG_EMPTY          , "Esp_Qmsg_Empty"          ,
  637.  ESP_QMSG_NEW_PROCESS    , "Esp_Qmsg_New_Process"    ,
  638.  ESP_QMSG_OPEN_CONNECT   , "Esp_Qmsg_OpenConnect"    ,
  639.  ESP_QMSG_SELECT_SESSION , "Esp_Qmsg_Select_Session" ,
  640.  ESP_QMSG_SELECT_ESP     , "Esp_Qmsg_Select_Esp"     ,
  641.  ESP_QMSG_PARENT_TERM    , "Esp_Qmsg_Parent_Term"    ,
  642.  ESP_QMSG_CHILD_TERM     , "Esp_Qmsg_Child_Term"     ,
  643.   -1 , ""
  644. };
  645.  
  646. void DumpQue( void *p,void *q)
  647. {
  648.  PREQUESTDATA     pqr = (PREQUESTDATA)p;
  649.  ESP_QUE_ELEMENT *pqe = (ESP_QUE_ELEMENT*)q;
  650.  FILE            *dmp;
  651.  int              i;
  652.  ESPQ_MSG          *pmsg;
  653.  
  654.   if( AlreadyOpen )
  655.     dmp = fopen("log.dat","a");
  656.   else
  657.   {
  658.     dmp = fopen("log.dat","w");
  659.     AlreadyOpen = 1;
  660.     fprintf(dmp,"\n");
  661.     fprintf(dmp,"msg                  ");
  662.     fprintf(dmp,"RqPid  ");
  663.     fprintf(dmp,"Rqdata ");
  664.     fprintf(dmp,"Ppid  ");
  665.     fprintf(dmp,"Pid   ");
  666.     fprintf(dmp,"Psid  ");
  667.     fprintf(dmp,"Sid   ");
  668.   }
  669.  
  670.  fprintf(dmp,"\n");
  671.  for( i = 0 , pmsg = EspMsg; pmsg[i].msgnum != -1 ; i++ )
  672.  {
  673.   if( (pqr->ulData == pmsg[i].msgnum ) )
  674.   {
  675.    fprintf(dmp,"%-21s",  pmsg[i].msg );
  676.    break;
  677.   }
  678.  }
  679.  fprintf(dmp,"%-07x",  pqr->pid );
  680.  fprintf(dmp,"%-07x",  pqr->ulData );
  681.  
  682.  
  683.  if( pqe )
  684.  {
  685.   fprintf(dmp,"%-06x",  pqe->ParentPid );
  686.   fprintf(dmp,"%-06x",  pqe->ChildPid );
  687.   fprintf(dmp,"%-06x",  pqe->ParentSid );
  688.   fprintf(dmp,"%-06x",  pqe->ChildSid );
  689.  }
  690.  
  691.  if( pqe == NULL )
  692.  {
  693.   fflush(dmp);
  694.   fclose(dmp);
  695.   return;
  696.  }
  697.  
  698. {
  699.  #define BUFFER_SIZE 64*1024-1
  700.  
  701.  char      ModuleName[CCHMAXPATH];
  702.  void     *pProcStatBuf;
  703.  ULONG     flags;
  704.  
  705.  ULONG     pid = pqe->ChildPid;
  706.  
  707.  qsPrec_t        *pProcRec  = NULL;     /* ptr to process record section     */
  708.  qsS16Headrec_t  *p16SemRec = NULL;     /* ptr to 16 bit sem section         */
  709.  
  710.  /****************************************************************************/
  711.  /* - Allocate a 64k buffer. This is the recommended size since a large      */
  712.  /*   system may generate this much. It's allocated on a 64k boundary        */
  713.  /*   because DosQprocStatus() is a 16 bit call and we don't want the        */
  714.  /*   buffer to overlap a 64k boundary.                                      */
  715.  /****************************************************************************/
  716.  flags = PAG_COMMIT|PAG_READ|PAG_WRITE|OBJ_TILE;
  717.  DosAllocMem( &pProcStatBuf,BUFFER_SIZE,flags);
  718.  DosQProcStatus( (ULONG*)pProcStatBuf , BUFFER_SIZE );
  719.  
  720.  /****************************************************************************/
  721.  /* Define a pointer to the process subsection of information.               */
  722.  /****************************************************************************/
  723.  pProcRec   = (qsPrec_t       *)((qsPtrRec_t*)pProcStatBuf)->pProcRec;
  724.  p16SemRec  = (qsS16Headrec_t *)((qsPtrRec_t*)pProcStatBuf)->p16SemRec;
  725.  
  726.  /****************************************************************************/
  727.  /* - scan to the proc record for the pid.                                   */
  728.  /****************************************************************************/
  729.  for( ;pProcRec->pid != pid; )
  730.  {
  731.   /****************************************************************************/
  732.   /* Get a pointer to the next process block and test for past end of block.  */
  733.   /****************************************************************************/
  734.   pProcRec = (qsPrec_t *)( (char*)(pProcRec->pThrdRec) +
  735.                                   (pProcRec->cTCB)*sizeof(qsTrec_t));
  736.  
  737.   if((void*)pProcRec >= (void*)p16SemRec )
  738.   {
  739.    pProcRec = NULL;
  740.    break;
  741.   }
  742.  }
  743.  
  744.  /****************************************************************************/
  745.  /* - now get the module name for this pid.                                  */
  746.  /* - scan the block of names checking to see if this is one of              */
  747.  /*   the child processes that we want to debug.                             */
  748.  /* - the names may be in one of the following formats:                      */
  749.  /*                                                                          */
  750.  /*      1. case1                                                            */
  751.  /*      2. case1.exe                                                        */
  752.  /*      3. d:\path1\path2\case1                                             */
  753.  /*      4. d:\path1\path2\case1.exe                                         */
  754.  /*                                                                          */
  755.  /* - copy a name from the name block into a local buffer.                   */
  756.  /* - append a .exe if needed.                                               */
  757.  /* - if the exe name contains a path then perform an explicit compare.      */
  758.  /* - if the exe name does not contain a path, then only compare it to       */
  759.  /*   name part of the module name.                                          */
  760.  /*                                                                          */
  761.  /****************************************************************************/
  762.  if(pProcRec != NULL )
  763.  {
  764.   memset(ModuleName,' ',sizeof(ModuleName) );
  765.   DosQueryModuleName(pProcRec->hMte,sizeof(ModuleName),ModuleName);
  766.   fprintf(dmp,"%s", ModuleName );
  767.  }
  768. }
  769.  fflush(dmp);
  770.  fclose(dmp);
  771.  
  772. }
  773. #endif
  774.  
  775. void DumpLineNums( MODULE *pModule )
  776. {
  777.  int       n;
  778.  LNOTAB   *p;
  779.  USHORT    NumEntries;
  780.  CSECT    *pCsect;
  781.  FILENAME *pFile;
  782.  
  783.  FILE *dmp;
  784.  dmp = fopen("log.dat","a");
  785.  
  786.  fprintf(dmp,"\n\nmid       =%d ",pModule->mid);
  787.  for( pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  788.  {
  789.   NumEntries = pCsect->NumEntries;
  790.   p          = pCsect->pLnoTab;
  791.   fprintf(dmp,"\nNumEntries=%d", NumEntries );
  792.   fprintf(dmp,"\n       sfi       lno       off");
  793.   for( n=0; n < NumEntries; n++,p++)
  794.   {
  795.    fprintf(dmp,"\n%10d%10d%10x",p->sfi, p->lno, p->off);
  796.   }
  797.  }
  798.  
  799.  pFile = pModule->pFiles;
  800.  for( ; pFile; pFile=pFile->next )
  801.  {
  802.   fprintf(dmp,"\n%d, %s", pFile->sfi, (char*)(pFile->FileName) + 1 );
  803.  }
  804.  
  805.  fflush(dmp);
  806.  fclose(dmp);
  807. }
  808.  
  809. /*****************************************************************************/
  810. /* - dump the internal class/struct record.                                  */
  811. /*****************************************************************************/
  812. void DumpClassRecord( TD_CLASS *pClassRecord )
  813. {
  814.  char  bigname[500];
  815.  char *cp;
  816.  
  817.  printf("\n");
  818.  printf("\nRecLen        =%d", pClassRecord->RecLen);
  819.  printf("\nRecType       =%x", pClassRecord->RecType);
  820.  printf("\nByteSize      =%d", pClassRecord->ByteSize);
  821.  printf("\nNumMembers    =%d", pClassRecord->NumMembers);
  822.  printf("\nItemListIndex =%d", pClassRecord->ItemListIndex);
  823.  
  824.  memset(bigname, 0, sizeof(bigname));
  825.  
  826.  strncpy( bigname, pClassRecord->Name, pClassRecord->NameLen );
  827.  
  828.  printf("\nName=         = %d,%s", pClassRecord->NameLen, bigname );
  829. }
  830.  
  831. /*****************************************************************************/
  832. /* - dump the internal class/struct record.                                  */
  833. /*****************************************************************************/
  834. void DumpMemFncRecord( TD_MEMFNC *pIntMemFnc )
  835. {
  836.  char  bigname[500];
  837.  char *cp;
  838.  
  839.  printf("\n");
  840.  printf("\nRecLen        =%d", pIntMemFnc->RecLen      );
  841.  printf("\nRecType       =%x", pIntMemFnc->RecType     );
  842.  printf("\nTypeQual      =%x", pIntMemFnc->TypeQual    );
  843.  printf("\nProtection    =%x", pIntMemFnc->Protection  );
  844.  printf("\nFuncType      =%d", pIntMemFnc->FuncType    );
  845.  printf("\nSubRecIndex   =%d", pIntMemFnc->SubRecIndex );
  846.  printf("\nvTableIndex   =%d", pIntMemFnc->vTableIndex );
  847.  printf("\nNameLen       =%d", pIntMemFnc->NameLen     );
  848.  
  849.  memset(bigname, 0, sizeof(bigname));
  850.  
  851.  strncpy( bigname, pIntMemFnc->Name, pIntMemFnc->NameLen );
  852.  
  853.  printf("\nName=         = %d,%s", pIntMemFnc->NameLen, bigname );
  854. }
  855.  
  856. /*****************************************************************************/
  857. /* - dump the internal class member record.                                  */
  858. /*****************************************************************************/
  859. void DumpClsMemRecord( TD_CLSMEM *pIntClsMem )
  860. {
  861.  char  bigname[500];
  862.  char *cp;
  863.  char *pName;
  864.  int   NameLen;
  865.  
  866.  printf("\n");
  867.  printf("\nRecLen        =%d", pIntClsMem->RecLen      );
  868.  printf("\nRecType       =%x", pIntClsMem->RecType     );
  869.  printf("\nTypeQual      =%x", pIntClsMem->TypeQual    );
  870.  printf("\nProtection    =%x", pIntClsMem->Protection  );
  871.  printf("\nTypeIndex     =%d", pIntClsMem->TypeIndex   );
  872.  printf("\nOffset        =%x", pIntClsMem->Offset      );
  873.  printf("\nNameLen       =%d", pIntClsMem->NameLen     );
  874.  
  875.  NameLen = pIntClsMem->NameLen;
  876.  pName   = pIntClsMem->Name;
  877.  if( pIntClsMem->TypeQual & 0x01 )
  878.  {
  879.   memset(bigname, 0, sizeof(bigname));
  880.  
  881.   strncpy( bigname, pName, NameLen );
  882.  
  883.   printf("\nStaticName=%d,%s", NameLen, bigname );
  884.  
  885.   pName += NameLen;
  886.   NameLen = *(USHORT*)pName;
  887.   pName += 2;
  888.  }
  889.  
  890.  memset(bigname, 0, sizeof(bigname));
  891.  
  892.  strncpy( bigname, pName, NameLen );
  893.  
  894.  printf("\nMemberName=%d,%s", NameLen, bigname );
  895. }
  896.  
  897. /*****************************************************************************/
  898. /* - dump the internal class member record.                                  */
  899. /*****************************************************************************/
  900. void DumpBseClsRecord( TD_BSECLS *pIntBseCls )
  901. {
  902.  char  bigname[500];
  903.  char *cp;
  904.  char *pName;
  905.  int   NameLen;
  906.  
  907.  printf("\n");
  908.  printf("\nRecLen        =%d", pIntBseCls->RecLen      );
  909.  printf("\nRecType       =%x", pIntBseCls->RecType     );
  910.  printf("\nTypeQual      =%x", pIntBseCls->TypeQual    );
  911.  printf("\nProtection    =%x", pIntBseCls->Protection  );
  912.  printf("\nTypeIndex     =%d", pIntBseCls->TypeIndex   );
  913.  printf("\nOffset        =%x", pIntBseCls->Offset      );
  914. }
  915.  
  916.