home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / c / library / dos / grafik / cgazv5n3 / ox.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-25  |  55.9 KB  |  1,525 lines
  1. /********  Listing 3  *************************  OX.C  ********
  2. *  ox.c -- Object Explorer,
  3. *  Author:   Thomas E. Siering, 1991. See Lisitng 1 for 
  4. *                      copyright notice.
  5. *  Compiler: Microsoft C 6.0, Turbo C++ 1.0
  6. * 
  7. *  Compile time switches: none
  8. * 
  9. *  Links with: svc.c and apps.c
  10. **************************************************************/
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <io.h>
  15. #include "ox.h"
  16.  
  17.  
  18. #define NEAR   0x62
  19. #define FAR    0x61
  20.  
  21. #define THREADMAX         4
  22. #define MAXLINELENGTH    16
  23.  
  24. extern FILE *AnalysisFH;
  25.  
  26. PRIVATE char *ObjBase;
  27. PRIVATE FILE *ObjFH;
  28. PRIVATE FIXUPTHREAD ThreadTable[THREADMAX * 2];  /* for Target AND Frame */
  29.  
  30.  
  31. PRIVATE LNODE ListLNAMES;
  32. PRIVATE LNODE ListSEGDEF;
  33. PRIVATE LNODE ListGRPDEF;
  34. PRIVATE LNODE ListEXTDEF;
  35.  
  36.  
  37. PRIVATE int GetExplicitFixupp(unsigned char *RecordP);
  38. PRIVATE int GetFixupThread(unsigned char *RecordP);
  39. PRIVATE LNODE *GetThreadFixupMethod(unsigned int method, unsigned int d,
  40.         char *RecordP);
  41. PRIVATE void GetFixupLocation(unsigned int loc, char *RecordP);
  42. PRIVATE int IteratedDataBlock(unsigned char *RecordP);
  43. PRIVATE void InstThreadTable(void);
  44. PRIVATE void PutThread(FIXUPTHREAD NewThread);
  45. PRIVATE FIXUPTHREAD *GetThread(unsigned char ThreadID, char ThreadType,
  46.         char *RecordP);
  47. PRIVATE int GetFixDatField(unsigned char *RecordP);
  48. PRIVATE char GetVarLengthIdx(char *RecordP, int *Index);
  49.  
  50.  
  51. /*------------------------------------------------------------
  52. *   InstObjExp  --  Instantiate the Object Explorer
  53. *-----------------------------------------------------------*/
  54. PUBLIC void InstObjExp(char ObjFN[], char **ws, long *ObjSize)
  55. {
  56.     if ((ObjFH = fopen(ObjFN, "rb")) == NULL) {
  57.         fprintf(stderr, "Could Not Open File %s\n", ObjFN);
  58.         exit(-1);
  59.     }
  60.  
  61.     if ((*ObjSize = filelength(fileno(ObjFH))) == -1) {
  62.         fprintf(stderr, "Error in File Size Determination\n");
  63.         exit(-1);
  64.     }
  65.  
  66.     if ((ObjBase = *ws = malloc((int) *ObjSize)) == NULL) {
  67.         fprintf(stderr, "Work Space Allocation Failed.  Aborting\n");
  68.         exit(-1);
  69.     }
  70.  
  71.     if (fread(*ws, sizeof(char), (int) *ObjSize, ObjFH) !=
  72.             (unsigned int) *ObjSize) {
  73.         fprintf(stderr, "Read of OBJ Failed.  Aborting\n");
  74.         exit(-1);
  75.     }
  76.     fclose(ObjFH);
  77.  
  78.     if ((char) **ws != (char) THEADR && (char) **ws != (char) LHEADR) {
  79.         fprintf(stderr, "Invalid OBJ file.  Aborting\n");
  80.         exit(-1);
  81.     }
  82.  
  83.     InstList(&ListLNAMES);    /* initialize symbol lists */
  84.     InstList(&ListSEGDEF);
  85.     InstList(&ListGRPDEF);
  86.     InstList(&ListEXTDEF);
  87.     InstThreadTable();
  88. }
  89.  
  90.  
  91. /*===============================================
  92. *  1. OMF comment records:
  93. *   THEADR      0x80
  94. *   COMENT      0x88
  95. *   MODEND      0x8A
  96. *===============================================*/
  97.  
  98. /*--------------------------------------------------------
  99. *  DoTHEADR --  Translator Header record (T-module)
  100. *  NOTE: MUST always appear as the first record in OBJ module
  101. *--------------------------------------------------------*/
  102. PUBLIC void DoTHEADR(unsigned char *RecordP)
  103. {
  104.     char *ModuleName;
  105.  
  106.     ModuleName = MakeASCIIZ(RecordP);
  107.  
  108.     Output(Message, AnalysisFH, "Module Name:\n     %s\n", ModuleName);
  109.     free(ModuleName);
  110. }
  111. /*--------------------------------------------------------
  112. *   DoCOMENT -- Comment record
  113. *   Within the given Comment Classes anything can be put here.             
  114. *   As a result, COMENT records are popular for OMF extensions.                                                                      
  115. *-------------------------------------------------------*/                
  116. PUBLIC void DoCOMENT(unsigned char *RecordP, int RecordLength)
  117. {
  118.     bool NoPurge, NoList;
  119.     unsigned char CommentClass;
  120.     char *Comment;
  121.     char Processor[6];
  122.     int PrintLength;
  123.     int Offset;
  124.  
  125.     NoPurge = *RecordP & (char) 0x80;
  126.     NoList =  *RecordP++ & (char) 0x40;
  127.     Output(Message, AnalysisFH, "     No Purge           :  %s\n",
  128.             NoPurge ? "ON" : "OFF");
  129.     Output(Message, AnalysisFH, "     No List            :  %s\n",
  130.             NoList ? "ON" : "OFF");
  131.     CommentClass = *RecordP++;
  132.     RecordLength -= 2;        /* past NoPurge/NoList and CommentClass */
  133.  
  134.     /* Note: This string is NOT preceded by "length" byte */
  135.     Comment = malloc(RecordLength + 1);
  136.     Comment[RecordLength] = '\0';
  137.     strncpy(Comment, RecordP, RecordLength);
  138.  
  139.     /* Comment Class */
  140.     Output(Message, AnalysisFH, "     Comment Class      :  %02X\n",
  141.             CommentClass & 0x00FF);
  142.  
  143.     switch(CommentClass) {
  144.         case 0x00 :
  145.             Output(Message, AnalysisFH,
  146.                     "     Language Translator:  %s\n", Comment);
  147.             break;
  148.         case 0x01 :
  149.             Output(Message, AnalysisFH,
  150.                     "     Copyright          :  %s\n", Comment);
  151.             break;
  152.         case 0x81 :      /* obsolete: 9F comment class should be used */
  153.             Output(Message, AnalysisFH,
  154.                     "     Library Specifier  :  %s\n", Comment);
  155.             break;
  156.         case 0x9C :
  157.             Output(Message, AnalysisFH,
  158.                     "     DOS Version        :  %d\n", *(int *) RecordP);
  159.             break;
  160.         case 0x9D :
  161.             if (Comment[0] == '0')
  162.                 strcpy(Processor, "8086");
  163.             else {
  164.                 strcpy(Processor, "80086");
  165.                 Processor[2] = Comment[0];
  166.             }
  167.             Output(Message, AnalysisFH, "     Target Processor   :  %s\n",
  168.                     Processor);
  169.             Output(Message, AnalysisFH, "     Memory Model       :  %c\n",
  170.                     Comment[1]);
  171.             break;
  172.         case 0x9E :             /* Sets LINK's DOSSEG */
  173.             Output(Message, AnalysisFH, "     Force Segment Order:  %s\n",
  174.                     Comment);
  175.             break;
  176.         case 0x9F :
  177.             Output(Message, AnalysisFH, "     Library Specifier  :  %s\n",
  178.                     Comment);
  179.             break;
  180.         case 0xA0 :             /* used for IMPDEF with Windows, OS/2 */
  181.             Output(Message, AnalysisFH, "     MS-Reserved Field  :  ");
  182.             switch (*RecordP) {
  183.                 case 1 :
  184.                     Output(Message, AnalysisFH, "IMPDEF\n");
  185.                     break;
  186.                 case 2:
  187.                     Output(Message, AnalysisFH, "EXPDEF\n");
  188.                     break;
  189.                 case 3:
  190.                     Output(Message, AnalysisFH, "INCDEF\n");
  191.                     break;
  192.                 case 4:
  193.                     Output(Message, AnalysisFH,
  194.                             "Protected Memory Lib. (386)\n");
  195.                     break;
  196.                 default:
  197.                     Output(Warning, AnalysisFH, "Unknown Comment Record\n");
  198.                     break;
  199.             }
  200.             break;
  201.         case 0xA1 :      /* meaning that obsolete TYPDEF/EXTDEF pairs */
  202.                          /* not used but COMDEF instead */
  203.             Output(Message, AnalysisFH, "     Microsoft Extension:  %s\n",
  204.                     Comment);
  205.             break;
  206.         case 0xA2 :
  207.             Output(Message, AnalysisFH, "     Start of Link Pass 2\n");
  208.             break;
  209.         case 0xA3 :
  210.             Output(Message, AnalysisFH, "     LIBMOD record\n");
  211.             break;
  212.         case 0xA4 :
  213.             Output(Message, AnalysisFH, "     EXESTR record\n");
  214.             break;
  215.         case 0xA5 :
  216.             Output(Message, AnalysisFH, "     QC # 1 record\n");
  217.             break;
  218.         case 0xA6 :
  219.             Output(Message, AnalysisFH, "     INCERR record\n");
  220.             break;
  221.         case 0xA7 :
  222.             Output(Message, AnalysisFH, "     NOPAD record\n");
  223.             break;
  224.         case 0xA8 :
  225.             Output(Message, AnalysisFH, "     WKEXT record\n");
  226.             break;
  227.         default:
  228.             if (CommentClass >= 0xC0)
  229.                 Output(Message, AnalysisFH, "     User-Defined Comm. :\n");
  230.             else
  231.              /* This is foul play, or some future non-compliant extension */
  232.                 Output(Message, AnalysisFH, "     Proprietary Comm.  :\n");
  233.  
  234.             /* Hex dump the comment (string printing it isn't safe!) */
  235.             Offset = GetRecordRelPos(RecordP);
  236.             while (RecordLength > 0) {
  237.                 PrintLength = (RecordLength > MAXLINELENGTH) ?
  238.                         MAXLINELENGTH : RecordLength;
  239.                 PrintObjDumpLine(RecordP, AnalysisFH, Offset, PrintLength);
  240.                 RecordLength -= PrintLength;
  241.                 Offset += PrintLength;
  242.                 RecordP    += PrintLength;
  243.             }
  244.             break;
  245.     }
  246.     free(Comment);
  247. }
  248.  
  249. /*--------------------------------------------------------------
  250. *  DoMODEND --  Module End record
  251. *  Indicates end of module, whether it's the main routine in a
  252. *  program, and, optionally, program entry point.
  253. *  NOTE: MUST always appear as the last record in OBJ module
  254. *-------------------------------------------------------------*/
  255. PUBLIC void DoMODEND(unsigned char *RecordP)
  256. {
  257.     bool IsMain;
  258.     bool HasEntryPoint;
  259.     bool IsRelocatableEP;
  260.  
  261.     /* The top two bytes are relevant:  byte 7 - is it main module, */
  262.     /*                        byte 6 - is starting address supplied */
  263.  
  264.     /* The following check will fail on Quick C generated OBJ modules.
  265.         This non-standard behavior is undocumented (but harmless).  */
  266.     #ifdef QUICKC_MYSTERY
  267.     if ((*RecordP & (char) 0x3E) != 0)
  268.         Output(Warning, AnalysisFH,
  269.                 "Unrecognizable Module End Attribute Record\n");
  270.     #endif
  271.  
  272.     IsMain = *RecordP & (char) 0x80;
  273.     HasEntryPoint = *RecordP & (char) 0x40;
  274.     IsRelocatableEP = *RecordP++ & (char) 0x01;
  275.  
  276.     Output(Message, AnalysisFH, "     %s / %s\n",
  277.             (IsMain) ? "Main module" : "Non-Main Module",
  278.             (HasEntryPoint) ? "Entry Point" : "No Entry Point");
  279.     if (HasEntryPoint)
  280.         Output(Message, AnalysisFH, "     %s\n",
  281.                 (IsRelocatableEP) ?
  282.                 "Relocatable Entry Point" : "Absolute Entry Point");
  283.  
  284.     if (HasEntryPoint)  /* Specified starting address */
  285.         GetFixDatField(RecordP);
  286. }
  287.  
  288. /*===============================================
  289. *  2. Symbol lists:
  290. *   LNAMES      0x96
  291. *   EXTDEF      0x8C
  292. *   PUBDEF      0x90
  293. *===============================================*/
  294.  
  295. /*-------------------------------------------------------------
  296. *   DoLNAMES -- Names List record
  297. *   List of names which will be referenced by subsequent SEGDEF
  298. *   and GRPDEF records in this module, using 1-based index.
  299. *   MS LINK limit is 255 logical names/module.
  300. *-------------------------------------------------------------*/
  301. PUBLIC void DoLNAMES(unsigned char *RecordP, int RecordLength)
  302. {
  303.     char *LName;
  304.  
  305.     while (RecordLength > 0) {
  306.         LName = MakeASCIIZ(RecordP);
  307.         Output(Message, AnalysisFH, "     %s\n",
  308.                 *RecordP != '\0' ? LName : "(NULLNAME)");
  309.  
  310.         ListLNAMES = AddListNode(ListLNAMES, LName);
  311.  
  312.         RecordLength -= ((int) *RecordP + 1);
  313.         RecordP += ((int) *RecordP + 1);
  314.     }
  315.  
  316.     if (RecordLength)
  317.         Output(Error, AnalysisFH,
  318.                 "LNAMES record not recognized.  Terminating\n");
  319. }
  320.  
  321.  
  322. /*---------------------------------------------------------------
  323. *   DoEXTDEF -- External Name Definitions record
  324. *   List of symbolic external references (symbols defined in other
  325. *   OBJ modules).  MS LINK limit is 1023 external names.
  326. *---------------------------------------------------------------*/
  327. PUBLIC void DoEXTDEF(unsigned char *RecordP, int RecordLength)
  328. {
  329.     char *ExtName;
  330.     int TypeIndex;
  331.     char IndexSize;
  332.  
  333.     while (RecordLength > 0) {
  334.         ExtName = MakeASCIIZ(RecordP);
  335.         ListEXTDEF = AddListNode(ListEXTDEF, ExtName); /*EXTDEF name list*/
  336.         Output(Message, AnalysisFH, "\n     External Symbol    :  %s \n",
  337.                 ExtName);
  338.         RecordLength -= ((int) *RecordP + 1);
  339.         RecordP += ((int) *RecordP + 1);
  340.  
  341.         /* Type index is reference to a TYPDEF record (if > 0)
  342.            EXTDEF/TYPDEF method is mostly obsolete, except for 
  343.            communal variables. It is replaced by COMDEF records. */
  344.  
  345.         IndexSize = GetVarLengthIdx(RecordP, &TypeIndex);
  346.         Output(Message, AnalysisFH, "     Type Index         :  %u\n",
  347.                 TypeIndex);
  348.         RecordLength -= IndexSize;
  349.         RecordP += IndexSize;
  350.     }
  351.     if (RecordLength)
  352.         Output(Error, AnalysisFH,
  353.                 "EXTDEF record not recognized.  Terminating\n");
  354. }
  355.  
  356. /*------------------------------------------------------------
  357. *   DoPUBDEF -- Public Name Definitions record
  358. *   This record contains the public names used to resolve the
  359. *   externals at link time.
  360. *-------------------------------------------------------------*/
  361. PUBLIC void DoPUBDEF(unsigned char *RecordP, int  RecordLength)
  362. {
  363.     char *PubName;
  364.     int  GroupIndex;
  365.     int  SegmentIndex;
  366.     LNODE *ListNodeP = NULL;
  367.     int TypeIndex;
  368.     char IndexSize;
  369.  
  370.     /* If a group is associated with this PUBDEF record, Group Index
  371.        indexes to the appropriate GRPDEF, otherwise it's 0 */
  372.     IndexSize = GetVarLengthIdx(RecordP, &GroupIndex);
  373.     RecordP += IndexSize;
  374.     RecordLength -= IndexSize;
  375.     if (GroupIndex != 0)
  376.         ListNodeP = GetListNode(ListLNAMES, GroupIndex);
  377.     Output(Message, AnalysisFH, "     Group   Name Index :  %u  --  %s\n",
  378.             GroupIndex, ListNodeP != NULL ? ListNodeP->InfoP : "NO GROUP");
  379.  
  380.     /* The Segment Index indexes to previous SEGDEF records to associate a
  381.        segment with this PUBDEF. If Segment Index = 0, Group Index = 0. */
  382.     ListNodeP = NULL;
  383.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  384.     RecordP += IndexSize;
  385.     RecordLength -= IndexSize;
  386.     if (SegmentIndex != 0)
  387.         ListNodeP = GetListNode(ListSEGDEF, SegmentIndex);
  388.     Output(Message, AnalysisFH, "     Segment Name Index :  %u  --  %s\n",
  389.         SegmentIndex, ListNodeP != NULL ? ListNodeP->InfoP : "NO SEGMENT");
  390.  
  391.     /* If both Group and Segment Index are 0, a Frame Number follows
  392.        which indexes the frame containing the Public symbols */
  393.     if (GroupIndex == 0 && SegmentIndex == 0) {
  394.         Output(Message, AnalysisFH, "     Frame Number = %Xx\n",
  395.                 *(int *) RecordP);
  396.         RecordP += 2;
  397.         RecordLength -= 2;
  398.     }
  399.  
  400.     while (RecordLength > 0) {
  401.         /* PUBLIC's name */
  402.         PubName = MakeASCIIZ(RecordP);
  403.         Output(Message, AnalysisFH, "\n     Public Name        :  %s \n",
  404.                 PubName);
  405.         free(PubName);
  406.         RecordLength -= ((int) *RecordP + 1);
  407.         RecordP += ((int) *RecordP + 1);
  408.  
  409.         /* PUBLIC's offset relative to segment, group, or frame (supra) */
  410.         Output(Message, AnalysisFH,
  411.                 "     Public Offset      :  %Xx\n", *(int *) RecordP);
  412.         RecordP += 2;
  413.         RecordLength -= 2;
  414.  
  415.         /* Type Index refers to preceding TYPDEF record. 0 = no data type */
  416.         IndexSize = GetVarLengthIdx(RecordP, &TypeIndex);
  417.         RecordP += IndexSize;
  418.         RecordLength -= IndexSize;
  419.         Output(Message, AnalysisFH, "     Type Index         :  %u\n",
  420.                 TypeIndex);
  421.     }
  422.     if (RecordLength)
  423.         Output(Error, AnalysisFH,
  424.                 "PUBDEF record not recognized.  Terminating\n");
  425. }
  426.  
  427. /*====================================
  428. *  3. Memory layout info:
  429. *   SEGDEF      0x98
  430. *   GRPDEF      0x9A
  431. *   COMDEF      0xB0
  432. *   TYPDEF      0x8E
  433. *====================================*/
  434.  
  435. /*---------------------------------------------------------
  436. *  DoSEGDEF --  Segment Definition record
  437. *    Describes a logical segment: name, length, alignment,
  438. *    combination with other logical segments.
  439. *    MS LINK limit: 255 SEGDEF records per OBJ modules
  440. *---------------------------------------------------------*/
  441. PUBLIC void DoSEGDEF(unsigned char *RecordP)
  442. {
  443.     char  *SegmentName;
  444.     long SegmentLength;
  445.     int SegmentIndex;
  446.     int ClassIndex;
  447.     int OverlayIndex;
  448.     char IndexSize;
  449.  
  450.     struct ACBP {
  451.         unsigned Page    : 1;
  452.         unsigned Big     : 1;
  453.         unsigned Combine : 3;
  454.         unsigned Align :   3;
  455.     } ACBP;
  456.  
  457.     ACBP = *(struct ACBP *) RecordP++;
  458.  
  459.     /* Segment Alignment at runtime */
  460.     switch(ACBP.Align) {
  461.         case 0 :
  462.             Output(Message, AnalysisFH, "     ABSOLUTE Segment\n");
  463.             break;
  464.         case 1 :
  465.             Output(Message, AnalysisFH, "     Relocatable/Align  :  BYTE\n");
  466.             break;
  467.         case 2 :
  468.             Output(Message, AnalysisFH, "     Relocatable/Align  :  WORD\n");
  469.             break;
  470.         case 3 :
  471.             Output(Message, AnalysisFH, "     Relocatable/Align  :  PARA\n");
  472.             break;
  473.         case 4 :
  474.             Output(Message, AnalysisFH, "     Relocatable/Align  :  PAGE\n");
  475.             break;
  476.         default:
  477.             Output(Warning, AnalysisFH,
  478.                     "Unrecognizable Segment Alignment Record\n");
  479.             break;
  480.     }
  481.  
  482.     /* Segment Combination that linker may perform to segments of same name.
  483.        Can either concatenate segments, or overlap them. Note: Absolute
  484.        segments (Align = 0) canNOT be combined (Combine = 0). */
  485.     switch(ACBP.Combine) {
  486.         case 0 :
  487.             Output(Message, AnalysisFH, "     PRIVATE Segment\n");
  488.             break;
  489.         case 2 :
  490.         case 4 :
  491.         case 7:
  492.             Output(Message, AnalysisFH,
  493.                     "     Combine Type  :  PUBLIC/Concatenate\n");
  494.             break;
  495.         case 5 :
  496.             Output(Message, AnalysisFH,
  497.                     "     Combine Type  :  STACK/Concatenate\n");
  498.             break;
  499.         case 6 :
  500.             Output(Message, AnalysisFH,
  501.                     "     Combine Type  :  COMMON/Overlap\n");
  502.             break;
  503.         default:
  504.             Output(Warning, AnalysisFH,
  505.                     "Unrecognizable Segment Combination Record\n");
  506.             break;
  507.     }
  508.  
  509.     /*  Big Field determines if segment size is EXACTLY 64k */
  510.     if (ACBP.Big == 1)
  511.         Output(Message, AnalysisFH, "     Segment Size       =  64Kb\n");
  512.     else
  513.         Output(Message, AnalysisFH, "     Segment Size       <  64Kb\n");
  514.  
  515.     /* Page field is unused in DOS and should be 0. */
  516.     if (ACBP.Page != 0)
  517.         Output(Message, AnalysisFH,
  518.                 "Unrecognized Page value in SEGDEF record\n");
  519.  
  520.  
  521.     /* Frame Number and Offset fields are present only for absolute segments.
  522.        Taken together, they provide the segment's starting address: */
  523.     if (ACBP.Align == 0) {          /* absolute segment specific fields */
  524.         Output(Message, AnalysisFH,
  525.                 "     Absolute Segment   : Frame Number   = %Xx\n",
  526.                 *(int *) RecordP);
  527.         RecordP += 2;
  528.         Output(Message, AnalysisFH,
  529.                 "     Absolute Segment   : Segment Offset = %Xx\n",
  530.                 *(unsigned char *) RecordP++);
  531.     }
  532.  
  533.     /* Segment Length in bytes */
  534.     SegmentLength = (long) *(unsigned int *) RecordP;
  535.     /* if Big field was 1 (i.e., 64K segment), 
  536.        Segment Length field is set to 0 */
  537.     if (ACBP.Big == 1 && SegmentLength == 0)
  538.         SegmentLength = 65536;          /* 64k */
  539.     Output(Message, AnalysisFH, "     Segment Length     :  %ld\n",
  540.             SegmentLength);
  541.     RecordP += 2;
  542.  
  543.     /* The Segment Name Index, Class Name Index, and Overlay Name Index
  544.        provide the names from previous LNAMES records. */
  545.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  546.     SegmentName = GetListNode(ListLNAMES, SegmentIndex)->InfoP;
  547.     Output(Message, AnalysisFH, "     Segment Name Index :  %d  --  %s\n",
  548.             SegmentIndex, SegmentName);
  549.     ListSEGDEF = AddListNode(ListSEGDEF, SegmentName);
  550.     RecordP += IndexSize;
  551.  
  552.     /* The Class Name Index gives the segment's class(e.g. CODE, or STACK),
  553.        so that linker can combine segments of equal class name. */
  554.     IndexSize = GetVarLengthIdx(RecordP, &ClassIndex);
  555.     Output(Message, AnalysisFH, "     Class   Name Index :  %d  --  %s\n",
  556.             ClassIndex, GetListNode(ListLNAMES, ClassIndex)->InfoP);
  557.     RecordP += IndexSize;
  558.  
  559.     /* The Overlay Name Index identifies a segment with a runtime overlay.
  560.        MS LINK ignores it, using command-line parameters to LINK instead. */
  561.     IndexSize = GetVarLengthIdx(RecordP, &OverlayIndex);
  562.     Output(Message, AnalysisFH, "     Overlay Name Index :  %d  --  %s\n",
  563.             OverlayIndex, GetListNode(ListLNAMES, OverlayIndex)->InfoP);
  564. }
  565. /*---------------------------------------------------------
  566. *   DoGRPDEF -- Group Definition record
  567. *     Defines a group of segments to reside together within
  568. *     64K frame at runtime.
  569. *     MS LINK limit: 21 GRPDEF records per OBJ module.
  570. *--------------------------------------------------------*/
  571. PUBLIC void DoGRPDEF(unsigned char *RecordP, int  RecordLength)
  572. {
  573.     char  *GroupName;
  574.     int GroupIndex;
  575.     int SegmentIndex;
  576.     char IndexSize;
  577.  
  578.     /* Get the Group Name via Group Name Index */
  579.     IndexSize = GetVarLengthIdx(RecordP, &GroupIndex);
  580.     GroupName = GetListNode(ListLNAMES, GroupIndex)->InfoP;
  581.     Output(Message, AnalysisFH, "     Group   Name Index :  %d  --  %s\n",
  582.             GroupIndex, GroupName);
  583.     /* Group Name may be later referenced in FIXUPP */
  584.     ListGRPDEF = AddListNode(ListGRPDEF, GroupName);
  585.     RecordLength -= IndexSize;
  586.     RecordP += IndexSize;
  587.  
  588.     /* Remainder of record is made up of Group Component Descriptors: */
  589.     while (RecordLength > 0) {
  590.         /* First byte is always FF, indicating following 
  591.            of Segment Name Index  */
  592.         ++RecordP;
  593.         RecordLength--;
  594.  
  595.         /* Segment Name Index relative to previous SEGDEF record */
  596.         IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  597.         Output(Message, AnalysisFH, 
  598.             "     Segment Name Index :  %d  --  %s\n",
  599.                   SegmentIndex, GetListNode(ListSEGDEF, 
  600.                   SegmentIndex)->InfoP);
  601.         RecordP += IndexSize;
  602.         RecordLength -= IndexSize;
  603.     }
  604.  
  605.     if (RecordLength)
  606.         Output(Error, AnalysisFH,
  607.                 "GRPDEF record not recognized.  Terminating\n");
  608. }
  609.  
  610. /*-------------------------------------------------------------------
  611. *   DoCOMDEF -- Common Name Definitions record
  612. *      MS extension declaring a (list of) communal variable(s).
  613. *      Being an extension COMDEF records must be indicated by COMENT
  614. *      record of Comment Class A1.
  615. *------------------------------------------------------------------*/
  616. PUBLIC void DoCOMDEF(unsigned char *RecordP, int RecordLength)
  617. {
  618.     char *ComName;
  619.     long CommunalSize;
  620.     int TypeIndex;
  621.     unsigned char DataSegmentType;
  622.     unsigned int  NameLength;
  623.     char IndexSize;
  624.     int i;
  625.  
  626.     while (RecordLength > 0) {
  627.         /* Communal Name */
  628.         ComName = MakeASCIIZ(RecordP);
  629.         ListEXTDEF = AddListNode(ListEXTDEF, ComName); /*EXTDEF name list*/
  630.         Output(Message, AnalysisFH,
  631.                 "\n     Communal Symbol    :  %s \n", ComName);
  632.         NameLength = *RecordP + 1;  /* name + length byte */
  633.         RecordLength -= NameLength;
  634.         RecordP += NameLength;
  635.  
  636.         /* Type Index indexes to TYPDEF, or is 0 if no associated type */
  637.         IndexSize = GetVarLengthIdx(RecordP, &TypeIndex);
  638.         Output(Message, AnalysisFH,
  639.                 "     Type Index         :  %X\n", (int) TypeIndex);
  640.         RecordLength -= IndexSize;
  641.         RecordP += IndexSize;
  642.  
  643.         /* Data Segment Type: is Communal Variable NEAR or FAR ? */
  644.         DataSegmentType = *RecordP++;
  645.         --RecordLength;
  646.         if (DataSegmentType == FAR)
  647.             Output(Message, AnalysisFH, 
  648.                     "     Default Data Segm. :  NO/FAR\n");
  649.         else if (DataSegmentType == NEAR)
  650.             Output(Message, AnalysisFH,
  651.                     "     Default Data Segm. :  YES/NEAR\n");
  652.         else
  653.             Output(Error, AnalysisFH,
  654.                     "COMDEF record not recognized.  Terminating\n");
  655.  
  656.         /* Communal Length field: amount of memory to allocate for communal.
  657.            Depending on Data Segment Type, the following bytes are 
  658.            interpreted: NEAR: variable size in bytes, FAR: number 
  659.            of elements, element size.
  660.  
  661.            NEAR: Variable Size field , 
  662.            FAR: Number of Elements/Element Size */
  663.  
  664.         for (i = 0; i < (DataSegmentType == NEAR ? 1 : 2); i++) {
  665.             /* The size field(s) is/are determined from first byte: */
  666.             switch (*RecordP) {
  667.                 /* 2 byte unsigned length field follows, i.e. < 64k */
  668.                 case  0x81 :
  669.                     ++RecordP;
  670.                     CommunalSize = (long) *(unsigned int *) RecordP;
  671.                     RecordLength -= 3;
  672.                     RecordP += 2;
  673.                     break;
  674.                 /* 3 byte unsigned length field: < 16M */
  675.                 case  0x84 :
  676.                     ++RecordP;
  677.                     CommunalSize = *(long *) RecordP & 0x00FFFFFF;
  678.                     RecordLength -= 4;
  679.                     RecordP += 3;
  680.                     break;
  681.                 /* 4 byte signed length field: < 2G */
  682.                 case  0x88 :
  683.                     ++RecordP;
  684.                     CommunalSize = *(long *) RecordP;
  685.                     RecordLength -= 5;
  686.                     RecordP += 4;
  687.                     break;
  688.                 /* char field of value < 80h is actual communal length: 
  689.                     < 128b */
  690.                 default :       /* 1 byte signed length field: < 128b */
  691.                     CommunalSize = (long) *RecordP++;
  692.                     --RecordLength;
  693.                     break;
  694.             }
  695.             if (DataSegmentType == NEAR)
  696.                 Output(Message, AnalysisFH,
  697.                         "     Communal Length    :  %ld bytes\n",
  698.                         CommunalSize);
  699.             else if (i == 0)
  700.                 Output(Message, AnalysisFH,
  701.                         "     Communal Elements  :  %ld bytes\n",
  702.                         CommunalSize);
  703.             else
  704.                 Output(Message, AnalysisFH,
  705.                         "     Element Size       :  %ld bytes\n",
  706.                         CommunalSize);
  707.         }
  708.     }
  709.  
  710.     if (RecordLength)
  711.         Output(Error, AnalysisFH,
  712.                 "COMDEF record not recognized.  Terminating\n");
  713. }
  714.  
  715. /*------------------------------------------------------------
  716. *  DoTYPDEF --  Type Definition record
  717. *    Type information about PUBDEF or EXTDEF name
  718. *------------------------------------------------------------*/
  719. PUBLIC void DoTYPDEF()
  720. {
  721.     Output(Warning, AnalysisFH, "TYPDEF not implemented\n");
  722. }
  723.  
  724. /*===============================================
  725. *  4. Code and data
  726. *   LEDATA      0xA0
  727. *   LIDATA      0xA2
  728. *==============================================*/
  729.  
  730. /*-------------------------------------------------------------
  731. *   DoLEDATA -- Logical Enumerated Data record
  732. *     Contiguous binary data, executable code or program data.
  733. *     Typically, preceded by SEGDEF and followed by FIXUPP record.
  734. *     Max. length for data field is 1024 bytes.
  735. *-------------------------------------------------------------*/
  736. PUBLIC void DoLEDATA(unsigned char *RecordP, int  RecordLength)
  737. {
  738.     int Offset;
  739.     int PrintLength;
  740.     int SegmentIndex;
  741.     char IndexSize;
  742.  
  743.     /* Segment Index field refers to SEGDEF record, indicating
  744.        segment into which to place this binary code/data. */
  745.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  746.     Output(Message, AnalysisFH, "     Segment Name Index :  %d  --  %s\n",
  747.             SegmentIndex, GetListNode(ListSEGDEF, SegmentIndex)->InfoP);
  748.     RecordP += IndexSize;
  749.     RecordLength -= IndexSize;
  750.  
  751.     /* Enumerated Data Offset: relative to Segment Index's segment base */
  752.     Output(Message, AnalysisFH, "     Enum. Data  Offset : %Xx\n",
  753.             *(int *) RecordP);
  754.     RecordP += 2;
  755.     RecordLength -= 2;
  756.  
  757.     Output(Message, AnalysisFH, "\nEnumerated Data:\n\n");
  758.  
  759.     Offset = 0;         /* offset of data relative to its record */
  760.     while (RecordLength > 0) {
  761.         PrintLength = (RecordLength > MAXLINELENGTH) ?
  762.                 MAXLINELENGTH : RecordLength;
  763.         PrintObjDumpLine(RecordP, AnalysisFH, Offset, PrintLength);
  764.         RecordLength -= PrintLength;
  765.         Offset += PrintLength;
  766.         RecordP    += PrintLength;
  767.     }
  768.  
  769.     if (RecordLength)
  770.         Output(Error, AnalysisFH,
  771.                 "LEDATA record not recognized.  Terminating\n");
  772. }
  773.  
  774. /*--------------------------------------------------------------
  775. *   DoLIDATA -- Logical Iterated Data record
  776. *      Binary code/data represented in repeating patterns (iterations).
  777. *      Typically, preceded by SEGDEF and followed by FIXUPP record.
  778. *      Max. size of iterated data block field is 512 bytes.
  779. *--------------------------------------------------------------*/
  780. PUBLIC void DoLIDATA(unsigned char *RecordP, int RecordLength)
  781. {
  782.     int BytesDone;
  783.     int SegmentIndex;
  784.     char IndexSize;
  785.  
  786.     /* Segment Index field refers to SEGDEF record, indicating segment
  787.     ** into which to place this binary code/data. */
  788.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  789.     Output(Message, AnalysisFH, "     Segment Name Index :  %d  --  %s\n",
  790.             SegmentIndex, GetListNode(ListSEGDEF, SegmentIndex)->InfoP);
  791.     RecordP += IndexSize;
  792.     RecordLength -= IndexSize;
  793.  
  794.     /* Iterated Data Offset: relative to Segment Index's segment base */
  795.     Output(Message, AnalysisFH, "     Iter. Data  Offset : %Xx\n",
  796.             *(int *) RecordP);
  797.     RecordP += 2;
  798.     RecordLength -= 2;
  799.  
  800.     while (RecordLength > 0) {
  801.         /* Iterated Data Blocks are defined recursively */
  802.         BytesDone = IteratedDataBlock(RecordP);
  803.         RecordLength -= BytesDone;
  804.         RecordP += BytesDone;
  805.     }
  806.  
  807.     if (RecordLength)
  808.         Output(Error, AnalysisFH,
  809.                 "LIDATA record not recognized.  Terminating\n");
  810. }
  811.  
  812. /*-----------------------------------------------------------------
  813. *   IteratedDataBlock -- Analyzes one Logical Iterated Data record
  814. *      This is separated out because of its recursive nature.
  815. *----------------------------------------------------------------*/
  816. PRIVATE int IteratedDataBlock(unsigned char *RecordP)
  817. {
  818.     int RepeatCount;
  819.     int BlockCount;
  820.     int BytesDone;
  821.     int Offset;
  822.     int DataBlockLength;
  823.     int PrintLength;
  824.     int RecordLength;
  825.  
  826.     /* Repeat Count is number of times to repeat Content field */
  827.     RepeatCount = *(int *) RecordP;
  828.     Output(Message, AnalysisFH, "\n     Repeat Count       : %d\n",
  829.             RepeatCount);
  830.     RecordP += 2;
  831.  
  832.     /* Block Count is number of iterated data blocks in Content field.
  833.     ** If 0, Content field contains data only. */
  834.     BlockCount = *(int *) RecordP;
  835.     Output(Message, AnalysisFH, "     Block Count       : %d\n", BlockCount);
  836.     RecordP += 2;
  837.     /* So far: Block Count and Repeat Count words */
  838.     BytesDone = 4;
  839.  
  840.     /* Content field: if Block Count != 0, nested iterated Data Blocks */
  841.     if (BlockCount > 0) {
  842.         FOREVER {
  843.             RecordLength = IteratedDataBlock(RecordP);
  844.             RecordP += RecordLength;
  845.             BytesDone += RecordLength;
  846.             if (--BlockCount == 0)
  847.                 return (BytesDone);
  848.         }
  849.     }
  850.  
  851.     /* With zero Block Count, this is data: length byte, then data bytes */
  852.     DataBlockLength = *(char *) RecordP++;
  853.     Output(Message, AnalysisFH, "     Data Block Length  : %d\n",
  854.             DataBlockLength);
  855.  
  856.     /* We've traversed: Data and its Length byte */
  857.     BytesDone += DataBlockLength + 1;
  858.  
  859.     /* Print the raw data */
  860.     Offset = 0;
  861.     while (DataBlockLength > 0) {
  862.         PrintLength = (DataBlockLength > MAXLINELENGTH) ?
  863.                 MAXLINELENGTH : DataBlockLength;
  864.         PrintObjDumpLine(RecordP, AnalysisFH, Offset, PrintLength);
  865.         DataBlockLength -= PrintLength;
  866.         Offset += PrintLength;
  867.         RecordP    += PrintLength;
  868.     }
  869.     return (BytesDone);
  870. }
  871.  
  872. /*===============================================
  873. *  5. Address binding/relocation:
  874. *   FIXUPP      0x9C
  875. *==============================================*/
  876.  
  877. /*----------------------------------------------------------------
  878. *   DoFIXUPP -- Relocation Fixup records: Used to resolve addresses             
  879. *     whose values cannot be determined prior to link time.
  880. *     LOCATION: address in OBJ module to be fixed up
  881. *     TARGET: address to which fixup refers (to be computed)
  882. *     FRAME: relative to which the address is computed
  883. *----------------------------------------------------------------*/
  884.  
  885. PUBLIC void DoFIXUPP(unsigned char *RecordP, int RecordLength)
  886. {
  887.     bool IsFixup;
  888.     int  FixupLength;
  889.  
  890.     while (RecordLength > 0) {
  891.         /* High bit determines difference between Thread field 
  892.             and Fixup field */
  893.         IsFixup = (bool) (*(char *) RecordP & 0x80);
  894.         if (IsFixup)
  895.             FixupLength = GetExplicitFixupp(RecordP);
  896.         else
  897.             FixupLength = GetFixupThread(RecordP);
  898.         RecordP += FixupLength;
  899.         RecordLength -= FixupLength;
  900.     }
  901.     if (RecordLength)
  902.         Output(Error, AnalysisFH,
  903.                 "FIXUPP record not recognized.  Terminating\n");
  904. }
  905.  
  906. /*-----------------------------------------------------------
  907. *   GetFixupThread --   Thread FIXUPP records
  908. *     Provides common info for reference by succeeding
  909. *     explicit fixup or thread fields in same or subsequent
  910. *     FIXUPP records.                                      
  911. *-----------------------------------------------------------*/
  912. PRIVATE int GetFixupThread(unsigned char *RecordP)
  913. {
  914.     struct ThrData {
  915.         unsigned ThreadNumber : 2;
  916.         unsigned Method       : 3;
  917.         unsigned NotUsed      : 1;
  918.         unsigned D            : 1;
  919.         unsigned FixupType    : 1;  /* 0 = Thread, 1 = Explicit FIXUPP */
  920.     }  ThreadData;
  921.  
  922.     FIXUPTHREAD Thread;
  923.     LNODE *ThreadName;
  924.     int RecLength = 1;      /* min. record length in bytes */
  925.     int IndexSize;
  926.  
  927.     Output(Message, AnalysisFH, "\n%04X  --  FIXUPP Thread:\n",
  928.             GetRecordRelPos(RecordP));
  929.  
  930.     /* Interpret the thread record */
  931.     ThreadData = *(struct ThrData *) RecordP++;
  932.     /* Thread will be known by an index 0-3 (for each, Frame and Target) */
  933.     Thread.ID = (char) ThreadData.ThreadNumber;
  934.  
  935.     /* D = 0 : Target Thread, identifies the fixup target */
  936.     /* D = 1 : Frame Thread, provides info about 64k frame */
  937.     Thread.Type = (char) (ThreadData.D == 0 ? 'T' : 'F');
  938.  
  939.     /* Methods: T0 - T7 (for D = 0), and F0 - F5 (for D = 1) */
  940.     Thread.Method = (char) ThreadData.Method;
  941.  
  942.  
  943.     /* Index Field appears always, except for frame threads 
  944.        using methods F3/4/5  */
  945.     if (!(Thread.Type == 'F' && Thread.Method > 2))
  946.         IndexSize = GetVarLengthIdx(RecordP, &Thread.ListIndex);
  947.     else
  948.         Thread.ListIndex = -1;      /* none */
  949.  
  950.     Output(Message, AnalysisFH, "\n     %s Thread #    :  %d\n",
  951.             Thread.Type == 'F' ? "Frame" : "Target",
  952.             (int) Thread.ID);
  953.  
  954.     /* The Method field (combined with D) gives linker method 
  955.        to identify T/F. DefList is applicable xxxDEF list to r
  956.        efer to via Index */
  957.     Thread.DefList = GetThreadFixupMethod((int) ThreadData.Method,
  958.             (int) ThreadData.D, RecordP - 1);
  959.  
  960.     if (Thread.ListIndex > 0) {
  961.         ThreadName = GetListNode(*(Thread.DefList),
  962.                 Thread.ListIndex)->InfoP;
  963.         Output(Message, AnalysisFH, "     %s Thread Index:  %u   --  %s\n",
  964.                 Thread.Type == 'F' ? "Frame" : "Target",
  965.                 Thread.ListIndex, ThreadName);
  966.         RecLength += IndexSize;         /* Record Length in bytes */
  967.     }
  968.  
  969.     PutThread(Thread);
  970.     return (RecLength);         /* Record Length in bytes */
  971. }
  972.  
  973. /*------------------------------------------------------------------
  974. *  GetThreadFixupMethod -- Interpret Method / D fields of Thread FIXUPP rec   
  975. *------------------------------------------------------------------*/
  976. PRIVATE LNODE *GetThreadFixupMethod(unsigned int Method, unsigned int D,
  977.         char *RecordP)
  978. {
  979.     if (D) {                            /* Frame Thread */
  980.         Output(Message, AnalysisFH, "     Frame ID Method   :  F%u  --  ",
  981.                 Method);
  982.         switch(Method) {
  983.             case 0 :
  984.                 Output(Message, AnalysisFH,
  985.                         "SEGDEF index: Highest #ered Frame cont. segm\n");
  986.                 return (&ListSEGDEF);
  987.             case 1 :
  988.                 Output(Message, AnalysisFH, "GRPDEF index\n");
  989.                 return (&ListGRPDEF);
  990.             case 2 :
  991.                 Output(Message, AnalysisFH, "EXTDEF index\n");
  992.                 return (&ListEXTDEF);
  993.             case 3 :
  994.                 Output(Message, AnalysisFH, "Frame Number\n");
  995.                 return (NULL);
  996.             case 4 :
  997.                 Output(Message, AnalysisFH,
  998.                         "Highest #ered Frame cont. segm of fixup loc\n");
  999.                 return (NULL);
  1000.             case 5 :
  1001.                 Output(Message, AnalysisFH, "Same as target frame\n");
  1002.                 return (NULL);
  1003.             default:
  1004.                 Output(Warning, AnalysisFH,
  1005.                    "\n%04X  --  FIXUPP: Bad Frame Thread Method Value\n",
  1006.                    GetRecordRelPos(RecordP));
  1007.                 return (NULL);
  1008.         }
  1009.     }
  1010.     else {                              /* Target Thread */
  1011.         Output(Message, AnalysisFH, "     Target ID Method   :  T%u  --  ",
  1012.                 Method);
  1013.         switch (Method) {
  1014.             case 0 :
  1015.                 Output(Message, AnalysisFH, "SEGDEF index and offset\n");
  1016.                 return (&ListSEGDEF);
  1017.             case 1 :
  1018.                 Output(Message, AnalysisFH, "GRPDEF index and offset\n");
  1019.                 return (&ListGRPDEF);
  1020.             case 2 :
  1021.                 Output(Message, AnalysisFH, "EXTDEF index and offset\n");
  1022.                 return (&ListEXTDEF);
  1023.             case 3 :
  1024.                 Output(Message, AnalysisFH, "Frame Number and offset\n");
  1025.                 return (NULL);
  1026.             case 4 :
  1027.                 Output(Message, AnalysisFH, "SEGDEF index only.");
  1028.                 Output(Message, AnalysisFH, "Target at Segment beginning\n");
  1029.                 return (&ListSEGDEF);
  1030.             case 5 :
  1031.                 Output(Message, AnalysisFH, "GRPDEF index only\n");
  1032.                 return (&ListGRPDEF);
  1033.             case 6 :
  1034.                 Output(Message, AnalysisFH, "EXTDEF index only\n");
  1035.                 return (&ListEXTDEF);
  1036.             case 7 :
  1037.                 Output(Message, AnalysisFH, "Frame Number only\n");
  1038.                 return (NULL);
  1039.             default:
  1040.                 Output(Warning, AnalysisFH,
  1041.                    "\n%04X  --  FIXUPP: Bad Target Thread Method Value\n",
  1042.                    GetRecordRelPos(RecordP));
  1043.                 return (NULL);
  1044.         }
  1045.     }
  1046. }
  1047.  
  1048. /*---------------------------------------------------------------
  1049. *   GetThread   --  Retrieve a thread from the thread data table
  1050. *                   If no valid thread, return NULL.
  1051. *--------------------------------------------------------------*/
  1052. PRIVATE FIXUPTHREAD *GetThread(unsigned char ThreadID, char ThreadType,
  1053.         char *RecordP)
  1054. {
  1055.     int Idx;
  1056.  
  1057.     if (ThreadID <= 3) {
  1058.         /* In table, we store Frame threads first then Target threads */
  1059.         Idx = (int) (ThreadType == 'F' ? ThreadID :
  1060.                 ThreadID + (char) THREADMAX);
  1061.         if (ThreadTable[Idx].ListIndex != -1)
  1062.             return (&ThreadTable[Idx]);
  1063.     }
  1064.  
  1065.     /* If we get here, we're in trouble! */
  1066.     Output(Warning, AnalysisFH,
  1067.             "\n%04X  --  FIXUPP: Bad Thread Reference\n",
  1068.             GetRecordRelPos(RecordP));
  1069.     return (NULL);
  1070. }
  1071.  
  1072. /*--------------------------------------------------------
  1073. *   PutThread   --  Save a thread in the thread data table
  1074. *-------------------------------------------------------*/
  1075. PRIVATE void PutThread(FIXUPTHREAD NewThread)
  1076. {
  1077.     int Idx;
  1078.  
  1079.     /* In table, we store Frame threads first then Target threads */
  1080.     Idx = (int) (NewThread.Type == 'F' ? NewThread.ID :
  1081.             NewThread.ID + (char) THREADMAX);
  1082.     ThreadTable[Idx] = NewThread;
  1083. }
  1084.  
  1085. /*-------------------------------------------------------
  1086. *   InstThreadTable --  Instantiate the Thread Table
  1087. *------------------------------------------------------*/
  1088. PRIVATE void InstThreadTable()
  1089. {
  1090.     int i;
  1091.  
  1092.     for (i = 0; i < THREADMAX * 2; i++)
  1093.         ThreadTable[i].ID = -1;
  1094. }
  1095.  
  1096. /*-------------------------------------------------------
  1097. *  GetExplicitFixupp -- Explicit FIXUPP records
  1098. *-------------------------------------------------------*/
  1099. PRIVATE int GetExplicitFixupp(unsigned char *RecordP)
  1100. {
  1101.     int RecordLength;
  1102.  
  1103.     union {
  1104.         struct {
  1105.           unsigned DataRecOffset : 10; /* LOCATION position in LxDATA rec */
  1106.           unsigned Loc         : 3;  /* location type to be fixed up */
  1107.           unsigned S           : 1;  /* unused, should be 0 */
  1108.           unsigned Mode        : 1;  /* segment-relative vs self-relative */
  1109.           unsigned FixupType   : 1;  /* explicit or thread */
  1110.         } Word;
  1111.         char Byte[2];
  1112.     } Locat;
  1113.  
  1114.     Output(Message, AnalysisFH, "\n%04X  --  Explicit FIXUPP :\n",
  1115.             GetRecordRelPos(RecordP));
  1116.  
  1117.     Locat.Byte[1] = *RecordP++;            /* read bit fields   */
  1118.     Locat.Byte[0] = *RecordP++;            /* in reverse order  */
  1119.  
  1120.     /* Mode bit */
  1121.     Output(Message, AnalysisFH, "\n     Fixup Relativity   :  %s \n",
  1122.             Locat.Word.Mode ? "SEGMENT" : "SELF");
  1123.  
  1124.     GetFixupLocation((int) Locat.Word.Loc, RecordP - 2);  /* Loc field */
  1125.  
  1126.                                  /* Data Rec Offset in previous LxDATA */
  1127.     Output(Message, AnalysisFH, "     Location Offset    :  %Xx\n",
  1128.             (int) Locat.Word.DataRecOffset);
  1129.  
  1130.     RecordLength = GetFixDatField(RecordP);
  1131.  
  1132.     return (RecordLength);
  1133. }
  1134.  
  1135. /*----------------------------------------------------------
  1136. *  GetFixupLocation --  Determine location to be fixed up.
  1137. *                       (Explicit FIXUPP record)
  1138. *----------------------------------------------------------*/
  1139. PRIVATE void GetFixupLocation(unsigned int Loc, char *RecordP)
  1140. {
  1141.     Output(Message, AnalysisFH, "     Fixup Location     :  ");
  1142.     switch (Loc) {
  1143.         case 0 :
  1144.             Output(Message, AnalysisFH, "Low-Order Byte\n");
  1145.             break;
  1146.         case 5 :        /* Loc = 5 is treated as Loc - 1 by linker */
  1147.             Output(Message, AnalysisFH, "Loader-resolved Offset/");
  1148.         case 1 :
  1149.             Output(Message, AnalysisFH, "Ptr-Offset (16-bit)\n");
  1150.             break;
  1151.         case 2 :
  1152.             Output(Message, AnalysisFH, "Ptr-Segment (16-bit)\n");
  1153.             break;
  1154.         case 3 :
  1155.             Output(Message, AnalysisFH, "FAR Pointer (32-bit)\n");
  1156.             break;
  1157.         case 4 :
  1158.             Output(Message, AnalysisFH, "High-Order Byte\n");
  1159.             break;
  1160.         default:
  1161.             Output(Warning, AnalysisFH,
  1162.                     "\n%04X  --  FIXUPP: Bad Loc field %04X\n",
  1163.                     GetRecordRelPos(RecordP), Loc);
  1164.             break;
  1165.     }
  1166. }
  1167.  
  1168. /*-----------------------------------------------------------------
  1169. *  GetFixDatField -- Interpret the FixDat field in explicit FIXUPP
  1170. *  record and its equivalent, the EndDat in MODEND.
  1171. *----------------------------------------------------------------*/
  1172. PRIVATE int GetFixDatField(unsigned char *RecordP)
  1173. {
  1174.     struct fd {
  1175.         unsigned Targt   : 2;           /* data record offset */
  1176.         unsigned P       : 1;
  1177.         unsigned T       : 1;
  1178.         unsigned Frame   : 3;
  1179.         unsigned F       : 1;
  1180.     } FixDat;
  1181.  
  1182.     LNODE *FrameList;
  1183.     LNODE *TargetList;
  1184.     FIXUPTHREAD *ThreadP;
  1185.     int FrameMethod;
  1186.     int TargetMethod;
  1187.     int FrameDatum;
  1188.     int TargetDatum;
  1189.     int DatumSize;
  1190.     int RecordLength;
  1191.                                         /* F/Frame fields */
  1192.     FixDat = *(struct fd *) RecordP++;
  1193.     if (FixDat.F) {               /* F = 1 => frame in previous thread */
  1194.         Output(Message, AnalysisFH, "     Frame  Reference   :  THREAD\n");
  1195.         ThreadP = GetThread((char) FixDat.Frame, 'F', RecordP - 1);
  1196.         Output(Message, AnalysisFH,
  1197.                 "     Frame  ID Method   :  Thread # %u  --  %s\n",
  1198.                 (int) FixDat.Frame,
  1199.                 GetListNode(*ThreadP->DefList, ThreadP->ListIndex)->InfoP);
  1200.     }
  1201.     else {                      /* F = 0 => explicit frame */
  1202.         Output(Message, AnalysisFH, "     Frame  Reference   :  EXPLICIT\n");
  1203.         FrameMethod = (int) FixDat.Frame;
  1204.         FrameList = GetThreadFixupMethod(FrameMethod, 1, RecordP - 1);
  1205.     }
  1206.  
  1207.                                 /* T field */
  1208.     if (FixDat.T)                 /* T = 1 => target in prev. thread */
  1209.         Output(Message, AnalysisFH, "     Target Reference   :  THREAD\n");
  1210.     else                        /* T = 0 => target explicit in FUP */
  1211.         Output(Message, AnalysisFH, "     Target Reference   :  EXPLICIT\n");
  1212.  
  1213.                                 /* P field */
  1214.     if (FixDat.P)                 /* P = 1 => target spec 2ndary way */
  1215.         Output(Message, AnalysisFH,
  1216.            "     Target Specific.   :  SECONDARY  --  IDX / NO OFFSET\n");
  1217.     else
  1218.         Output(Message, AnalysisFH,
  1219.            "     Target Specific.   :  PRIMARY  --  IDX / OFFSET\n");
  1220.  
  1221.                                         /* Target field */
  1222.     if (FixDat.T) {               /* T = 1 => thread target spec */
  1223.         ThreadP = GetThread((char) FixDat.Targt, 'T', RecordP - 1);
  1224.         Output(Message, AnalysisFH,
  1225.                 "     Target ID Method   :  Thread # %u  --  %s\n",
  1226.                 (int) FixDat.Targt,
  1227.                 GetListNode(*ThreadP->DefList, ThreadP->ListIndex)->InfoP);
  1228.     }
  1229.     else {          /*  T = 0 => explicit target spec */
  1230.                     /* Target = method of identifying target */
  1231.       TargetMethod = (int) ((FixDat.P) ? (FixDat.Targt + 4) : FixDat.Targt);
  1232.       TargetList = GetThreadFixupMethod(TargetMethod, 0, RecordP - 1);
  1233.     }
  1234.     RecordLength = 3;
  1235.  
  1236.     /* Frame Datum */
  1237.     if (FixDat.F == 0 && FrameMethod < 4) {
  1238.         DatumSize = GetVarLengthIdx(RecordP, &FrameDatum);
  1239.         Output(Message, AnalysisFH, 
  1240.             "     Frame  Datum       :  %d  --  %s\n",
  1241.             FrameDatum, (FrameList != NULL) ?
  1242.             GetListNode(*FrameList, FrameDatum)->InfoP : " ");
  1243.         RecordP += DatumSize;
  1244.         RecordLength += DatumSize;
  1245.     }
  1246.  
  1247.     /* Target Datum */
  1248.     if (FixDat.T == 0) {
  1249.         DatumSize = GetVarLengthIdx(RecordP, &TargetDatum);
  1250.         Output(Message, AnalysisFH, 
  1251.             "     Target Datum       :  %d  --  %s\n",
  1252.             TargetDatum, (TargetList != NULL) ?
  1253.             GetListNode(*TargetList, TargetDatum)->InfoP : " ");
  1254.         RecordP += DatumSize;
  1255.         RecordLength += DatumSize;
  1256.     }
  1257.  
  1258.     /* Target Displacement */
  1259.     if (FixDat.P == 0) {
  1260.         Output(Message, AnalysisFH, "     Target Displacement:  %Xx\n",
  1261.                 *(int *) RecordP);
  1262.         RecordP += 2;
  1263.         RecordLength += 2;
  1264.     }
  1265.     return (RecordLength);
  1266. }
  1267.  
  1268. /*===========================
  1269. *  6. Debugging info:
  1270. *   LINNUM      0x94
  1271. *==========================*/
  1272.  
  1273. /*----------------------------------------------------
  1274. *  DoLINNUM --  Line Numbers record: relates source code line 
  1275. *      numbers to OBJ code addresses.
  1276. *---------------------------------------------------*/
  1277. PUBLIC void DoLINNUM(unsigned char *RecordP, int  RecordLength)
  1278. {
  1279.     int  GroupIndex;
  1280.     int  SegmentIndex;
  1281.     char IndexSize;
  1282.     LNODE *ListNodeP;
  1283.     int LineNumber;
  1284.     unsigned int LineNumberOffset;
  1285.  
  1286.     /* The Line Number Base (Group Index/Segment Index) describes the
  1287.        segment to which the line number refers.
  1288.        Group containing this code (always 0 for MS translators) */
  1289.     if ((GroupIndex = (int) *RecordP++) != 0) {
  1290.        ListNodeP = GetListNode(ListLNAMES, GroupIndex);
  1291.        Output(Message, AnalysisFH, "     Group   Name Index :  %u  --  %s\n",
  1292.               GroupIndex, (ListNodeP != NULL) ? ListNodeP->InfoP : " ");
  1293.     }
  1294.     else
  1295.         Output(Message, AnalysisFH,
  1296.                 "     Group   Name Index :  %u  --  NO GROUP\n", GroupIndex);
  1297.     RecordLength--;
  1298.  
  1299.     /* Segment Index refers to a previous SEGDEF record. */
  1300.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  1301.     RecordP += IndexSize;
  1302.     RecordLength -= IndexSize;
  1303.     if (SegmentIndex != 0) {
  1304.        ListNodeP = GetListNode(ListSEGDEF, SegmentIndex);
  1305.        Output(Message, AnalysisFH, "     Segment Name Index :  %u  --  %s\n",
  1306.                SegmentIndex, (ListNodeP != NULL) ? ListNodeP->InfoP : " ");
  1307.     }
  1308.     else
  1309.         Output(Message, AnalysisFH,
  1310.                 "     Segment Name Index :  %u  --  NO SEGMENT\n",
  1311.                 SegmentIndex);
  1312.  
  1313.     while (RecordLength > 0) {
  1314.         /* Line Number: source code line number (0 <= n <= 32,767) */
  1315.         LineNumber = *(int *) RecordP;
  1316.         Output(Message, AnalysisFH, "     Line Number        :  %d\n",
  1317.                 LineNumber);
  1318.         RecordP += 2;
  1319.  
  1320.         /* Line Number Offset: offset into code (in segment specified
  1321.            by Line Number Base) to which line number refers */
  1322.         LineNumberOffset = *(unsigned int *) RecordP;
  1323.         Output(Message, AnalysisFH, "     Line # Offset      :  %Xx\n\n",
  1324.                 LineNumberOffset);
  1325.         RecordP += 2;
  1326.         RecordLength -= 4;
  1327.     }
  1328.  
  1329.     if (RecordLength)
  1330.         Output(Error, AnalysisFH,
  1331.                 "LINNUM record not recognized.  Terminating\n");
  1332. }
  1333.  
  1334. /*================================
  1335. *  7. Obsolete record types
  1336. *   BLKDEF      0x7A
  1337. *   BLKEND      0x7C
  1338. *   LHEADR      0x82
  1339. *===============================*/
  1340.  
  1341. /*----------------------------------------
  1342. *   DoBLKDEF -- Block Definition record
  1343. *----------------------------------------*/
  1344. PUBLIC void DoBLKDEF()
  1345. {
  1346.     Output(Warning, AnalysisFH, "BLKDEF not implemented\n");
  1347. }
  1348.  
  1349. /*----------------------------------------
  1350. *   DoBLKEND -- Block End Record
  1351. *----------------------------------------*/
  1352. PUBLIC void DoBLKEND()
  1353. {
  1354.     Output(Message, AnalysisFH, "\nBLOCK END\n");
  1355. }
  1356.  
  1357. /*----------------------------------------
  1358. *  DoLHEADR --  Translator Header Record (L-module)
  1359. *  NOTE: MUST always appear as the first record in OBJ module
  1360. *---------------------------------------*/
  1361. PUBLIC void DoLHEADR(unsigned char *RecordP)
  1362. {
  1363.     char *ModuleName;
  1364.  
  1365.     ModuleName = MakeASCIIZ(RecordP);
  1366.  
  1367.     Output(Message, AnalysisFH, "Module Name:\n     %s\n", ModuleName);
  1368.     free(ModuleName);
  1369. }
  1370.  
  1371. /*===============================================
  1372. *  8. Microsoft extensions
  1373. *   BAKPAT      0xB2 (0xB3, for 32-bit offsets)
  1374. *   LEXTDEF     0xB4
  1375. *   LPUBDEF     0xB6 (0xB7, for 32-bit offsets)
  1376. *   LCOMDEF     0xB8
  1377. *===============================================*/
  1378.  
  1379. /*-------------------------------------------------------
  1380. ** DoBAKPAT --  Back Patch record: Supplementary to FIXUPP records,
  1381. *    BAKPAT handles back patches to locations that a regular fix-up
  1382. *    record cannot easily deal with, e.g. forward references in
  1383. *    one-pass compilers. This record is specific to Quick C.
  1384. *-------------------------------------------------------*/
  1385. PUBLIC void DoBAKPAT(unsigned char *RecordP, int  RecordLength)
  1386. {
  1387.     int  SegmentIndex;
  1388.     int IndexSize;
  1389.     LNODE *ListNodeP;
  1390.     char LocTyp;
  1391.     unsigned int Offset;
  1392.     int PatchValue;
  1393.  
  1394.     /* Segment Index refers to a previous SEGDEF record. */
  1395.     IndexSize = GetVarLengthIdx(RecordP, &SegmentIndex);
  1396.     RecordP += IndexSize;
  1397.     RecordLength -= IndexSize;
  1398.     ListNodeP = GetListNode(ListSEGDEF, SegmentIndex);
  1399.     Output(Message, AnalysisFH, "     Segment Name Index :  %u  --  %s\n",
  1400.             SegmentIndex, (ListNodeP != NULL) ? ListNodeP->InfoP : " ");
  1401.  
  1402.     /* LocTyp  indicates type of location to patch: 0 -> low-byte,
  1403.     **  1 -> word offset, 32 -> double-word offset              */
  1404.     LocTyp = *RecordP++;
  1405.     RecordLength--;
  1406.     Output(Message, AnalysisFH, "     Location Type      :  %d\n",
  1407.             LocTyp);
  1408.  
  1409.     /* The remainder of the record is a repeatable pair of Offset into
  1410.        segment to patch, and value to add to patched Location   */
  1411.     while (RecordLength > 0) {
  1412.         Offset = *(unsigned int *) RecordP;
  1413.         Output(Message, AnalysisFH, "     Offset             :  %04Xx\n",
  1414.                 Offset);
  1415.         RecordP += 2;
  1416.  
  1417.         PatchValue = *(int *) RecordP;
  1418.         Output(Message, AnalysisFH, "     Patch Value        :  %04Xx\n\n",
  1419.                 PatchValue);
  1420.         RecordP += 2;
  1421.         RecordLength -= 4;
  1422.     }
  1423.  
  1424.     if (RecordLength)
  1425.         Output(Error, AnalysisFH,
  1426.                 "BAKPAT record not recognized.  Terminating\n");
  1427. }
  1428.  
  1429. #define  OTRANGE  32
  1430. #define  LOREC    0x7A
  1431. #define  HIREC    0xB8
  1432.  
  1433. PRIVATE char ObjTypes[OTRANGE][OMFNAMELENGTH] = {
  1434.     { "BLKDEF" },        /* 0x7A */
  1435.     { "BLKEND" },        /* 0x7C */
  1436.     { ""       },        /* 0x7E */
  1437.     { "THEADR" },        /* 0x80 */
  1438.     { ""       },        /* 0x82 */
  1439.     { ""       },        /* 0x84 */
  1440.     { ""       },        /* 0x86 */
  1441.     { "COMENT" },        /* 0x88 */
  1442.     { "MODEND" },        /* 0x8A */
  1443.     { "EXTDEF" },        /* 0x8C */
  1444.     { "TYPDEF" },        /* 0x8E */
  1445.     { "PUBDEF" },        /* 0x90 */
  1446.     { ""       },        /* 0x92 */
  1447.     { "LINNUM" },        /* 0x94 */
  1448.     { "LNAMES" },        /* 0x96 */
  1449.     { "SEGDEF" },        /* 0x98 */
  1450.     { "GRPDEF" },        /* 0x9A */
  1451.     { "FIXUPP" },        /* 0x9C */
  1452.     { ""       },        /* 0x9E */
  1453.     { "LEDATA" },        /* 0xA0 */
  1454.     { "LIDATA" },        /* 0xA2 */
  1455.     { ""       },        /* 0xA4 */
  1456.     { ""       },        /* 0xA6 */
  1457.     { ""       },        /* 0xA8 */
  1458.     { ""       },        /* 0xAA */
  1459.     { ""       },        /* 0xAC */
  1460.     { ""       },        /* 0xAE */
  1461.     { "COMDEF" },        /* 0xB0 */
  1462.     { "BAKPAT" },        /* 0xB2 */
  1463.     { "LEXTDEF" },       /* 0xB4 */
  1464.     { "LPUBDEF" },       /* 0xB6 */
  1465.     { "LCOMDEF" }        /* 0xB8 */
  1466. };
  1467.  
  1468. /*---------------------------------------------------------------------
  1469. *   GetObjRecordName -- Supply an OBJ record type number, receive the
  1470. *      record-type name. NOTE: this table has been tailored to a subset
  1471. *      of Intel records plus extensions as used by Microsoft.
  1472. *--------------------------------------------------------------------*/
  1473. PUBLIC RC GetObjRecordName(unsigned char ObjRecType, char ObjRecName[])
  1474. {
  1475.     if (ObjRecType < LOREC || ObjRecType > HIREC) {
  1476.         ObjRecName[0] = '\0';
  1477.         return (!OK);
  1478.     }
  1479.  
  1480.     strcpy(ObjRecName, ObjTypes[(ObjRecType - LOREC) / 2]);
  1481.     if (ObjRecName[0] == '\0')
  1482.         return (!OK);
  1483.     return (OK);
  1484. }
  1485.  
  1486. /*-------------------------------------------------------------------
  1487. *   GetRecordRelPos --  Get an OBJ record's relative position in the 
  1488. *      OBJ module. Note : The return type is unsigned int, assuming a     
  1489. *      a maximum  OBJ module size of 64K.
  1490. *------------------------------------------------------------------*/
  1491. PUBLIC unsigned int GetRecordRelPos(char *CurrentPosition)
  1492. {
  1493.     return (CurrentPosition - ObjBase);
  1494. }
  1495.  
  1496. /*-------------------------------------------------------------------
  1497. *   GetVarLengthIdx --  Indexes are variable length: 0-7Fh is fit into 
  1498. *      one byte; 80-7FFF (the max index), is fit into two bytes.
  1499. *      A two byte field is indicated by the high bit being set,
  1500. *      and is non-INTEL byte order.
  1501. *    Example: 8283 equals 283h.
  1502. *    Returns: Length of index in bytes
  1503. *-------------------------------------------------------------------*/
  1504. PRIVATE char GetVarLengthIdx(char *RecordP, int *Index)
  1505. {
  1506.     #define BYTE    1
  1507.     #define WORD    2
  1508.  
  1509.     union {
  1510.         char Byte[2];
  1511.         int  Word;
  1512.     } Int;
  1513.  
  1514.     if (*RecordP & 0x80) {      /* we're dealing with TWO bytes */
  1515.         /* Clear high bit, and make this index's high byte */
  1516.         Int.Byte[1] = *RecordP++ & (char) 0x7F;
  1517.         Int.Byte[0] = *RecordP;
  1518.         *Index = Int.Word;
  1519.         return (WORD);
  1520.     }
  1521.     else {                      /* simple byte 0 - 7Fh */
  1522.         *Index = (int) *RecordP;
  1523.         return (BYTE);
  1524.     }
  1525. }