home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBOPAS / EXAMIN.ZIP / EXAMIN.PAS
Encoding:
Pascal/Delphi Source File  |  1985-11-17  |  8.9 KB  |  261 lines
  1. {THIS PROGRAM ALLOWS EXAMINATION OF THE SYMBOL TABLE GENERATED BY TURBO
  2.  VERSION 3.00B.  IT EXAMINES THE TABLE GENERATED WHEN IT IS COMPILED.
  3.  THE SYMBOL TABLE RESIDES IN SSEG JUST FAR ENOUGH BELOW THE STACK THAT THE
  4.  TWO DON'T INTERFERE.  IT IS SCANNED FROM LOWER MEMORY IN LARGE CHUNKS, EACH
  5.  OF WHICH STARTS WITH A COUNT FOR THAT CHUNK TO ALLOW JUMPING OVER INFO
  6.  THAT IS NOT WANTED.  HOWEVER, EACH CHUNK IS SCANNED BACKWARDS (FROM HIGHER
  7.  TO LOWER MEMORY). AN EXCEPTION IS THE SYMBOL NAMES THEMSELVES WHICH ARE
  8.  IN A FORWARD DIRECTION ( BUT THE LENGTH BYTE IS AT THE UPPER MEMORY END).
  9.  
  10.  THIS PROGRAM ATTEMPTS TO MAKE THE INFORMATION IN THE TABLE MORE CLEAR.
  11.  EACH CHUNK IS SCANNED BACKWARDS BUT THE INFORMATION IS OUTPUT FROM LEFT TO
  12.  RIGHT.  SYMBOL NAMES ARE OUTPUT SO THAT THEY CORRESPOND TO THE PROGRAM
  13.  SYMBOLS.
  14.  
  15.  THE FIRST HEX VALUE OUTPUT DOES NOT APPEAR IN THE SYMBOL TABLE BUT RATHER
  16.  IS THE OFFSET OF THAT SYMBOL TABLE ITEM IN SSEG.  IT IS OFTEN USED AS A
  17.  POINTER FROM WITHIN OTHER SYMBOL TABLE ITEMS.  FOR INSTANCE, A VARIABLE OF
  18.  TYPE INTEGER WILL HAVE WITHIN ITS DEFINITION A POINTER TO THE DEFINITION
  19.  OF TYPE INTEGER.
  20.  
  21.  NEXT ON THE LINE IS A WORD DEFINING THE SYMBOL TABLE ITEM TYPE (PROCEDURE,
  22.  FUNCTION, VARIABLE, TYPE DEFINITION, CONST, ETC).  THE HIGH BYTE OF THIS
  23.  WORD DETERMINES THE TYPE.  THE LOW BYTE IS USUALLY ZERO EXCEPT FOR RECORDS
  24.  WHERE IT APPEARS TO DEFINE WHICH RECORD THE SYMBOL BELONGS TO.  SEE THE
  25.  CASE STATEMENT IN 'MAIN' FOR WHICH SYMBOL TYPES HAVE WHICH NUMBERS.
  26.  
  27.  IF THE SYMBOL TYPE HAS A SYMBOL, THE NEXT BYTE IS THE SYMBOL LENGTH AND
  28.  THIS IS FOLLOWED BY THE SYMBOL NAME ITSELF.
  29.  
  30.  MORE INFORMATION ON WHAT IS WHAT CAN BE FOUND IN THE CODE COMMENTS.
  31.  
  32.  THE VERY LAST ITEM ON THE LINE IS THE COUNT OF BYTES FOR THAT ITEM.
  33.  
  34.  NOTE THAT ALL ITEMS APPEARING AFTER THE 'INTEGER' SYMBOL DEFINITION APPEAR
  35.  IN THE TABLE FOR EVERY COMPILATION.  THEY ARE COPIED THERE IN ONE BLOCK.
  36.  
  37.  THE LAST TEN LINES REPRESENT STANDARD TYPE DEFINITIONS. THESE ARE:
  38.    INTEGER
  39.    CHAR
  40.    REAL
  41.    BOOLEAN
  42.    FILE
  43.    BYTE
  44.    POINTER
  45.    UNKNOWN
  46.    UNKNOWN
  47.    UNKNOWN
  48.  
  49.  AS COMPILATION TAKES PLACE, THE SYMBOL INFORMATION FOR LOCAL VARIABLES,
  50.  LOCAL PROCEDURES, AND OTHER LOCALS IS ENTERED IN THE SYMBOL TABLE.  HOWEVER,
  51.  THIS INFORMATION IS OVERWRITTEN AS SOON AS IT IS NO LONGER NEEDED, SO THAT
  52.  IT IS NOT AVAIABLE WHEN COMPILATION IS COMPLETE.
  53.              }
  54. PROGRAM EXAMINE;
  55. LABEL 99;
  56. {THE FOLLOWING THREE CONSTANTS ARE THOSE NEEDED TO EXTRACT THE SYMBOLS
  57.  AND MAY WELL BE DIFFERENT FOR VERSION OTHER THAN 3.00B.}
  58. CONST
  59.    TURBO_DS=$178;     {OFFSET REL TO PROGRAM DSEG WHICH CONTAINS THE
  60.                        COMPILER DSEG}
  61.    SYMBOL_START=$598; {OFFSET REL TO COMPILER DSEG CONTAINING THE OFFSET OF THE
  62.                        SYMBOL TABLE START (RELATIVE TO SSEG)}
  63.    SYMBOL_END=$59A;   {OFFSET REL TO COMPILER DSEG CONTAINING THE OFFSET OF THE
  64.                        SYMBOL TABLE END (RELATIVE TO SSEG)}
  65. {THE FOLLOWING CONST's, TYPE's AND VAR's ARE NECESSARY FOR THE OPERATION OF
  66.  THE PROGRAM}
  67. TYPE   STRING30=STRING[30];
  68. VAR     TURB_DS,SYMTYPE,COUNT,SYMLENG,
  69.         SYMINDX,ENDSYM,NEXTSYM,OLDSYMINDX         :INTEGER;
  70.         NAME                                      :STRING30;
  71.         OUT                                       :TEXT;
  72. {END OF NECESSARY ITEMS}
  73.  
  74. {BELOW IS AN AREA WHERE TYPES, CONST's, VAR's,PROCEDURE's AND FUNCTION's
  75.  MAY BE ADDED TO SEE WHAT APPEARS IN THE SYMBOL TABLE}
  76.  
  77. {DEFINE SOME TYPED CONSTANTS FOR OBSERVATION}
  78. CONST
  79.    CINT            :INTEGER = $ABCD;
  80.    CSTRING         :STRING[20] = 'STRING';
  81. TYPE    RECTYPE=RECORD ABC,DEF,GHI :INTEGER; END;
  82.         RECTYPE2=RECORD ABC,DEF,GHI :INTEGER; END;
  83.         VARREC  =RECORD
  84.                    BBB,BBBB  :BYTE;
  85.                    CASE VA :INTEGER OF
  86.                       2,3 :(PDQ :BYTE;
  87.                             RST :INTEGER;);
  88.                       8   :(XYZ :CHAR;
  89.                             OTHER :INTEGER);
  90.                     END;
  91.         ARTYPE =ARRAY[-5..11] OF CHAR;
  92.         ABC=(A,B,C,D,E,F);
  93. VAR     REC  :RECTYPE;
  94. VAR     XX :ABC;
  95.         REC2 :RECTYPE2;
  96.         VREC  :VARREC;
  97.         ARY  :ARTYPE;
  98.         ARYPTR :^ARTYPE;
  99.         PT   :^INTEGER;
  100.         ARRAY1  :ARRAY[A..E] OF INTEGER;
  101.         ARRAY2  :ARRAY[-1..4,1..5] OF INTEGER;
  102.         ARRAY3  :ARRAY[-1..4,-5..5,-1..2] OF INTEGER;
  103.         CPT  :^CHAR;
  104. FUNCTION DUMMY(VAR XX :BYTE):REAL;
  105. BEGIN END;
  106.  
  107. {END OF EXPERIMENTAL AREA}
  108.  
  109. {-------------SPACE}
  110. PROCEDURE SPACE(N :INTEGER); {OUTPUT N SPACES}
  111. VAR   I  :INTEGER;
  112. BEGIN
  113. FOR I:=1 TO N DO  WRITE(OUT,' ');
  114. END;
  115.  
  116. {-------------DONAME}
  117. PROCEDURE DONAME;   {OUTPUT SYMBOL NAME}
  118. VAR   I,J  :INTEGER;
  119. BEGIN
  120. J:=1;
  121. FOR I:=SYMINDX-SYMLENG+1 TO SYMINDX DO
  122.   BEGIN
  123.   WRITE(OUT,CHR(MEM[SSEG:I]));  J:=J+1;
  124.   END;
  125. WHILE J<=16 DO BEGIN SPACE(1); J:=J+1; END;
  126. SYMINDX:=SYMINDX-SYMLENG;
  127. END;
  128.  
  129. {-------------WRITEHEX2}
  130. PROCEDURE WRITEHEX2(N :BYTE);
  131. {WRITE A BYTE IN HEX}
  132. VAR       BY    :BYTE;
  133.           CH    :CHAR;
  134.           I     :INTEGER;
  135. BEGIN
  136. FOR I:=1 TO 2 DO
  137.    BEGIN
  138.    BY:=N SHR 4;
  139.    IF BY<=9 THEN CH:=CHR(BY+ORD('0'))
  140.    ELSE CH:=CHR(BY-10+ORD('A'));
  141.    WRITE(OUT,CH);
  142.    N:=N SHL 4;
  143.    END;
  144. END;
  145.  
  146. {-------------WRITEHEX4}
  147. PROCEDURE WRITEHEX4(N :INTEGER);
  148. {WRITE A WORD IN HEX}
  149. BEGIN
  150. WRITEHEX2(HI(N)); WRITEHEX2(LO(N));
  151. END;
  152.  
  153. {-------------OUT2}
  154. PROCEDURE OUT2;  {OUTPUT THE NEXT BYTE, UPDATE SYMINDX}
  155. BEGIN
  156. WRITEHEX2(MEM[SSEG:SYMINDX]);  SPACE(1);
  157. SYMINDX:=SYMINDX-1;
  158. END;
  159.  
  160. {-------------OUT4}
  161. PROCEDURE OUT4;  {OUTPUT THE NEXT WORD, UPDATE SYMINDX}
  162. BEGIN
  163. WRITEHEX4(MEMW[SSEG:SYMINDX-1]);  SPACE(1);
  164. SYMINDX:=SYMINDX-2;
  165. END;
  166.  
  167. {-------------FINISH_PROC_FUNC}
  168. PROCEDURE FINISH_PROC_FUNC; {FINISH UP PROCEDURE, FUNCTIONS SYMTYPES}
  169. VAR    NDUMMIES,I  :INTEGER;
  170. BEGIN
  171. WRITELN(OUT); SPACE(10);
  172. OUT4;    {OFFSET IN CSEG FOR PROC/FUNC}
  173. OUT4;    {6+SPACE OCCUPIED BY PARAMETERS + LOCALS}
  174. OUT2; OUT2; OUT2; OUT2; OUT2;  {???}
  175. NDUMMIES:=MEM[SSEG:SYMINDX];   {THE # OF DUMMY PARAMETERS}
  176. OUT2;    {THE # OF DUMMY PARAMETERS}
  177. FOR I:=1 TO NDUMMIES DO
  178.   BEGIN
  179.   WRITELN(OUT); SPACE(14);
  180.   OUT4;   {PTS TO TYPE DEFINITION OF DUMMY}
  181.   OUT2;   {0, DUMMY IS BY VALUE--FF, DUMMY IS BY ADDRESS}
  182.   OUT2;   {??}
  183.   SYMLENG:=MEM[SSEG:SYMINDX];
  184.   OUT2;   {LENGTH OF DUMMY NAME}
  185.   DONAME; {DUMMY PARAMETER NAME}
  186.   END;
  187. END;
  188.  
  189. {-------------MAIN}
  190. BEGIN
  191. WRITE('Output Filename? '); READLN(NAME);
  192. ASSIGN(OUT, NAME);
  193. REWRITE(OUT);
  194. TURB_DS:=MEMW[DSEG:TURBO_DS];  {DSEG FOR THE COMPILER}
  195. SYMINDX:=MEMW[TURB_DS:SYMBOL_START]; {INITIATE SYMBOL INDEX}
  196. ENDSYM:=MEMW[TURB_DS:SYMBOL_END];
  197. OLDSYMINDX:=SYMINDX;
  198. WHILE SYMINDX<ENDSYM DO
  199.    BEGIN
  200.    COUNT:=MEMW[SSEG:SYMINDX];     {BYTE COUNT OF THIS SYMBOL ITEM}
  201.    NEXTSYM:=SYMINDX+COUNT;        {KEEP TRACK OF WHERE NEXT SYMBOL ITEM STARTS}
  202.    SYMINDX:=NEXTSYM-2;            {THE ADDRESS OF THIS SYMBOL ITEM}
  203.    WRITEHEX4(SYMINDX); WRITE(OUT,'-');
  204.    SYMTYPE:=MEMW[SSEG:SYMINDX];   {THE SYMBOL TYPE CODE.  SEE BELOW FOR LIST}
  205.    WRITEHEX4(SYMTYPE);  SPACE(1);
  206.    SYMINDX:=SYMINDX-1;
  207.    IF (HI(SYMTYPE)<>0) AND (HI(SYMTYPE)<>8) THEN
  208.      BEGIN
  209.      SYMLENG:=MEM[SSEG:SYMINDX];    {LENGTH IN BYTES OF THE SYMBOL NAME}
  210.      OUT2;
  211.      DONAME;
  212.      END;
  213.  
  214.    CASE HI(SYMTYPE) OF
  215.      8,           {STRING}
  216.      0:  BEGIN    {TYPE DEFINITION}
  217.          OUT4;    {SIZEOF}
  218.          OUT4;    {UPPER LIMIT, DON'T CARE FOR POINTER}
  219.          OUT4;    {LOWER LIMIT, TYPE POINTED TO FOR POINTER}
  220.          OUT2;    {STORED AS A WORD BUT SEEM TO BE SEPARATE, USE UNKNOWN}
  221.          OUT2;    {4 FOR POINTER, BYTE SEEMS TO INDICATE TYPE}
  222.          END;
  223.      1:           {LABEL}
  224.          OUT4;    {OFFSET IN CSEG OF LABEL}
  225.      2:  BEGIN    {CONSTANTS}
  226.          OUT2;    {BYTE REPRESENTING TYPE??.  SEEMS TO CORRESPOND TO BYTE
  227.                    IN TYPE DEFINITION}
  228.          OUT4;    {VALUE (WORD FOR INTEGER BUT CAN BE STRING OR REAL)}
  229.          END;
  230.      3:           {TYPE NAME}
  231.          OUT4;    {PTS TO TYPE DEFINITION}
  232.      4:  BEGIN    {DATA AND TYPED CONSTANTS}
  233.          OUT4;    {PTS TO TYPE DEFINITION}
  234.          OUT4;    {OFFSET OF DATA}
  235.          OUT2;    {FF=DSEG, FE=CSEG, 1=LOCAL ON STACK? }
  236.          OUT2;    {ALWAYS 0?. SEEMS TO BE STORED AS WORD WITH ABOVE}
  237.          END;
  238.      5:  BEGIN    {PROCEDURE}
  239.          OUT4;  OUT4; OUT2;  {UNUSED FILL TO MATCH FUNCTION}
  240.          OUT2;    {USUALLY FF, CAN BE 0}
  241.          FINISH_PROC_FUNC;
  242.          END;
  243.      6:  BEGIN    {FUNCTION}
  244.          OUT4;    {PTS TO FUNCTION TYPE DEFINITION}
  245.          OUT4;    {WORD OF UNKNOWN USE}
  246.          OUT2;    {BYTE OF UNKNOWN USE}
  247.          OUT2;    {USUALLY FF, CAN BE 0}
  248.          FINISH_PROC_FUNC;
  249.          END;
  250.      ELSE;  {WHAT IS 7?  DOES 9 EXIST? }
  251.     END;   {CASE}
  252.    WHILE SYMINDX>OLDSYMINDX+1 DO  {FINISH UP ANY REMAINING BYTES}
  253.      OUT2;
  254.    OUT4;   {THE COUNT}
  255.    SYMINDX:=NEXTSYM;
  256.    OLDSYMINDX:=OLDSYMINDX+COUNT;
  257.    WRITELN(OUT);
  258.    END;   {WHILE}
  259. CLOSE(OUT);
  260. 99:END.
  261.