home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sd386v50.zip / sd386src.zip / MAPSYMS.C < prev    next >
Text File  |  1995-04-13  |  34KB  |  778 lines
  1. /*****************************************************************************/
  2. /* File:                                             IBM INTERNAL USE ONLY813*/
  3. /*   mapsyms.                                                                */
  4. /*                                                                           */
  5. /* Description:                                                              */
  6. /*                                                                           */
  7. /*   Mapping funtions for symbols from other formats to the internal format. */
  8. /*                                                                           */
  9. /* History:                                                                  */
  10. /*...                                                                        */
  11. /*... 03/01/93  813   Selwyn    Changes for HL02/HL03.                       */
  12. /*****************************************************************************/
  13. #include "all.h"                        /* SD86 include files                */
  14. #include "mapsyms.h"                    /*                                   */
  15.  
  16. /*****************************************************************************/
  17. /* MapMS16Syms()                                                          809*/
  18. /*                                                                           */
  19. /* Description:                                                              */
  20. /*   Map a 16 bit MSC 6.0/IBM C2 1.1 raw symbol table to the internal symbol */
  21. /*   table.                                                                  */
  22. /*                                                                           */
  23. /* Parameters:                                                               */
  24. /*   RawTable       (input)  - Pointer to the raw symbol table.              */
  25. /*   IntSymTable    (output) - Pointer to the internal symbol table.         */
  26. /*   symlen         (input)  - Length of the raw symbol table.               */
  27. /*                                                                           */
  28. /* Return:                                                                   */
  29. /*   None.                                                                   */
  30. /*                                                                           */
  31. /* Assumptions:                                                              */
  32. /*                                                                           */
  33. /* - Raw symbol table has already been loaded into the memory.               */
  34. /* - Memory for the internal symbol table has already been allocated.        */
  35. /*                                                                           */
  36. /*****************************************************************************/
  37. void  MapMS16Syms( uchar *RawTable, SSRec *IntSymTable, uint symlen )   /*809*/
  38. {
  39.   int LenSymSectionMS16;
  40.   SSRec *mapptr;
  41.   SSrec *MS16ptr;
  42.   uchar  MS16len;
  43.  
  44.   LenSymSectionMS16 = symlen;
  45.   MS16ptr = (SSrec *)RawTable;
  46.   mapptr = IntSymTable;
  47.  
  48.   /***************************************************************************/
  49.   /* Scan the Raw symbol table. Depending on the type of each raw symbol     */
  50.   /* table record, copy the information to the internal symbol table record. */
  51.   /***************************************************************************/
  52.   while( LenSymSectionMS16 > 0 )
  53.   {
  54.     LenSymSectionMS16 -= (MS16ptr->RecLen + 1);
  55.     switch( MS16ptr->RecType )
  56.     {
  57.       case SSPROC:
  58.       {
  59.         SSProc    *procmapptr  = (SSProc  *)mapptr;
  60.         SSProc16  *proc16ptr   = (SSProc16 *)MS16ptr;
  61.  
  62.         MS16len = proc16ptr->RecLen;
  63.         procmapptr->RecLen     = MS16len + 8;
  64.         procmapptr->Flags      = PROCEDURE;
  65.         procmapptr->RecType    = SSPROC;
  66.  
  67.         procmapptr->ProcOffset = proc16ptr->ProcOffset;
  68.         /*********************************************************************/
  69.         /* - Change the "A*" in the 0:16 pointer type indexes to "E*".       */
  70.         /*********************************************************************/
  71.         procmapptr->TypeIndex  = GetInternal0_16PtrIndex(
  72.                                    proc16ptr->TypeIndex );
  73.         procmapptr->ProcLen    = proc16ptr->ProcLen;
  74.  
  75.         procmapptr->DebugStart = proc16ptr->DebugStart;
  76.         procmapptr->DebugEnd   = proc16ptr->DebugEnd;
  77.  
  78.         procmapptr->ClassType  = proc16ptr->Reserved;
  79.         procmapptr->NearFar    = proc16ptr->NearFar;
  80.         procmapptr->NameLen    = (ushort)proc16ptr->Name[0];
  81.  
  82.         strncpy( procmapptr->Name, &(proc16ptr->Name[1]),
  83.                  proc16ptr->Name[0] );
  84.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  85.         mapptr  = (SSRec *)((uchar *)mapptr + procmapptr->RecLen + 2);
  86.         break;
  87.       }
  88.  
  89.       case SSBEGIN:
  90.       {
  91.         SSBegin16 *Begin16ptr  = (SSBegin16 *)MS16ptr;
  92.         SSBegin   *Beginmapptr = (SSBegin *)mapptr;
  93.  
  94.         MS16len = Begin16ptr->RecLen;
  95.         Beginmapptr->RecLen      = sizeof( SSBegin ) - 2;
  96.         Beginmapptr->RecType     = SSBEGIN;
  97.  
  98.         Beginmapptr->BlockOffset = Begin16ptr->BlockOffset;
  99.         Beginmapptr->BlockLen    = Begin16ptr->BlockLen;
  100.  
  101.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  102.         mapptr = (SSRec *)((uchar *)mapptr + Beginmapptr->RecLen + 2);
  103.         break;
  104.       }
  105.  
  106.       case SSEND:
  107.       {
  108.         SSEnd16 *End16ptr  = (SSEnd16 *)MS16ptr;
  109.         SSEnd   *Endmapptr = (SSEnd  *)mapptr;
  110.  
  111.         MS16len = End16ptr->RecLen;
  112.         Endmapptr->RecLen   = sizeof( SSEnd ) - 2;
  113.         Endmapptr->RecType  = SSEND;
  114.         mapptr = (SSRec *)((uchar *)mapptr + Endmapptr->RecLen + 2);
  115.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  116.         break;
  117.       }
  118.  
  119.       case SSDEF:
  120.       {
  121.         SSDef16 *Def16ptr  = (SSDef16 *)MS16ptr;
  122.         SSDef   *Defmapptr = (SSDef  *)mapptr;
  123.         short    FrameOffset = 0;
  124.  
  125.         MS16len = Def16ptr->RecLen;
  126.         Defmapptr->RecLen   = MS16len + 3;
  127.         Defmapptr->RecType  = SSDEF;
  128.         FrameOffset = Def16ptr->FrameOffset;
  129.         if( FrameOffset < 0 )
  130.           Defmapptr->FrameOffset = -(int)(- FrameOffset);
  131.         else
  132.           Defmapptr->FrameOffset = (int)FrameOffset;
  133.         /*********************************************************************/
  134.         /* - Change the "A*" in the 0:16 pointer type indexes to "E*".       */
  135.         /*********************************************************************/
  136.         Defmapptr->TypeIndex   = GetInternal0_16PtrIndex( Def16ptr->TypeIndex );
  137.         Defmapptr->NameLen     = (ushort)Def16ptr->Name[0];
  138.  
  139.         strncpy( Defmapptr->Name, &(Def16ptr->Name[1]), Def16ptr->Name[0] );
  140.         mapptr = (SSRec *)((uchar *)mapptr + Defmapptr->RecLen + 2);
  141.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  142.         break;
  143.       }
  144.  
  145.       case SSVAR:
  146.       {
  147.         SSVar16  *Var16ptr   = (SSVar16 *)MS16ptr;
  148.         SSVar    *Varmapptr  = (SSVar  *)mapptr;
  149.  
  150.         MS16len = Var16ptr->RecLen;
  151.         Varmapptr->RecLen    = MS16len + 4;
  152.         Varmapptr->Flags     = STATIC;
  153.         Varmapptr->RecType   = SSVAR;
  154.         Varmapptr->Offset    = Var16ptr->Offset;
  155.         Varmapptr->ObjectNum = Var16ptr->ObjectNum;
  156.         /*********************************************************************/
  157.         /* - Change the "A*" in the 0:16 pointer type indexes to "E*".       */
  158.         /*********************************************************************/
  159.         Varmapptr->TypeIndex = GetInternal0_16PtrIndex( Var16ptr->TypeIndex );
  160.         Varmapptr->NameLen   = (ushort)Var16ptr->Name[0];
  161.  
  162.         strncpy( Varmapptr->Name, &(Var16ptr->Name[1]), Var16ptr->Name[0] );
  163.         mapptr = (SSRec *)((uchar *)mapptr + Varmapptr->RecLen + 2);
  164.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  165.         break;
  166.       }
  167.  
  168.       case SSCHGDEF:
  169.       {
  170.         SSChgDef16  *ChgDef16ptr  = (SSChgDef16 *)MS16ptr;
  171.         SSChgDef    *ChgDefmapptr = (SSChgDef  *)mapptr;
  172.  
  173.         MS16len = ChgDef16ptr->RecLen;
  174.         ChgDefmapptr->RecLen   = sizeof( SSChgDef ) - 2;
  175.         ChgDefmapptr->RecType  = SSCHGDEF;
  176.         ChgDefmapptr->SegNum   = ChgDef16ptr->SegNum;
  177.         ChgDefmapptr->Reserved = ChgDef16ptr->Reserved;
  178.  
  179.         mapptr = (SSRec *)((uchar *)mapptr + ChgDefmapptr->RecLen + 2);
  180.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  181.         break;
  182.       }
  183.  
  184.       case SSUSERDEF:
  185.       {
  186.         SSUserDef16 *UserDef16ptr  = (SSUserDef16 *)MS16ptr;
  187.         SSUserDef   *UserDefmapptr = (SSUserDef *)mapptr;
  188.  
  189.         MS16len = UserDef16ptr->RecLen;
  190.         UserDefmapptr->RecLen    = MS16len + 1;
  191.         UserDefmapptr->RecType   = SSUSERDEF;
  192.         /*********************************************************************/
  193.         /* - Change the "A*" in the 0:16 pointer type indexes to "E*".       */
  194.         /*********************************************************************/
  195.         UserDefmapptr->TypeIndex = GetInternal0_16PtrIndex(
  196.                                      UserDef16ptr->TypeIndex );
  197.         UserDefmapptr->NameLen   = (ushort)UserDef16ptr->Name[0];
  198.         strncpy( UserDefmapptr->Name, &(UserDef16ptr->Name[1]),
  199.                  UserDef16ptr->Name[0] );
  200.  
  201.         mapptr = (SSRec *)((uchar *)mapptr + UserDefmapptr->RecLen + 2);
  202.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  203.         break;
  204.       }
  205.  
  206.       case SSREG:
  207.       {
  208.         SSReg16 *Reg16ptr  = (SSReg16 *)MS16ptr;
  209.         SSReg   *Regmapptr = (SSReg  *)mapptr;
  210.  
  211.         MS16len = Reg16ptr->RecLen;
  212.         Regmapptr->RecLen    = MS16len + 1;
  213.         Regmapptr->RecType   = SSREG;
  214.         /*********************************************************************/
  215.         /* - Change the "A*" in the 0:16 pointer type indexes to "E*".       */
  216.         /*********************************************************************/
  217.         Regmapptr->TypeIndex = GetInternal0_16PtrIndex( Reg16ptr->TypeIndex );
  218.         Regmapptr->RegNum    = Reg16ptr->RegNum;
  219.         Regmapptr->NameLen   = (ushort)Reg16ptr->Name[0];
  220.         strncpy( Regmapptr->Name, &(Reg16ptr->Name[1]),
  221.                  Reg16ptr->Name[0] );
  222.  
  223.         mapptr = (SSRec *)((uchar *)mapptr + Regmapptr->RecLen + 2);
  224.         MS16ptr = (SSrec *)((uchar *)MS16ptr + MS16len + 1);
  225.         break;
  226.       }
  227.  
  228.       default:
  229.       {                                                                 /*810*/
  230.         SSReg16 *Reg16ptr = (SSReg16 *)MS16ptr;                         /*810*/
  231.         MS16ptr = (SSrec *)((uchar *)MS16ptr + Reg16ptr->RecLen + 1);   /*810*/
  232.         break;                                                          /*810*/
  233.       }                                                                 /*810*/
  234.     }
  235.   }
  236. }
  237.  
  238. /*****************************************************************************/
  239. /* MapMS32Syms()                                                          809*/
  240. /*                                                                           */
  241. /* Description:                                                              */
  242. /*   Map a 32 bit MSC 6.0 raw symbol table to the internal symbol table.     */
  243. /*                                                                           */
  244. /* Parameters:                                                               */
  245. /*   RawTable       (input)  - Pointer to the raw symbol table.              */
  246. /*   IntSymTable    (output) - Pointer to the internal symbol table          */
  247. /*   symlen         (input)  - Length of the raw symbol table.               */
  248. /*                                                                           */
  249. /* Return:                                                                   */
  250. /*   None.                                                                   */
  251. /*                                                                           */
  252. /* Assumptions:                                                              */
  253. /*                                                                           */
  254. /* - Raw symbol table has already been loaded into the memory.               */
  255. /* - Memory for the internal symbol table has already been allocated.        */
  256. /*                                                                           */
  257. /*****************************************************************************/
  258. void  MapMS32Syms( uchar *RawTable, SSRec *IntSymTable, uint symlen )   /*809*/
  259. {
  260.   int LenSymSectionMS32;
  261.   SSRec *mapptr;
  262.   SSrec *MS32ptr;
  263.   uchar  MS32len;
  264.  
  265.   LenSymSectionMS32 = symlen;
  266.   MS32ptr = (SSrec *)RawTable;
  267.   mapptr = IntSymTable;
  268.  
  269.   /***************************************************************************/
  270.   /* Scan the Raw symbol table. Depending on the type of each raw symbol     */
  271.   /* table record, copy the information to the internal symbol table record. */
  272.   /***************************************************************************/
  273.   while( LenSymSectionMS32 > 0 )
  274.   {
  275.     LenSymSectionMS32 -= (MS32ptr->RecLen + 1);
  276.     switch( MS32ptr->RecType )
  277.     {
  278.       case SSPROC32:
  279.       {
  280.         SSProc    *procmapptr  = (SSProc  *)mapptr;
  281.         SSProc32  *proc32ptr   = (SSProc32 *)MS32ptr;
  282.  
  283.         MS32len = proc32ptr->RecLen;
  284.         procmapptr->RecLen     = MS32len + 6;
  285.         procmapptr->Flags      = PROCEDURE;
  286.         procmapptr->RecType    = SSPROC;
  287.  
  288.         procmapptr->ProcOffset = proc32ptr->ProcOffset;
  289.         procmapptr->TypeIndex  = proc32ptr->TypeIndex;
  290.         procmapptr->ProcLen    = proc32ptr->ProcLen;
  291.  
  292.         procmapptr->DebugStart = proc32ptr->DebugStart;
  293.         procmapptr->DebugEnd   = proc32ptr->DebugEnd;
  294.  
  295.         procmapptr->ClassType  = proc32ptr->Reserved;
  296.         procmapptr->NearFar    = proc32ptr->NearFar;
  297.         procmapptr->NameLen    = (ushort)proc32ptr->Name[0];
  298.  
  299.         strncpy( procmapptr->Name, &(proc32ptr->Name[1]),
  300.                  proc32ptr->Name[0] );
  301.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  302.         mapptr = (SSRec *)((uchar *)mapptr + procmapptr->RecLen + 2);
  303.         break;
  304.       }
  305.  
  306.       case SSBEGIN32:
  307.       {
  308.         SSBegin32 *Begin32ptr  = (SSBegin32 *)MS32ptr;
  309.         SSBegin   *Beginmapptr = (SSBegin *)mapptr;
  310.  
  311.         MS32len = Begin32ptr->RecLen;
  312.         Beginmapptr->RecLen      = sizeof( SSBegin ) - 2;
  313.         Beginmapptr->RecType     = SSBEGIN;
  314.  
  315.         Beginmapptr->BlockOffset = Begin32ptr->BlockOffset;
  316.         Beginmapptr->BlockLen    = Begin32ptr->BlockLen;
  317.  
  318.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  319.         mapptr = (SSRec *)((uchar *)mapptr + Beginmapptr->RecLen + 2);
  320.         break;
  321.       }
  322.  
  323.       case SSEND32:
  324.       {
  325.         SSEnd32 *End32ptr  = (SSEnd32 *)MS32ptr;
  326.         SSEnd   *Endmapptr = (SSEnd  *)mapptr;
  327.  
  328.         MS32len = End32ptr->RecLen;
  329.         Endmapptr->RecLen   = sizeof( SSEnd ) - 2;
  330.         Endmapptr->RecType  = SSEND;
  331.         mapptr = (SSRec *)((uchar *)mapptr + Endmapptr->RecLen + 2);
  332.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  333.         break;
  334.       }
  335.  
  336.       case SSDEF32:
  337.       {
  338.         SSDef32 *Def32ptr  = (SSDef32 *)MS32ptr;
  339.         SSDef   *Defmapptr = (SSDef  *)mapptr;
  340.         short    FrameOffset = 0;
  341.  
  342.         MS32len = Def32ptr->RecLen;
  343.         Defmapptr->RecLen   = MS32len + 1;
  344.         Defmapptr->RecType  = SSDEF;
  345.         FrameOffset = Def32ptr->FrameOffset;
  346.         if( FrameOffset < 0 )
  347.           Defmapptr->FrameOffset = -(int)(- FrameOffset);
  348.         else
  349.           Defmapptr->FrameOffset = (int)FrameOffset;
  350.         Defmapptr->TypeIndex   = Def32ptr->TypeIndex;
  351.         Defmapptr->NameLen     = (ushort)Def32ptr->Name[0];
  352.  
  353.         strncpy( Defmapptr->Name, &(Def32ptr->Name[1]), Def32ptr->Name[0] );
  354.         mapptr = (SSRec *)((uchar *)mapptr + Defmapptr->RecLen + 2);
  355.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  356.         break;
  357.       }
  358.  
  359.       case SSVAR32:
  360.       {
  361.         SSVar32  *Var32ptr   = (SSVar32 *)MS32ptr;
  362.         SSVar    *Varmapptr  = (SSVar  *)mapptr;
  363.  
  364.         MS32len = Var32ptr->RecLen;
  365.         Varmapptr->RecLen    = MS32len + 2;
  366.         Varmapptr->Flags     = STATIC;
  367.         Varmapptr->RecType   = SSVAR;
  368.         Varmapptr->Offset    = Var32ptr->Offset;
  369.         Varmapptr->ObjectNum = Var32ptr->ObjectNum;
  370.         Varmapptr->TypeIndex = Var32ptr->TypeIndex;
  371.         Varmapptr->NameLen   = (ushort)Var32ptr->Name[0];
  372.  
  373.         strncpy( Varmapptr->Name, &(Var32ptr->Name[1]), Var32ptr->Name[0] );
  374.         mapptr = (SSRec *)((uchar *)mapptr + Varmapptr->RecLen + 2);
  375.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  376.         break;
  377.       }
  378.  
  379.       case SSCHGDEF32:
  380.       {
  381.         SSChgDef32  *ChgDef32ptr  = (SSChgDef32 *)MS32ptr;
  382.         SSChgDef    *ChgDefmapptr = (SSChgDef  *)mapptr;
  383.  
  384.         MS32len = ChgDef32ptr->RecLen;
  385.         ChgDefmapptr->RecLen   = sizeof( SSChgDef ) - 2;
  386.         ChgDefmapptr->RecType  = SSCHGDEF;
  387.         ChgDefmapptr->SegNum   = ChgDef32ptr->SegNum;
  388.         ChgDefmapptr->Reserved = ChgDef32ptr->Reserved;
  389.  
  390.         mapptr = (SSRec *)((uchar *)mapptr + ChgDefmapptr->RecLen + 2);
  391.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  392.         break;
  393.       }
  394.  
  395.       case SSUSERDEF32:
  396.       {
  397.         SSUserDef32 *UserDef32ptr  = (SSUserDef32 *)MS32ptr;
  398.         SSUserDef   *UserDefmapptr = (SSUserDef *)mapptr;
  399.  
  400.         MS32len = UserDef32ptr->RecLen;
  401.         UserDefmapptr->RecLen    = MS32len + 1;
  402.         UserDefmapptr->RecType   = SSUSERDEF;
  403.         UserDefmapptr->TypeIndex = UserDef32ptr->TypeIndex;
  404.         UserDefmapptr->NameLen   = (ushort)UserDef32ptr->Name[0];
  405.         strncpy( UserDefmapptr->Name, &(UserDef32ptr->Name[1]),
  406.                  UserDef32ptr->Name[0] );
  407.  
  408.         mapptr = (SSRec *)((uchar *)mapptr + UserDefmapptr->RecLen + 2);
  409.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  410.         break;
  411.       }
  412.  
  413.       case SSREG32:
  414.       {
  415.         SSReg32 *Reg32ptr  = (SSReg32 *)MS32ptr;
  416.         SSReg   *Regmapptr = (SSReg  *)mapptr;
  417.  
  418.         MS32len = Reg32ptr->RecLen;
  419.         Regmapptr->RecLen    = MS32len + 1;
  420.         Regmapptr->RecType   = SSREG;
  421.         Regmapptr->TypeIndex = Reg32ptr->TypeIndex;
  422.         Regmapptr->RegNum    = Reg32ptr->RegNum;
  423.         Regmapptr->NameLen   = (ushort)Reg32ptr->Name[0];
  424.         strncpy( Regmapptr->Name, &(Reg32ptr->Name[1]),
  425.                  Reg32ptr->Name[0] );
  426.  
  427.         mapptr = (SSRec *)((uchar *)mapptr + Regmapptr->RecLen + 2);
  428.         MS32ptr = (SSrec *)((uchar *)MS32ptr + MS32len + 1);
  429.         break;
  430.       }
  431.  
  432.       default:
  433.       {                                                                 /*810*/
  434.         SSReg32 *reg32ptr = (SSReg32 *)MS32ptr;                         /*810*/
  435.         MS32ptr = (SSrec *)((uchar *)MS32ptr + reg32ptr->RecLen + 1);   /*810*/
  436.         break;                                                          /*810*/
  437.       }                                                                 /*810*/
  438.    }
  439.  }
  440. }
  441.  
  442. /*****************************************************************************/
  443. /* MapHLLSyms()                                                           809*/
  444. /*                                                                           */
  445. /* Description:                                                              */
  446. /*   Map a 32 bit IBM HLL raw symbol table to the internal symbol table.     */
  447. /*                                                                           */
  448. /* Parameters:                                                               */
  449. /*   RawTable       (input)  - Pointer to the raw symbol table.              */
  450. /*   IntSymTable    (output) - Pointer to the internal symbol table          */
  451. /*   mptr           (input)  - Pointer to the MODULE structure.              */
  452. /*                                                                           */
  453. /* Return:                                                                   */
  454. /*   None.                                                                   */
  455. /*                                                                           */
  456. /* Assumptions:                                                              */
  457. /*                                                                           */
  458. /* - Raw symbol table has already been loaded into the memory.               */
  459. /* - Memory for the internal symbol table has already been allocated.        */
  460. /*                                                                           */
  461. /*****************************************************************************/
  462. void  MapHLLSyms( uchar *RawTable, SSRec *IntSymTable, MODULE *mptr )   /*809*/
  463. {
  464.   int LenSymSectionHLL;
  465.   SSRec *mapptr;
  466.   SSrec *HLLptr;
  467.   uchar  HLLlen;
  468.   uchar  RecordType;
  469.   uint   Adjust;
  470.  
  471.   LenSymSectionHLL = mptr->SymLen;
  472.   HLLptr = (SSrec *)RawTable;
  473.   mapptr = IntSymTable;
  474.  
  475.   /***************************************************************************/
  476.   /* Scan the Raw symbol table. Depending on the type of each raw symbol     */
  477.   /* table record, copy the information to the internal symbol table record. */
  478.   /*                                                                         */
  479.   /* The record length in HLL level 3 format could be in encoded format, so  */
  480.   /* call functions "GetRecordLength" and "GetRecordType" to get the length  */
  481.   /* and type for each raw symbol table record.                              */
  482.   /***************************************************************************/
  483.   while( LenSymSectionHLL > 0 )
  484.   {
  485.     HLLlen     = GetRecordLength( (uchar *)HLLptr, mptr );
  486.     RecordType = GetRecordType( (uchar *)HLLptr, mptr );
  487.  
  488.     Adjust = 1;
  489.     if( TestBit( *(uchar *)HLLptr, 7 ) &&
  490.                                (
  491.                                 (mptr->DbgFormatFlags.Syms == TYPE104_HL03) ||
  492.                                 (mptr->DbgFormatFlags.Syms == TYPE104_HL04)
  493.                                )
  494.       )
  495.       Adjust = 2;
  496.  
  497.     LenSymSectionHLL -= (HLLlen + Adjust);
  498.     switch( RecordType )
  499.     {
  500.       case SSPROC:
  501.       case SSENTRY:
  502.       case SSPROCCPP:
  503.       case SSMEMFUNC:
  504.       {
  505.         SSProc    *procmapptr  = (SSProc  *)mapptr;
  506.         SSProcHLL *procHLLptr;
  507.  
  508.         procHLLptr = (SSProcHLL *)( (uchar *)HLLptr + Adjust + 1 );
  509.         procmapptr->RecLen     = HLLlen + 2;
  510.         switch( RecordType )
  511.         {
  512.           case SSPROC:
  513.             procmapptr->Flags = PROCEDURE;
  514.             break;
  515.           case SSENTRY:
  516.             procmapptr->Flags = SECONDENTRY;
  517.             break;
  518.           case SSPROCCPP:
  519.             procmapptr->Flags = CPPPROCEDURE;
  520.             break;
  521.           case SSMEMFUNC:
  522.             procmapptr->Flags = MEMBERFUNC;
  523.             break;
  524.         }
  525.  
  526.         procmapptr->RecType    = SSPROC;
  527.         procmapptr->ProcOffset = procHLLptr->ProcOffset;
  528.         procmapptr->TypeIndex  = procHLLptr->TypeIndex;
  529.         procmapptr->ProcLen    = procHLLptr->ProcLen;
  530.  
  531.         procmapptr->DebugStart = procHLLptr->DebugStart;
  532.         procmapptr->DebugEnd   = procHLLptr->DebugEnd;
  533.  
  534.         procmapptr->ClassType  = procHLLptr->Reserved;
  535.         procmapptr->NearFar    = procHLLptr->NearFar;
  536.         procmapptr->NameLen    =
  537.              GetRecordLength( (uchar *)&(procHLLptr->Name[0]), mptr );
  538.  
  539.         strncpy( procmapptr->Name, &(procHLLptr->Name[1]),
  540.                  procmapptr->NameLen );
  541.         mapptr = (SSRec *)((uchar *)mapptr + procmapptr->RecLen + 2);
  542.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  543.  
  544.         break;
  545.       }
  546.  
  547.       case SSBEGIN:
  548.       {
  549.         SSBeginHLL *BeginHLLptr;
  550.         SSBegin    *Beginmapptr  = (SSBegin *)mapptr;
  551.  
  552.         BeginHLLptr = (SSBeginHLL *)( (uchar *)HLLptr + Adjust + 1 );
  553.  
  554.         Beginmapptr->RecLen      = sizeof( SSBegin ) - 2;
  555.         Beginmapptr->RecType     = SSBEGIN;
  556.         Beginmapptr->BlockOffset = BeginHLLptr->BlockOffset;
  557.         Beginmapptr->BlockLen    = BeginHLLptr->BlockLen;
  558.  
  559.         mapptr = (SSRec *)((uchar *)mapptr + Beginmapptr->RecLen + 2);
  560.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  561.  
  562.         break;
  563.       }
  564.  
  565.       case SSEND:
  566.       {
  567.         SSEnd    *Endmapptr = (SSEnd  *)mapptr;
  568.  
  569.         Endmapptr->RecLen   = sizeof( SSEnd ) - 2;
  570.         Endmapptr->RecType  = SSEND;
  571.         mapptr = (SSRec *)((uchar *)mapptr + Endmapptr->RecLen + 2);
  572.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  573.  
  574.         break;
  575.       }
  576.  
  577.       case SSDEF:
  578.       {
  579.         SSDefHLL *DefHLLptr;
  580.         SSDef    *Defmapptr = (SSDef  *)mapptr;
  581.  
  582.         DefHLLptr = (SSDefHLL *)( (uchar *)HLLptr + Adjust + 1 );
  583.  
  584.         Defmapptr->RecLen   = HLLlen + 1;
  585.         Defmapptr->RecType  = SSDEF;
  586.         Defmapptr->FrameOffset = DefHLLptr->FrameOffset;
  587.         Defmapptr->TypeIndex   = DefHLLptr->TypeIndex;
  588.         Defmapptr->NameLen     = (ushort)DefHLLptr->Name[0];
  589.  
  590.         strncpy( Defmapptr->Name, &(DefHLLptr->Name[1]), DefHLLptr->Name[0] );
  591.         mapptr = (SSRec *)((uchar *)mapptr + Defmapptr->RecLen + 2);
  592.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  593.  
  594.         break;
  595.       }
  596.  
  597.       case SSCHGDEF:
  598.       {
  599.         SSChgDefHLL *ChgDefHLLptr;
  600.         SSChgDef    *ChgDefmapptr = (SSChgDef  *)mapptr;
  601.  
  602.         ChgDefHLLptr = (SSChgDefHLL *)( (uchar *)HLLptr + Adjust + 1 );
  603.  
  604.         ChgDefmapptr->RecLen   = sizeof( SSChgDef ) - 2;
  605.         ChgDefmapptr->RecType  = SSCHGDEF;
  606.         ChgDefmapptr->SegNum   = ChgDefHLLptr->SegNum;
  607.         ChgDefmapptr->Reserved = ChgDefHLLptr->Reserved;
  608.  
  609.         mapptr = (SSRec *)((uchar *)mapptr + ChgDefmapptr->RecLen + 2);
  610.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  611.  
  612.         break;
  613.       }
  614.  
  615.       case SSVAR:
  616.       case SSVARCPP:
  617.       {
  618.         SSVarHLL *VarHLLptr;
  619.         SSVar    *Varmapptr  = (SSVar  *)mapptr;
  620.  
  621.         VarHLLptr = (SSVarHLL *)( (uchar *)HLLptr + Adjust + 1 );
  622.  
  623.         Varmapptr->RecLen    = HLLlen + 2;
  624.         switch( RecordType )
  625.         {
  626.           case SSVAR:
  627.             Varmapptr->Flags = STATIC;
  628.             break;
  629.           case SSVARCPP:
  630.             Varmapptr->Flags = CPPSTATIC;
  631.             break;
  632.         }
  633.         Varmapptr->RecType   = SSVAR;
  634.         Varmapptr->Offset    = VarHLLptr->Offset;
  635.         Varmapptr->ObjectNum = VarHLLptr->ObjectNum;
  636.         Varmapptr->TypeIndex = VarHLLptr->TypeIndex;
  637.         Varmapptr->NameLen   =
  638.              GetRecordLength( (uchar *)&(VarHLLptr->Name[0]), mptr );
  639.  
  640.         strncpy( Varmapptr->Name, &(VarHLLptr->Name[1]), Varmapptr->NameLen );
  641.         mapptr = (SSRec *)((uchar *)mapptr + Varmapptr->RecLen + 2);
  642.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  643.  
  644.         break;
  645.       }
  646.  
  647.       case SSUSERDEF:
  648.       {
  649.         SSUserDefHLL *UserDefHLLptr;
  650.         SSUserDef    *UserDefmapptr = (SSUserDef *)mapptr;
  651.  
  652.         UserDefHLLptr = (SSUserDefHLL *)( (uchar *)HLLptr + Adjust + 1 );
  653.  
  654.         UserDefmapptr->RecLen    = HLLlen + 1;
  655.         UserDefmapptr->RecType   = SSUSERDEF;
  656.         UserDefmapptr->TypeIndex = UserDefHLLptr->TypeIndex;
  657.         UserDefmapptr->NameLen   = (ushort)UserDefHLLptr->Name[0];
  658.         strncpy( UserDefmapptr->Name, &(UserDefHLLptr->Name[1]),
  659.                  UserDefHLLptr->Name[0] );
  660.  
  661.         mapptr = (SSRec *)((uchar *)mapptr + UserDefmapptr->RecLen + 2);
  662.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  663.  
  664.         break;
  665.       }
  666.  
  667.       case SSREG:
  668.       {
  669.         SSRegHLL *RegHLLptr;
  670.         SSReg    *Regmapptr  = (SSReg  *)mapptr;
  671.  
  672.         RegHLLptr = (SSRegHLL *)( (uchar *)HLLptr + Adjust + 1 );
  673.  
  674.         Regmapptr->RecLen    = HLLlen + 1;
  675.         Regmapptr->RecType   = SSREG;
  676.         Regmapptr->TypeIndex = RegHLLptr->TypeIndex;
  677.         Regmapptr->RegNum    = RegHLLptr->RegNum;
  678.         Regmapptr->NameLen   = (ushort)RegHLLptr->Name[0];
  679.         strncpy( Regmapptr->Name, &(RegHLLptr->Name[1]),
  680.                  RegHLLptr->Name[0] );
  681.  
  682.         mapptr = (SSRec *)((uchar *)mapptr + Regmapptr->RecLen + 2);
  683.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust);
  684.  
  685.         break;
  686.       }
  687.  
  688.       default:
  689.       {                                                                 /*810*/
  690.         HLLptr = (SSrec *)((uchar *)HLLptr + HLLlen + Adjust );         /*810*/
  691.         break;                                                          /*810*/
  692.       }                                                                 /*810*/
  693.    }
  694.  }
  695. }
  696.  
  697. /*****************************************************************************/
  698. /* GetRecordLength()                                                      809*/
  699. /*                                                                           */
  700. /* Description:                                                              */
  701. /*   Get the symbol record length from the encoded length.                   */
  702. /*                                                                           */
  703. /* Parameters:                                                               */
  704. /*                                                                           */
  705. /*   Buffer   (input)  - Pointer to the start of the symbol record.          */
  706. /*   pModule  (input)  - Pointer to the module structure.                    */
  707. /*                                                                           */
  708. /* Return:                                                                   */
  709. /*                                                                           */
  710. /*   Length of the symbol record.                                            */
  711. /*                                                                           */
  712. /* Assumptions:                                                              */
  713. /*                                                                           */
  714. /* -  The buffer passed points to the start of the symbol record.            */
  715. /*                                                                           */
  716. /*****************************************************************************/
  717. ushort  GetRecordLength( uchar *Buffer, MODULE *pModule )               /*809*/
  718. {
  719.   ushort RecordLength;
  720.  
  721.   /***************************************************************************/
  722.   /* - Set the default record length.                                        */
  723.   /* - Check to see if the 7th bit in the first byte is set and the symbol   */
  724.   /*   type is HL03. If so calculate the record length.                      */
  725.   /* - Return the record length.                                             */
  726.   /***************************************************************************/
  727.   RecordLength = *Buffer;
  728.   if( *Buffer & 0x80 )
  729.   {
  730.     if( (pModule->DbgFormatFlags.Syms == TYPE104_HL03) ||
  731.         (pModule->DbgFormatFlags.Syms == TYPE104_HL04)
  732.       )
  733.       RecordLength = ((*Buffer & 0x7F) << 8) + *(Buffer + 1);
  734.   }
  735.   return( RecordLength );
  736. }
  737.  
  738. /*****************************************************************************/
  739. /* GetRecordType()                                                        809*/
  740. /*                                                                           */
  741. /* Description:                                                              */
  742. /*   Get the symbol record type which is present after an encoded length.    */
  743. /*                                                                           */
  744. /* Parameters:                                                               */
  745. /*                                                                           */
  746. /*   Buffer   (input)  - Pointer to the start of the symbol record.          */
  747. /*   pModule  (input)  - Pointer to the module structure.                    */
  748. /*                                                                           */
  749. /* Return:                                                                   */
  750. /*                                                                           */
  751. /*   Type of the symbol record.                                              */
  752. /*                                                                           */
  753. /* Assumptions:                                                              */
  754. /*                                                                           */
  755. /* -  The buffer passed points to the start of the symbol record.            */
  756. /*                                                                           */
  757. /*****************************************************************************/
  758. uchar  GetRecordType( uchar *Buffer, MODULE *pModule )                  /*809*/
  759. {
  760.   uchar RecordType;
  761.  
  762.   /***************************************************************************/
  763.   /* - Set the default record type.                                          */
  764.   /* - Check to see if the 7th bit in the first byte is set and the symbol   */
  765.   /*   type is HL03. If so calculate the record type.                        */
  766.   /* - Return the record type.                                               */
  767.   /***************************************************************************/
  768.   RecordType = *(Buffer + 1);
  769.   if( *Buffer & 0x80 )
  770.   {
  771.     if( (pModule->DbgFormatFlags.Syms == TYPE104_HL03) ||
  772.         (pModule->DbgFormatFlags.Syms == TYPE104_HL04)
  773.       )
  774.       RecordType = *(Buffer + 2);
  775.   }
  776.   return( RecordType );
  777. }
  778.