Subversion Repositories openrisc_me

-- 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;