home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / LINNUM.C < prev    next >
C/C++ Source or Header  |  1996-08-27  |  132KB  |  2,838 lines
  1. /*****************************************************************************/
  2. /* File:                                                                     */
  3. /*                                                                           */
  4. /*   linnum.c                                                                */
  5. /*                                                                           */
  6. /* Description:                                                              */
  7. /*                                                                           */
  8. /*   Line number table interface functions.                                  */
  9. /*                                                                           */
  10. /* History:                                                                  */
  11. /*                                                                           */
  12. /*   04/10/95 Updated.                                                       */
  13. /*                                                                           */
  14. /*****************************************************************************/
  15.  
  16. #include "all.h"
  17.  
  18. /*****************************************************************************/
  19. /* DBGetLnoTab                                                               */
  20. /*                                                                           */
  21. /* Description:                                                              */
  22. /*                                                                           */
  23. /*   Get pointer to a module's lineno table.                                 */
  24. /*                                                                           */
  25. /* Parameters:                                                               */
  26. /*                                                                           */
  27. /*   mid        module(compile unit) we want the table for.                  */
  28. /*                                                                           */
  29. /* Return:                                                                   */
  30. /*                                                                           */
  31. /* Assumptions:                                                              */
  32. /*                                                                           */
  33. /*****************************************************************************/
  34. void DBGetLnoTab( ULONG mid )
  35. {
  36.  UCHAR    LnoFlag;
  37.  MODULE  *pModule;
  38.  DEBFILE *pdf;
  39.  
  40.  pdf     = DBFindPdf( mid );
  41.  pModule = GetPtrToModule( mid, pdf );
  42.  LnoFlag = pModule->DbgFormatFlags.Lins;
  43.  switch( LnoFlag )
  44.  {
  45.   case TYPE10B_HL01:
  46.    BuildHL01Tables( pModule, pdf );
  47.    break;
  48.  
  49.   case TYPE10B_HL02: /* not supported any more/never released*/
  50.   case TYPE10B_HL03:
  51.    BuildHL03Tables( pModule, pdf );
  52.    break;
  53.  
  54.   case TYPE10B_HL04:
  55.    BuildHL04Tables( pModule, pdf );
  56.    break;
  57.  
  58.   case TYPE105:
  59.    Build105Tables( pModule, pdf );
  60.    break;
  61.  
  62.   case TYPE109_32:
  63.    Build109_32Tables( pModule, pdf );
  64.    break;
  65.  
  66.   case TYPE109_16:
  67.    Build109_16Tables( pModule, pdf );
  68.    break;
  69.  }
  70. }
  71.  
  72. /*****************************************************************************/
  73. /* DBMapInstAddr                                                             */
  74. /*                                                                           */
  75. /* Description:                                                              */
  76. /*                                                                           */
  77. /*   get mid and line number table entry for the instruction address.        */
  78. /*                                                                           */
  79. /* Parameters:                                                               */
  80. /*                                                                           */
  81. /*   address       instruction address.                                      */
  82. /*   ppLnoTabEntry receiver of a ptr to the line number table entry          */
  83. /*                 containing this address.                                  */
  84. /*   pdf                                                                     */
  85. /*                                                                           */
  86. /* Return:                                                                   */
  87. /*                                                                           */
  88. /*   mid        module id containing the address.                            */
  89. /*              0 ==> not found.                                             */
  90. /*                                                                           */
  91. /*****************************************************************************/
  92. ULONG DBMapInstAddr( ULONG address, LNOTAB **ppLnoTabEntry ,DEBFILE *pdf )
  93. {
  94.  MODULE *pModule;
  95.  CSECT  *pCsect;
  96.  ULONG   mid;
  97.  
  98.  pModule = GetModuleWithAddr( address, pdf );
  99.  
  100.  if( (pModule != NULL) &&
  101.      (pModule->LineNums != 0) &&
  102.      (pModule->modflags.LnoTabLoaded == FALSE) )
  103.  {
  104.   DBGetLnoTab( pModule->mid );
  105.   pModule->modflags.LnoTabLoaded = TRUE;
  106.  }
  107.  
  108.  pCsect = GetCsectWithAddr( pModule,  address );
  109.  
  110.  *ppLnoTabEntry = NULL;
  111.  if( pCsect )
  112.   *ppLnoTabEntry = GetLnoWithAddr( pCsect, address );
  113.  
  114.  mid = 0;
  115.  if( pModule )
  116.   mid = pModule->mid;
  117.  return(mid);
  118. }
  119.  
  120. /*****************************************************************************/
  121. /* DBMapLno                                                                  */
  122. /*                                                                           */
  123. /* Description:                                                              */
  124. /*                                                                           */
  125. /*   get the base and span of a line or module.                              */
  126. /*                                                                           */
  127. /* Parameters:                                                               */
  128. /*                                                                           */
  129. /*   mid        - module id.                                                 */
  130. /*   lno        - line number  for line number info.                         */
  131. /*                0 for module info.                                         */
  132. /*   sfi        - source file(index) containing the line number.             */
  133. /*   span       - where to put the span of line or module.                   */
  134. /*   pdf                                                                     */
  135. /*                                                                           */
  136. /* Return:                                                                   */
  137. /*                                                                           */
  138. /*   BaseAddr   if lno  = 0, returns Flat base address of csect and          */
  139. /*                           size of the csect.                              */
  140. /*              if lno != 0, returns Flat base address of line in module     */
  141. /*                           and the span of the line.                       */
  142. /*              no find lno, return NULL and span = 0;                       */
  143. /*                                                                           */
  144. /*                                                                           */
  145. /* Assumptions:                                                              */
  146. /*                                                                           */
  147. /*****************************************************************************/
  148. ULONG DBMapLno( ULONG mid, int lno, int sfi, ULONG *span , DEBFILE *pdf )
  149. {
  150.  MODULE *pModule;
  151.  LNOTAB *pLnoTabEntry;
  152.  ULONG   BaseAddr;
  153.  
  154.  /****************************************************************************/
  155.  /* - load the line number table if it hasn't been loaded.                   */
  156.  /****************************************************************************/
  157.  pModule = GetPtrToModule( mid, pdf );
  158.  if( (pModule == NULL)           ||
  159.      (pModule->LineNums == 0)    ||
  160.      (pModule->LineNumsLen == 0)
  161.    )
  162.  {
  163.   *span    = 0;
  164.   BaseAddr = 0;
  165.  }
  166.  
  167.  /****************************************************************************/
  168.  /* - load the line number table if not yet loaded.                          */
  169.  /****************************************************************************/
  170.  if( pModule->modflags.LnoTabLoaded == FALSE )
  171.  {
  172.   DBGetLnoTab( pModule->mid );
  173.   pModule->modflags.LnoTabLoaded = TRUE;
  174.  }
  175.  
  176.  if( lno != 0 )
  177.  {
  178.   pLnoTabEntry = GetLnoTabEntry( pModule, lno, sfi );
  179.   if( pLnoTabEntry != NULL )
  180.   {
  181.    BaseAddr = pLnoTabEntry->off;
  182.    *span    = GetLineSpan( pModule, pLnoTabEntry);
  183.   }
  184.   else
  185.   {
  186.    BaseAddr = 0;
  187.    *span    = 0;
  188.   }
  189.  }
  190.  else if( lno == 0 )
  191.  {
  192.   BaseAddr     = 0;
  193.   pLnoTabEntry = GetLnoTabEntry( pModule, 0, sfi );
  194.   if( pLnoTabEntry )
  195.    BaseAddr = pLnoTabEntry->off;
  196.  }
  197.  return(BaseAddr);
  198. }
  199.  
  200. /*****************************************************************************/
  201. /*  DBMapNonExLine()                                                         */
  202. /*                                                                           */
  203. /* Description:                                                              */
  204. /*                                                                           */
  205. /*   Map a non-executable line number to an executable line number.          */
  206. /*                                                                           */
  207. /* Parameters:                                                               */
  208. /*                                                                           */
  209. /*   mid                                                                     */
  210. /*   lno        non-executable line number.                                  */
  211. /*   sfi        source file containing the line number.                      */
  212. /*   pdf                                                                     */
  213. /*                                                                           */
  214. /* Return:                                                                   */
  215. /*                                                                           */
  216. /*   BaseAddr   address of the mapped executable line.                       */
  217. /*                                                                           */
  218. /* Assumptions                                                               */
  219. /*                                                                           */
  220. /*****************************************************************************/
  221. ULONG DBMapNonExLine( ULONG mid, int lno, int sfi, DEBFILE *pdf )
  222. {
  223.  MODULE *pModule;
  224.  LNOTAB *pLnoTabEntry;
  225.  ULONG   BaseAddr;
  226.  
  227.  pModule = GetPtrToModule( mid, pdf );
  228.  
  229.  if( pModule == NULL )
  230.   return(0);
  231.  
  232.  pLnoTabEntry = GetLnoTabNextEntry( pModule, lno, sfi );
  233.  
  234.  BaseAddr = 0;
  235.  if( pLnoTabEntry != NULL )
  236.   BaseAddr = pLnoTabEntry->off;
  237.  
  238.  return(BaseAddr);
  239. }
  240.  
  241. /*****************************************************************************/
  242. /* GetSourceFileIndex()                                                      */
  243. /*                                                                           */
  244. /* Description:                                                              */
  245. /*                                                                           */
  246. /*   Get the sfi for a mid and filename. The filename does not include       */
  247. /*   path info.                                                              */
  248. /*                                                                           */
  249. /* Parameters:                                                               */
  250. /*                                                                           */
  251. /*   mid        module defining file table to search.                        */
  252. /*   pFileName  -> the filename we're looking for.                           */
  253. /*                                                                           */
  254. /* Return:                                                                   */
  255. /*                                                                           */
  256. /*   sfi        index of the source file if found.                           */
  257. /*              0 if not found.                                              */
  258. /*                                                                           */
  259. /* Assumptions:                                                              */
  260. /*                                                                           */
  261. /*   pFileName is a length-prefixed z-string.                                */
  262. /*                                                                           */
  263. /*****************************************************************************/
  264. int GetSourceFileIndex( ULONG mid, UCHAR *pFileName )
  265. {
  266.  MODULE   *pModule;
  267.  UCHAR     LnoFlag;
  268.  int       sfi;
  269.  FILENAME *pFile;
  270.  
  271.  pModule = GetPtrToModule( mid, NULL );
  272.  if(pModule == NULL)
  273.   return(0);
  274.  
  275.  /****************************************************************************/
  276.  /* - scan the loaded file name tables first.                                */
  277.  /****************************************************************************/
  278.  sfi = 0;
  279.  for( pFile = pModule->pFiles; pFile != NULL; pFile=pFile->next )
  280.  {
  281.   int   len;
  282.   char *cp;
  283.   char *cpp;
  284.  
  285.   cp  = pFile->FileName;
  286.   cpp = strrchr( cp+1, '\\' );
  287.  
  288.   if( cpp == NULL )
  289.   {
  290.    /**************************************************************************/
  291.    /* - come here if no path info.                                           */
  292.    /**************************************************************************/
  293.    len = *cp;
  294.    if( (len == *pFileName) && (strnicmp(pFileName, cp, len+1) == 0) )
  295.    {
  296.     sfi = pFile->sfi;
  297.     break;
  298.    }
  299.   }
  300.   else
  301.   {
  302.    /**************************************************************************/
  303.    /* - come here if there is path info.                                     */
  304.    /**************************************************************************/
  305.    cpp =  strrchr( cp+1, '\\' );
  306.    cpp = cpp + 1;
  307.    len = *cp -(cpp-cp) + 1;
  308.    if( (len == *pFileName) && (strnicmp(pFileName+1, cpp, len) == 0) )
  309.    {
  310.     sfi = pFile->sfi;
  311.     break;
  312.    }
  313.   }
  314.  }
  315.  if( sfi != 0 )
  316.   return(sfi);
  317.  
  318.  /****************************************************************************/
  319.  /* - if we haven't found it at this point, then go look in the files        */
  320.  /*   defined in the line number tables.                                     */
  321.  /****************************************************************************/
  322.  LnoFlag = pModule->DbgFormatFlags.Lins;
  323.  switch( LnoFlag )
  324.  {
  325.   case TYPE10B_HL01:
  326.    sfi =  GetHL01Sfi( mid, pFileName );
  327.    break;
  328.  
  329.   case TYPE10B_HL02:                  /* not supported/never released      */
  330.   case TYPE10B_HL03:
  331.    sfi =  GetHL03Sfi( mid, pFileName );
  332.    break;
  333.  
  334.   case TYPE10B_HL04:
  335.    sfi = GetHL04Sfi( mid, pFileName );
  336.    break;
  337.  
  338.   case TYPE105:
  339.    sfi = Get105Sfi( mid, pFileName );
  340.    break;
  341.  
  342.   case TYPE109_32:
  343.    sfi = Get109_32Sfi( mid, pFileName );
  344.    break;
  345.  
  346.   case TYPE109_16:
  347.    sfi = Get109_16Sfi( mid, pFileName );
  348.    break;
  349.  }
  350.  return(sfi);
  351. }
  352.  
  353. /*****************************************************************************/
  354. /* MapSourceFileToMidSfi()                                                   */
  355. /*                                                                           */
  356. /* Description:                                                              */
  357. /*                                                                           */
  358. /*   Find the mid for a given source file name.                              */
  359. /*                                                                           */
  360. /* Parameters:                                                               */
  361. /*                                                                           */
  362. /*   pFileName  -> to the source file name.                                  */
  363. /*   psfi       -> to the receiver of the sfi.                               */
  364. /*   pdf                                                                     */
  365. /*                                                                           */
  366. /* Return:                                                                   */
  367. /*                                                                           */
  368. /*   mid                                                                     */
  369. /*                                                                           */
  370. /* Assumptions:                                                              */
  371. /*                                                                           */
  372. /*****************************************************************************/
  373. ULONG MapSourceFileToMidSfi( char *pSourceFileName, int *psfi, DEBFILE *pdf )
  374. {
  375.  MODULE *pModule;
  376.  ULONG   mid;
  377.  int     sfi;
  378.  
  379.  sfi = mid = 0;
  380.  for( pModule = pdf->MidAnchor; pModule != NULL ; pModule=pModule->NextMod)
  381.  {
  382.   sfi = GetSourceFileIndex( pModule->mid, pSourceFileName );
  383.   if( sfi )
  384.   {
  385.    mid = pModule->mid;
  386.    break;
  387.   }
  388.  }
  389.  *psfi = sfi;
  390.  return(mid);
  391. }
  392.  
  393. /*****************************************************************************/
  394. /* BuildHL04Tables()                                                         */
  395. /*                                                                           */
  396. /* Description:                                                              */
  397. /*                                                                           */
  398. /*   Build the HL04 tables.                                                  */
  399. /*                                                                           */
  400. /* Parameters:                                                               */
  401. /*                                                                           */
  402. /*   pModule                                                                 */
  403. /*   pdf                                                                     */
  404. /*                                                                           */
  405. /* Return:                                                                   */
  406. /*                                                                           */
  407. /*****************************************************************************/
  408. void BuildHL04Tables(  MODULE *pModule, DEBFILE *pdf )
  409. {
  410.  HEADER_HL04       *pHeader;
  411.  ULONG              lfo;
  412.  ULONG              lfoend;
  413.  ULONG              LineNumberTableSize;
  414.  FIRST_ENTRY_HL04  *pFirstEntry;
  415.  CSECTMAP          *pCsectMap = NULL;
  416.  CSECTMAP          *pmap;
  417.  CSECTMAP          *pnextmap;
  418.  UCHAR             *pTablePtr;
  419.  USHORT             NumEntries;
  420.  CSECT             *pCsect;
  421.  UCHAR             *pLineNumberTable;
  422.  UCHAR             *pTable;
  423.  UCHAR             *pTableEnd;
  424.  UCHAR             *pFileNameTable;
  425.  ULONG              BaseOffset;
  426.  ULONG              MteLoadAddr;
  427.  ULONG              CsectLo;
  428.  ULONG              CsectHi;
  429.  
  430.  MteLoadAddr = GetLoadAddr( pdf->mte, 1 );
  431.  
  432.  /****************************************************************************/
  433.  /* - define long file offsets for the start and end of the table.           */
  434.  /****************************************************************************/
  435.  lfo    = pdf->DebugOff + pModule->LineNums;
  436.  lfoend = lfo + pModule->LineNumsLen - 1;
  437.  
  438.  /****************************************************************************/
  439.  /* - now read the rest of the file into memory.                             */
  440.  /****************************************************************************/
  441.  LineNumberTableSize = lfoend - lfo + 1;
  442.  pLineNumberTable    = Talloc( LineNumberTableSize );
  443.  
  444.  seekf(pdf, lfo);
  445.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  446.  
  447.  /****************************************************************************/
  448.  /* - Scan the line number table and build  a map of the the table(s) to     */
  449.  /*   csects.                                                                */
  450.  /****************************************************************************/
  451.  pHeader     = (HEADER_HL04 *)pLineNumberTable;
  452.  pTable      = pLineNumberTable + sizeof(HEADER_HL04) +
  453.                pHeader->FileNameTableSize;
  454.  
  455.  pTableEnd   = pLineNumberTable + LineNumberTableSize;
  456.  pFirstEntry = (FIRST_ENTRY_HL04 *)pTable;
  457.  pmap        = (CSECTMAP *)&pCsectMap;
  458.  
  459.  for( ; pTable < pTableEnd; )
  460.  {
  461.   NumEntries = pFirstEntry->NumEntries;
  462.   BaseOffset = pFirstEntry->BaseOffset;
  463.  
  464.   /***************************************************************************/
  465.   /* - find the Csect that this table section maps to.                       */
  466.   /***************************************************************************/
  467.   for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  468.   {
  469.    CsectLo = pCsect->CsectLo - MteLoadAddr + 0x10000;
  470.    CsectHi = pCsect->CsectHi - MteLoadAddr + 0x10000;
  471.  
  472.    if( (BaseOffset >= CsectLo) &&
  473.        (BaseOffset <= CsectHi)
  474.      )
  475.     break;
  476.   }
  477.  
  478.   if( pCsect )
  479.   {
  480.    pmap->next              = (CSECTMAP*)Talloc(sizeof(CSECTMAP));
  481.    pmap->next->pFirstEntry = pFirstEntry;
  482.    pmap->next->pCsect      = pCsect;
  483.    pmap->next->NumEntries  = NumEntries;
  484.    pmap                    = pmap->next;
  485.   }
  486.  
  487.   pTable = pTable + sizeof(FIRST_ENTRY_HL04) +
  488.                      NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL04);
  489.  
  490.   pFirstEntry =  (FIRST_ENTRY_HL04 *)pTable;
  491.  }
  492.  
  493.  /****************************************************************************/
  494.  /* - At this point, we have built a map of table sections to csects.        */
  495.  /* - For each Csect, scan the map and count the number of entries           */
  496.  /*   that will be in the line number table for that Csect.                  */
  497.  /****************************************************************************/
  498.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  499.  {
  500.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  501.   {
  502.    if(pmap->pCsect == pCsect)
  503.     pCsect->NumEntries += pmap->NumEntries; /* call func to get real count */
  504.   }
  505.  }
  506.  
  507. /*---------------------------------------------------------------------------*/
  508. /* - dump the map of line number tables to csects.                           */
  509. /*****************************************************************************/
  510. // DumpCsectMap( pModule, pCsectMap, TYPE10B_HL04 );
  511. /*---------------------------------------------------------------------------*/
  512.  
  513.  /****************************************************************************/
  514.  /* - Now, scan the Csects, allocate the table, and map the entries to       */
  515.  /*   the table.                                                             */
  516.  /****************************************************************************/
  517.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  518.  {
  519.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  520.   pTablePtr = (UCHAR*)pCsect->pLnoTab;
  521.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  522.   {
  523.    if(pmap->pCsect == pCsect)
  524.    {
  525.     pTablePtr  = AppendHL04Table( (LNOTAB *)pTablePtr, pmap->pFirstEntry,
  526.                                   MteLoadAddr );
  527.    }
  528.   }
  529.  }
  530.  
  531.  /****************************************************************************/
  532.  /* - Now, scan the Csects and build the file names list for the source      */
  533.  /*   file indexes that appear in the table.                                 */
  534.  /****************************************************************************/
  535.  pFileNameTable = pLineNumberTable + sizeof(HEADER_HL04) +
  536.                   sizeof(FILE_NAME_TABLE_ENTRY_HL04) - 1;
  537.  
  538.  AddFileNames( pModule, pFileNameTable );
  539.  
  540. /*---------------------------------------------------------------------------*/
  541. /* - dump the map of line number tables to csects.                           */
  542. /*****************************************************************************/
  543. // DumpLineNums( pModule );
  544. /*---------------------------------------------------------------------------*/
  545.  
  546.  /****************************************************************************/
  547.  /* - At this point, the line number table has been mapped to the Csect      */
  548.  /*   tables.                                                                */
  549.  /* - So, we can free the map.                                               */
  550.  /* - And, we can free the bulk table.                                       */
  551.  /****************************************************************************/
  552.  for( pmap = pCsectMap ; pmap ; pmap = pnextmap )
  553.   {pnextmap = pmap->next; Tfree(pmap);}
  554.  
  555.  if(pLineNumberTable) Tfree(pLineNumberTable);
  556. }
  557.  
  558. /*****************************************************************************/
  559. /* BuildHL03Tables()                                                         */
  560. /*                                                                           */
  561. /* Description:                                                              */
  562. /*                                                                           */
  563. /*   Build the HL03 tables.                                                  */
  564. /*                                                                           */
  565. /* Parameters:                                                               */
  566. /*                                                                           */
  567. /*   pModule                                                                 */
  568. /*   pdf                                                                     */
  569. /*                                                                           */
  570. /* Return:                                                                   */
  571. /*                                                                           */
  572. /*****************************************************************************/
  573. void BuildHL03Tables(  MODULE *pModule, DEBFILE *pdf )
  574. {
  575.  ULONG             lfo;
  576.  ULONG             lfoend;
  577.  ULONG             LineNumberTableSize;
  578.  FIRST_ENTRY_HL03 *pFirstEntry;
  579.  CSECTMAP         *pCsectMap = NULL;
  580.  CSECTMAP         *pmap;
  581.  CSECTMAP         *pnextmap;
  582.  UCHAR            *pTablePtr;
  583.  USHORT            NumEntries;
  584.  CSECT            *pCsect;
  585.  UCHAR            *pLineNumberTable;
  586.  UCHAR            *pTable;
  587.  UCHAR            *pTableEnd;
  588.  UCHAR            *pFileNameTable;
  589.  
  590.  /****************************************************************************/
  591.  /* - define long file offsets for the start and end of the table.           */
  592.  /****************************************************************************/
  593.  lfo    = pdf->DebugOff + pModule->LineNums;
  594.  lfoend = lfo + pModule->LineNumsLen - 1;
  595.  
  596.  /****************************************************************************/
  597.  /* - now read the rest of the file into memory.                             */
  598.  /****************************************************************************/
  599.  LineNumberTableSize = lfoend - lfo + 1;
  600.  pLineNumberTable    = Talloc( LineNumberTableSize );
  601.  
  602.  seekf(pdf, lfo);
  603.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  604.  
  605.  /****************************************************************************/
  606.  /* - Scan the line number table and build  a map of the the table(s) to     */
  607.  /*   csects.                                                                */
  608.  /****************************************************************************/
  609.  pFirstEntry = (FIRST_ENTRY_HL03 *)pLineNumberTable;
  610.  pTable      = pLineNumberTable;
  611.  pTableEnd   = pLineNumberTable + LineNumberTableSize;
  612.  pmap        = (CSECTMAP *)&pCsectMap;
  613.  
  614.  for( ; pTable < pTableEnd; )
  615.  {
  616.   NumEntries = pFirstEntry->NumEntries;
  617.  
  618.   /***************************************************************************/
  619.   /* - find the Csect that this table section maps to.                       */
  620.   /***************************************************************************/
  621.   for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  622.   {
  623.    if( pCsect->SegNum == pFirstEntry->SegNum )
  624.     break;
  625.   }
  626.  
  627.   if( pCsect )
  628.   {
  629.    pmap->next              = (CSECTMAP*)Talloc(sizeof(CSECTMAP));
  630.    pmap->next->pFirstEntry = pFirstEntry;
  631.    pmap->next->pCsect      = pCsect;
  632.    pmap->next->NumEntries  = NumEntries;
  633.    pmap                    = pmap->next;
  634.   }
  635.  
  636.   pTable = pTable + sizeof(FIRST_ENTRY_HL03) +
  637.                     NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL03) +
  638.                     pFirstEntry->FileNameTableSize;
  639.  
  640.   pFirstEntry =  (FIRST_ENTRY_HL03 *)pTable;
  641.  }
  642.  
  643.  /****************************************************************************/
  644.  /* - At this point, we have built a map of table sections to csects.        */
  645.  /* - For each Csect, scan the map and count the number of entries           */
  646.  /*   that will be in the line number table for that Csect.                  */
  647.  /****************************************************************************/
  648.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  649.  {
  650.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  651.   {
  652.    if(pmap->pCsect == pCsect)
  653.     pCsect->NumEntries += pmap->NumEntries; /* call func to get real count */
  654.   }
  655.  }
  656.  
  657. /*---------------------------------------------------------------------------*/
  658. /* - dump the map of line number tables to csects.                           */
  659. /*****************************************************************************/
  660. // DumpCsectMap( pModule, pCsectMap, TYPE10B_HL03 );
  661. /*---------------------------------------------------------------------------*/
  662.  
  663.  /****************************************************************************/
  664.  /* - Now, scan the Csects, allocate the table, and map the entries to       */
  665.  /*   the table.                                                             */
  666.  /****************************************************************************/
  667.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  668.  {
  669.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  670.   pTablePtr = (UCHAR*)pCsect->pLnoTab;
  671.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  672.   {
  673.    if(pmap->pCsect == pCsect)
  674.    {
  675.     pTablePtr = AppendHL03Table((LNOTAB *)pTablePtr,
  676.                                 pmap->pFirstEntry, pCsect->CsectLo);
  677.    }
  678.   }
  679.  }
  680.  
  681.  /****************************************************************************/
  682.  /* - Now, scan the Csects and build the file names list for the source      */
  683.  /*   file indexes that appear in the table.                                 */
  684.  /****************************************************************************/
  685.  pFirstEntry    = (FIRST_ENTRY_HL03 *)pLineNumberTable;
  686.  NumEntries     = pFirstEntry->NumEntries;
  687.  pFileNameTable = pLineNumberTable + sizeof(FIRST_ENTRY_HL03) +
  688.                   NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL03) +
  689.                   sizeof(FILE_NAME_TABLE_ENTRY_HL03) - 1;
  690.  
  691.  AddFileNames( pModule, pFileNameTable );
  692.  
  693. /*---------------------------------------------------------------------------*/
  694. /* - dump the map of line number tables to csects.                           */
  695. /*****************************************************************************/
  696. // DumpLineNums( pModule );
  697. /*---------------------------------------------------------------------------*/
  698.  
  699.  /****************************************************************************/
  700.  /* - At this point, the line number table has been mapped to the Csect      */
  701.  /*   tables.                                                                */
  702.  /* - So, we can free the map.                                               */
  703.  /* - And, we can free the bulk table.                                       */
  704.  /****************************************************************************/
  705.  for( pmap = pCsectMap ; pmap ; pmap = pnextmap )
  706.   {pnextmap = pmap->next; Tfree(pmap);}
  707.  
  708.  if(pLineNumberTable) Tfree(pLineNumberTable);
  709. }
  710.  
  711. /*****************************************************************************/
  712. /* BuildHL01Tables()                                                         */
  713. /*                                                                           */
  714. /* Description:                                                              */
  715. /*                                                                           */
  716. /*   Build the HL01 tables.                                                  */
  717. /*                                                                           */
  718. /* Parameters:                                                               */
  719. /*                                                                           */
  720. /*   pModule                                                                 */
  721. /*   pdf                                                                     */
  722. /*                                                                           */
  723. /* Return:                                                                   */
  724. /*                                                                           */
  725. /*****************************************************************************/
  726. void BuildHL01Tables(  MODULE *pModule, DEBFILE *pdf )
  727. {
  728.  ULONG             lfo;
  729.  ULONG             lfoend;
  730.  ULONG             LineNumberTableSize;
  731.  FIRST_ENTRY_HL01 *pFirstEntry;
  732.  UCHAR            *pTablePtr;
  733.  USHORT            NumEntries;
  734.  CSECT            *pCsect;
  735.  
  736.  UCHAR            *pLineNumberTable;
  737.  UCHAR            *pFileNameTable;
  738.  
  739.  /****************************************************************************/
  740.  /* - define long file offsets for the start and end of the table.           */
  741.  /* - move the file pointer to the start of the table.                       */
  742.  /* - read the first entry in the table.                                     */
  743.  /* - define the number of entries in the table.                             */
  744.  /* - compute the size of the table.                                         */
  745.  /* - then, read it.                                                         */
  746.  /****************************************************************************/
  747.  lfo    = pdf->DebugOff + pModule->LineNums;
  748.  lfoend = lfo + pModule->LineNumsLen - 1;
  749.  
  750.  LineNumberTableSize = lfoend - lfo + 1;
  751.  pLineNumberTable    = Talloc( LineNumberTableSize );
  752.  
  753.  seekf(pdf, lfo);
  754.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  755.  
  756.  /***************************************************************************/
  757.  /* - There is only one HL01 table and it is "assumed" to map to            */
  758.  /*   the first Csect listed for the module.                                */
  759.  /***************************************************************************/
  760.  pFirstEntry = (FIRST_ENTRY_HL01 *)pLineNumberTable;
  761.  
  762.  pCsect      = pModule->pCsects;
  763.  
  764.  if( pCsect )
  765.  {
  766.   pCsect->NumEntries = pFirstEntry->NumEntries;
  767.  }
  768.  
  769.  /****************************************************************************/
  770.  /* - Now, allocate the table and map the entries to the table.              */
  771.  /****************************************************************************/
  772.  pCsect = pModule->pCsects;
  773.  if( pCsect )
  774.  {
  775.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  776.   pTablePtr       = (UCHAR*)pCsect->pLnoTab;
  777.  
  778.   AppendHL01Table( (LNOTAB *)pTablePtr, pFirstEntry, pCsect->CsectLo );
  779.  }
  780.  
  781.  /****************************************************************************/
  782.  /* - Now, scan the Csects and build the file names list for the source      */
  783.  /*   file indexes that appear in the table.                                 */
  784.  /****************************************************************************/
  785.  NumEntries      =  pFirstEntry->NumEntries;
  786.  pFileNameTable  =  (char*)pLineNumberTable + sizeof(FIRST_ENTRY_HL01);
  787.  pFileNameTable += NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL01);
  788.  pFileNameTable += sizeof(FILE_NAME_TABLE_ENTRY_HL01) - 1;
  789.  
  790.  AddFileNames( pModule, pFileNameTable );
  791.  
  792. /*---------------------------------------------------------------------------*/
  793. /* - dump the map of line number tables to csects.                           */
  794. /*****************************************************************************/
  795. // DumpLineNums( pModule );
  796. /*---------------------------------------------------------------------------*/
  797.  
  798.  /****************************************************************************/
  799.  /* - free the bulk table.                                                   */
  800.  /****************************************************************************/
  801.  if(pLineNumberTable) Tfree(pLineNumberTable);
  802. }
  803.  
  804. /*****************************************************************************/
  805. /* Build109_16Tables()                                                       */
  806. /*                                                                           */
  807. /* Description:                                                              */
  808. /*                                                                           */
  809. /*   Build the 109_16.                                                       */
  810. /*                                                                           */
  811. /* Parameters:                                                               */
  812. /*                                                                           */
  813. /*   pModule                                                                 */
  814. /*   pdf                                                                     */
  815. /*                                                                           */
  816. /* Return:                                                                   */
  817. /*                                                                           */
  818. /*****************************************************************************/
  819. void Build109_16Tables(  MODULE *pModule, DEBFILE *pdf )
  820. {
  821.  ULONG               lfo;
  822.  ULONG               lfoend;
  823.  ULONG               LineNumberTableSize;
  824.  FIRST_ENTRY_109_16 *pFirstEntry;
  825.  CSECTMAP           *pCsectMap = NULL;
  826.  CSECTMAP           *pmap;
  827.  CSECTMAP           *pnextmap;
  828.  UCHAR              *pTablePtr;
  829.  USHORT              NumEntries;
  830.  CSECT              *pCsect;
  831.  UCHAR              *pLineNumberTable;
  832.  UCHAR              *pTable;
  833.  UCHAR              *pTableEnd;
  834.  int                 FileNameLen;
  835.  int                 sfi;
  836.  UCHAR              *pFileName;
  837.  
  838.  /****************************************************************************/
  839.  /* - define long file offsets for the start and end of the table.           */
  840.  /* - read the line number table into memory.                                */
  841.  /****************************************************************************/
  842.  lfo    = pdf->DebugOff + pModule->LineNums;
  843.  lfoend = lfo + pModule->LineNumsLen - 1;
  844.  
  845.  LineNumberTableSize = lfoend - lfo + 1;
  846.  pLineNumberTable    = Talloc( LineNumberTableSize );
  847.  
  848.  seekf(pdf, lfo);
  849.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  850.  
  851.  /****************************************************************************/
  852.  /* - Scan the line number table and build  a map of the the table(s) to     */
  853.  /*   csects.                                                                */
  854.  /****************************************************************************/
  855.  pTable       = pLineNumberTable;
  856.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  857.  pmap         = (CSECTMAP *)&pCsectMap;
  858.  
  859.  /****************************************************************************/
  860.  /* - Move past the first file name                                          */
  861.  /****************************************************************************/
  862.  
  863.  for( ; pTable < pTableEnd; )
  864.  {
  865.   FileNameLen = *pTable;
  866.   pFirstEntry = (FIRST_ENTRY_109_16*)(pTable + FileNameLen + 1);
  867.   NumEntries  = pFirstEntry->NumEntries;
  868.  
  869.   /***************************************************************************/
  870.   /* - find the Csect that this table section maps to.                       */
  871.   /***************************************************************************/
  872.   for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  873.   {
  874.    if( pCsect->SegNum == pFirstEntry->SegNum )
  875.     break;
  876.   }
  877.  
  878.   if( pCsect )
  879.   {
  880.    pmap->next              = (CSECTMAP*)Talloc(sizeof(CSECTMAP));
  881.    pmap->next->pFirstEntry = pTable;
  882.    pmap->next->pCsect      = pCsect;
  883.    pmap->next->NumEntries  = NumEntries;
  884.    pmap                    = pmap->next;
  885.   }
  886.  
  887.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_109_16) +
  888.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_109_16);
  889.  }
  890.  
  891.  /****************************************************************************/
  892.  /* - At this point, we have built a map of table sections to csects.        */
  893.  /* - For each Csect, scan the map and count the number of entries           */
  894.  /*   that will be in the line number table for that Csect.                  */
  895.  /****************************************************************************/
  896.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  897.  {
  898.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  899.   {
  900.    if(pmap->pCsect == pCsect)
  901.     pCsect->NumEntries += pmap->NumEntries; /* call func to get real count */
  902.   }
  903.  }
  904.  
  905.  /****************************************************************************/
  906.  /* - Add some "contrived" source file indexes for MS style tables.          */
  907.  /****************************************************************************/
  908.  if( pModule->pCsects )
  909.   MakeSfis( pCsectMap );
  910.  
  911. /*---------------------------------------------------------------------------*/
  912. /* - dump the map of line number tables to csects.                           */
  913. /*****************************************************************************/
  914. // DumpCsectMap( pModule, pCsectMap, TYPE109_16 );
  915. /*---------------------------------------------------------------------------*/
  916.  
  917.  /****************************************************************************/
  918.  /* - Now, scan the Csects, allocate the table, and map the entries to       */
  919.  /*   the table.                                                             */
  920.  /****************************************************************************/
  921.  for( pCsect=pModule->pCsects; pCsect!=NULL; pCsect=pCsect->next )
  922.  {
  923.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  924.   pTablePtr = (UCHAR*)pCsect->pLnoTab;
  925.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  926.   {
  927.    sfi = pmap->mssfi;
  928.    if(pmap->pCsect == pCsect)
  929.    {
  930.     FIRST_ENTRY_109_16 *p109_16Table;
  931.  
  932.     pFileName    = pmap->pFirstEntry;
  933.     p109_16Table = (FIRST_ENTRY_109_16 *)(pFileName + *pFileName + 1);
  934.  
  935.     pTablePtr = Append109_16Table((LNOTAB *)pTablePtr, p109_16Table,
  936.                                   pCsect->SegFlatAddr, sfi);
  937.    }
  938.   }
  939.  }
  940.  
  941.  /****************************************************************************/
  942.  /* - now, build/add a file names list to the module.                        */
  943.  /****************************************************************************/
  944.  if( pModule->pCsects )
  945.   AddFilesToModule( pModule, pCsectMap );
  946.  
  947. /*---------------------------------------------------------------------------*/
  948. /* - dump the map of line number tables to csects.                           */
  949. /*****************************************************************************/
  950. // DumpLineNums( pModule );
  951. /*---------------------------------------------------------------------------*/
  952.  
  953.  /****************************************************************************/
  954.  /* - At this point, the line number table has been mapped to the Csect      */
  955.  /*   tables.                                                                */
  956.  /* - So, we can free the map.                                               */
  957.  /* - And, we can free the bulk table.                                       */
  958.  /****************************************************************************/
  959.  for( pmap = pCsectMap ; pmap ; pmap = pnextmap )
  960.   {pnextmap = pmap->next; Tfree(pmap);}
  961.  
  962.  if(pLineNumberTable) Tfree(pLineNumberTable);
  963. }
  964.  
  965. /*****************************************************************************/
  966. /* Build109_32Tables()                                                       */
  967. /*                                                                           */
  968. /* Description:                                                              */
  969. /*                                                                           */
  970. /*   Build the 109_32 tables.                                                */
  971. /*                                                                           */
  972. /* Parameters:                                                               */
  973. /*                                                                           */
  974. /*   pModule                                                                 */
  975. /*   pdf                                                                     */
  976. /*                                                                           */
  977. /* Return:                                                                   */
  978. /*                                                                           */
  979. /*****************************************************************************/
  980. void Build109_32Tables(  MODULE *pModule, DEBFILE *pdf )
  981. {
  982.  ULONG               lfo;
  983.  ULONG               lfoend;
  984.  ULONG               LineNumberTableSize;
  985.  FIRST_ENTRY_109_32 *pFirstEntry;
  986.  CSECTMAP           *pCsectMap = NULL;
  987.  CSECTMAP           *pmap;
  988.  CSECTMAP           *pnextmap;
  989.  UCHAR              *pTablePtr;
  990.  USHORT              NumEntries;
  991.  CSECT              *pCsect;
  992.  UCHAR              *pLineNumberTable;
  993.  UCHAR              *pTable;
  994.  UCHAR              *pTableEnd;
  995.  int                 FileNameLen;
  996.  int                 sfi;
  997.  UCHAR              *pFileName;
  998.  
  999.  /****************************************************************************/
  1000.  /* - define long file offsets for the start and end of the table.           */
  1001.  /* - read the line number table into memory.                                */
  1002.  /****************************************************************************/
  1003.  lfo    = pdf->DebugOff + pModule->LineNums;
  1004.  lfoend = lfo + pModule->LineNumsLen - 1;
  1005.  
  1006.  LineNumberTableSize = lfoend - lfo + 1;
  1007.  pLineNumberTable    = Talloc( LineNumberTableSize );
  1008.  
  1009.  seekf(pdf, lfo);
  1010.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  1011.  
  1012.  /****************************************************************************/
  1013.  /* - Scan the line number table and build  a map of the the table(s) to     */
  1014.  /*   csects.                                                                */
  1015.  /****************************************************************************/
  1016.  pTable       = pLineNumberTable;
  1017.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  1018.  pmap         = (CSECTMAP *)&pCsectMap;
  1019.  
  1020.  for( ; pTable < pTableEnd; )
  1021.  {
  1022.   FileNameLen = *pTable;
  1023.   pFirstEntry = (FIRST_ENTRY_109_32*)(pTable + FileNameLen + 1);
  1024.   NumEntries  = pFirstEntry->NumEntries;
  1025.  
  1026.   /***************************************************************************/
  1027.   /* - find the Csect that this table section maps to.                       */
  1028.   /***************************************************************************/
  1029.   for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  1030.   {
  1031.    if( pCsect->SegNum == pFirstEntry->SegNum )
  1032.     break;
  1033.   }
  1034.  
  1035.   if( pCsect )
  1036.   {
  1037.    pmap->next              = (CSECTMAP*)Talloc(sizeof(CSECTMAP));
  1038.    pmap->next->pFirstEntry = pTable;
  1039.    pmap->next->pCsect      = pCsect;
  1040.    pmap->next->NumEntries  = NumEntries;
  1041.    pmap                    = pmap->next;
  1042.   }
  1043.  
  1044.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_109_32) +
  1045.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_109_32);
  1046.  }
  1047.  
  1048.  /****************************************************************************/
  1049.  /* - At this point, we have built a map of table sections to csects.        */
  1050.  /* - For each Csect, scan the map and count the number of entries           */
  1051.  /*   that will be in the line number table for that Csect.                  */
  1052.  /****************************************************************************/
  1053.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  1054.  {
  1055.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1056.   {
  1057.    if(pmap->pCsect == pCsect)
  1058.     pCsect->NumEntries += pmap->NumEntries; /* call func to get real count */
  1059.   }
  1060.  }
  1061.  
  1062.  /****************************************************************************/
  1063.  /* - Add some "contrived" source file indexes for MS style tables.          */
  1064.  /****************************************************************************/
  1065.  if( pModule->pCsects )
  1066.   MakeSfis( pCsectMap );
  1067.  
  1068. /*---------------------------------------------------------------------------*/
  1069. /* - dump the map of line number tables to csects.                           */
  1070. /*****************************************************************************/
  1071. // DumpCsectMap( pModule, pCsectMap, TYPE109_32 );
  1072. /*---------------------------------------------------------------------------*/
  1073.  
  1074.  /****************************************************************************/
  1075.  /* - Now, scan the Csects, allocate the table, and map the entries to       */
  1076.  /*   the table.                                                             */
  1077.  /****************************************************************************/
  1078.  for( pCsect=pModule->pCsects; pCsect!=NULL; pCsect=pCsect->next )
  1079.  {
  1080.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  1081.   pTablePtr = (UCHAR*)pCsect->pLnoTab;
  1082.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1083.   {
  1084.    sfi = pmap->mssfi;
  1085.    if(pmap->pCsect == pCsect)
  1086.    {
  1087.     FIRST_ENTRY_109_32 *p109_32Table;
  1088.  
  1089.     pFileName    = pmap->pFirstEntry;
  1090.     p109_32Table = (FIRST_ENTRY_109_32 *)(pFileName + *pFileName + 1);
  1091.  
  1092.     pTablePtr = Append109_32Table((LNOTAB *)pTablePtr, p109_32Table,
  1093.                                   pCsect->SegFlatAddr, sfi);
  1094.    }
  1095.   }
  1096.  }
  1097.  
  1098.  /****************************************************************************/
  1099.  /* - now, build/add a file names list to the module.                        */
  1100.  /****************************************************************************/
  1101.  if( pModule->pCsects )
  1102.   AddFilesToModule( pModule, pCsectMap );
  1103.  
  1104. /*---------------------------------------------------------------------------*/
  1105. /* - dump the map of line number tables to csects.                           */
  1106. /*****************************************************************************/
  1107. // DumpLineNums( pModule );
  1108. /*---------------------------------------------------------------------------*/
  1109.  
  1110.  /****************************************************************************/
  1111.  /* - At this point, the line number table has been mapped to the Csect      */
  1112.  /*   tables.                                                                */
  1113.  /* - So, we can free the map.                                               */
  1114.  /* - And, we can free the bulk table.                                       */
  1115.  /****************************************************************************/
  1116.  for( pmap = pCsectMap ; pmap ; pmap = pnextmap )
  1117.   {pnextmap = pmap->next; Tfree(pmap);}
  1118.  
  1119.  if(pLineNumberTable) Tfree(pLineNumberTable);
  1120. }
  1121.  
  1122. /*****************************************************************************/
  1123. /* Build105Tables()                                                          */
  1124. /*                                                                           */
  1125. /* Description:                                                              */
  1126. /*                                                                           */
  1127. /*   Build the 105 tables.                                                   */
  1128. /*                                                                           */
  1129. /* Parameters:                                                               */
  1130. /*                                                                           */
  1131. /*   pModule                                                                 */
  1132. /*   pdf                                                                     */
  1133. /*                                                                           */
  1134. /* Return:                                                                   */
  1135. /*                                                                           */
  1136. /*****************************************************************************/
  1137. void Build105Tables(  MODULE *pModule, DEBFILE *pdf )
  1138. {
  1139.  ULONG            lfo;
  1140.  ULONG            lfoend;
  1141.  ULONG            LineNumberTableSize;
  1142.  FIRST_ENTRY_105 *pFirstEntry;
  1143.  CSECTMAP        *pCsectMap = NULL;
  1144.  CSECTMAP        *pmap;
  1145.  CSECTMAP        *pnextmap;
  1146.  UCHAR           *pTablePtr;
  1147.  USHORT           NumEntries;
  1148.  CSECT           *pCsect;
  1149.  UCHAR           *pLineNumberTable;
  1150.  UCHAR           *pTable;
  1151.  UCHAR           *pTableEnd;
  1152.  int              FileNameLen;
  1153.  int              sfi;
  1154.  UCHAR           *pFileName;
  1155.  
  1156.  /****************************************************************************/
  1157.  /* - define long file offsets for the start and end of the table.           */
  1158.  /* - read the line number table into memory.                                */
  1159.  /****************************************************************************/
  1160.  lfo    = pdf->DebugOff + pModule->LineNums;
  1161.  lfoend = lfo + pModule->LineNumsLen - 1;
  1162.  
  1163.  LineNumberTableSize = lfoend - lfo + 1;
  1164.  pLineNumberTable    = Talloc( LineNumberTableSize );
  1165.  
  1166.  seekf(pdf, lfo);
  1167.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  1168.  
  1169.  /****************************************************************************/
  1170.  /* - Scan the line number table and build  a map of the the table(s) to     */
  1171.  /*   csects.                                                                */
  1172.  /****************************************************************************/
  1173.  pTable       = pLineNumberTable;
  1174.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  1175.  pmap         = (CSECTMAP *)&pCsectMap;
  1176.  
  1177.  /****************************************************************************/
  1178.  /* - Move past the first file name                                          */
  1179.  /****************************************************************************/
  1180.  
  1181.  for( ; pTable < pTableEnd; )
  1182.  {
  1183.   FileNameLen = *pTable;
  1184.   pFirstEntry = (FIRST_ENTRY_105*)(pTable + FileNameLen + 1);
  1185.   NumEntries  = pFirstEntry->NumEntries;
  1186.  
  1187.   /***************************************************************************/
  1188.   /* - find the Csect that this table section maps to.                       */
  1189.   /* - 105 types only have one csect.                                        */
  1190.   /***************************************************************************/
  1191.   pCsect = pModule->pCsects;
  1192.  
  1193.   if( pCsect )
  1194.   {
  1195.    pmap->next              = (CSECTMAP*)Talloc(sizeof(CSECTMAP));
  1196.    pmap->next->pFirstEntry = pTable;
  1197.    pmap->next->pCsect      = pCsect;
  1198.    pmap->next->NumEntries  = NumEntries;
  1199.    pmap                    = pmap->next;
  1200.   }
  1201.  
  1202.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_105) +
  1203.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_105);
  1204.  }
  1205.  
  1206.  /****************************************************************************/
  1207.  /* - At this point, we have built a map of table sections to csects.        */
  1208.  /* - For each Csect, scan the map and count the number of entries           */
  1209.  /*   that will be in the line number table for that Csect.                  */
  1210.  /****************************************************************************/
  1211.  pCsect = pModule->pCsects;
  1212.  
  1213.  if( pCsect )
  1214.  {
  1215.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1216.   {
  1217.    if(pmap->pCsect == pCsect)
  1218.     pCsect->NumEntries += pmap->NumEntries; /* call func to get real count */
  1219.   }
  1220.  }
  1221.  
  1222.  /****************************************************************************/
  1223.  /* - Add some "contrived" source file indexes for MS style tables.          */
  1224.  /****************************************************************************/
  1225.  if( pModule->pCsects )
  1226.   MakeSfis( pCsectMap );
  1227.  
  1228. /*---------------------------------------------------------------------------*/
  1229. /* - dump the map of line number tables to csects.                           */
  1230. /*****************************************************************************/
  1231. // DumpCsectMap( pModule, pCsectMap, TYPE105 );
  1232. /*---------------------------------------------------------------------------*/
  1233.  
  1234.  /****************************************************************************/
  1235.  /* - Now, scan the Csects, allocate the table, and map the entries to       */
  1236.  /*   the table.                                                             */
  1237.  /****************************************************************************/
  1238.  for( pCsect=pModule->pCsects; pCsect!=NULL; pCsect=pCsect->next )
  1239.  {
  1240.   pCsect->pLnoTab = Talloc(pCsect->NumEntries*sizeof(LNOTAB));
  1241.   pTablePtr = (UCHAR*)pCsect->pLnoTab;
  1242.   for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1243.   {
  1244.    sfi = pmap->mssfi;
  1245.    if(pmap->pCsect == pCsect)
  1246.    {
  1247.     FIRST_ENTRY_105 *p105Table;
  1248.  
  1249.     pFileName = pmap->pFirstEntry;
  1250.     p105Table = (FIRST_ENTRY_105 *)(pFileName + *pFileName + 1);
  1251.  
  1252.     pTablePtr = Append105Table( (LNOTAB *)pTablePtr, p105Table,
  1253.                                 pCsect->SegFlatAddr, sfi);
  1254.    }
  1255.   }
  1256.  }
  1257.  
  1258.  /****************************************************************************/
  1259.  /* - now, build/add a file names list to the module.                        */
  1260.  /****************************************************************************/
  1261.  if( pModule->pCsects )
  1262.   AddFilesToModule( pModule, pCsectMap );
  1263.  
  1264. /*---------------------------------------------------------------------------*/
  1265. /* - dump the map of line number tables to csects.                           */
  1266. /*****************************************************************************/
  1267. // DumpLineNums( pModule );
  1268. /*---------------------------------------------------------------------------*/
  1269.  
  1270.  /****************************************************************************/
  1271.  /* - At this point, the line number table has been mapped to the Csect      */
  1272.  /*   tables.                                                                */
  1273.  /* - So, we can free the map.                                               */
  1274.  /* - And, we can free the bulk table.                                       */
  1275.  /****************************************************************************/
  1276.  for( pmap = pCsectMap ; pmap ; pmap = pnextmap )
  1277.   {pnextmap = pmap->next; Tfree(pmap);}
  1278.  
  1279.  if(pLineNumberTable) Tfree(pLineNumberTable);
  1280. }
  1281.  
  1282. /*****************************************************************************/
  1283. /* GetModuleWithAddr()                                                       */
  1284. /*                                                                           */
  1285. /* Description:                                                              */
  1286. /*                                                                           */
  1287. /*  Find the module that contains the address.                               */
  1288. /*                                                                           */
  1289. /* Parameters:                                                               */
  1290. /*                                                                           */
  1291. /*  addr                                                                     */
  1292. /*  pdf                                                                      */
  1293. /*                                                                           */
  1294. /* Return:                                                                   */
  1295. /*                                                                           */
  1296. /*  pModule                                                                  */
  1297. /*  NULL                                                                     */
  1298. /*                                                                           */
  1299. /* Assumptions:                                                              */
  1300. /*                                                                           */
  1301. /*    pdf != NULL                                                            */
  1302. /*                                                                           */
  1303. /*****************************************************************************/
  1304. MODULE *GetModuleWithAddr( ULONG addr, DEBFILE *pdf )
  1305. {
  1306.  MODULE *pModule;
  1307.  
  1308.  for( pModule = pdf->MidAnchor; pModule; pModule = pModule->NextMod )
  1309.  {
  1310.   if( GetCsectWithAddr( pModule, addr) )
  1311.    break;
  1312.  }
  1313.  return( pModule );
  1314. }
  1315.  
  1316. /*****************************************************************************/
  1317. /* GetLnoWithAddr()                                                          */
  1318. /*                                                                           */
  1319. /* Description:                                                              */
  1320. /*                                                                           */
  1321. /*  Find the line number that contains this address.                         */
  1322. /*                                                                           */
  1323. /* Parameters:                                                               */
  1324. /*                                                                           */
  1325. /*  addr                                                                     */
  1326. /*  pCsect     -> to the csect containing the address.                       */
  1327. /*                                                                           */
  1328. /* Return:                                                                   */
  1329. /*                                                                           */
  1330. /*  p          -> to the table entry with the line number containing         */
  1331. /*                this address.                                              */
  1332. /*                                                                           */
  1333. /* Assumptions:                                                              */
  1334. /*                                                                           */
  1335. /*  - the line number table is already loaded.                               */
  1336. /*                                                                           */
  1337. /*****************************************************************************/
  1338. LNOTAB *GetLnoWithAddr( CSECT* pCsect, ULONG addr )
  1339. {
  1340.  LNOTAB *plnolo;
  1341.  LNOTAB *plnohi;
  1342.  int     i;
  1343.  LNOTAB *pLnoTab;
  1344.  int     NumEntries;
  1345.  
  1346.  pLnoTab    = pCsect->pLnoTab;
  1347.  NumEntries = pCsect->NumEntries;
  1348.  plnolo     = pLnoTab;
  1349.  plnohi     = plnolo + 1;
  1350.  
  1351.  for( i=1; i < NumEntries; i++ )
  1352.  {
  1353.   if( (addr >= plnolo->off) && ( addr < plnohi->off ) )
  1354.    { break;}
  1355.   plnolo++;
  1356.   if(plnolo->sfi == 0)
  1357.    plnolo++;
  1358.   plnohi++;
  1359.   if(plnohi->sfi == 0)
  1360.    plnohi++;
  1361.  }
  1362.  
  1363.  return( plnolo );
  1364. }
  1365.  
  1366. /*****************************************************************************/
  1367. /* GetFileName()                                                             */
  1368. /*                                                                           */
  1369. /* Description:                                                              */
  1370. /*                                                                           */
  1371. /*  Get the file name for a given module and sfi.                            */
  1372. /*                                                                           */
  1373. /* Parameters:                                                               */
  1374. /*                                                                           */
  1375. /*  mid                                                                      */
  1376. /*  sfi        source file index.                                            */
  1377. /*                                                                           */
  1378. /* Return:                                                                   */
  1379. /*                                                                           */
  1380. /*  cp         -> to the file name.                                          */
  1381. /*             NULL==> did not find.                                         */
  1382. /*                                                                           */
  1383. /* Assumptions:                                                              */
  1384. /*                                                                           */
  1385. /*****************************************************************************/
  1386. char *GetFileName( ULONG mid, int sfi )
  1387. {
  1388.  MODULE   *pModule;
  1389.  FILENAME *pFile;
  1390.  char     *cp = NULL;
  1391.  
  1392.  pModule = GetPtrToModule( mid, NULL);
  1393.  if( pModule == NULL )
  1394.   return(NULL);
  1395.  
  1396.  for( pFile = pModule->pFiles; pFile != NULL; pFile=pFile->next )
  1397.  {
  1398.   if( sfi == pFile->sfi )
  1399.   {
  1400.    cp = pFile->FileName;
  1401.    break;
  1402.   }
  1403.  }
  1404.  return( cp );
  1405. }
  1406.  
  1407. /*****************************************************************************/
  1408. /* AddFileNames()                                                            */
  1409. /*                                                                           */
  1410. /* Description:                                                              */
  1411. /*                                                                           */
  1412. /*  Add the file name linked list to the module structure.                   */
  1413. /*                                                                           */
  1414. /* Parameters:                                                               */
  1415. /*                                                                           */
  1416. /*  pModule                                                                  */
  1417. /*  pFileNameTable                                                           */
  1418. /*                                                                           */
  1419. /* Return:                                                                   */
  1420. /*                                                                           */
  1421. /*  void                                                                     */
  1422. /*                                                                           */
  1423. /* Assumptions:                                                              */
  1424. /*                                                                           */
  1425. /*****************************************************************************/
  1426. void AddFileNames( MODULE *pModule, UCHAR *pFileNameTable )
  1427. {
  1428.  CSECT    *pCsect;
  1429.  int       NumEntries;
  1430.  UCHAR    *pFileName;
  1431.  LNOTAB   *pLnoTabEntry;
  1432.  FILENAME *pLast;
  1433.  FILENAME *pFile;
  1434.  
  1435.  for(pCsect = pModule->pCsects; pCsect != NULL; pCsect=pCsect->next )
  1436.  {
  1437.   NumEntries   = pCsect->NumEntries;
  1438.   pLnoTabEntry = pCsect->pLnoTab;
  1439.  
  1440.   for( ; NumEntries--; pLnoTabEntry++ )
  1441.   {
  1442.    int sfi;
  1443.  
  1444.    sfi = pLnoTabEntry->sfi;
  1445.    if( sfi == 0 )
  1446.     continue;
  1447.    /**************************************************************************/
  1448.    /* - scan the list of files to see if this sfi is accounted for.          */
  1449.    /**************************************************************************/
  1450.    pLast = (FILENAME *)&(pModule->pFiles);
  1451.    for( pFile = pModule->pFiles; pFile != NULL; pLast=pFile, pFile=pFile->next )
  1452.    {
  1453.     if( sfi == pFile->sfi )
  1454.      break;
  1455.    }
  1456.  
  1457.    if( pFile == NULL )
  1458.    {
  1459.     int i;
  1460.     int size;
  1461.     int len;
  1462.     /*************************************************************************/
  1463.     /* - fall in here if this sfi is not yet accounted for.                  */
  1464.     /*************************************************************************/
  1465.     pFileName = pFileNameTable;
  1466.     for( i = 1; i < sfi; i++ )
  1467.     {
  1468.      pFileName += *pFileName + 1;
  1469.     }
  1470.  
  1471.     /*************************************************************************/
  1472.     /* - add the file name to the list.                                      */
  1473.     /*************************************************************************/
  1474.     len         = *pFileName;
  1475.     size        = sizeof(FILENAME) + len + 1;
  1476.     pFile       = Talloc(size);
  1477.     pFile->sfi  = sfi;
  1478.     strncpy( pFile->FileName, pFileName, len + 1 );
  1479.     pLast->next = pFile;
  1480.    }
  1481.   }
  1482.  }
  1483. }
  1484.  
  1485. /*****************************************************************************/
  1486. /* MakeSfis()                                                                */
  1487. /*                                                                           */
  1488. /* Description:                                                              */
  1489. /*                                                                           */
  1490. /*  Make source file indexes for MS style tables.                            */
  1491. /*                                                                           */
  1492. /* Parameters:                                                               */
  1493. /*                                                                           */
  1494. /*  pCsectMap                                                                */
  1495. /*                                                                           */
  1496. /* Return:                                                                   */
  1497. /*                                                                           */
  1498. /*  void                                                                     */
  1499. /*                                                                           */
  1500. /* Assumptions:                                                              */
  1501. /*                                                                           */
  1502. /*****************************************************************************/
  1503. void MakeSfis( CSECTMAP *pCsectMap )
  1504. {
  1505.  int       sfi;
  1506.  UCHAR    *pFileName;
  1507.  UCHAR    *pFileNamex;
  1508.  CSECTMAP *pmap;
  1509.  CSECTMAP *pmapx;
  1510.  
  1511.  sfi = 1;
  1512.  for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next, sfi++ )
  1513.  {
  1514.   pmap->IsFileUnique = TRUE;
  1515.  
  1516.   pFileName = pmap->pFirstEntry;
  1517.   for( pmapx = pCsectMap; pmapx != pmap; pmapx=pmapx->next )
  1518.   {
  1519.    pFileNamex = pmapx->pFirstEntry;
  1520.    if( strncmp( pFileName, pFileNamex, *pFileName+1 ) == 0 )
  1521.    {
  1522.     pmap->mssfi        = pmapx->mssfi;
  1523.     pmap->IsFileUnique = FALSE;
  1524.     break;
  1525.    }
  1526.   }
  1527.   if( pmap->IsFileUnique == TRUE )
  1528.    pmap->mssfi = sfi;
  1529.  }
  1530. }
  1531.  
  1532. /*****************************************************************************/
  1533. /* AddFilesToModule()                                                        */
  1534. /*                                                                           */
  1535. /* Description:                                                              */
  1536. /*                                                                           */
  1537. /*  Make a file name table for MS style tables.                              */
  1538. /*                                                                           */
  1539. /* Parameters:                                                               */
  1540. /*                                                                           */
  1541. /*  pCsectMap                                                                */
  1542. /*  pModule                                                                  */
  1543. /*                                                                           */
  1544. /* Return:                                                                   */
  1545. /*                                                                           */
  1546. /*  void                                                                     */
  1547. /*                                                                           */
  1548. /* Assumptions:                                                              */
  1549. /*                                                                           */
  1550. /*****************************************************************************/
  1551. void AddFilesToModule( MODULE *pModule, CSECTMAP *pCsectMap )
  1552. {
  1553.  UCHAR    *pFileName;
  1554.  UCHAR    *pFileNamex;
  1555.  UCHAR    *pFileNameTable;
  1556.  CSECTMAP *pmap;
  1557.  int       FileTableLen;
  1558.  int       FileNameLen;
  1559.  
  1560.  FileTableLen = 0;
  1561.  for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1562.  {
  1563.   pFileName     = pmap->pFirstEntry;
  1564.   FileTableLen += *pFileName + 1;
  1565.  }
  1566.  
  1567.  pFileNameTable = pFileNamex = Talloc(FileTableLen);
  1568.  
  1569.  for( pmap = pCsectMap; pmap != NULL; pmap=pmap->next )
  1570.  {
  1571.   pFileName   = pmap->pFirstEntry;
  1572.   FileNameLen = *pFileName;
  1573.   strncpy(pFileNamex, pFileName, FileNameLen + 1 );
  1574.   pFileNamex  += FileNameLen + 1;
  1575.  }
  1576.  AddFileNames( pModule, pFileNameTable );
  1577.  if(pFileNameTable) Tfree(pFileNameTable);
  1578. }
  1579.  
  1580.  
  1581. /*****************************************************************************/
  1582. /* DBLsegInfo                                                                */
  1583. /*                                                                           */
  1584. /* Description:                                                              */
  1585. /*   get logical segment containing address.                                 */
  1586. /*                                                                           */
  1587. /* Parameters:                                                               */
  1588. /*                                                                           */
  1589. /*   addr       contained address.                                           */
  1590. /*   lenptr     where to put the segment size for the caller.                */
  1591. /*   pdf        pointer to debug file with the data.                         */
  1592. /*                                                                           */
  1593. /* Return:                                                                   */
  1594. /*                                                                           */
  1595. /*   base       base address of the csect containing the addr.               */
  1596. /*                                                                           */
  1597. /* Assumptions:                                                              */
  1598. /*                                                                           */
  1599. /*  The addr is contained within a valid pdf-it has not been freed           */
  1600. /*  by DosFreeModule().                                                      */
  1601. /*                                                                           */
  1602. /*                                                                           */
  1603. /*****************************************************************************/
  1604. ULONG DBLsegInfo( ULONG addr, uint *lenptr , DEBFILE *pdf)
  1605. {
  1606.  MODULE     *mptr;
  1607.  CSECT  *pCsect;
  1608.  
  1609.  for(
  1610.      mptr = pdf->MidAnchor;
  1611.      mptr != NULL;
  1612.      mptr = mptr->NextMod
  1613.     )
  1614.  {
  1615.   if( (pCsect = GetCsectWithAddr( mptr, addr )) != NULL)
  1616.    break;
  1617.  }
  1618.  
  1619.  if ( pCsect )
  1620.  {
  1621.   *lenptr = pCsect->CsectSize;
  1622.   return(  pCsect->CsectLo );
  1623.  }
  1624.  
  1625.  /****************************************************************************/
  1626.  /* If we get here, then we were not able to find a module within the        */
  1627.  /* pdf that contained the addr. So, we will back up one level of            */
  1628.  /* resolution and try to find the code object that contains this            */
  1629.  /* address. We will use the code object and size.                           */
  1630.  /****************************************************************************/
  1631.  {
  1632.   int           i;
  1633.   uint          NumCodeObjs;
  1634.   uint          *pi;
  1635.   OBJTABLEENTRY *te;
  1636.   int            foundit = FALSE;
  1637.  
  1638.  
  1639.   NumCodeObjs = *(pi=pdf->CodeObjs);
  1640.   te = (OBJTABLEENTRY *)++pi;
  1641.   for(i=1; (foundit==FALSE) && (i <= NumCodeObjs); i++,te++ )
  1642.   {
  1643.    if( (te->ObjType == CODE)     &&
  1644.        (addr >= te->ObjLoadAddr) &&
  1645.        (addr <  te->ObjLoadAddr + te->ObjLoadSize) )
  1646.      { foundit = TRUE; break; }
  1647.   }
  1648.  
  1649.   /* te is pointing to the code object we want. */
  1650.  
  1651.   if( foundit == TRUE )
  1652.   {
  1653.    *lenptr = te->ObjLoadSize;
  1654.    return( te->ObjLoadAddr );
  1655.   }
  1656.  }
  1657.  return( NULL );
  1658. }
  1659.  
  1660. /*****************************************************************************/
  1661. /* DBModName                                                                 */
  1662. /*                                                                           */
  1663. /* Description:                                                              */
  1664. /*                                                                           */
  1665. /*   get module name for a specifed module id.                               */
  1666. /*                                                                           */
  1667. /* Parameters:                                                               */
  1668. /*                                                                           */
  1669. /*   mid           module id for the name we're looking for.                 */
  1670. /*   pdf        -> to EXE/DLL structure.                                     */
  1671. /*   ftype         0==>exe/dll name. 1==>source file name.                   */
  1672. /*                                                                           */
  1673. /* Return:                                                                   */
  1674. /*                                                                           */
  1675. /*   p          -> to the module name.                                       */
  1676. /*                                                                           */
  1677. /*****************************************************************************/
  1678. UCHAR *DBModName( ULONG mid , int sfi, DEBFILE *pdf , int *ftype)
  1679. {
  1680.  MODULE  *pModule;
  1681.  char    *p;
  1682.  UCHAR    ModuleNameLength = 0;
  1683.  char    *pSourceFileName;
  1684.  
  1685.  *ftype  = 0;
  1686.  /****************************************************************************/
  1687.  /* If linked without /CO, then return the EXE/DLL name.                     */
  1688.  /****************************************************************************/
  1689.  if ( pdf->SrcOrAsm == ASM_LEVEL )
  1690.  {
  1691.   ModuleNameLength = strlen(pdf->DebFilePtr->fn);
  1692.   p = Talloc(ModuleNameLength + 1);
  1693.   p[0] = ModuleNameLength;
  1694.   strncpy(p+1, pdf->DebFilePtr->fn, ModuleNameLength);
  1695.   return(p);
  1696.  }
  1697.  
  1698.  /****************************************************************************/
  1699.  /* - get a ptr to the module structure.                                     */
  1700.  /****************************************************************************/
  1701.  pModule = GetPtrToModule( mid, pdf );
  1702.  if(pModule == NULL)
  1703.   return(NULL);
  1704.  
  1705.  /****************************************************************************/
  1706.  /* - find the source file name.                                             */
  1707.  /****************************************************************************/
  1708.  pSourceFileName = GetFileName(mid, sfi);
  1709.  if( pSourceFileName != NULL )
  1710.  {
  1711.   *ftype = 1;
  1712.  }
  1713.  return(pSourceFileName);
  1714. }
  1715.  
  1716. /*****************************************************************************/
  1717. /* AppendHL01Tables()                                                        */
  1718. /*                                                                           */
  1719. /* Description:                                                              */
  1720. /*                                                                           */
  1721. /*   Append a line number table.                                             */
  1722. /*                                                                           */
  1723. /* Parameters:                                                               */
  1724. /*                                                                           */
  1725. /*   pLnoTab    -> to the table we're mapping to.                            */
  1726. /*   pHL01Table -> to the table we're mapping from.                          */
  1727. /*   BaseOffset    table offsets are relative to this offset.                */
  1728. /*                                                                           */
  1729. /* Return:                                                                   */
  1730. /*                                                                           */
  1731. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  1732. /*                                                                           */
  1733. /* Assumptions:                                                              */
  1734. /*                                                                           */
  1735. /*   pHL01Table points to a "FirstEntry" record.                             */
  1736. /*                                                                           */
  1737. /*****************************************************************************/
  1738. UCHAR *AppendHL01Table( LNOTAB *pLnoTab,
  1739.                         FIRST_ENTRY_HL01 *pHL01Table,
  1740.                         ULONG BaseOffset)
  1741. {
  1742.  LINE_NUMBER_TABLE_ENTRY_HL01 *pFromEntry;
  1743.  
  1744.  int     i;
  1745.  LNOTAB *pToEntry;
  1746.  USHORT  NumEntries;
  1747.  UCHAR  *pTable;
  1748.  
  1749.  NumEntries = pHL01Table->NumEntries;
  1750.  pTable     = (char*)pHL01Table + sizeof(FIRST_ENTRY_HL01);
  1751.  
  1752.  pFromEntry   = (LINE_NUMBER_TABLE_ENTRY_HL01 *)pTable;
  1753.  pToEntry     = pLnoTab;
  1754.  
  1755.  for( i=1; i <= NumEntries; i++ )
  1756.  {
  1757.   pToEntry->lno = pFromEntry->LineNumber;
  1758.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  1759.   pToEntry->sfi = pFromEntry->SourceFileIndex;
  1760.   pToEntry++;
  1761.   pFromEntry++;
  1762.  }
  1763.  return((UCHAR*)pToEntry);
  1764. }
  1765.  
  1766. /*****************************************************************************/
  1767. /* AppendHL04Tables()                                                        */
  1768. /*                                                                           */
  1769. /* Description:                                                              */
  1770. /*                                                                           */
  1771. /*   Append a line number table.                                             */
  1772. /*                                                                           */
  1773. /* Parameters:                                                               */
  1774. /*                                                                           */
  1775. /*   pLnoTab    -> to the table we're mapping to.                            */
  1776. /*   pHL04Table -> to the table we're mapping from.                          */
  1777. /*                                                                           */
  1778. /* Return:                                                                   */
  1779. /*                                                                           */
  1780. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  1781. /*                                                                           */
  1782. /* Assumptions:                                                              */
  1783. /*                                                                           */
  1784. /*   pHL04Table points to a "FirstEntry" record.                             */
  1785. /*                                                                           */
  1786. /*****************************************************************************/
  1787. UCHAR *AppendHL04Table( LNOTAB           *pLnoTab,
  1788.                         FIRST_ENTRY_HL04 *pHL04Table,
  1789.                         ULONG             MteLoadAddr )
  1790. {
  1791.  LINE_NUMBER_TABLE_ENTRY_HL04 *pFromEntry;
  1792.  
  1793.  int     i;
  1794.  LNOTAB *pToEntry;
  1795.  char   *cptr;
  1796.  USHORT  NumEntries;
  1797.  ULONG   BaseOffset;
  1798.  
  1799.  /****************************************************************************/
  1800.  /* - define the number of entries from the first entry record.              */
  1801.  /* - define the base offset address from the first entry record.            */
  1802.  /* - define a ptr to the first (lno,off,sfi) entry.                         */
  1803.  /****************************************************************************/
  1804.  NumEntries = pHL04Table->NumEntries;
  1805.  BaseOffset = MteLoadAddr + pHL04Table->BaseOffset - 0x10000;
  1806.  cptr       = (char*)pHL04Table + sizeof(FIRST_ENTRY_HL04);
  1807.  pFromEntry = (LINE_NUMBER_TABLE_ENTRY_HL04 *)cptr;
  1808.  pToEntry   = pLnoTab;
  1809.  
  1810.  for( i=1; i <= NumEntries; i++ )
  1811.  {
  1812.   pToEntry->lno = pFromEntry->LineNumber;
  1813.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  1814.   pToEntry->sfi = pFromEntry->SourceFileIndex;
  1815.   pToEntry++;
  1816.   pFromEntry++;
  1817.  }
  1818.  return((UCHAR*)pToEntry);
  1819. }
  1820.  
  1821. /*****************************************************************************/
  1822. /* AppendHL03Tables()                                                        */
  1823. /*                                                                           */
  1824. /* Description:                                                              */
  1825. /*                                                                           */
  1826. /*   Append a line number table to a csect table.                            */
  1827. /*                                                                           */
  1828. /* Parameters:                                                               */
  1829. /*                                                                           */
  1830. /*   pLnoTab    -> to the table we're mapping to.                            */
  1831. /*   pHL04Table -> to the table we're mapping from.                          */
  1832. /*   BaseOffset    table offsets are relative to this base.                  */
  1833. /*                                                                           */
  1834. /* Return:                                                                   */
  1835. /*                                                                           */
  1836. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  1837. /*                                                                           */
  1838. /* Assumptions:                                                              */
  1839. /*                                                                           */
  1840. /*   pHL03Table points to a "FirstEntry" record.                             */
  1841. /*                                                                           */
  1842. /*****************************************************************************/
  1843. UCHAR *AppendHL03Table( LNOTAB *pLnoTab,
  1844.                         FIRST_ENTRY_HL03 *pHL03Table,
  1845.                         ULONG BaseOffset)
  1846. {
  1847.  LINE_NUMBER_TABLE_ENTRY_HL03 *pFromEntry;
  1848.  
  1849.  int     i;
  1850.  LNOTAB *pToEntry;
  1851.  char   *cptr;
  1852.  USHORT  NumEntries;
  1853.  
  1854.  /****************************************************************************/
  1855.  /* - define the number of entries from the first entry record.              */
  1856.  /* - define the base offset address from the first entry record.            */
  1857.  /* - define a ptr to the first (lno,off,sfi) entry.                         */
  1858.  /****************************************************************************/
  1859.  NumEntries   = pHL03Table->NumEntries;
  1860.  
  1861.  cptr         = (char*)pHL03Table + sizeof(FIRST_ENTRY_HL03);
  1862.  pFromEntry   = (LINE_NUMBER_TABLE_ENTRY_HL03 *)cptr;
  1863.  pToEntry     = pLnoTab;
  1864.  
  1865.  for( i=1; i <= NumEntries; i++ )
  1866.  {
  1867.   pToEntry->lno = pFromEntry->LineNumber;
  1868.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  1869.   pToEntry->sfi = pFromEntry->SourceFileIndex;
  1870.   pToEntry++;
  1871.   pFromEntry++;
  1872.  }
  1873.  return((UCHAR*)pToEntry);
  1874. }
  1875.  
  1876. /*****************************************************************************/
  1877. /* Append109_16Tables()                                                      */
  1878. /*                                                                           */
  1879. /* Description:                                                              */
  1880. /*                                                                           */
  1881. /*   Append a line number table to a csect table.                            */
  1882. /*                                                                           */
  1883. /* Parameters:                                                               */
  1884. /*                                                                           */
  1885. /*   pLnoTab    -> to the table we're mapping to.                            */
  1886. /*   p109_16Table  -> to the table we're mapping from.                       */
  1887. /*   BaseOffset    table offsets are relative to this base.                  */
  1888. /*   sfi           source file index                                         */
  1889. /*                                                                           */
  1890. /* Return:                                                                   */
  1891. /*                                                                           */
  1892. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  1893. /*                                                                           */
  1894. /* Assumptions:                                                              */
  1895. /*                                                                           */
  1896. /*   p109_16Table points to a "FirstEntry" record.                           */
  1897. /*                                                                           */
  1898. /*****************************************************************************/
  1899. UCHAR *Append109_16Table( LNOTAB *pLnoTab,
  1900.                        FIRST_ENTRY_109_16 *p109_16Table,
  1901.                         ULONG BaseOffset,
  1902.                         int sfi)
  1903. {
  1904.  LINE_NUMBER_TABLE_ENTRY_109_16 *pFromEntry;
  1905.  
  1906.  int     i;
  1907.  LNOTAB *pToEntry;
  1908.  char   *cptr;
  1909.  USHORT  NumEntries;
  1910.  
  1911.  /****************************************************************************/
  1912.  /* - define the number of entries from the first entry record.              */
  1913.  /* - define the base offset address from the first entry record.            */
  1914.  /* - define a ptr to the first (lno,off,sfi) entry.                         */
  1915.  /****************************************************************************/
  1916.  NumEntries   = p109_16Table->NumEntries;
  1917.  cptr         = (char*)p109_16Table + sizeof(FIRST_ENTRY_109_16);
  1918.  pFromEntry   = (LINE_NUMBER_TABLE_ENTRY_109_16 *)cptr;
  1919.  pToEntry     = pLnoTab;
  1920.  
  1921.  for( i=1; i <= NumEntries; i++ )
  1922.  {
  1923.   pToEntry->lno = pFromEntry->LineNumber;
  1924.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  1925.   pToEntry->sfi = sfi;
  1926.   pToEntry++;
  1927.   pFromEntry++;
  1928.  }
  1929.  return((UCHAR*)pToEntry);
  1930. }
  1931.  
  1932. /*****************************************************************************/
  1933. /* Append109_32Tables()                                                      */
  1934. /*                                                                           */
  1935. /* Description:                                                              */
  1936. /*                                                                           */
  1937. /*   Append a line number table.                                             */
  1938. /*                                                                           */
  1939. /* Parameters:                                                               */
  1940. /*                                                                           */
  1941. /*   pLnoTab    -> to the table we're mapping to.                            */
  1942. /*   p109_32Table  -> to the table we're mapping from.                       */
  1943. /*   BaseOffset    table values are relative to this base.                   */
  1944. /*                 relative.                                                 */
  1945. /*   sfi           source file index                                         */
  1946. /*                                                                           */
  1947. /* Return:                                                                   */
  1948. /*                                                                           */
  1949. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  1950. /*                                                                           */
  1951. /* Assumptions:                                                              */
  1952. /*                                                                           */
  1953. /*   p109_32Table points to a "FirstEntry" record.                           */
  1954. /*                                                                           */
  1955. /*****************************************************************************/
  1956. UCHAR *Append109_32Table( LNOTAB *pLnoTab,
  1957.                           FIRST_ENTRY_109_32 *p109_32Table,
  1958.                           ULONG BaseOffset,
  1959.                           int    sfi)
  1960. {
  1961.  LINE_NUMBER_TABLE_ENTRY_109_32 *pFromEntry;
  1962.  
  1963.  int     i;
  1964.  LNOTAB *pToEntry;
  1965.  char   *cptr;
  1966.  USHORT  NumEntries;
  1967.  
  1968.  /****************************************************************************/
  1969.  /* - define the number of entries from the first entry record.              */
  1970.  /* - define the base offset address from the first entry record.            */
  1971.  /* - define a ptr to the first (lno,off,sfi) entry.                         */
  1972.  /****************************************************************************/
  1973.  NumEntries   = p109_32Table->NumEntries;
  1974.  cptr         = (char*)p109_32Table + sizeof(FIRST_ENTRY_109_32);
  1975.  pFromEntry   = (LINE_NUMBER_TABLE_ENTRY_109_32 *)cptr;
  1976.  pToEntry     = pLnoTab;
  1977.  
  1978.  for( i=1; i <= NumEntries; i++ )
  1979.  {
  1980.   pToEntry->lno = pFromEntry->LineNumber;
  1981.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  1982.   pToEntry->sfi = sfi;
  1983.   pToEntry++;
  1984.   pFromEntry++;
  1985.  }
  1986.  return((UCHAR*)pToEntry);
  1987. }
  1988.  
  1989. /*****************************************************************************/
  1990. /* Append105Tables()                                                         */
  1991. /*                                                                           */
  1992. /* Description:                                                              */
  1993. /*                                                                           */
  1994. /*   Append a line number table.                                             */
  1995. /*                                                                           */
  1996. /* Parameters:                                                               */
  1997. /*                                                                           */
  1998. /*   pLnoTab    -> to the table we're mapping to.                            */
  1999. /*   p105Table  -> to the table we're mapping from.                          */
  2000. /*   BaseOffset    table offsets are relative to this base.                  */
  2001. /*   sfi           source file index                                         */
  2002. /*                                                                           */
  2003. /* Return:                                                                   */
  2004. /*                                                                           */
  2005. /*   pToEntry   -> to next available table LNOTAB slot.                      */
  2006. /*                                                                           */
  2007. /* Assumptions:                                                              */
  2008. /*                                                                           */
  2009. /*   p105Table points to a "FirstEntry" record.                              */
  2010. /*                                                                           */
  2011. /*****************************************************************************/
  2012. UCHAR *Append105Table( LNOTAB *pLnoTab,
  2013.                        FIRST_ENTRY_105 *p105Table,
  2014.                        ULONG BaseOffset,
  2015.                        int    sfi)
  2016. {
  2017.  LINE_NUMBER_TABLE_ENTRY_105 *pFromEntry;
  2018.  
  2019.  int     i;
  2020.  LNOTAB *pToEntry;
  2021.  char   *cptr;
  2022.  USHORT  NumEntries;
  2023.  
  2024.  /****************************************************************************/
  2025.  /* - define the number of entries from the first entry record.              */
  2026.  /* - define the base offset address from the first entry record.            */
  2027.  /* - define a ptr to the first (lno,off,sfi) entry.                         */
  2028.  /****************************************************************************/
  2029.  NumEntries   = p105Table->NumEntries;
  2030.  cptr         = (char*)p105Table + sizeof(FIRST_ENTRY_105);
  2031.  pFromEntry   = (LINE_NUMBER_TABLE_ENTRY_105 *)cptr;
  2032.  pToEntry     = pLnoTab;
  2033.  
  2034.  for( i=1; i <= NumEntries; i++ )
  2035.  {
  2036.   pToEntry->lno = pFromEntry->LineNumber;
  2037.   pToEntry->off = pFromEntry->Offset + BaseOffset;
  2038.   pToEntry->sfi = sfi;
  2039.   pToEntry++;
  2040.   pFromEntry++;
  2041.  }
  2042.  return((UCHAR*)pToEntry);
  2043. }
  2044.  
  2045. /*****************************************************************************/
  2046. /* GetLnoTabEntry()                                                          */
  2047. /*                                                                           */
  2048. /* Description:                                                              */
  2049. /*                                                                           */
  2050. /*   Get the line number table entry for a given (lno,sfi).                  */
  2051. /*                                                                           */
  2052. /* Parameters:                                                               */
  2053. /*                                                                           */
  2054. /*   pModule                                                                 */
  2055. /*   lno                                                                     */
  2056. /*   sfi           source file index                                         */
  2057. /*                                                                           */
  2058. /* Return:                                                                   */
  2059. /*                                                                           */
  2060. /*   pLnoTab       line number table entry.                                  */
  2061. /*                                                                           */
  2062. /* Assumptions:                                                              */
  2063. /*                                                                           */
  2064. /*   sfi != 0                                                                */
  2065. /*                                                                           */
  2066. /*****************************************************************************/
  2067. LNOTAB *GetLnoTabEntry( MODULE *pModule, int lno, int sfi )
  2068. {
  2069.  CSECT  *pCsect;
  2070.  LNOTAB *pLnoTabEntry;
  2071.  LNOTAB *pLnoTab;
  2072.  int     NumEntries;
  2073.  ULONG   lnolo;
  2074.  
  2075.  pLnoTab = NULL;
  2076.  pCsect  = pModule->pCsects;
  2077.  
  2078.  if( lno == 0 )
  2079.  {
  2080.   /***************************************************************************/
  2081.   /* - find the lowest line number in the tables for this sfi.               */
  2082.   /***************************************************************************/
  2083.   lnolo = 0xffffffff;
  2084.   for( ; pCsect != NULL; pCsect=pCsect->next)
  2085.   {
  2086.    NumEntries   = pCsect->NumEntries;
  2087.    pLnoTabEntry = pCsect->pLnoTab;
  2088.  
  2089.    if( (pLnoTabEntry != NULL) && ( NumEntries > 0 ) )
  2090.    {
  2091.     for( ; NumEntries; pLnoTabEntry++, NumEntries-- )
  2092.     {
  2093.      if( (pLnoTabEntry->sfi == sfi) && (pLnoTabEntry->lno < lnolo ) )
  2094.      {
  2095.       lnolo   = pLnoTabEntry->lno;
  2096.       pLnoTab = pLnoTabEntry;
  2097.       break;
  2098.      }
  2099.     }
  2100.    }
  2101.   }
  2102.  }
  2103.  else /* if(lno != 0) */
  2104.  {
  2105.   for( ; (pLnoTab == NULL) && (pCsect != NULL); pCsect=pCsect->next)
  2106.   {
  2107.    NumEntries   = pCsect->NumEntries;
  2108.    pLnoTabEntry = pCsect->pLnoTab;
  2109.  
  2110.    if( (pLnoTabEntry != NULL) && ( NumEntries > 0 ) )
  2111.    {
  2112.     for( ; NumEntries; pLnoTabEntry++, NumEntries-- )
  2113.     {
  2114.      if( (pLnoTabEntry->sfi == sfi) && (pLnoTabEntry->lno == lno ) )
  2115.      {
  2116.       pLnoTab = pLnoTabEntry;
  2117.       break;
  2118.      }
  2119.     }
  2120.    }
  2121.   }
  2122.  }
  2123.  return(pLnoTab);
  2124. }
  2125.  
  2126. /*****************************************************************************/
  2127. /* GetLnoTabNextEntry()                                                      */
  2128. /*                                                                           */
  2129. /* Description:                                                              */
  2130. /*                                                                           */
  2131. /*   Get the next executable line following the (lno,sfi).                   */
  2132. /*                                                                           */
  2133. /* Parameters:                                                               */
  2134. /*                                                                           */
  2135. /*   pModule                                                                 */
  2136. /*   lno                                                                     */
  2137. /*   sfi           source file index                                         */
  2138. /*                                                                           */
  2139. /* Return:                                                                   */
  2140. /*                                                                           */
  2141. /*   pLnoTab       line number table entry.                                  */
  2142. /*                                                                           */
  2143. /* Assumptions:                                                              */
  2144. /*                                                                           */
  2145. /*   sfi != 0                                                                */
  2146. /*   pModule != NULL                                                         */
  2147. /*                                                                           */
  2148. /*****************************************************************************/
  2149. LNOTAB *GetLnoTabNextEntry( MODULE *pModule, int lno, int sfi )
  2150. {
  2151.  CSECT  *pCsect;
  2152.  LNOTAB *pLnoTabEntry;
  2153.  LNOTAB *pLnoNear;
  2154.  int     NumEntries;
  2155.  ULONG   LnoNear;
  2156.  
  2157.  /****************************************************************************/
  2158.  /* - scan the tables and get the max lno for this sfi.                      */
  2159.  /****************************************************************************/
  2160.  LnoNear  = 0xffffffff;
  2161.  pLnoNear = NULL;
  2162.  pCsect   = pModule->pCsects;
  2163.  
  2164.  for( ; pCsect != NULL; pCsect=pCsect->next)
  2165.  {
  2166.   NumEntries   = pCsect->NumEntries;
  2167.   pLnoTabEntry = pCsect->pLnoTab;
  2168.  
  2169.   if( (pLnoTabEntry != NULL) && ( NumEntries > 0 ) )
  2170.   {
  2171.    for( ; NumEntries; pLnoTabEntry++, NumEntries-- )
  2172.    {
  2173.     if( (pLnoTabEntry->sfi == sfi) &&
  2174.         (pLnoTabEntry->lno > lno ) &&
  2175.         (pLnoTabEntry->lno < LnoNear)
  2176.       )
  2177.     {
  2178.      pLnoNear = pLnoTabEntry;
  2179.      LnoNear  = pLnoNear->lno;
  2180.     }
  2181.    }
  2182.   }
  2183.  }
  2184.  
  2185.  return(pLnoNear);
  2186. }
  2187.  
  2188. /*****************************************************************************/
  2189. /* GetLineSpan()                                                             */
  2190. /*                                                                           */
  2191. /* Description:                                                              */
  2192. /*                                                                           */
  2193. /*   Get the span of a line.                                                 */
  2194. /*                                                                           */
  2195. /* Parameters:                                                               */
  2196. /*                                                                           */
  2197. /*   pModule                                                                 */
  2198. /*   pLnoTabBase   -> to line number table entry containing the base line    */
  2199. /*                    that we want the span for.                             */
  2200. /*                                                                           */
  2201. /* Return:                                                                   */
  2202. /*                                                                           */
  2203. /*   span                                                                    */
  2204. /*                                                                           */
  2205. /* Assumptions:                                                              */
  2206. /*                                                                           */
  2207. /*   pModule != NULL                                                         */
  2208. /*   pLnoTabBase != NULL                                                     */
  2209. /*                                                                           */
  2210. /*****************************************************************************/
  2211. ULONG GetLineSpan( MODULE *pModule, LNOTAB *pLnoTabBase  )
  2212. {
  2213.  CSECT  *pCsect;
  2214.  LNOTAB *pLnoTab;
  2215.  int     NumEntries;
  2216.  ULONG   addrlo;
  2217.  ULONG   addrhi;
  2218.  ULONG   LeastDelta;
  2219.  ULONG   delta;
  2220.  ULONG   span;
  2221.  int     n;
  2222.  
  2223.  span   = 0;
  2224.  pCsect = GetCsectWithAddr( pModule, pLnoTabBase->off);
  2225.  
  2226.  if( pCsect )
  2227.  {
  2228.   LeastDelta = 0xFFFFFFFF;
  2229.   addrlo     = pLnoTabBase->off;
  2230.   NumEntries = pCsect->NumEntries;
  2231.   pLnoTab    = pCsect->pLnoTab;
  2232.  
  2233.   for ( n=1 ; n <= NumEntries ; n++, pLnoTab++ )
  2234.   {
  2235.    addrhi = pLnoTab->off;
  2236.    if( (addrhi > addrlo) &&
  2237.        ( (delta = (addrhi - addrlo)) < LeastDelta )
  2238.      )
  2239.     LeastDelta = delta;
  2240. /* printf("\n%10x %10x %10x", addrlo, addrhi, LeastDelta);fflush(0); */
  2241.   }
  2242.  
  2243.   if( LeastDelta == 0xFFFFFFFF )
  2244.    span = pCsect->CsectHi - pLnoTabBase->off + 1;
  2245.   else
  2246.    span = LeastDelta;
  2247.  }
  2248.  
  2249.  return(span);
  2250. }
  2251.  
  2252. /*****************************************************************************/
  2253. /* GetHL04Sfi()                                                              */
  2254. /*                                                                           */
  2255. /* Description:                                                              */
  2256. /*                                                                           */
  2257. /*   Get the sfi for the file.                                               */
  2258. /*                                                                           */
  2259. /* Parameters:                                                               */
  2260. /*                                                                           */
  2261. /*   pFileName                                                               */
  2262. /*   mid                                                                     */
  2263. /*                                                                           */
  2264. /* Return:                                                                   */
  2265. /*                                                                           */
  2266. /*****************************************************************************/
  2267. int GetHL04Sfi( ULONG mid, UCHAR *pFileName )
  2268. {
  2269.  HEADER_HL04  Header;
  2270.  MODULE      *pModule;
  2271.  ULONG        FileNameTableLen;
  2272.  UCHAR       *pFileNameTable = NULL;
  2273.  ULONG        lfo;
  2274.  DEBFILE     *pdf;
  2275.  int          sfi;
  2276.  
  2277.  pdf     = DBFindPdf( mid );
  2278.  pModule = GetPtrToModule( mid, pdf );
  2279.  if( !(pdf && pModule) )
  2280.   return(NULL);
  2281.  
  2282.  /**************************************************************************/
  2283.  /* - move the file pointer to the start of the line number subsection.    */
  2284.  /* - read the header and get the filename table size.                     */
  2285.  /**************************************************************************/
  2286.  lfo = pdf->DebugOff + pModule->LineNums;
  2287.  
  2288.  seekf(pdf, lfo);
  2289.  readf((UCHAR *)&Header, sizeof(Header), pdf);
  2290.  
  2291.  FileNameTableLen = Header.FileNameTableSize -
  2292.                      sizeof(FILE_NAME_TABLE_ENTRY_HL04) + 2;
  2293.  
  2294.  /**************************************************************************/
  2295.  /* - allocate the table.                                                  */
  2296.  /* - move past the header.                                                */
  2297.  /**************************************************************************/
  2298.  pFileNameTable = Talloc(FileNameTableLen);
  2299.  
  2300.  lfo += sizeof(HEADER_HL04) + sizeof(FILE_NAME_TABLE_ENTRY_HL04) - 1;
  2301.  seekf(pdf, lfo);
  2302.  readf( (UCHAR *)pFileNameTable, FileNameTableLen, pdf );
  2303.  
  2304.  sfi = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2305.  
  2306.  Tfree(pFileNameTable);
  2307.  return(sfi);
  2308. }
  2309.  
  2310. /*****************************************************************************/
  2311. /* GetHL03Sfi()                                                              */
  2312. /*                                                                           */
  2313. /* Description:                                                              */
  2314. /*                                                                           */
  2315. /*   Get the sfi for the file.                                               */
  2316. /*                                                                           */
  2317. /* Parameters:                                                               */
  2318. /*                                                                           */
  2319. /*   pFileName                                                               */
  2320. /*   mid                                                                     */
  2321. /*                                                                           */
  2322. /* Return:                                                                   */
  2323. /*                                                                           */
  2324. /*****************************************************************************/
  2325. int GetHL03Sfi( ULONG mid, UCHAR *pFileName )
  2326. {
  2327.  FIRST_ENTRY_HL03  FirstEntry;
  2328.  MODULE           *pModule;
  2329.  ULONG             FileNameTableLen;
  2330.  UCHAR            *pFileNameTable = NULL;
  2331.  ULONG             lfo;
  2332.  DEBFILE          *pdf;
  2333.  int               sfi;
  2334.  int               NumEntries;
  2335.  
  2336.  pdf     = DBFindPdf( mid );
  2337.  pModule = GetPtrToModule( mid, pdf );
  2338.  if( !(pdf && pModule) )
  2339.   return(NULL);
  2340.  
  2341.  /************************************************************************/
  2342.  /* - move the file pointer to the start of the line number subsection.  */
  2343.  /* - read the first entry.                                              */
  2344.  /* - calculate the table size - the table header.                       */
  2345.  /* - allocate the table.                                                */
  2346.  /* - move to the start of the table and read it.                        */
  2347.  /************************************************************************/
  2348.  lfo = pdf->DebugOff + pModule->LineNums;
  2349.  seekf(pdf, lfo);
  2350.  readf((UCHAR *)&FirstEntry, sizeof(FirstEntry), pdf);
  2351.  
  2352.  FileNameTableLen = FirstEntry.FileNameTableSize -
  2353.                      sizeof(FILE_NAME_TABLE_ENTRY_HL03) + 2;
  2354.  
  2355.  pFileNameTable = Talloc(FileNameTableLen);
  2356.  
  2357.  NumEntries = FirstEntry.NumEntries;
  2358.  
  2359.  lfo  = lfo + sizeof(FIRST_ENTRY_HL03) +
  2360.         NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL03) +
  2361.         sizeof(FILE_NAME_TABLE_ENTRY_HL03) - 1;
  2362.  
  2363.  seekf(pdf, lfo);
  2364.  
  2365.  readf( (UCHAR *)pFileNameTable, FileNameTableLen, pdf );
  2366.  
  2367.  sfi = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2368.  Tfree(pFileNameTable);
  2369.  return(sfi);
  2370. }
  2371.  
  2372. /*****************************************************************************/
  2373. /* GetHL01Sfi()                                                              */
  2374. /*                                                                           */
  2375. /* Description:                                                              */
  2376. /*                                                                           */
  2377. /*   Get the sfi for the file.                                               */
  2378. /*                                                                           */
  2379. /* Parameters:                                                               */
  2380. /*                                                                           */
  2381. /*   pFileName                                                               */
  2382. /*   mid                                                                     */
  2383. /*                                                                           */
  2384. /* Return:                                                                   */
  2385. /*                                                                           */
  2386. /*****************************************************************************/
  2387. int GetHL01Sfi( ULONG mid, UCHAR *pFileName )
  2388. {
  2389.  FIRST_ENTRY_HL01  FirstEntry;
  2390.  MODULE           *pModule;
  2391.  ULONG             FileNameTableLen;
  2392.  UCHAR            *pFileNameTable = NULL;
  2393.  ULONG             lfo;
  2394.  DEBFILE          *pdf;
  2395.  int               sfi;
  2396.  int               NumEntries;
  2397.  ULONG             lfostart;
  2398.  UCHAR             FileNameLen;
  2399.  USHORT            PathTableEntries;
  2400.  
  2401.  FILE_NAME_TABLE_ENTRY_HL01    FirstFileNameTableEntry;
  2402.  
  2403.  pdf     = DBFindPdf( mid );
  2404.  pModule = GetPtrToModule( mid, pdf );
  2405.  if( !(pdf && pModule) )
  2406.   return(NULL);
  2407.  
  2408.  /************************************************************************/
  2409.  /* - move the file pointer to the start of the line number subsection.  */
  2410.  /* - read the first entry.                                              */
  2411.  /************************************************************************/
  2412.  lfo = pdf->DebugOff + pModule->LineNums;
  2413.  seekf(pdf, lfo);
  2414.  readf((UCHAR *)&FirstEntry, sizeof(FirstEntry), pdf);
  2415.  
  2416.  /****************************************************************************/
  2417.  /* - move to the start of the file name table and read the first entry.     */
  2418.  /****************************************************************************/
  2419.  NumEntries       = FirstEntry.NumEntries;
  2420.  PathTableEntries = FirstEntry.PathTableEntries;
  2421.  lfo = lfo + sizeof(FirstEntry) +
  2422.        NumEntries*sizeof(LINE_NUMBER_TABLE_ENTRY_HL01) +
  2423.        PathTableEntries*sizeof(PATH_TABLE_ENTRY_HL01);
  2424.  
  2425.  seekf(pdf, lfo);
  2426.  readf( (UCHAR *)&FirstFileNameTableEntry,
  2427.                     sizeof(FirstFileNameTableEntry), pdf);
  2428.  
  2429.  lfostart         = lfo + sizeof(FirstFileNameTableEntry) - 1;
  2430.  NumEntries       = FirstFileNameTableEntry.NumberOfSourceFiles;
  2431.  FileNameTableLen = 0;
  2432.  for( lfo = lfostart; NumEntries--; )
  2433.  {
  2434.   seekf(pdf, lfo);
  2435.   readf( (UCHAR *)&FileNameLen, 1, pdf );
  2436.   FileNameTableLen += FileNameLen + 1;
  2437.   lfo += FileNameLen + 1;
  2438.  }
  2439.  FileNameTableLen += 1; // to grow on
  2440.  
  2441.  pFileNameTable = Talloc(FileNameTableLen);
  2442.  
  2443.  seekf( pdf, lfostart );
  2444.  readf( (UCHAR *)pFileNameTable, FileNameTableLen, pdf );
  2445.  
  2446.  sfi = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2447.  Tfree(pFileNameTable);
  2448.  return(sfi);
  2449. }
  2450.  
  2451. int GetSfi( UCHAR *pFileName, UCHAR *pFileNameTable, ULONG FileNameTableLen )
  2452. {
  2453.  int               sfi;
  2454.  int               index;
  2455.  UCHAR            *pTable;
  2456.  UCHAR            *pTableEnd;
  2457.  
  2458.  pTable    = pFileNameTable;
  2459.  pTableEnd = pFileNameTable + FileNameTableLen - 1;
  2460.  sfi       = 0;
  2461.  for( index=1 ; pTable < pTableEnd; index++ )
  2462.  {
  2463.   char   *cp  = NULL;
  2464.   char   *cpp = NULL;
  2465.   int     len;
  2466.   UCHAR   SaveByte;
  2467.  
  2468.   cp  = pTable;
  2469.  
  2470.   SaveByte    = pTable[*cp+1];
  2471.   pTable[*cp+1] = 0;
  2472.   cpp         = strrchr( cp+1, '\\' );
  2473.  
  2474.   if( cpp == NULL )
  2475.   {
  2476.    /**************************************************************************/
  2477.    /* - come here if no path info.                                           */
  2478.    /**************************************************************************/
  2479.    len = *cp;
  2480.    if( (len == *pFileName) && (strnicmp(pFileName, cp, len+1) == 0) )
  2481.    {
  2482.     sfi = index;
  2483.     break;
  2484.    }
  2485.   }
  2486.   else
  2487.   {
  2488.    /**************************************************************************/
  2489.    /* - come here if there is path info.                                     */
  2490.    /**************************************************************************/
  2491.    cpp =  strrchr( cp+1, '\\' );
  2492.    cpp = cpp + 1;
  2493.    len = *cp -(cpp-cp) + 1;
  2494.    if( (len == *pFileName) && (strnicmp(pFileName+1, cpp, len) == 0) )
  2495.    {
  2496.     sfi = index;
  2497.     break;
  2498.    }
  2499.   }
  2500.   pTable[*cp+1] = SaveByte;
  2501.   pTable += *pTable + 1;
  2502.  }
  2503.  return(sfi);
  2504. }
  2505.  
  2506. /*****************************************************************************/
  2507. /* Get109_16Sfi()                                                            */
  2508. /*                                                                           */
  2509. /* Description:                                                              */
  2510. /*                                                                           */
  2511. /*   Get the source file index in a 109_16 table.                            */
  2512. /*                                                                           */
  2513. /* Parameters:                                                               */
  2514. /*                                                                           */
  2515. /*   pFileName                                                               */
  2516. /*   mid                                                                     */
  2517. /*                                                                           */
  2518. /* Return:                                                                   */
  2519. /*                                                                           */
  2520. /*****************************************************************************/
  2521. int Get109_16Sfi( ULONG mid, UCHAR *pFileName )
  2522. {
  2523.  ULONG                lfo;
  2524.  ULONG                lfoend;
  2525.  ULONG                LineNumberTableSize;
  2526.  FIRST_ENTRY_109_16  *pFirstEntry;
  2527.  FILE_NAME_TABLE_MAP *pTableMap = NULL;
  2528.  FILE_NAME_TABLE_MAP *pmap;
  2529.  FILE_NAME_TABLE_MAP *pnextmap;
  2530.  USHORT               NumEntries;
  2531.  UCHAR               *pLineNumberTable;
  2532.  UCHAR               *pTable;
  2533.  UCHAR               *pTableEnd;
  2534.  int                  FileNameLen;
  2535.  int                  sfi;
  2536.  UCHAR               *pFileNameTable;
  2537.  ULONG                FileNameTableLen;
  2538.  DEBFILE             *pdf;
  2539.  MODULE              *pModule;
  2540.  int                  len;
  2541.  
  2542.  pdf     = DBFindPdf( mid );
  2543.  pModule = GetPtrToModule( mid, pdf );
  2544.  if( !(pdf && pModule) )
  2545.   return(NULL);
  2546.  
  2547.  /****************************************************************************/
  2548.  /* - define long file offsets for the start and end of the table.           */
  2549.  /* - read the line number table into memory.                                */
  2550.  /****************************************************************************/
  2551.  lfo    = pdf->DebugOff + pModule->LineNums;
  2552.  lfoend = lfo + pModule->LineNumsLen - 1;
  2553.  
  2554.  LineNumberTableSize = lfoend - lfo + 1;
  2555.  pLineNumberTable    = Talloc( LineNumberTableSize );
  2556.  
  2557.  seekf(pdf, lfo);
  2558.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  2559.  
  2560.  /****************************************************************************/
  2561.  /* - Scan the line number table and build  a map of pointers to tables.     */
  2562.  /****************************************************************************/
  2563.  pTable       = pLineNumberTable;
  2564.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  2565.  pmap         = (FILE_NAME_TABLE_MAP *)&pTableMap;
  2566.  
  2567.  for( ; pTable < pTableEnd; )
  2568.  {
  2569.   FileNameLen = *pTable;
  2570.   pFirstEntry = (FIRST_ENTRY_109_16*)(pTable + FileNameLen + 1);
  2571.   NumEntries  = pFirstEntry->NumEntries;
  2572.  
  2573.   len = sizeof(FILE_NAME_TABLE_MAP);
  2574.  
  2575.   pmap->next              = (FILE_NAME_TABLE_MAP*)Talloc(len);
  2576.   pmap->next->pFirstEntry = pTable;
  2577.   pmap                    = pmap->next;
  2578.  
  2579.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_109_16) +
  2580.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_109_16);
  2581.  }
  2582.  
  2583.  pFileNameTable = BuildFileNameTable( pTableMap, &FileNameTableLen );
  2584.  sfi            = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2585.  
  2586.  /****************************************************************************/
  2587.  /* - free the table allocated by BuildFileNameTable().                      */
  2588.  /* - free the map.                                                          */
  2589.  /* - free the line number table.                                            */
  2590.  /****************************************************************************/
  2591.  if( pFileNameTable ) Tfree(pFileNameTable);
  2592.  
  2593.  for( pmap = pTableMap ; pmap ; pmap = pnextmap )
  2594.   {pnextmap = pmap->next; Tfree(pmap);}
  2595.  
  2596.  if(pLineNumberTable) Tfree(pLineNumberTable);
  2597.  return(sfi);
  2598. }
  2599.  
  2600. /*****************************************************************************/
  2601. /* Get105Sfi()                                                               */
  2602. /*                                                                           */
  2603. /* Description:                                                              */
  2604. /*                                                                           */
  2605. /*   Get the source file index in a 109_16 table.                            */
  2606. /*                                                                           */
  2607. /* Parameters:                                                               */
  2608. /*                                                                           */
  2609. /*   pFileName                                                               */
  2610. /*   mid                                                                     */
  2611. /*                                                                           */
  2612. /* Return:                                                                   */
  2613. /*                                                                           */
  2614. /*****************************************************************************/
  2615. int Get105Sfi( ULONG mid, UCHAR *pFileName )
  2616. {
  2617.  ULONG                lfo;
  2618.  ULONG                lfoend;
  2619.  ULONG                LineNumberTableSize;
  2620.  FIRST_ENTRY_105     *pFirstEntry;
  2621.  FILE_NAME_TABLE_MAP *pTableMap = NULL;
  2622.  FILE_NAME_TABLE_MAP *pmap;
  2623.  FILE_NAME_TABLE_MAP *pnextmap;
  2624.  USHORT               NumEntries;
  2625.  UCHAR               *pLineNumberTable;
  2626.  UCHAR               *pTable;
  2627.  UCHAR               *pTableEnd;
  2628.  int                  FileNameLen;
  2629.  int                  sfi;
  2630.  UCHAR               *pFileNameTable;
  2631.  ULONG                FileNameTableLen;
  2632.  DEBFILE             *pdf;
  2633.  MODULE              *pModule;
  2634.  int                  len;
  2635.  
  2636.  pdf     = DBFindPdf( mid );
  2637.  pModule = GetPtrToModule( mid, pdf );
  2638.  if( !(pdf && pModule) )
  2639.   return(NULL);
  2640.  
  2641.  /****************************************************************************/
  2642.  /* - define long file offsets for the start and end of the table.           */
  2643.  /* - read the line number table into memory.                                */
  2644.  /****************************************************************************/
  2645.  lfo    = pdf->DebugOff + pModule->LineNums;
  2646.  lfoend = lfo + pModule->LineNumsLen - 1;
  2647.  
  2648.  LineNumberTableSize = lfoend - lfo + 1;
  2649.  pLineNumberTable    = Talloc( LineNumberTableSize );
  2650.  
  2651.  seekf(pdf, lfo);
  2652.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  2653.  
  2654.  /****************************************************************************/
  2655.  /* - Scan the line number table and build  a map of pointers to tables.     */
  2656.  /****************************************************************************/
  2657.  pTable       = pLineNumberTable;
  2658.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  2659.  pmap         = (FILE_NAME_TABLE_MAP *)&pTableMap;
  2660.  
  2661.  for( ; pTable < pTableEnd; )
  2662.  {
  2663.   FileNameLen = *pTable;
  2664.   pFirstEntry = (FIRST_ENTRY_105*)(pTable + FileNameLen + 1);
  2665.   NumEntries  = pFirstEntry->NumEntries;
  2666.  
  2667.   len = sizeof(FILE_NAME_TABLE_MAP);
  2668.  
  2669.   pmap->next              = (FILE_NAME_TABLE_MAP*)Talloc(len);
  2670.   pmap->next->pFirstEntry = pTable;
  2671.   pmap                    = pmap->next;
  2672.  
  2673.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_105) +
  2674.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_105);
  2675.  }
  2676.  
  2677.  pFileNameTable = BuildFileNameTable( pTableMap, &FileNameTableLen );
  2678.  sfi            = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2679.  
  2680.  /****************************************************************************/
  2681.  /* - free the table allocated by BuildFileNameTable().                      */
  2682.  /* - free the map.                                                          */
  2683.  /* - free the line number table.                                            */
  2684.  /****************************************************************************/
  2685.  if( pFileNameTable ) Tfree(pFileNameTable);
  2686.  
  2687.  for( pmap = pTableMap ; pmap ; pmap = pnextmap )
  2688.   {pnextmap = pmap->next; Tfree(pmap);}
  2689.  
  2690.  if(pLineNumberTable) Tfree(pLineNumberTable);
  2691.  return(sfi);
  2692. }
  2693.  
  2694. /*****************************************************************************/
  2695. /* Get109_32Sfi()                                                            */
  2696. /*                                                                           */
  2697. /* Description:                                                              */
  2698. /*                                                                           */
  2699. /*   Get the source file index in a 109_16 table.                            */
  2700. /*                                                                           */
  2701. /* Parameters:                                                               */
  2702. /*                                                                           */
  2703. /*   pFileName                                                               */
  2704. /*   mid                                                                     */
  2705. /*                                                                           */
  2706. /* Return:                                                                   */
  2707. /*                                                                           */
  2708. /*****************************************************************************/
  2709. int Get109_32Sfi( ULONG mid, UCHAR *pFileName )
  2710. {
  2711.  ULONG                lfo;
  2712.  ULONG                lfoend;
  2713.  ULONG                LineNumberTableSize;
  2714.  FIRST_ENTRY_109_32  *pFirstEntry;
  2715.  FILE_NAME_TABLE_MAP *pTableMap = NULL;
  2716.  FILE_NAME_TABLE_MAP *pmap;
  2717.  FILE_NAME_TABLE_MAP *pnextmap;
  2718.  USHORT               NumEntries;
  2719.  UCHAR               *pLineNumberTable;
  2720.  UCHAR               *pTable;
  2721.  UCHAR               *pTableEnd;
  2722.  int                  FileNameLen;
  2723.  int                  sfi;
  2724.  UCHAR               *pFileNameTable;
  2725.  ULONG                FileNameTableLen;
  2726.  DEBFILE             *pdf;
  2727.  MODULE              *pModule;
  2728.  int                  len;
  2729.  
  2730.  pdf     = DBFindPdf( mid );
  2731.  pModule = GetPtrToModule( mid, pdf );
  2732.  if( !(pdf && pModule) )
  2733.   return(NULL);
  2734.  
  2735.  /****************************************************************************/
  2736.  /* - define long file offsets for the start and end of the table.           */
  2737.  /* - read the line number table into memory.                                */
  2738.  /****************************************************************************/
  2739.  lfo    = pdf->DebugOff + pModule->LineNums;
  2740.  lfoend = lfo + pModule->LineNumsLen - 1;
  2741.  
  2742.  LineNumberTableSize = lfoend - lfo + 1;
  2743.  pLineNumberTable    = Talloc( LineNumberTableSize );
  2744.  
  2745.  seekf(pdf, lfo);
  2746.  readf( pLineNumberTable, LineNumberTableSize, pdf);
  2747.  
  2748.  /****************************************************************************/
  2749.  /* - Scan the line number table and build  a map of pointers to tables.     */
  2750.  /****************************************************************************/
  2751.  pTable       = pLineNumberTable;
  2752.  pTableEnd    = pLineNumberTable + LineNumberTableSize;
  2753.  pmap         = (FILE_NAME_TABLE_MAP *)&pTableMap;
  2754.  
  2755.  for( ; pTable < pTableEnd; )
  2756.  {
  2757.   FileNameLen = *pTable;
  2758.   pFirstEntry = (FIRST_ENTRY_109_32*)(pTable + FileNameLen + 1);
  2759.   NumEntries  = pFirstEntry->NumEntries;
  2760.  
  2761.   len = sizeof(FILE_NAME_TABLE_MAP);
  2762.  
  2763.   pmap->next              = (FILE_NAME_TABLE_MAP*)Talloc(len);
  2764.   pmap->next->pFirstEntry = pTable;
  2765.   pmap                    = pmap->next;
  2766.  
  2767.   pTable = pTable + FileNameLen + 1 + sizeof(FIRST_ENTRY_109_32) +
  2768.                      (NumEntries)*sizeof(LINE_NUMBER_TABLE_ENTRY_109_32);
  2769.  }
  2770.  
  2771.  pFileNameTable = BuildFileNameTable( pTableMap, &FileNameTableLen );
  2772.  sfi            = GetSfi( pFileName, pFileNameTable, FileNameTableLen );
  2773.  
  2774.  /****************************************************************************/
  2775.  /* - free the table allocated by BuildFileNameTable().                      */
  2776.  /* - free the map.                                                          */
  2777.  /* - free the line number table.                                            */
  2778.  /****************************************************************************/
  2779.  if( pFileNameTable ) Tfree(pFileNameTable);
  2780.  
  2781.  for( pmap = pTableMap ; pmap ; pmap = pnextmap )
  2782.   {pnextmap = pmap->next; Tfree(pmap);}
  2783.  
  2784.  if(pLineNumberTable) Tfree(pLineNumberTable);
  2785.  return(sfi);
  2786. }
  2787.  
  2788. /*****************************************************************************/
  2789. /* BuildFileNameTable()                                                      */
  2790. /*                                                                           */
  2791. /* Description:                                                              */
  2792. /*                                                                           */
  2793. /*  Build a file name table for MS style tables.                             */
  2794. /*                                                                           */
  2795. /* Parameters:                                                               */
  2796. /*                                                                           */
  2797. /*  pTableMap                                                                */
  2798. /*  pTableLen                                                                */
  2799. /*                                                                           */
  2800. /* Return:                                                                   */
  2801. /*                                                                           */
  2802. /*  pFileNameTable                                                           */
  2803. /*                                                                           */
  2804. /* Assumptions:                                                              */
  2805. /*                                                                           */
  2806. /*****************************************************************************/
  2807. UCHAR *BuildFileNameTable( FILE_NAME_TABLE_MAP *pTableMap, ULONG *pTableLen )
  2808. {
  2809.  UCHAR    *pFileName;
  2810.  UCHAR    *pFileNamex;
  2811.  UCHAR    *pFileNameTable;
  2812.  int       FileTableLen;
  2813.  int       FileNameLen;
  2814.  
  2815.  FILE_NAME_TABLE_MAP *pmap;
  2816.  
  2817.  FileTableLen = 0;
  2818.  for( pmap = pTableMap; pmap != NULL; pmap=pmap->next )
  2819.  {
  2820.   pFileName     = pmap->pFirstEntry;
  2821.   FileTableLen += *pFileName + 1;
  2822.  }
  2823.  
  2824.  FileTableLen   += 1;
  2825.  pFileNameTable  = pFileNamex = Talloc(FileTableLen);
  2826.  
  2827.  for( pmap = pTableMap; pmap != NULL; pmap=pmap->next )
  2828.  {
  2829.   pFileName   = pmap->pFirstEntry;
  2830.   FileNameLen = *pFileName;
  2831.   strncpy(pFileNamex, pFileName, FileNameLen + 1 );
  2832.   pFileNamex  += FileNameLen + 1;
  2833.  }
  2834.  
  2835.  *pTableLen = FileTableLen;
  2836.  return(pFileNameTable);
  2837. }
  2838.