home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / MAPLINES.C < prev    next >
Text File  |  1996-08-21  |  22KB  |  468 lines
  1. /*****************************************************************************/
  2. /* File:                                                                     */
  3. /*   maplines.c                                                              */
  4. /*                                                                           */
  5. /* Description:                                                              */
  6. /*                                                                           */
  7. /*   Mapping funtions for line numbers from other formats to the internal    */
  8. /*   format.                                                                 */
  9. /*                                                                           */
  10. /* History:                                                                  */
  11. /*                                                                           */
  12. /*   04/06/95 Updated.                                                       */
  13. /*                                                                           */
  14. /*****************************************************************************/
  15.  
  16. #include "all.h"
  17.  
  18. /*****************************************************************************/
  19. /* MapHL04LineNumbers()                                                      */
  20. /*                                                                           */
  21. /* Description:                                                              */
  22. /*                                                                           */
  23. /*   Map HL04 line numbers to an internal table.                             */
  24. /*                                                                           */
  25. /* Parameters:                                                               */
  26. /*                                                                           */
  27. /*   pLineNumberTable          -> to the table we're mapping from.           */
  28. /*   CountOfLineNumberEntries  number of entries in the table.               */
  29. /*   pTrueLineNumberEntryCount -> receiver of the actual number of entries   */
  30. /*                               mapped.                                     */
  31. /*   BaseOffset               base added to line number table value.         */
  32. /*                                                                           */
  33. /* Return:                                                                   */
  34. /*                                                                           */
  35. /*   pTrueLineNumberTable -> to the table we're mapping into.                */
  36. /*                                                                           */
  37. /* Assumptions:                                                              */
  38. /*                                                                           */
  39. /*****************************************************************************/
  40. LINNUM_ENTRY *MapHL04LineNumbers(LINE_NUMBER_TABLE_ENTRY_HL04 *pLineNumberTable,
  41.                                  USHORT  CountOfLineNumberEntries,
  42.                                  USHORT *pTrueLineNumberEntryCount,
  43.                                  ULONG   BaseOffset )
  44. {
  45.  int i;
  46.  
  47.  USHORT             TrueLineNumberEntryCount;
  48.  USHORT             PreviousLineNumber;
  49.  ULONG              TrueLineNumberTableSize;
  50.  LINNUM_ENTRY     *pTrueLineNumberTable;
  51.  
  52.  LINE_NUMBER_TABLE_ENTRY_HL04 *pLineNumberEntry;
  53.  LINNUM_ENTRY                 *pTrueLineNumberEntry;
  54.  
  55.  /****************************************************************************/
  56.  /* - We will extract the line number entries from the first table for       */
  57.  /*   the top level source file( source file index = 1).                     */
  58.  /*                                                                          */
  59.  /*   NOTE:                                                                  */
  60.  /*                                                                          */
  61.  /*   There may be multiple tables if the user has used the alloc_text       */
  62.  /*   pragma.  There may also be multiple tables if the user has pulled in   */
  63.  /*   code from an include file.  At this point, neither multiple code       */
  64.  /*   segments or code in include files is supported.                        */
  65.  /*                                                                          */
  66.  /****************************************************************************/
  67.  
  68.  /****************************************************************************/
  69.  /* - Scan the table and zero out the line numbers that are not for source   */
  70.  /*   file index == 1.                                                       */
  71.  /****************************************************************************/
  72.  pLineNumberEntry   = pLineNumberTable;
  73.  PreviousLineNumber = pLineNumberEntry->LineNumber;
  74.  
  75.  for( i=1; i <= CountOfLineNumberEntries; i++ )
  76.  {
  77.   if( pLineNumberEntry->SourceFileIndex != 1 )
  78.    pLineNumberEntry->LineNumber = 0;
  79.   pLineNumberEntry++;
  80.  }
  81.  
  82.  /****************************************************************************/
  83.  /* - sort the table precipitating zero entries.                             */
  84.  /****************************************************************************/
  85.  qsort( pLineNumberTable,               /* ->to line number table.           */
  86.         CountOfLineNumberEntries,       /* number of table entries.          */
  87.         sizeof(*pLineNumberEntry),      /* size of a single entry.           */
  88.         compare                         /* qsort required compare function.  */
  89.       );
  90.  
  91.  /****************************************************************************/
  92.  /* Now, eliminate duplicate entries.                                        */
  93.  /*                                                                          */
  94.  /*  - scan past the 0 entries at the bottom of the table.                   */
  95.  /*  - set duplicate entries to 0 while retaining the duplicate with the     */
  96.  /*    lowest offset.                                                        */
  97.  /****************************************************************************/
  98.  pLineNumberEntry = pLineNumberTable;
  99.  for( i=1; i <= CountOfLineNumberEntries; i++ )
  100.  {
  101.   if(pLineNumberEntry->LineNumber != 0)
  102.    break;
  103.   pLineNumberEntry++;
  104.  }
  105.  
  106.  PreviousLineNumber = pLineNumberEntry->LineNumber;
  107.  pLineNumberEntry++;
  108.  
  109.  for( ; i <= CountOfLineNumberEntries; i++ )
  110.  {
  111.   if( pLineNumberEntry->LineNumber == PreviousLineNumber )
  112.   {
  113.    /**************************************************************************/
  114.    /* - count the number of duplicate entries                                */
  115.    /**************************************************************************/
  116.    LINE_NUMBER_TABLE_ENTRY_HL04 *pEntry;
  117.  
  118.    int NumberOfDuplicateEntries;
  119.    int j;
  120.  
  121.    NumberOfDuplicateEntries = 1;
  122.    pEntry                   = pLineNumberEntry;
  123.    j                        = i;
  124.  
  125.    while( (pEntry->LineNumber == PreviousLineNumber) &&
  126.           (j <= CountOfLineNumberEntries)
  127.         )
  128.    {
  129.     NumberOfDuplicateEntries++; j++; pEntry++;
  130.    }
  131.  
  132.    /**************************************************************************/
  133.    /* - sort the piece of the table to preserve the offset order. this may   */
  134.    /*   have been screwed up by the first sort.                              */
  135.    /**************************************************************************/
  136.    pEntry = pLineNumberEntry;
  137.    pEntry--;
  138.    qsort( pEntry,                         /* ->to line number table.         */
  139.           NumberOfDuplicateEntries,       /* number of entries duplicated.   */
  140.           sizeof(*pLineNumberEntry),      /* size of a single entry.         */
  141.           ucompare                        /* qsort required compare function.*/
  142.         );
  143.  
  144.    /**************************************************************************/
  145.    /* - set duplicate entries to zero.                                       */
  146.    /**************************************************************************/
  147.    pEntry++;
  148.    for( j=2; j <= NumberOfDuplicateEntries; j++, pEntry++ )
  149.    {
  150.     pEntry->LineNumber = 0;
  151.    }
  152.  
  153.    /**************************************************************************/
  154.    /* - update the loop variables.                                           */
  155.    /**************************************************************************/
  156.    i                += NumberOfDuplicateEntries;
  157.    pLineNumberEntry =  pEntry;
  158.   }
  159.   PreviousLineNumber = pLineNumberEntry->LineNumber;
  160.   pLineNumberEntry++;
  161.  }
  162.  
  163.  /****************************************************************************/
  164.  /* - now, count the number of entries that we're going to map.              */
  165.  /****************************************************************************/
  166.  pLineNumberEntry         = pLineNumberTable;
  167.  PreviousLineNumber       = pLineNumberEntry->LineNumber;
  168.  TrueLineNumberEntryCount = 0;
  169.  
  170.  for( i=1; i <= CountOfLineNumberEntries; i++ )
  171.  {
  172.   if( pLineNumberEntry->LineNumber != 0 )
  173.    TrueLineNumberEntryCount++;
  174.   pLineNumberEntry++;
  175.  }
  176.  
  177.  /****************************************************************************/
  178.  /* - give the caller the number of entries that will be in the table.       */
  179.  /****************************************************************************/
  180.  *pTrueLineNumberEntryCount = TrueLineNumberEntryCount;
  181.  
  182.  /****************************************************************************/
  183.  /* - now, do the mapping.                                                   */
  184.  /****************************************************************************/
  185.  TrueLineNumberTableSize = TrueLineNumberEntryCount* sizeof(LINNUM_ENTRY);
  186.  pTrueLineNumberTable    = Talloc( TrueLineNumberTableSize );
  187.  pLineNumberEntry        = pLineNumberTable;
  188.  pTrueLineNumberEntry    = pTrueLineNumberTable;
  189.  
  190.  for( i=1; i <= CountOfLineNumberEntries; i++ )
  191.  {
  192.   if( pLineNumberEntry->LineNumber != 0 )
  193.   {
  194.    pTrueLineNumberEntry->lno = pLineNumberEntry->LineNumber;
  195.    pTrueLineNumberEntry->off = pLineNumberEntry->Offset + BaseOffset;
  196.  
  197.    pLineNumberEntry++;
  198.    pTrueLineNumberEntry++;
  199.   }
  200.   else
  201.    pLineNumberEntry++;
  202.  }
  203.  
  204. #if 0
  205. /*****************************************************************************/
  206. /* - print the line number table                                             */
  207. /*****************************************************************************/
  208. {
  209.  LINNUM_ENTRY *pEntry;
  210.  
  211.  pEntry = pTrueLineNumberTable;
  212.  printf("\n\nBaseoffset=%x", BaseOffset);
  213.  for( i = 1; i<=TrueLineNumberEntryCount; i++ )
  214.  {
  215.   printf("\nlno=%d, offset=%x", pEntry->lno, pEntry->off );fflush(0);
  216.   pEntry++;
  217.  }
  218. }
  219. #endif
  220.  
  221.  return(pTrueLineNumberTable);
  222. }
  223.  
  224. /*****************************************************************************/
  225. /* MapCV16LineNumbers()                                                      */
  226. /*                                                                           */
  227. /* Description:                                                              */
  228. /*   Map a 16 bit MSC raw line number table to the internal line number      */
  229. /*   table.                                                                  */
  230. /*                                                                           */
  231. /* Parameters:                                                               */
  232. /*   RawTable       (input)  - Pointer to the raw line number table.         */
  233. /*   InternalTable  (output) - Pointer to the internal line number table.    */
  234. /*   TableSize      (input)  - Size of the raw line number table.            */
  235. /*   ModSegIndex    (input)  - Segment number of the module.                 */
  236. /*                                                                           */
  237. /* Return:                                                                   */
  238. /*   None.                                                                   */
  239. /*                                                                           */
  240. /* Assumptions:                                                              */
  241. /*                                                                           */
  242. /* - Raw line number table has already been loaded into the memory.          */
  243. /* - Memory for the internal line number table has already been allocated.   */
  244. /*                                                                           */
  245. /*****************************************************************************/
  246. void  MapCV16LineNumbers( uint *RawTable, uint *InternalTable,
  247.                             uint TableSize, ushort ModSegIndex )
  248. {
  249.   uchar  *TablePtr;
  250.   uchar  *EndTable;
  251.   uint    Skip;
  252.   uint    NumLnoEntries;
  253.   uint    Size;
  254.   ushort  SegIndex;
  255.   uchar   *IntTablePtr = (uchar *)InternalTable;
  256.  
  257.   /***************************************************************************/
  258.   /* The raw line number table for MSC 16 bit module has                     */
  259.   /* - 2 byte line number                                                    */
  260.   /* - 2 byte offset                                                         */
  261.   /* for each line number entry. We have to copy the line number and offset  */
  262.   /* to our internal table which has 4 byte offset for each entry.           */
  263.   /***************************************************************************/
  264.   TablePtr = (uchar *)RawTable;
  265.   EndTable = TablePtr + TableSize;
  266.  
  267.   /***************************************************************************/
  268.   /* - Scan through the raw table and map those entries which are in the     */
  269.   /*   module's segment to the internal line number table.                   */
  270.   /***************************************************************************/
  271.   while( TablePtr < EndTable )
  272.   {
  273.     Skip = *TablePtr + 1;
  274.     TablePtr += Skip;
  275.  
  276.     SegIndex = *(ushort *)TablePtr;
  277.     TablePtr += 2;
  278.  
  279.     NumLnoEntries = *(ushort *)TablePtr;
  280.     TablePtr += 2;
  281.  
  282.     Size = NumLnoEntries * (2 * sizeof( ushort ));
  283.  
  284.     if( SegIndex == ModSegIndex )
  285.     {
  286.       LNOTAB16  *pLnoTable16;
  287.       LNOTAB    *pLnoTable32;
  288.       int        i;
  289.  
  290.       pLnoTable16 = (LNOTAB16 *)TablePtr;
  291.       pLnoTable32 = (LNOTAB *)IntTablePtr;
  292.  
  293.       for( i = 0; i < NumLnoEntries; i++ )
  294.       {
  295.         pLnoTable32->lno = pLnoTable16->lno;
  296.         pLnoTable32->off = pLnoTable16->off;
  297.         pLnoTable32++;
  298.         pLnoTable16++;
  299.       }
  300.       IntTablePtr = (uchar *)pLnoTable32;
  301.     }
  302.     TablePtr += Size;
  303.   }
  304. }
  305.  
  306. /*****************************************************************************/
  307. /* MapT105LineNumbers()                                                      */
  308. /*                                                                           */
  309. /* Description:                                                              */
  310. /*   Map a IBM C2 1.1 raw line number table to the internal line number      */
  311. /*   table.                                                                  */
  312. /*                                                                           */
  313. /* Parameters:                                                               */
  314. /*   RawTable       (input)  - Pointer to the raw line number table.         */
  315. /*   InternalTable  (output) - Pointer to the internal line number table.    */
  316. /*   TableSize      (input)  - Size of the raw line number table.            */
  317. /*                                                                           */
  318. /* Return:                                                                   */
  319. /*   None.                                                                   */
  320. /*                                                                           */
  321. /* Assumptions:                                                              */
  322. /*                                                                           */
  323. /* - Raw line number table has already been loaded into the memory.          */
  324. /* - Memory for the internal line number table has already been allocated.   */
  325. /*                                                                           */
  326. /*****************************************************************************/
  327. void  MapT105LineNumbers( uint *RawTable, uint *InternalTable,
  328.                           uint TableSize )
  329. {
  330.   uchar    *TablePtr;
  331.   uchar    *EndTable;
  332.   uint     Skip;
  333.   uint     NumLnoEntries;
  334.   uint     Size;
  335.   LNOTAB16 *pLnoTable16;
  336.   LNOTAB   *pLnoTable32;
  337.   int      i;
  338.   uchar    *IntTablePtr = (uchar *)InternalTable;
  339.  
  340.   TablePtr = (uchar *)RawTable;
  341.   EndTable = TablePtr + TableSize;
  342.  
  343.   /***************************************************************************/
  344.   /* The raw line number table for IBM C2 1.1 module has                     */
  345.   /* - 2 byte line number                                                    */
  346.   /* - 2 byte offset                                                         */
  347.   /* for each line number entry. We have to copy the line number and offset  */
  348.   /* to our internal table which has 4 byte offset for each entry.           */
  349.   /* - Scan through the raw table and map the entries to the internal line   */
  350.   /*   number table.                                                         */
  351.   /***************************************************************************/
  352.   while( TablePtr < EndTable )
  353.   {
  354.     Skip = *TablePtr + 1;
  355.     TablePtr += Skip;
  356.  
  357.     NumLnoEntries = *(ushort *)TablePtr;
  358.     TablePtr += 2;
  359.  
  360.     Size = NumLnoEntries * (2 * sizeof( ushort ));
  361.  
  362.     pLnoTable16 = (LNOTAB16 *)TablePtr;
  363.     pLnoTable32 = (LNOTAB *)IntTablePtr;
  364.  
  365.     for( i = 0; i < NumLnoEntries; i++ )
  366.     {
  367.       pLnoTable32->lno = pLnoTable16->lno;
  368.       pLnoTable32->off = pLnoTable16->off;
  369.       pLnoTable32++;
  370.       pLnoTable16++;
  371.     }
  372.     IntTablePtr = (uchar *)pLnoTable32;
  373.     TablePtr += Size;
  374.   }
  375. }
  376.  
  377. /*****************************************************************************/
  378. /* MapCV32LineNumbers()                                                      */
  379. /*                                                                           */
  380. /* Description:                                                              */
  381. /*   Map a 32 bit MSC raw line number table to the internal line number      */
  382. /*   table.                                                                  */
  383. /*                                                                           */
  384. /* Parameters:                                                               */
  385. /*   RawTable       (input)  - Pointer to the raw line number table.         */
  386. /*   InternalTable  (output) - Pointer to the internal line number table.    */
  387. /*   TableSize      (input)  - Size of the raw line number table.            */
  388. /*   ModSegIndex    (input)  - Segment number of the module.                 */
  389. /*                                                                           */
  390. /* Return:                                                                   */
  391. /*   None.                                                                   */
  392. /*                                                                           */
  393. /* Assumptions:                                                              */
  394. /*                                                                           */
  395. /* - Raw line number table has already been loaded into the memory.          */
  396. /* - Memory for the internal line number table has already been allocated.   */
  397. /*                                                                           */
  398. /*****************************************************************************/
  399. void  MapCV32LineNumbers( uint *RawTable, uint *InternalTable,
  400.                           uint TableSize, ushort ModSegIndex )
  401. {
  402.   uchar  *TablePtr;
  403.   uchar  *EndTable;
  404.   uint    Skip;
  405.   uint    NumLnoEntries;
  406.   uint    Size;
  407.   ushort  SegIndex;
  408.  
  409.   /***************************************************************************/
  410.   /* The raw line number table for MSC 32 bit module has                     */
  411.   /* - 2 byte line number                                                    */
  412.   /* - 4 byte offset                                                         */
  413.   /* for each line number entry. We can do a memcpy for the entries since it */
  414.   /* has the same format as our internal line number table.                  */
  415.   /***************************************************************************/
  416.   TablePtr = (uchar *)RawTable;
  417.   EndTable = TablePtr + TableSize;
  418.  
  419.   /***************************************************************************/
  420.   /* Scan through the raw line number table, memcpy the info for the entries */
  421.   /* in the module's segment.                                                */
  422.   /***************************************************************************/
  423.   while( TablePtr < EndTable )
  424.   {
  425.     Skip = *TablePtr + 1;
  426.     TablePtr += Skip;
  427.  
  428.     SegIndex = *(ushort *)TablePtr;
  429.     TablePtr += 2;
  430.  
  431.     NumLnoEntries = *(ushort *)TablePtr;
  432.     TablePtr += 2;
  433.  
  434.     Size = NumLnoEntries * (sizeof( ushort ) + sizeof( ulong ));
  435.  
  436.     if( SegIndex == ModSegIndex )
  437.     {
  438.       memcpy( InternalTable, TablePtr, Size );
  439.       InternalTable += Size;
  440.     }
  441.     TablePtr += Size;
  442.   }
  443. }
  444.  
  445. /*****************************************************************************/
  446. /* compare function for qsort                                                */
  447. /*****************************************************************************/
  448. int compare( const void *key, const void *element)
  449. {
  450.  if( *(USHORT*)key <  *(USHORT*)element) return(-1) ;
  451.  if( *(USHORT*)key == *(USHORT*)element) return( 0) ;
  452.  if( *(USHORT*)key >  *(USHORT*)element) return(+1) ;
  453. }
  454.  
  455. int ucompare( const void *key, const void *element)
  456. {
  457.  LINE_NUMBER_TABLE_ENTRY_HL04 *pkey;
  458.  LINE_NUMBER_TABLE_ENTRY_HL04 *pelement;
  459.  
  460.  pkey     = (LINE_NUMBER_TABLE_ENTRY_HL04 *)key;
  461.  pelement = (LINE_NUMBER_TABLE_ENTRY_HL04 *)element;
  462.  
  463.  if( pkey->Offset <  pelement->Offset ) return(-1) ;
  464.  if( pkey->Offset == pelement->Offset ) return( 0) ;
  465.  if( pkey->Offset >  pelement->Offset ) return(+1) ;
  466. }
  467.  
  468.