home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sherlock.zip / SYM / SYMDUMP / SYMDUMP.C < prev    next >
C/C++ Source or Header  |  1992-05-21  |  6KB  |  203 lines
  1. /*
  2. ** Dump a .SYM
  3. */
  4. #include    <os2.h>
  5. #include    <stdio.h>
  6. #include    <stdlib.h>
  7. #include    <memory.h>
  8. #include    "mapsym.h"
  9.  
  10. FILE *symFile;
  11.  
  12. void dumpSymbols(FILE *symFile,
  13.         long base, long pConstDef, WORD cConsts,
  14.         int is32Bit);
  15. void dumpMap(FILE *symFile, MAPDEF *map);
  16. void dumpLineDefs(FILE *symFile, WORD ppLineDef, int is32Bit);
  17.  
  18. int main(int argc, char **argv)
  19. {
  20. MAPDEF    map;
  21. long    base;
  22.  
  23.     /*
  24.     ** Make sure the number of parameters is correct.
  25.     */
  26.     if(argc != 2) {
  27.     fprintf(stderr, "Usage: SYMDUMP file.sym\n");
  28.     exit(1);
  29.     }
  30.  
  31.     /*
  32.     ** Try to open the file.
  33.     */
  34.     if((symFile = fopen(argv[1], "rb")) == NULL) {
  35.     fprintf(stderr, "Unable to open %s\n", argv[1]);
  36.     exit(1);
  37.     }
  38.  
  39.     /*
  40.     ** Dump the first record
  41.     */
  42.     memset(&map, 0, sizeof(map));
  43.     do {
  44.     dumpMap(symFile, &map);
  45.     fseek(symFile, ((long) map.ppNextMap) << 4, SEEK_SET);
  46.     } while(map.ppNextMap != 0);
  47.  
  48.     /*
  49.     ** Close the file
  50.     */
  51.     fclose(symFile);
  52.     return 0;
  53. }
  54.  
  55. void dumpMap(FILE *symFile, MAPDEF *map)
  56. {
  57. WORD    i;
  58. long    base;
  59. SEGDEF    segdef;
  60. char    buff[255];
  61.  
  62.     /*
  63.     ** Dump the map header.
  64.     */
  65.     base = map->ppNextMap << 4;
  66.     fread(map, sizeof(MAPDEF), 1, symFile);
  67.     if(map->ppNextMap == 0)
  68.     return;
  69.     fprintf(stderr, "ppNextMap  : %04x\n", map->ppNextMap);
  70.     fprintf(stderr, "bFlags     : %02x\n", map->bFlags);
  71.     fprintf(stderr, "bReserved1 : %02x\n", map->bReserved1);
  72.     fprintf(stderr, "pSegEntry  : %04x\n", map->pSegEntry);
  73.     fprintf(stderr, "cConsts    : %04x\n", map->cConsts);
  74.     fprintf(stderr, "pConstDef  : %04x\n", map->pConstDef);
  75.     fprintf(stderr, "cSegs      : %04x\n", map->cSegs);
  76.     fprintf(stderr, "ppSegDef   : %04x\n", map->ppSegDef);
  77.     fprintf(stderr, "cbMaxSym   : %02x\n", map->cbMaxSym);
  78.     fprintf(stderr, "cbModName  : %02x\n", map->cbModName);
  79.     fread(buff, map->cbModName, 1, symFile);
  80.     buff[map->cbModName] = '\0';
  81.     fprintf(stderr, "ModName    : %s\n", buff);
  82.  
  83.     /*
  84.     ** Dump the constant symbols
  85.     */
  86.     fprintf(stderr, "\n\nCONSTANTS\n");
  87.     dumpSymbols(symFile, base,
  88.         (long) map->pConstDef, (WORD) map->cConsts,
  89.         map->bFlags & 0x01);
  90.  
  91.     /*
  92.     ** Dump each segment.
  93.     */
  94.     base = ((DWORD) (map->ppSegDef)) << 4;
  95.     fprintf(stderr, "SYMBOLS\n");
  96.     for(i=0; i<map->cSegs; i++) {
  97.     fseek(symFile, base, SEEK_SET);
  98.     fread(&segdef, sizeof(SEGDEF), 1, symFile);
  99.  
  100.     fprintf(stderr, "\n\nSegment\n");
  101.     fprintf(stderr, "ppNextSeg  : %04x\n", segdef.ppNextSeg);
  102.     fprintf(stderr, "cSymbols   : %04x\n", segdef.cSymbols);
  103.     fprintf(stderr, "pSymDef    : %04x\n", segdef.pSymDef);
  104.     fprintf(stderr, "wReserved1 : %04x\n", segdef.wReserved1);
  105.     fprintf(stderr, "wReserved2 : %04x\n", segdef.wReserved2);
  106.     fprintf(stderr, "wReserved3 : %04x\n", segdef.wReserved3);
  107.     fprintf(stderr, "wReserved4 : %04x\n", segdef.wReserved4);
  108.     fprintf(stderr, "bFlags     : %02x\n", segdef.bFlags);
  109.     fprintf(stderr, "bReserved1 : %02x\n", segdef.bReserved1);
  110.     fprintf(stderr, "ppLineDef  : %04x\n", segdef.ppLineDef);
  111.     fprintf(stderr, "bReserved2 : %02x\n", segdef.bReserved2);
  112.     fprintf(stderr, "bReserved3 : %02x\n", segdef.bReserved3);
  113.     fprintf(stderr, "cbSegName  : %02x\n", segdef.cbSegName);
  114.     fread(buff, segdef.cbSegName, 1, symFile);
  115.     buff[segdef.cbSegName] = '\0';
  116.     fprintf(stderr, "SegName    : %s\n", buff);
  117.  
  118.     dumpSymbols(symFile,
  119.             base, segdef.pSymDef, segdef.cSymbols,
  120.             segdef.bFlags & 0x01);
  121.     dumpLineDefs(symFile, segdef.ppLineDef, segdef.bFlags & 0x01);
  122.     base = ((DWORD) (segdef.ppNextSeg)) << 4;
  123.     }
  124. }
  125.  
  126. void dumpSymbols(FILE *symFile,
  127.         long base, long pConstDef, WORD cConsts,
  128.         int is32Bit)
  129. {
  130. SYMDEF16    sym16;
  131. SYMDEF32    sym32;
  132. char        buff[255];
  133. WORD        i;
  134. BYTE        cbName;
  135. DWORD        val;
  136. WORD       *ptrs;
  137.  
  138. fprintf(stderr, "cConsts = %d\n", cConsts);
  139.     fseek(symFile, base + pConstDef, SEEK_SET);
  140.     ptrs = malloc(cConsts * sizeof(WORD));
  141.     fread(ptrs, cConsts, sizeof(WORD), symFile);
  142.     fprintf(stderr, "%30s\t%s\n", "Name", "Value");
  143.     for(i=0; i<cConsts; i++) {
  144.     fseek(symFile, base + ((DWORD) ptrs[i]), SEEK_SET);
  145.     if(is32Bit) {
  146.         fread(&sym32, sizeof(SYMDEF32), 1, symFile);
  147.         cbName = sym32.dbSymName;
  148.         val    = sym32.lSymVal;
  149.     } else {
  150.         fread(&sym16, sizeof(SYMDEF16), 1, symFile);
  151.         cbName = sym16.dbSymName;
  152.         val    = (DWORD) sym16.wSymVal;
  153.     }
  154.     fread(buff, cbName, 1, symFile);
  155.     buff[cbName] = '\0';
  156.     fprintf(stderr, "%4d %30s\t%08lx\n", i+1, buff, val);
  157.     }
  158. }
  159.  
  160. void dumpLineDefs(FILE *symFile, WORD ppLineDef, int is32Bit)
  161. {
  162. WORD        i;
  163. long        base;
  164. LINEINF32  *line32;
  165. LINEINF16  *line16;
  166. LINEDEF     line;
  167. char        buff[255];
  168.  
  169.     if(ppLineDef == 0)
  170.     return;
  171.     base = ftell(symFile);
  172.     fseek(symFile, ppLineDef << 4, SEEK_SET);
  173.     fread(&line, sizeof(LINEDEF), 1, symFile);
  174.     fprintf(stderr, "ppNextLine : %04x\n", line.ppNextLine);
  175.     fprintf(stderr, "wReserved1 : %04x\n", line.wReserved1);
  176.     fprintf(stderr, "pLines     : %04x\n", line.pLines);
  177.     fprintf(stderr, "wReserved2 : %04x\n", line.wReserved2);
  178.     fprintf(stderr, "cLines     : %02x\n", line.cLines);
  179.     fprintf(stderr, "cbFileName : %02x\n", line.cbFileName);
  180.     fread(buff, 1, line.cbFileName, symFile);
  181.     buff[line.cbFileName] = '\0';
  182.     fprintf(stderr, "FileName   : %s\n", buff);
  183.  
  184.     fseek(symFile, base + line.pLines, SEEK_SET);
  185.     if(is32Bit) {
  186.     line32 = malloc(line.cLines * sizeof(LINEINF32));
  187.     fread(line32, line.cLines, sizeof(LINEINF32), symFile);
  188.     } else {
  189.     line16 = malloc(line.cLines * sizeof(LINEINF16));
  190.     fread(line16, line.cLines, sizeof(LINEINF16), symFile);
  191.     }
  192.  
  193. fprintf(stderr, "is32Bit = %d\n", is32Bit);
  194.     for(i=0; i<line.cLines; i++) {
  195.     if(is32Bit)
  196.         fprintf(stderr, "%08x\t%4d\n",
  197.             line32[i].lCodeOffset, line32[i].dwFileOffset);
  198.     else
  199.         fprintf(stderr, "%04x\t%4d\n",
  200.             line16[i].wCodeOffset, line16[i].dwFileOffset);
  201.     }
  202. }
  203.