home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / cgazv5n3 / apps.c next >
Encoding:
C/C++ Source or Header  |  1991-02-25  |  10.0 KB  |  291 lines
  1. /*******  Listing 5  ***************************  APPS.C  ************
  2. *  apps.c -- Applications using OBJECT CODE EXPLORER
  3. *  Author:   Thomas E. Siering, 1991. Copyruight notice in Listing 1
  4. * 
  5. *  Compiler: Microsoft C 6.0, Turbo C++ 1.0
  6. * 
  7. *  Compile time switches:
  8. *    PRN - listings use only characters avaialable on printers
  9. *    CON - listings use only characters available on the console
  10. * 
  11. *  Links with: svc.c and ox.c. This module contains the main driver
  12. * 
  13. *  Usage: apps file.obj
  14. * 
  15. *  Generates file.dmp and file.anl, showing the contents of file.obj
  16. ***********************************************************************/
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #include <ctype.h>
  21. #include "ox.h"
  22.  
  23.  
  24. /* Define the following DOS system constants for non MS C compilers */
  25. #ifndef _MAX_PATH
  26. #define _MAX_PATH    260    /* max. length of full pathname */
  27. #endif
  28. #ifndef _MAX_FNAME
  29. #define _MAX_FNAME    256    /* max. length of file name component */
  30. #endif
  31.  
  32. #if defined(__TURBOC__)
  33. #define SplitPath fnsplit          /* Turbo C */
  34. #else
  35. #define SplitPath _splitpath       /* MS C    */
  36. #endif
  37.  
  38.  
  39. PUBLIC FILE *AnalysisFH;
  40. PUBLIC char *obj;
  41.  
  42. PRIVATE char ProgramName[] = { "ox" };
  43.  
  44.  
  45. PRIVATE void Init(int argc, char *argv[], char ObjFN[], char **ws,
  46.         long *ObjSize);
  47. PRIVATE void Dump(char *ObjP, int FileLength, char *ObjName);
  48. PRIVATE void Analyze(char Obj[], long ObjLength, char *ObjName);
  49.  
  50.  
  51. PUBLIC void main(int argc, char *argv[]);
  52.  
  53. void main(int argc, char *argv[])
  54. {
  55.     long FileLength;
  56.     char ObjFN[_MAX_FNAME];
  57.  
  58.     Init(argc, argv, ObjFN, &obj, &FileLength);
  59.     Dump(obj, (int) FileLength, ObjFN);
  60.     if (argv[2][1] != 'd' && argv[2][1] != 'D')
  61.         Analyze(obj, FileLength, ObjFN);
  62.     free(obj);
  63. }
  64.  
  65. /*----------------------------------------------
  66. *   Init  --  Initialize various mundane things
  67. *--------------------------------------------**/
  68. PRIVATE void Init(int argc, char *argv[], char ObjFNRoot[], char **ws,
  69.         long *ObjSize)
  70. {
  71.     char ObjFileName[_MAX_PATH];
  72.     char Dummy[_MAX_PATH];
  73.     char FileExt[5];        /* allow for leading . and trailing \0 */
  74.  
  75.     if (argc < 2) {
  76.         fprintf(stderr, "CALL: %s FN.OBJ [options]\n", ProgramName);
  77.         fprintf(stderr, "Options: /d -- Dump only\n");
  78.         exit(-1);
  79.     }
  80.  
  81.     strcpy(ObjFileName, argv[1]);
  82.     strcpy(ObjFNRoot, argv[1]);   /* for remainder of program, w/out ext. */
  83.  
  84.     /* Did the user enter an extension w/ file name? */
  85.     SplitPath(ObjFileName, Dummy, Dummy, Dummy, FileExt);
  86.     if (FileExt[0] == '.' && FileExt[1] != '\0')  /* has an extension */
  87.         ObjFNRoot[strrchr(ObjFNRoot, '.') - ObjFNRoot] = '\0';
  88.     else
  89.         strcat(ObjFileName, ".OBJ\0");  /* OBJ ext needed to open file */
  90.  
  91.     InstObjExp(ObjFileName, ws, ObjSize);
  92. }
  93.  
  94. #define  PRN           /* for output ctl: enable PRN -OR- CON */
  95. /* #define  CON */
  96. #ifdef PRN
  97.    #define CHKCHAR  !isprint
  98. #else
  99.    #define CHKCHAR  iscntrl
  100. #endif
  101.  
  102. #define  MAXLN    16
  103. #define  ASCIICOL 62
  104.  
  105. /*-----------------------------------------
  106. *   Dump --  formatted dump of OBJ records
  107. *----------------------------------------*/
  108. PRIVATE void Dump(char *ObjP, int  FileLength, char *ObjName)
  109. {
  110.     FILE *DumpFH;
  111.     int  LocCtr = 0;
  112.     char ObjRecName[OMFNAMELENGTH];
  113.     char DumpFN[_MAX_PATH];
  114.     int  RecLength;
  115.     int  PrintLength;
  116.  
  117.     strcpy(DumpFN, ObjName);
  118.     strcat(DumpFN, ".DMP");
  119.  
  120.     if ((DumpFH = fopen(DumpFN, "w")) == NULL) {
  121.         fprintf(stderr, "\aCould Not Open File %s.\n", DumpFN);
  122.         exit(0xFF);
  123.     }
  124.  
  125.     while (FileLength) {
  126.         RecLength = *((int *) (ObjP + 1)) + 3;
  127.         if (GetObjRecordName(*ObjP, ObjRecName) != OK) {
  128.             Output(Warning, DumpFH,
  129.                     "\aNon-MS-Documented Record %02X in file %s.\n",
  130.                     *ObjP & 0x00FF, ObjName);
  131.             Output(Message, DumpFH, "      **%02X**:\n", *ObjP & 0x00FF);
  132.         }
  133.         else
  134.             Output(Message, DumpFH, "      %s:\n", ObjRecName);
  135.  
  136.         while (RecLength) {
  137.             PrintLength = (RecLength > MAXLN) ? MAXLN : RecLength;
  138.             PrintObjDumpLine(ObjP, DumpFH, LocCtr, PrintLength);
  139.             RecLength -= PrintLength;
  140.             FileLength   -= PrintLength;
  141.             LocCtr += PrintLength;
  142.             ObjP    += PrintLength;
  143.         }
  144.     }
  145.     fclose(DumpFH);
  146. }
  147.  
  148. /*----------------------------------------------------------
  149. *   PrintObjDumpLine -- print one line of formatted OBJ dump
  150. *----------------------------------------------------------*/
  151. PUBLIC void PrintObjDumpLine(char *src, FILE *dest, int LocCtr, 
  152.                              int PrintLength)
  153. {
  154.     int i;
  155.     static char line[100];
  156.     char *lptr = line;
  157.     char *aptr = line + ASCIICOL;
  158.  
  159.     memset(line, ' ', sizeof(line));
  160.     lptr += sprintf(lptr, "%04X    ", LocCtr);
  161.  
  162.     for (i = 0; i < PrintLength; i++, src++) {
  163.         if (i == 8) {
  164.             lptr += 3;
  165.             aptr += 2;
  166.         }
  167.         sprintf(lptr, "%02X", *src & 0x00FF);
  168.         *aptr++ = (CHKCHAR(*src)) ? (char) '.' : *src;
  169.         lptr += 2;
  170.         *lptr++ = ' ';
  171.     }
  172.     sprintf(aptr, "\n\0");
  173.     fputs(line, dest);
  174. }
  175.  
  176. /*-----------------------------------------------------
  177. *   Analyze -- Analyze the OBJ module records in detail
  178. *----------------------------------------------------*/
  179. PRIVATE void Analyze(
  180.     char Obj[],                 /* OBJ file in memory  */
  181.     long ObjLength,             /* PrintLength of OBJ  */
  182.     char *ObjName)              /* name of OBJ         */
  183.  
  184. {
  185.     char *RecordP = Obj;
  186.     unsigned char RecordType = '\0';
  187.     unsigned int  RecordLength;
  188.     char AnalysisFN[_MAX_PATH];
  189.     char RecordName[8];
  190.  
  191.     strcpy(AnalysisFN, ObjName);
  192.     strcat(AnalysisFN, ".ANL");
  193.  
  194.     if ((AnalysisFH = fopen(AnalysisFN, "w")) == NULL) {
  195.         fprintf(stderr, "\aCould Not Open File %s.\n", AnalysisFN);
  196.         exit(-1);
  197.     }
  198.  
  199.     while (ObjLength > 0L) {
  200.         RecordType = *RecordP;
  201.         if (GetObjRecordName(RecordType, RecordName) == OK)
  202.             Output(Message, AnalysisFH, "\n%04X   --   %s\n",
  203.                     GetRecordRelPos(RecordP), RecordName);
  204.         RecordP++;
  205.         RecordLength = *(int *) RecordP;
  206.         RecordP += 2;            /* advance ptr past type/PrintLength */
  207.         --RecordLength;          /* discount CHKSM */
  208.         ObjLength -= 4L;         /* discount CHKSM/type/PrintLength */
  209.  
  210.         switch(RecordType) {
  211.             case BLKDEF :        /* 0x7A */
  212.                 DoBLKDEF();
  213.                 break;
  214.             case BLKEND :        /* 0x7C : end-of-program-block indicator */
  215.                 DoBLKEND();
  216.                 break;
  217.             case THEADR :        /* 0x80 : Translator Header Record -- T  */
  218.                 DoTHEADR(RecordP);
  219.                 break;
  220.             case LHEADR :        /* 0x82 : Translator Header Record -- L  */
  221.                 DoLHEADR(RecordP);
  222.                 break;
  223.             case COMENT :        /* 0x88 : Comment Record */
  224.                 DoCOMENT(RecordP, RecordLength);
  225.                 break;
  226.             case MODEND :        /* 0x8A : Module End Record */
  227.                 DoMODEND(RecordP);
  228.                 break;
  229.             case EXTDEF :        /* 0x8C : External Definitions Record */
  230.                 DoEXTDEF(RecordP, RecordLength);
  231.                 break;
  232.             case TYPDEF :        /* 0x8E : Type Definitions Rec (obsolete)*/
  233.                 DoTYPDEF();
  234.                 break;
  235.             case PUBDEF :        /* 0x90 : Public Definitions Record */
  236.                 DoPUBDEF(RecordP, RecordLength);
  237.                 break;
  238.             case LINNUM :        /* 0x94 : Line Numbers Record */
  239.                 DoLINNUM(RecordP, RecordLength);
  240.                 break;
  241.             case LNAMES :        /* 0x96 : Names List Record */
  242.                 DoLNAMES(RecordP, RecordLength);
  243.                 break;
  244.             case SEGDEF :        /* 0x98 : Segment Definition Record */
  245.                 DoSEGDEF(RecordP);
  246.                 break;
  247.             case GRPDEF :        /* 0x9A : Group Definition Record  */
  248.                 DoGRPDEF(RecordP, RecordLength);
  249.                 break;
  250.             case FIXUPP :        /* 0x9C : References Fixup Record  */
  251.                 DoFIXUPP(RecordP, RecordLength);
  252.                 break;
  253.             case LEDATA :        /* 0xA0 : Enumerated Data Record   */
  254.                 DoLEDATA(RecordP, RecordLength);
  255.                 break;
  256.             case LIDATA :        /* 0xA2 : Iterated Data Record     */
  257.                 DoLIDATA(RecordP, RecordLength);
  258.                 break;
  259.             case COMDEF :        /* 0xA0 : Communal Names Definition Rec */
  260.                 DoCOMDEF(RecordP, RecordLength);
  261.                 break;
  262.             case BAKPAT:         /* 0xB2 : MS Extension: Quick-C backpatch */
  263.                 DoBAKPAT(RecordP, RecordLength);
  264.                 break;
  265.             case LEXTDEF:        /* 0xB4 : MS Extension: local EXTDEF */
  266.                 DoEXTDEF(RecordP, RecordLength);
  267.                 break;
  268.             case LPUBDEF:       /* 0xB6 : MS Extension: local PUBDEF */
  269.                 DoPUBDEF(RecordP, RecordLength);
  270.                 break;
  271.             case LCOMDEF:       /* 0xB8 : MS Extension: local COMDEF */
  272.                 DoCOMDEF(RecordP, RecordLength);
  273.                 break;
  274.  
  275.             default:            /* not recognized, undocumented, or error */
  276.                 Output(Warning, AnalysisFH,
  277.                         "Non-MS-Documented Record %02X at offset %Xx\n",
  278.                         RecordType & 0x00FF, (RecordP - Obj));
  279.                 break;
  280.         }
  281.         ObjLength -= (long) RecordLength;
  282.         RecordP += RecordLength;
  283.         ++RecordP;                         /* skip CHKSM        */
  284.     }
  285.  
  286.     if (ObjLength > 0L)     /* Any leftovers?  This should NOT happen! */
  287.         Output(Error, AnalysisFH,
  288.                 "OBJ module record not recognized. Terminating\n");
  289.  
  290.     fclose(AnalysisFH);
  291. }