path: root/gcc/testsuite/ada/acats/support/macrosub.ada

-- MACROSUB.ADA
--
--                             Grant of Unlimited Rights
--
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained 
--     unlimited rights in the software and documentation contained herein.
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making 
--     this public release, the Government intends to confer upon all 
--     recipients unlimited rights  equal to those held by the Government.  
--     These rights include rights to use, duplicate, release or disclose the 
--     released technical data and computer software in whole or in part, in 
--     any manner and for any purpose whatsoever, and to have or permit others 
--     to do so.
--
--                                    DISCLAIMER
--
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED 
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE 
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
--     PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--
-----------------------------------------------------------------------
--                                                                   --
--   THIS PROGRAM IS CALLED MACROSUB.  IT IS USED TO REPLACE THE     --
--   MACROS IN THE ACVC TEST SUITE WITH THEIR PROPER VALUES.  THE    --
--   STEPS LISTED BELOW SHOULD BE FOLLOWED TO ENSURE PROPER RUNNING  --
--   OF THE MACROSUB PROGRAM:                                        --
--                                                                   --
--           1) Edit the file MACRO.DFS (included with the testtape) --
--              and insert your macro values.  The macros which use  --
--              the value of MAX_IN_LEN are calculated automatically --
--              and do not need to be entered.                       --
--                                                                   --
--           2) Create a file called TSTTESTS.DAT which includes all --
--              of the .TST test file names and their directory      --
--              specifications, if necessary.  If a different name   --
--              other than TSTTESTS.DAT is used, this name must be   --
--              substituted in the MACROSUB.ADA file.                --
--                                                                   --
--           3) Compile and link MACROSUB.                           --
--                                                                   --
--           4) Run the MACROSUB program.                            --
--                                                                   --
--   WHEN THE PROGRAM FINISHES RUNNING, THE MACROS WILL HAVE BEEN    --
--   REPLACED WITH THE APPROPRIATE VALUES FROM MACRO.DFS.            --
--                                                                   --
--                                                                   --
--                                                                   --
-- HISTORY:                                                          --
--     BCB 04/17/90  CHANGED MODE OF CALC_MAX_VALS TO OUT.  CHANGED  --
--                   VALUE OF MAX_VAL_LENGTH FROM 512 TO 400.  ADDED --
--                   EXCEPTION HANDLER SO PROGRAM DOES NOT CRASH IF  --
--                   AN EXCEPTION IS RAISED.  ADDED MESSAGES TO      --
--                   REPORT PROGRESS OF PROGRAM.  CHANGED PROGRAM SO --
--                   IT DOES NOT ABORT IF A FILE CANNOT BE FOUND.    --
--                   MODIFIED PROGRAM SO IT ACCEPTS FILENAMES WITH   --
--                   VERSION NUMBERS.                                --
-----------------------------------------------------------------------

WITH TEXT_IO;
USE TEXT_IO;

PACKAGE DEFS IS

-----------------------------------------------------------------------
--                                                                   --
--   THIS PACKAGE IS USED BY MACROSUB.ADA, PARSEMAC.ADA, AND BY      --
--   GETSUBS.ADA.  THE PACKAGE CONTAINS VARIABLE DECLARATIONS WHICH  --
--   NEED TO BE KNOWN BY ALL OF THE PROCEDURES AND PACKAGES WHICH    --
--   MAKE UP THE PROGRAM.                                            --
--                                                                   --
-----------------------------------------------------------------------

     MAX_VAL_LENGTH : CONSTANT INTEGER := 400;

     SUBTYPE VAL_STRING IS STRING (1..MAX_VAL_LENGTH);

     TYPE REC_TYPE IS RECORD
          MACRO_NAME : STRING (1..80);
          NAME_LENGTH, VALUE_LENGTH : INTEGER;
          MACRO_VALUE : VAL_STRING;
     END RECORD;

     TYPE TABLE_TYPE IS ARRAY (1..100) OF REC_TYPE;

     SYMBOL_TABLE : TABLE_TYPE;

     NUM_MACROS : INTEGER;

END DEFS;

WITH TEXT_IO;
USE TEXT_IO;
WITH DEFS;
USE DEFS;

PACKAGE GETSUBS IS

------------------------------------------------------------------------
--                                                                    --
--  THIS PACKAGE IS USED BY MACROSUB.ADA FOR READING FROM MACRO.DFS   --
--  THE VALUES FOR THE MACRO SUBSTITUTIONS FOR A TEST TAPE.           --
--                                                                    --
------------------------------------------------------------------------

     MAC_FILE, LINE_LEN : EXCEPTION;

     PROCEDURE CALC_MAX_VALS(INDEX, LENGTH, MAX_IN_LEN : IN INTEGER;
                             CALCULATED : OUT BOOLEAN);

     PROCEDURE FILL_TABLE;

END GETSUBS;

PACKAGE BODY GETSUBS IS

-----------------------------------------------------------------------
--                                                                   --
--    PROCEDURE CALC_MAX_VALS CALCULATES THE VALUE FOR THE MACRO     --
--    READ FROM MACRO.DFS IF ITS LENGTH IS EQUAL OR NEARLY EQUAL TO  --
--    MAX_IN_LEN.  IT THEN RETURNS A FLAG SET TO TRUE IF A VALUE WAS --
--    CALCULATED, FALSE IF ONE WAS NOT.                              --
--                                                                   --
-----------------------------------------------------------------------

     PROCEDURE CALC_MAX_VALS(INDEX, LENGTH, MAX_IN_LEN : IN INTEGER;
                             CALCULATED : OUT BOOLEAN) IS

     BEGIN

          IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) = "BIG_ID1"
               THEN SYMBOL_TABLE (INDEX).MACRO_VALUE (1..MAX_IN_LEN) :=
               (1..(MAX_IN_LEN-1) => 'A') & "1";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_ID2" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN-1) => 'A') & "2";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_ID3" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN + 1)/2 => 'A') & "3" &
               ((MAX_IN_LEN + 1)/2 + 2..MAX_IN_LEN => 'A');
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_ID4" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN + 1)/2 => 'A') & "4" &
               ((MAX_IN_LEN + 1)/2 + 2..MAX_IN_LEN => 'A');
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_STRING1" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..(MAX_IN_LEN + 1)/2 + 2) :=
                          '"' & (1..(MAX_IN_LEN + 1)/2 => 'A') & '"';
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_STRING2" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN - (MAX_IN_LEN + 1)/2 + 2) :=
               '"' & (2..MAX_IN_LEN - (MAX_IN_LEN + 1)/2 => 'A') &
               '1' & '"';
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "MAX_STRING_LITERAL" THEN SYMBOL_TABLE (INDEX).
               MACRO_VALUE (1..MAX_IN_LEN) := '"' &
               (1..MAX_IN_LEN-2 => 'A') & '"';
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_INT_LIT" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN)  := (1..MAX_IN_LEN-3 => '0') & "298";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BIG_REAL_LIT" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN) := (1..MAX_IN_LEN-5 => '0') & "690.0";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "MAX_LEN_INT_BASED_LITERAL" THEN
               SYMBOL_TABLE (INDEX).
               MACRO_VALUE (1..MAX_IN_LEN) := "2:" &
               (1..MAX_IN_LEN - 5 => '0') & "11:";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "MAX_LEN_REAL_BASED_LITERAL" THEN SYMBOL_TABLE (INDEX).
               MACRO_VALUE (1..MAX_IN_LEN) := "16:" &
               (1..MAX_IN_LEN - 7 => '0') & "F.E:";
               CALCULATED := TRUE;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BLANKS" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
               (1..MAX_IN_LEN-20) := (1..MAX_IN_LEN-20 => ' ');
               CALCULATED := TRUE;
          ELSE
               CALCULATED := FALSE;
          END IF;
          IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
               "BLANKS" THEN SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
               MAX_IN_LEN - 20;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
                "BIG_STRING1" THEN
               SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
                           (MAX_IN_LEN + 1)/2 + 2;
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
                "BIG_STRING2" THEN
               SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
                      MAX_IN_LEN - (MAX_IN_LEN + 1)/2 + 2;
          ELSE SYMBOL_TABLE (INDEX).VALUE_LENGTH := MAX_IN_LEN;
          END IF;
     END CALC_MAX_VALS;

-----------------------------------------------------------------------
--                                                                   --
--    PROCEDURE FILL_TABLE READS THE MACRO NAMES AND MACRO VALUES IN --
--    FROM MACRO.DFS AND STORES THEM IN THE SYMBOL TABLE.  PROCEDURE --
--    CALC_MAX_VALS IS CALLED TO DETERMINE IF THE MACRO VALUE SHOULD --
--    BE CALCULATED OR READ FROM MACRO.DFS.                          --
--                                                                   --
-----------------------------------------------------------------------

     PROCEDURE FILL_TABLE IS

          INFILE1 : FILE_TYPE;
          MACRO_FILE : CONSTANT STRING := "MACRO.DFS";
          A_LINE : VAL_STRING;
          I, INDEX, LENGTH, HOLD, A_LENGTH, NAME : INTEGER;
          MAX_IN_LEN : INTEGER := 1;
          CALCULATED : BOOLEAN;

     BEGIN
          INDEX := 1;
          BEGIN
               OPEN (INFILE1, IN_FILE, MACRO_FILE);
          EXCEPTION
               WHEN NAME_ERROR =>
                    PUT_LINE ("** ERROR: MACRO FILE " & MACRO_FILE &
                              " NOT FOUND.");
                    RAISE MAC_FILE;
          END;
          WHILE NOT END_OF_FILE (INFILE1) LOOP
               GET_LINE (INFILE1, A_LINE, A_LENGTH);
               IF A_LENGTH > 0 AND A_LINE (1..2) /= "--" AND
                  A_LINE (1) /= ' ' AND A_LINE (1) /= ASCII.HT THEN
                    I := 1;
                    WHILE I <= A_LENGTH AND THEN
                           ((A_LINE (I) IN 'A'..'Z') OR
                            (A_LINE (I) IN '0'..'9') OR
                            A_LINE (I) = '_') LOOP
                         I := I + 1;
                    END LOOP;
                    I := I - 1;
                    LENGTH := I;
                    BEGIN
                         SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) :=
                              A_LINE (1..I);
                    EXCEPTION
                         WHEN CONSTRAINT_ERROR =>
                              PUT_LINE ("** ERROR: LINE LENGTH IS " &
                                        "GREATER THAN MAX_VAL_LENGTH.");
                              RAISE LINE_LEN;
                    END;
                    SYMBOL_TABLE (INDEX).NAME_LENGTH := I;
                    CALC_MAX_VALS (INDEX, LENGTH, MAX_IN_LEN,
                                   CALCULATED);
                    IF NOT CALCULATED THEN
                         I := I + 1;
                         WHILE A_LINE (I) = ' ' OR A_LINE (I) =
                           ASCII.HT LOOP
                              I := I + 1;
                              IF SYMBOL_TABLE (INDEX).MACRO_NAME
                                   (1..LENGTH) = "BLANKS" THEN
                                   EXIT;
                              END IF;
                         END LOOP;
                         HOLD := I;

-- MACRO VALUE BEGINS AT POSITION HOLD.
-- NOW FIND WHERE IT ENDS BY STARTING AT THE END OF THE INPUT
-- LINE AND SEARCHING BACKWARD FOR A NON-BLANK.

                         I := A_LENGTH;
                         WHILE I > HOLD AND THEN (A_LINE (I) = ' '
                            OR A_LINE(I) = ASCII.HT) LOOP
                              I := I - 1;
                         END LOOP;
                         LENGTH := I - HOLD + 1;
                         SYMBOL_TABLE (INDEX).MACRO_VALUE (1..LENGTH)
                              := A_LINE (HOLD..I);
                         SYMBOL_TABLE (INDEX).VALUE_LENGTH := LENGTH;
                         NAME := SYMBOL_TABLE (INDEX).NAME_LENGTH;
                         IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..NAME) =
                              "MAX_IN_LEN" THEN MAX_IN_LEN :=
                              INTEGER'VALUE (SYMBOL_TABLE (INDEX).
                              MACRO_VALUE (1..LENGTH));
                         END IF;
                    END IF;
                    INDEX := INDEX + 1;
               END IF;
          END LOOP;
          NUM_MACROS := INDEX - 1;
          CLOSE (INFILE1);
     END FILL_TABLE;

BEGIN
     NULL;
END GETSUBS;

WITH TEXT_IO;
USE TEXT_IO;
WITH DEFS;
USE DEFS;

PACKAGE PARSEMAC IS

------------------------------------------------------------------------
--                                                                    --
--   THIS PACKAGE IS USED BY MACROSUB.ADA FOR FINDING A MACRO TO      --
--   SUBSTITUTE.  MACRO SUBSTITUTIONS ARE MADE IN *.TST TESTS IN THE  --
--   ACVC TEST SUITE.  THIS PROCEDURE IS CURRENTLY SET UP FOR ACVC    --
--   VERSION 1.10.                                                    --
--                                                                    --
------------------------------------------------------------------------

     PROCEDURE LOOK_FOR_MACRO (A_LINE : IN STRING;
                               A_LENGTH : IN INTEGER;
                               PTR : IN OUT INTEGER;
                               MACRO : OUT STRING;
                               MACRO_LEN : IN OUT INTEGER);


     PROCEDURE WHICH_MACRO (MACRO : IN STRING;
                            MACRO_LEN : IN INTEGER;
                            TEMP_MACRO : OUT STRING;
                            TEMP_MACRO_LEN : IN OUT INTEGER);

END PARSEMAC;

PACKAGE BODY PARSEMAC IS

-----------------------------------------------------------------------
--    PROCEDURE LOOK_FOR_MACRO LOOKS FOR A DOLLAR SIGN WHICH SIGNALS --
--    THE START OF A MACRO IN THE *.TST FILES.  IT THEN COUNTS       --
--    CHARACTERS UNTIL A <LETTER>, <NUMBER>, OR <_> IS NOT FOUND.    --
--    RETURN PARAMETERS SEND THE BEGINNING POINTER AND LENGTH OF THE --
--    MACRO BACK TO THE MAIN PROGRAM.  ALSO RETURNED IS THE MACRO    --
--    STRING.                                                        --
-----------------------------------------------------------------------

     PROCEDURE LOOK_FOR_MACRO (A_LINE : IN STRING;
                               A_LENGTH : IN INTEGER;
                               PTR : IN OUT INTEGER;
                               MACRO : OUT STRING;
                               MACRO_LEN : IN OUT INTEGER) IS

     II, J : INTEGER := INTEGER'LAST;

     BEGIN
          FOR I IN PTR..A_LENGTH LOOP
               IF A_LINE (I) = '$' THEN
                    II := I+1;
                    EXIT;
               END IF;
               II := I;
          END LOOP;
          IF II < A_LENGTH THEN    -- DOLLAR SIGN IS FOUND.
               J := II;
               WHILE J <= A_LENGTH AND THEN ((A_LINE(J) IN 'A'..'Z') OR
                      (A_LINE(J) IN '0'..'9') OR
                       A_LINE(J) = '_') LOOP
                       J := J+1;
               END LOOP;
               J := J-1;
               MACRO_LEN := (J-II+1);
               MACRO (1..MACRO_LEN) := A_LINE (II .. J);
                             -- DON'T INCLUDE THE DOLLAR SIGN
               PTR := J+1;
          ELSE
               MACRO_LEN := 0;
          END IF;
     RETURN;
     END LOOK_FOR_MACRO;

------------------------------------------------------------------------
--    PROCEDURE WHICH_MACRO COMPARES THE INPUT MACRO STRING TO A      --
--    VALUE READ FROM MACRO.DFS AND STORED IN THE SYMBOL TABLE AND    --
--    RETURNS THE MACRO SUBSTITUTION STRING BACK TO THE MAIN PROGRAM. --
------------------------------------------------------------------------

     PROCEDURE WHICH_MACRO (MACRO : IN STRING;
                            MACRO_LEN : IN INTEGER;
                            TEMP_MACRO : OUT STRING;
                            TEMP_MACRO_LEN : IN OUT INTEGER) IS

     BEGIN
          FOR INDEX IN 1 .. NUM_MACROS LOOP
               IF MACRO (1..MACRO_LEN) =
                  SYMBOL_TABLE (INDEX).MACRO_NAME
                      (1..SYMBOL_TABLE (INDEX).NAME_LENGTH) THEN
                    TEMP_MACRO_LEN :=
                      SYMBOL_TABLE (INDEX).VALUE_LENGTH;
                    TEMP_MACRO (1..TEMP_MACRO_LEN) :=
                      SYMBOL_TABLE (INDEX).MACRO_VALUE
                        (1..TEMP_MACRO_LEN);
                    EXIT;
               END IF;
               IF INDEX = NUM_MACROS THEN
                    PUT_LINE ("** ERROR: MACRO " & MACRO (1..MACRO_LEN)
                              & " NOT FOUND.  UPDATE PROGRAM.");
                    TEMP_MACRO_LEN := MACRO_LEN;
                    TEMP_MACRO (1..TEMP_MACRO_LEN) :=
                       MACRO (1..MACRO_LEN);
               END IF;
          END LOOP;

     END WHICH_MACRO;

BEGIN
     NULL;
END PARSEMAC;

WITH TEXT_IO, GETSUBS, PARSEMAC, DEFS;
USE TEXT_IO, GETSUBS, PARSEMAC, DEFS;

PROCEDURE MACROSUB IS

------------------------------------------------------------------------
--                                                                    --
--    MACROSUB IS THE MAIN PROGRAM THAT CALLS PROCEDURES IN TWO       --
--    PACKAGES, GETSUBS AND PARSEMAC.  THIS PROGRAM IS USED TO MAKE   --
--    THE MACRO SUBSTITUTIONS FOR TST TESTS IN THE ACVC TEST SUITE.   --
--                                                                    --
------------------------------------------------------------------------

     INFILE1, INFILE2, OUTFILE1     : FILE_TYPE;
     FNAME, MACRO                   : VAL_STRING;
     LENGTH, A_LENGTH, PTR,
     TEMP_MACRO_LENGTH, MACRO_LEN, FILE_COUNT : INTEGER := 0;
     A_LINE, TEMP_MACRO, TEMP_LINE, NEW_LINE : VAL_STRING;
     END_OF_LINE_SEARCH, FLAG       : BOOLEAN := FALSE;
     TESTS_FILE                     : CONSTANT STRING := "TSTTESTS.DAT";
     TSTTESTS,FILE_CRE              : EXCEPTION;

BEGIN
     PUT_LINE ("BEGINNING MACRO SUBSTITUTIONS.");
     FILL_TABLE;
     BEGIN
          OPEN (INFILE2, IN_FILE, TESTS_FILE);
     EXCEPTION
          WHEN NAME_ERROR =>
               PUT_LINE ("** ERROR: ERROR DURING OPENING OF " &
                         "TSTTESTS.DAT");
               RAISE TSTTESTS;
     END;
     WHILE NOT END_OF_FILE (INFILE2) LOOP
          GET_LINE (INFILE2, FNAME, LENGTH);
          FILE_COUNT := FILE_COUNT + 1;
          BEGIN
               OPEN (INFILE1, IN_FILE, FNAME(1..LENGTH));
          EXCEPTION
               WHEN NAME_ERROR =>
                    PUT_LINE ("** ERROR: ERROR DURING OPENING OF " &
                              FNAME(1..LENGTH) & ".");
                    FLAG := TRUE;
          END;
          IF NOT FLAG THEN
               PUT_LINE ("WORKING ON " & FNAME(1..LENGTH));
               IF FILE_COUNT = 70 THEN
                    PUT_LINE ("MACRO SUBSTITUTIONS HALF COMPLETED.");
               END IF;
               FOR I IN REVERSE 1 .. LENGTH LOOP
                    IF FNAME(I) = ';' THEN
                         LENGTH := I - 1;
                         EXIT;
                    END IF;
               END LOOP;
               IF FNAME (LENGTH-2..LENGTH) = "TST" THEN
                    FNAME (LENGTH-2..LENGTH) := "ADT";
               ELSIF FNAME (LENGTH-2..LENGTH) = "tst" THEN
                    FNAME (LENGTH-2..LENGTH) := "adt";
               END IF;
               BEGIN
                    CREATE (OUTFILE1, OUT_FILE, FNAME (1..LENGTH));
               EXCEPTION
                    WHEN OTHERS =>
                         PUT_LINE ("** ERROR: EXCEPTION RAISED DURING" &
                                   " ATTEMPTED CREATION OF " &
                                   FNAME(1..LENGTH) & ".");
                         RAISE FILE_CRE;
               END;
               WHILE NOT END_OF_FILE (INFILE1) LOOP
                    GET_LINE (INFILE1, A_LINE, A_LENGTH);
                    IF A_LENGTH > 0 AND A_LINE(1..2) /= "--" THEN
                         END_OF_LINE_SEARCH := FALSE;
                         PTR := 1;
                         WHILE NOT END_OF_LINE_SEARCH LOOP
                              LOOK_FOR_MACRO (A_LINE, A_LENGTH, PTR,
                                              MACRO, MACRO_LEN);
                              IF MACRO_LEN = 0 THEN
                                   END_OF_LINE_SEARCH := TRUE;
                              ELSE --  SEE WHICH MACRO IT IS
                                   WHICH_MACRO (MACRO, MACRO_LEN,
                                       TEMP_MACRO, TEMP_MACRO_LENGTH);
                              END IF;
                              IF NOT END_OF_LINE_SEARCH THEN
                                   IF PTR-MACRO_LEN-2 > 0 THEN
                                 -- IF MACRO IS NOT FIRST ON THE LINE
                                        NEW_LINE (1..PTR-MACRO_LEN-2)
                                         := A_LINE(1..PTR-MACRO_LEN -2);
                                 -- THE OLD LINE UNTIL THE DOLLAR SIGN
                                   END IF;
                                   NEW_LINE(PTR-MACRO_LEN-1 ..
                                            TEMP_MACRO_LENGTH +
                                            (PTR-MACRO_LEN) - 2) :=
                                       TEMP_MACRO(1..TEMP_MACRO_LENGTH);
                                   IF PTR <= A_LENGTH THEN
                                 -- IF MACRO IS NOT LAST ON THE LINE
                                        NEW_LINE (TEMP_MACRO_LENGTH +
                                             PTR-MACRO_LEN - 1 ..
                                             TEMP_MACRO_LENGTH - 1 +
                                             A_LENGTH - MACRO_LEN) :=
                                             A_LINE (PTR..A_LENGTH);
                                   ELSE
                                        END_OF_LINE_SEARCH := TRUE;
                                   END IF;
                                   A_LENGTH := A_LENGTH +
                                               TEMP_MACRO_LENGTH -
                                               MACRO_LEN - 1;
                                   A_LINE (1..A_LENGTH) :=
                                          NEW_LINE (1..A_LENGTH);
                                   PTR := PTR - MACRO_LEN +
                                          TEMP_MACRO_LENGTH - 1;
                              END IF;
                         END LOOP;
                    END IF;
                    PUT_LINE (OUTFILE1, A_LINE (1..A_LENGTH));
               END LOOP;
               CLOSE (OUTFILE1);
               CLOSE (INFILE1);
          ELSE
               FLAG := FALSE;
          END IF;
     END LOOP;
     CLOSE (INFILE2);
     PUT_LINE ("MACRO SUBSTITUTIONS COMPLETED.");
EXCEPTION
     WHEN MAC_FILE | LINE_LEN | TSTTESTS | FILE_CRE =>
          NULL;
     WHEN OTHERS =>
          PUT_LINE ("UNEXPECTED EXCEPTION RAISED");
END MACROSUB;