home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sherlock.zip / SYM / SYM.C < prev    next >
C/C++ Source or Header  |  1994-06-29  |  5KB  |  220 lines
  1. /*
  2. **  Sherlock - Copyright 1992, 1993, 1994
  3. **    Harfmann Software
  4. **    Compuserve: 73147,213
  5. **    All rights reserved
  6. */
  7. /*
  8. ** SYM file interface functions to extract symbolic information
  9. ** given a state to extract information from.
  10. */
  11. #include    <stdio.h>
  12. #include    <string.h>
  13. #include    <malloc.h>
  14. #include    <memory.h>
  15. #include    <sys\stat.h>
  16.  
  17. #define     INCL_DOSPROCESS
  18. #include    <os2.h>
  19. #include    "..\Debug.h"
  20.  
  21. #include    "..\SrcInter.h"
  22. #include    "MapSym.h"
  23.  
  24. /*
  25. ** Global variables.
  26. */
  27. static int (* _System Dispatch)(int command);
  28. DebugBuffer *debugBuffer;
  29.  
  30. /*
  31. ** Answer the linkage priority.
  32. ** Return 1 for insert in front of list - (first crack at linking)
  33. ** Return 0 for add to end of list.    - (last crack at linking)
  34. */
  35. int _System linkPriority(void)
  36. {
  37.     return 0;
  38. }
  39.  
  40. /*
  41. ** Load the symbols.
  42. */
  43. SymData32 *load32Symbols(FILE *symFile,
  44.         long base, long pConstDef, WORD cConsts)
  45. {
  46. SYMDEF32    sym32;
  47. WORD        i;
  48. SymData32  *symHead=NULL;
  49. SymData32  *symData=NULL;
  50. WORD       *ptrs;
  51.  
  52.     fseek(symFile, base + pConstDef, SEEK_SET);
  53.     ptrs = (WORD *) malloc(cConsts * sizeof(WORD));
  54.     fread(ptrs, cConsts, sizeof(WORD), symFile);
  55.     for(i=0; i<cConsts; i++) {
  56.     fseek(symFile, base + ((DWORD) ptrs[i]), SEEK_SET);
  57.     fread(&sym32, sizeof(SYMDEF32), 1, symFile);
  58.     if(symHead == NULL) {
  59.         symData = (SymData32 *) malloc(sizeof(SymData32) + sym32.dbSymName);
  60.         symHead = symData;
  61.         symData->next = NULL;
  62.     } else {
  63.         symData->next = (SymData32 *) malloc(sizeof(SymData32) + sym32.dbSymName);
  64.         symData = symData->next;
  65.         symData->next = NULL;
  66.     }
  67.     symData->lSymVal = sym32.lSymVal;
  68.     fread(symData->SymName, sym32.dbSymName, 1, symFile);
  69.     symData->SymName[sym32.dbSymName] = '\0';
  70.     }
  71.     return symHead;
  72. }
  73.  
  74. /*
  75. ** Load the symbols.
  76. */
  77. SymData16 *load16Symbols(FILE *symFile,
  78.         long base, long pConstDef, WORD cConsts)
  79. {
  80. SYMDEF16    sym16;
  81. WORD        i;
  82. SymData16  *symHead=NULL;
  83. SymData16  *symData=NULL;
  84. WORD       *ptrs;
  85.  
  86.     fseek(symFile, base + pConstDef, SEEK_SET);
  87.     ptrs = (WORD *) malloc(cConsts * sizeof(WORD));
  88.     fread(ptrs, cConsts, sizeof(WORD), symFile);
  89.     for(i=0; i<cConsts; i++) {
  90.     fseek(symFile, base + ((DWORD) ptrs[i]), SEEK_SET);
  91.     fread(&sym16, sizeof(SYMDEF16), 1, symFile);
  92.     if(symHead == NULL) {
  93.         symData = (SymData16 *) malloc(sizeof(SymData16) + sym16.dbSymName);
  94.         symHead = symData;
  95.         symData->next = NULL;
  96.     } else {
  97.         symData->next = (SymData16 *) malloc(sizeof(SymData16) + sym16.dbSymName);
  98.         symData = symData->next;
  99.         symData->next = NULL;
  100.     }
  101.     symData->wSymVal = sym16.wSymVal;
  102.     fread(symData->SymName, sym16.dbSymName, 1, symFile);
  103.     symData->SymName[sym16.dbSymName] = '\0';
  104.     }
  105.     return symHead;
  106. }
  107.  
  108. /*
  109. ** Answer whether the module named is a MapSym module.
  110. ** If so, set the function pointers and return true.
  111. */
  112. int _System isKnownModule(DebugModule *module,
  113.                int (* _System DispatchCommand)(int command),
  114.                DebugBuffer *buffer)
  115. {
  116. FILE       *symFile;
  117. char       *chPtr;
  118. WORD        i;
  119. char        symName[CCHMAXPATH];
  120. MAPDEF        mapDef;
  121. SEGDEF        segDef;
  122. SymSegmentData *auxData;
  123. ULONG        base;
  124.  
  125.     debugBuffer = buffer;
  126.     Dispatch = DispatchCommand;
  127.  
  128.     /*
  129.     ** Open the file.
  130.     */
  131.     strcpy(symName, module->name);
  132.     chPtr = strrchr(symName, '.');
  133.     if(chPtr == NULL)
  134.     return 0;
  135.     strcpy(chPtr, ".SYM");
  136.     if((symFile = fopen(symName, "rb")) == NULL)
  137.     return 0;
  138.  
  139.     /*
  140.     ** Read the map definition header.
  141.     */
  142.     fread(&mapDef, sizeof(mapDef), 1, symFile);
  143.  
  144.     /*
  145.     ** Read the segment definitions.
  146.     */
  147.     base = ((ULONG) mapDef.ppSegDef) << 4;
  148.     for(i=0; i<mapDef.cSegs; i++) {
  149.  
  150.     /*
  151.     ** Get the segment definition
  152.     */
  153.     fseek(symFile, base, SEEK_SET);
  154.     fread(&segDef, sizeof(segDef), 1, symFile);
  155.  
  156.     /*
  157.     ** If not the first time through, get a new block.
  158.     */
  159.     if(i == 0) {
  160.         module->AuxData = (void *)
  161.         calloc(sizeof(SymSegmentData) + segDef.cbSegName, 1);
  162.         auxData = (SymSegmentData *) module->AuxData;
  163.         auxData->next = NULL;
  164.     } else {
  165.         auxData->next = (SymSegmentData *)
  166.         calloc(sizeof(SymSegmentData) + segDef.cbSegName, 1);
  167.         auxData = auxData->next;
  168.         auxData->next = NULL;
  169.     }
  170.     fread(auxData->name, segDef.cbSegName, 1, symFile);
  171.     auxData->name[segDef.cbSegName] = 0;
  172.  
  173.     /*
  174.     ** Now, get the symbols.
  175.     */
  176.     if(segDef.bFlags & 0x01) {
  177.         auxData->first16Symbol = NULL;
  178.         auxData->first32Symbol =
  179.         load32Symbols(symFile,
  180.                   base,
  181.                   segDef.pSymDef,
  182.                   segDef.cSymbols);
  183.     } else {
  184.         auxData->first32Symbol = NULL;
  185.         auxData->first16Symbol =
  186.         load16Symbols(symFile,
  187.                   base,
  188.                   segDef.pSymDef,
  189.                   segDef.cSymbols);
  190.     }
  191.     base = ((ULONG) segDef.ppNextSeg) << 4;
  192.     }
  193.     fclose(symFile);
  194.  
  195.     /*
  196.     ** Set up the links to access the data.
  197.     */
  198.     module->FindSource       = SymFindSource;
  199.     module->FindSourceLine = SymFindSourceLine;
  200.     module->FindFuncAddr   = SymFindFuncAddr;
  201.  
  202. #if 0
  203.     module->GetName       = SymGetName;
  204.     module->GetArray       = SymGetArray;
  205.     module->GetNumMembers  = SymGetNumMembers;
  206.     module->GetMemberIndex = SymGetMemberIndex;
  207. #endif
  208.     return 1;
  209. }
  210.  
  211. /*
  212. ** Define the stub for connecting to the system.
  213. */
  214. int DispatchCommand(int command)
  215. {
  216.     if(Dispatch)
  217.     return Dispatch(command);
  218.     return DBG_N_Error;
  219. }
  220.