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