home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / MADTRB3.ZIP / CONVRT.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-01-06  |  12.3 KB  |  393 lines
  1. {$U-,C-,I-}
  2. PROGRAM CONVERT;
  3.  
  4.  
  5. {------------------------------------------------------------------------------
  6.  
  7.     WARNING  WARNING  WARNING  WARNING  WARNING  WARNING  WARNING  WARNING
  8.  
  9.       THIS PROGRAM HAS BEEN TESTED ON MANY DIFFERENT FORMS OF PROCEDURES
  10.   AND FUNCTIONS, BUT MAY NOT WORK ON THE PARTICULAR ONE YOU HAVE CREATED.  IF
  11.   YOUR PROCEDURE DOES NOT WORK MAKE SURE THAT THERE ARE NO NESTED PROCEDURES
  12.   AND THAT THERE IS ENOUGH MEMORY TO LOAD THE FULL PROCEDURE IN.
  13.  
  14.   SPECIFICALLY FOR VERSION 2.00B OF THE GENERIC MS-DOS OR IBM PC-DOS
  15.   IMPLEMENTATIONS TURBO PASCAL.  IT WOULD BE EASY TO CONVERT THIS FOR OTHER
  16.   VERSIONS OF THOSE SAME IMPLEMENTATIONS.  SEE CONSIDERATION #4 BELOW.  IF
  17.   ANYONE WANTS TO CONVERT THIS FOR THE CP/M 86 IMPLEMENTATION, YOU ARE WELCOME
  18.   TO DO SO AND UPLOAD IT HERE.
  19.  
  20.  ------------------------------------------------------------------------------
  21.  
  22.  
  23.       CONVERT IS USED TO CHANGE PRECOMPILED CHAIN FILES INTO A FORMAT THAT IS
  24.  CALLABLE BY A TURBO PROGRAM AS AN EXTERNAL .COM FILE.  THERE IS A LOADER
  25.  ( LOADER.INC ) THAT MUST BE INCLUDED IE.  $I LOADER.INC  BY THE PROGRAM THAT
  26.  IS TO USE THE .COM FILES CREATED BY CONVERT.
  27.  
  28.  
  29.       THERE ARE JUST A FEW CONSIDERATIONS AND PRECAUTIONS THAT MUST BE TAKEN
  30.  FOR THE EXTERNAL CREATED BY CONVERT TO WORK PROPERLY :
  31.  
  32.    1 : THE FILES TO BE CONVERTED MUST BE CHAIN FILES.
  33.    2 : THE PROCEDURE SHOULD HAVE A DUMMY BEGIN END. TO BE COMPILED. DO
  34.        NOT PUT ANYTHING INSIDE THE BEGIN END. OF THE EXTERNAL PROCEDURE.
  35.    3 : EACH PROCEDURE OR FUNCTION CANNOT HAVE NESTED PROCEDURES OR FUNCTIONS
  36.        INSIDE OF IT.
  37.       013D
  38.    4 : THE PROGRAM CONVERT MUST HAVE THE CONST LIBRARYSIZE SET TO THE ENDING
  39.        OF THE TURBO RUN-TIME LIBRARY ( $2828 FOR THE PC 2.00B, $2565 FOR
  40.        THE GENERIC MS-DOS IMPLEMENTATION OF TURBO PASCAL VERSION 2.00B ).
  41.    5 : EACH PROGRAM THAT USES THE LOADER AND AN EXTERNAL PROCEDURE CANNOT
  42.        BE RUN TWICE WITHIN TURBO,  UNLESS A RECOMPILATION OCCURS.
  43.  
  44.  FOR AN EXAMPLE OF AN EXTERNAL AND A CALLING PROGRAM READ THE FILE CONVRT.DOC.
  45.  
  46.                                                      WRITTEN BY
  47.                                                      JIM MCCARTHY
  48.                                                      TECHNICAL SUPPORT
  49.                                                      BORLAND INTERNATIONAL
  50.  
  51. ------------------------------------------------------------------------------}
  52.  
  53.   CONST
  54.     LIBRARYSIZE = $2954;               { SIZE OF RUN-TIME LIBRARY }
  55.     PROCSTART   = $296A;               { LIBRARYSIZE + $16 }
  56.  
  57.   TYPE
  58.     STR3  = STRING[ 3 ];
  59.     STR80 = STRING[ 80 ];
  60.     CHARARR15 = ARRAY [ 0..15 ] OF CHAR;
  61.     PTR   = ^PROC;
  62.     PROC  = RECORD
  63.               BYTE_VAL : BYTE;
  64.               SETADDR : BOOLEAN;
  65.               NEXT : PTR;
  66.             END;
  67.  
  68.   CONST
  69.     HEXSTR : CHARARR15 = '0123456789ABCDEF';
  70.  
  71.   VAR
  72.     PROC_TOP, PROC_CURRENT, PROC_TEMP,
  73.     HEAD_TOP, HEAD_CURRENT, HEAD_TEMP    : PTR;
  74.     CMDLINE                              : STR80 ABSOLUTE CSEG:$0080;
  75.     FILENAME, OUTFILE, BASE              : STR80;
  76.     EXTENSION                            : STR3;
  77.     ELEMENT, BYTE_BUFF                   : BYTE;
  78.     INP, OUT                             : FILE OF BYTE;
  79.     I, J, SIZE, ADDRESS, TABLE_SIZE,
  80.     TABLE_ADDR, CURRENT_ADDR, NUM_CALLS,
  81.     PROG_SIZE, SIZE_FILE                 : INTEGER;
  82.  
  83.   PROCEDURE INIT;
  84.  
  85.     VAR
  86.       I : INTEGER;
  87.  
  88.     BEGIN
  89.       FOR I := 1 TO 5 DO WRITELN;
  90.       HEAD_TOP := NIL;
  91.       PROC_TOP := NIL;
  92.       NUM_CALLS := 0;
  93.       I := $100;
  94.       PROG_SIZE := 0;
  95.       TABLE_ADDR := 1;
  96.       CURRENT_ADDR := 0;
  97.     END;
  98.  
  99.  
  100.   PROCEDURE REPORT( FILENAME : STR80; ERROR : INTEGER );
  101.  
  102.     BEGIN
  103.       CASE ( ERROR ) OF
  104.         1 : WRITELN( 'DISK FULL.' );
  105.         2 : WRITELN( 'FILE MUST NOT BE A .COM FILE.' );
  106.         3 : WRITELN( 'CANNOT OPEN FILE : ''', FILENAME, '''.' );
  107.         4 : WRITELN( 'READ ERROR ON FILE : ''',FILENAME,'''.' );
  108.         5 : WRITELN( 'WRITE ERROR ON FILE : ''',FILENAME,'''.' );
  109.       END;
  110.       WRITELN( 'PROGRAM ENDING.' );
  111.       CLOSE( INP );
  112.       CLOSE( OUT );
  113.       HALT;
  114.     END;
  115.  
  116.   PROCEDURE TRUNCFORSP( VAR BUFFER : STR80 );
  117.  
  118.     VAR
  119.       I, J, LEN : INTEGER;
  120.  
  121.     BEGIN
  122.       I := 1;
  123.       LEN := LENGTH( BUFFER );
  124.       WHILE ( BUFFER[ I ] = ' ' ) AND ( I <= LEN ) DO
  125.         I := I + 1;
  126.       FOR J := 1 TO LEN - I + 1 DO
  127.         BUFFER[ J ] := BUFFER[ I + J - 1 ];
  128.       BUFFER[ 0 ] := CHR(LEN - I + 1);
  129.     END;
  130.  
  131.   FUNCTION HEXADDR( ADDRESS : INTEGER ) : STR80;
  132.  
  133.     VAR
  134.       BUFFER : STR80;
  135.       LOW1NIB, LOW2NIB, HIGH1NIB, HIGH2NIB : BYTE;
  136.  
  137.     BEGIN
  138.       LOW1NIB := ADDRESS AND $F;
  139.       HIGH1NIB := ( ADDRESS AND $F0 ) SHR 4;
  140.       LOW2NIB := ( ADDRESS AND $F00 ) SHR 8;
  141.       HIGH2NIB := ( ADDRESS AND $F000 ) SHR 12;
  142.       HEXADDR := HEXSTR[ HIGH2NIB ] + HEXSTR[ LOW2NIB ] +
  143.                  HEXSTR[ HIGH1NIB ] + HEXSTR[ LOW1NIB ];
  144.     END;
  145.  
  146.   PROCEDURE GETFILEBASE( VAR FILENAME : STR80;  VAR BASE : STR80;
  147.                          VAR EXTENSION : STR3 );
  148.  
  149.     VAR
  150.       I, J : INTEGER;
  151.  
  152.     BEGIN
  153.       I := 1;
  154.       WHILE ( NOT ( FILENAME[ I ] IN [ '.', ' ' ] )) AND
  155.             ( I <= LENGTH( FILENAME )) DO
  156.         BEGIN
  157.           FILENAME[ I ] := UPCASE( FILENAME[ I ] );
  158.           BASE[ I ] := FILENAME[ I ];
  159.           BASE[ 0 ] := CHR( I );
  160.           I := I + 1;
  161.         END;
  162.       IF ( FILENAME[ I ] = '.' ) THEN
  163.         BEGIN
  164.           I := I + 1;
  165.           J := 1;
  166.           WHILE ( NOT ( FILENAME[ I ] IN [ ' ', '.' ] )) AND
  167.                 ( I <= LENGTH( FILENAME )) AND ( J <= 3 ) DO
  168.             BEGIN
  169.               FILENAME[ I ] := UPCASE( FILENAME[ I ] );
  170.               EXTENSION[ J ] := FILENAME[ I ];
  171.               EXTENSION[ 0 ] := CHR( J );
  172.               J := J + 1;
  173.               I := I + 1;
  174.             END;
  175.         END;
  176.     END;
  177.  
  178.   PROCEDURE SETUPFILES( FILENAME : STR80 );
  179.  
  180.     BEGIN
  181.       ASSIGN( INP, FILENAME );
  182.       RESET( INP );
  183.       IF ( IORESULT <> 0 ) THEN REPORT( FILENAME, 3 );
  184.       GETFILEBASE( FILENAME, BASE, EXTENSION );
  185.       IF ( EXTENSION <> 'COM' ) THEN
  186.         OUTFILE := BASE + '.COM'
  187.       ELSE REPORT( '', 2 );
  188.       ASSIGN( OUT, OUTFILE );
  189.       REWRITE( OUT );
  190.       IF ( IORESULT <> 0 ) THEN REPORT( '', 1 );
  191.     END;
  192.  
  193.    PROCEDURE ADDHEADPTR( VALUE : BYTE; SETCALL : BOOLEAN );
  194.  
  195.      BEGIN
  196.        NEW( HEAD_TEMP );
  197.        HEAD_TEMP^.BYTE_VAL := VALUE;
  198.        HEAD_TEMP^.SETADDR := SETCALL;
  199.        IF ( HEAD_TOP <> NIL ) THEN
  200.          HEAD_CURRENT^.NEXT := HEAD_TEMP
  201.        ELSE
  202.          HEAD_TOP := HEAD_TEMP;
  203.        HEAD_CURRENT := HEAD_TEMP;
  204.        HEAD_CURRENT^.NEXT := NIL;
  205.      END;
  206.  
  207.    PROCEDURE ADDPROCPTR( VALUE : BYTE; SETCALL : BOOLEAN );
  208.  
  209.      BEGIN
  210.        NEW( PROC_TEMP );
  211.        PROC_TEMP^.BYTE_VAL := VALUE;
  212.        PROC_TEMP^.SETADDR := SETCALL;
  213.        IF ( PROC_TOP <> NIL ) THEN
  214.          PROC_CURRENT^.NEXT := PROC_TEMP
  215.        ELSE
  216.          PROC_TOP := PROC_TEMP;
  217.        PROC_CURRENT := PROC_TEMP;
  218.        PROC_CURRENT^.NEXT := NIL;
  219.      END;
  220.  
  221.    PROCEDURE DUMPPTR( TOP : PTR );
  222.  
  223.      VAR
  224.        CURRENT, TEMP : PTR;
  225.        VALUE : BYTE;
  226.        I : INTEGER;
  227.  
  228.      BEGIN
  229.        I := 0;
  230.        CURRENT := TOP;
  231.        WHILE ( CURRENT <> NIL ) DO
  232.          BEGIN
  233.            TEMP := CURRENT;
  234.            VALUE := CURRENT^.BYTE_VAL;
  235.            WRITE( OUT, VALUE );
  236.            IF ( IORESULT <> 0 ) THEN REPORT( OUTFILE, 5 );
  237.            CURRENT := CURRENT^.NEXT;
  238.            I := I + 1;
  239.          END;
  240.      END;
  241.  
  242.   PROCEDURE CREATHEADER( VAR HEADER_SIZE : INTEGER; NUMCALLS : INTEGER );
  243.  
  244.     VAR
  245.       TEMP, TEMP1, TEMP2 : PTR;
  246.       I, CURRENT_ADDR : INTEGER;
  247.  
  248.     BEGIN
  249.       CURRENT_ADDR := 0;
  250.       HEADER_SIZE := 0;
  251.       TEMP := PROC_TOP;
  252.       I := 0;
  253.       WHILE ( TEMP <> NIL ) AND ( I <= NUMCALLS ) DO
  254.         BEGIN
  255.           IF ( TEMP^.BYTE_VAL = $E8 ) OR ( TEMP^.BYTE_VAL = $E9 ) THEN
  256.             BEGIN
  257.               TEMP1 := TEMP^.NEXT;
  258.               TEMP2 := TEMP1^.NEXT;
  259.               ADDRESS := ( TEMP2^.BYTE_VAL SHL 8 ) + TEMP1^.BYTE_VAL;
  260.               ADDRESS := ( PROCSTART + CURRENT_ADDR + 2 ) - ( ADDRESS XOR $FFFF );
  261.               IF ( TEMP^.BYTE_VAL = $E9 ) THEN
  262.                 WRITE( 'JMP MADE TO  : ', HEXADDR( ADDRESS ))
  263.               ELSE
  264.                 WRITE( 'CE_VAL = $E9 ) THEN
  265.                 WRITE( 'JMP MADE TO  : ', HEXADDR( ADDRESS ))
  266.               ELSE
  267.                 WRITE( 'CALL MADE TO : ', HEXADDR( ADDRESS ));
  268.               IF ( ADDRESS < LIBRARYSIZE ) AND ( ADDRESS > $100 ) THEN
  269.                 BEGIN
  270.                   WRITELN( '  ADDRESS TO BE CHANGED.' );
  271.                   TEMP^.SETADDR := TRUE;
  272.                   ADDHEADPTR( $E9, FALSE );
  273.                   ADDHEADPTR( ADDRESS AND $FF, FALSE );
  274.                   ADDHEADPTR(( ADDRESS AND $FF00 ) SHR 8, FALSE );
  275.                   HEADER_SIZE := HEADER_SIZE + 3;
  276.                   I := I + 1;
  277.                 END
  278.               ELSE
  279.                 WRITELN( '  ADDRESS NOT CHANGED.' );
  280.               CURRENT_ADDR := CURRENT_ADDR + 2;
  281.               TEMP := TEMP2^.NEXT;
  282.             END
  283.           ELSE TEMP := TEMP^.NEXT;
  284.           CURRENT_ADDR := CURRENT_ADDR + 1;
  285.         END;
  286.       WRITELN;
  287.     END;
  288.  
  289.   PROCEDURE SETPROCCALLS( HEADER_SIZE, NUMCALLS : INTEGER );
  290.  
  291.     VAR
  292.       ADDRESS, CURRENT_ADDR, CURR_PROC_ADDR,
  293.       CURR_HEAD_ADDR, I, LINE                  : INTEGER;
  294.       TEMP, TEMP1, TEMP2                       : PTR;
  295.  
  296.     BEGIN
  297.       TEMP := PROC_TOP;
  298.       CURR_HEAD_ADDR := 3;
  299.       CURR_PROC_ADDR := HEADER_SIZE + 3;
  300.       CURRENT_ADDR := 0;
  301.       LINE := 1;
  302.       I := 0;
  303.       WHILE ( TEMP <> NIL ) AND ( I <= NUMCALLS ) DO
  304.         BEGIN
  305.           IF (( TEMP^.BYTE_VAL = $E8 ) OR ( TEMP^.BYTE_VAL = $E9 )) AND
  306.              ( TEMP^.SETADDR = TRUE ) THEN
  307.             BEGIN
  308.               TEMP1 := TEMP^.NEXT;
  309.               TEMP2 := TEMP1^.NEXT;
  310.               TEMP := TEMP2^.NEXT;
  311.               ADDRESS := ( CURR_PROC_ADDR - CURR_HEAD_ADDR + 2 ) XOR $FFFF;
  312.               TEMP1^.BYTE_VAL := ( ADDRESS AND $FF );
  313.               TEMP2^.BYTE_VAL := ( ADDRESS AND $FF00 ) SHR 8;
  314.               CURRENT_ADDR := CURRENT_ADDR + 2;
  315.               CURR_HEAD_ADDR := CURR_HEAD_ADDR + 3;
  316.               CURR_PROC_ADDR := CURR_PROC_ADDR + 2;
  317.               I := I + 1;
  318.             END
  319.           ELSE
  320.             TEMP := TEMP^.NEXT;
  321.           CURR_PROC_ADDR := CURR_PROC_ADDR + 1;
  322.           CURRENT_ADDR := CURRENT_ADDR + 1;
  323.           LINE := LINE + 1;
  324.         END;
  325.     END;
  326.  
  327.   PROCEDURE POINTTOSTART;
  328.  
  329.     VAR
  330.       I : INTEGER;
  331.       BYTE_VAL : BYTE;
  332.  
  333.     BEGIN
  334.       FOR I := 0 TO $15 DO
  335.         BEGIN
  336.           READ( INP, BYTE_VAL );
  337.           IF ( IORESULT <> 0 ) THEN REPORT( FILENAME, 4 );
  338.         END;
  339.     END;
  340.  
  341.   PROCEDURE SETHEADERSIZE( TABLE_SIZE : INTEGER );
  342.  
  343.     VAR
  344.       ELEMENT : BYTE;
  345.  
  346.     BEGIN
  347.       ELEMENT := $E9;
  348.       WRITE( OUT, ELEMENT );
  349.       ELEMENT := TABLE_SIZE AND $FF;
  350.       WRITE( OUT, ELEMENT );
  351.       ELEMENT := ( TABLE_SIZE AND $FF00 ) SHR 8;
  352.       WRITE( OUT, ELEMENT );
  353.     END;
  354.  
  355.   BEGIN
  356.     LOWVIDEO;
  357.     FILENAME := CMDLINE;
  358.     IF ( LENGTH( FILENAME ) = 0 ) THEN
  359.       BEGIN
  360.         WRITE( 'CHAIN FILE NAME TO CONVERT TO .COM FILE : ' );
  361.         HIGHVIDEO;
  362.         READLN( FILENAME );
  363.         LOWVIDEO;
  364.         WRITELN;
  365.       END;
  366.     TRUNCFORSP( FILENAME );
  367.     IF ( LENGTH( FILENAME ) > 0 ) THEN
  368.       BEGIN
  369.         INIT;
  370.         SETUPFILES( FILENAME );
  371.         POINTTOSTART;
  372.         SIZE_FILE := FILESIZE( INP );
  373.         WHILE ( NOT EOF( INP )) AND ( MEMAVAIL > 10 ) AND
  374.               ( PROG_SIZE < SIZE_FILE - $1C ) DO
  375.           BEGIN
  376.             READ( INP, BYTE_BUFF );
  377.             ADDPROCPTR( BYTE_BUFF, FALSE );
  378.             IF ( BYTE_BUFF = $E8 ) OR ( BYTE_BUFF = $E9 ) THEN
  379.               NUM_CALLS := NUM_CALLS + 1;
  380.             PROG_SIZE := PROG_SIZE + 1;
  381.           END;
  382.         WRITELN( 'BYTES OF PROGRAM READ : ', HEXADDR( PROG_SIZE ));
  383.         WRITELN( 'CALLS  OR  JUMPS MADE : ', HEXADDR( NUM_CALLS ));
  384.         WRITELN;
  385.         CREATHEADER( TABLE_SIZE, NUM_CALLS );
  386.         WRITELN( 'HEADER SIZE : ', HEXADDR( TABLE_SIZE ));
  387.         SETPROCCALLS( TABLE_SIZE, NUM_CALLS );
  388.         SETHEADERSIZE( TABLE_SIZE );
  389.         DUMPPTR( HEAD_TOP );
  390.         DUMPPTR( PROC_TOP );
  391.         CLOSE( INP );
  392.         CLOSE( OUT );
  393.