OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [testsuite/] [ada/] [acats/] [support/] [macrosub.ada] - Blame information for rev 154

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 149 jeremybenn
-- MACROSUB.ADA
2
--
3
--                             Grant of Unlimited Rights
4
--
5
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
6
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained 
7
--     unlimited rights in the software and documentation contained herein.
8
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making 
9
--     this public release, the Government intends to confer upon all 
10
--     recipients unlimited rights  equal to those held by the Government.  
11
--     These rights include rights to use, duplicate, release or disclose the 
12
--     released technical data and computer software in whole or in part, in 
13
--     any manner and for any purpose whatsoever, and to have or permit others 
14
--     to do so.
15
--
16
--                                    DISCLAIMER
17
--
18
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
19
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED 
20
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
21
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE 
22
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
23
--     PARTICULAR PURPOSE OF SAID MATERIAL.
24
--*
25
--
26
-----------------------------------------------------------------------
27
--                                                                   --
28
--   THIS PROGRAM IS CALLED MACROSUB.  IT IS USED TO REPLACE THE     --
29
--   MACROS IN THE ACVC TEST SUITE WITH THEIR PROPER VALUES.  THE    --
30
--   STEPS LISTED BELOW SHOULD BE FOLLOWED TO ENSURE PROPER RUNNING  --
31
--   OF THE MACROSUB PROGRAM:                                        --
32
--                                                                   --
33
--           1) Edit the file MACRO.DFS (included with the testtape) --
34
--              and insert your macro values.  The macros which use  --
35
--              the value of MAX_IN_LEN are calculated automatically --
36
--              and do not need to be entered.                       --
37
--                                                                   --
38
--           2) Create a file called TSTTESTS.DAT which includes all --
39
--              of the .TST test file names and their directory      --
40
--              specifications, if necessary.  If a different name   --
41
--              other than TSTTESTS.DAT is used, this name must be   --
42
--              substituted in the MACROSUB.ADA file.                --
43
--                                                                   --
44
--           3) Compile and link MACROSUB.                           --
45
--                                                                   --
46
--           4) Run the MACROSUB program.                            --
47
--                                                                   --
48
--   WHEN THE PROGRAM FINISHES RUNNING, THE MACROS WILL HAVE BEEN    --
49
--   REPLACED WITH THE APPROPRIATE VALUES FROM MACRO.DFS.            --
50
--                                                                   --
51
--                                                                   --
52
--                                                                   --
53
-- HISTORY:                                                          --
54
--     BCB 04/17/90  CHANGED MODE OF CALC_MAX_VALS TO OUT.  CHANGED  --
55
--                   VALUE OF MAX_VAL_LENGTH FROM 512 TO 400.  ADDED --
56
--                   EXCEPTION HANDLER SO PROGRAM DOES NOT CRASH IF  --
57
--                   AN EXCEPTION IS RAISED.  ADDED MESSAGES TO      --
58
--                   REPORT PROGRESS OF PROGRAM.  CHANGED PROGRAM SO --
59
--                   IT DOES NOT ABORT IF A FILE CANNOT BE FOUND.    --
60
--                   MODIFIED PROGRAM SO IT ACCEPTS FILENAMES WITH   --
61
--                   VERSION NUMBERS.                                --
62
-----------------------------------------------------------------------
63
 
64
WITH TEXT_IO;
65
USE TEXT_IO;
66
 
67
PACKAGE DEFS IS
68
 
69
-----------------------------------------------------------------------
70
--                                                                   --
71
--   THIS PACKAGE IS USED BY MACROSUB.ADA, PARSEMAC.ADA, AND BY      --
72
--   GETSUBS.ADA.  THE PACKAGE CONTAINS VARIABLE DECLARATIONS WHICH  --
73
--   NEED TO BE KNOWN BY ALL OF THE PROCEDURES AND PACKAGES WHICH    --
74
--   MAKE UP THE PROGRAM.                                            --
75
--                                                                   --
76
-----------------------------------------------------------------------
77
 
78
     MAX_VAL_LENGTH : CONSTANT INTEGER := 400;
79
 
80
     SUBTYPE VAL_STRING IS STRING (1..MAX_VAL_LENGTH);
81
 
82
     TYPE REC_TYPE IS RECORD
83
          MACRO_NAME : STRING (1..80);
84
          NAME_LENGTH, VALUE_LENGTH : INTEGER;
85
          MACRO_VALUE : VAL_STRING;
86
     END RECORD;
87
 
88
     TYPE TABLE_TYPE IS ARRAY (1..100) OF REC_TYPE;
89
 
90
     SYMBOL_TABLE : TABLE_TYPE;
91
 
92
     NUM_MACROS : INTEGER;
93
 
94
END DEFS;
95
 
96
WITH TEXT_IO;
97
USE TEXT_IO;
98
WITH DEFS;
99
USE DEFS;
100
 
101
PACKAGE GETSUBS IS
102
 
103
------------------------------------------------------------------------
104
--                                                                    --
105
--  THIS PACKAGE IS USED BY MACROSUB.ADA FOR READING FROM MACRO.DFS   --
106
--  THE VALUES FOR THE MACRO SUBSTITUTIONS FOR A TEST TAPE.           --
107
--                                                                    --
108
------------------------------------------------------------------------
109
 
110
     MAC_FILE, LINE_LEN : EXCEPTION;
111
 
112
     PROCEDURE CALC_MAX_VALS(INDEX, LENGTH, MAX_IN_LEN : IN INTEGER;
113
                             CALCULATED : OUT BOOLEAN);
114
 
115
     PROCEDURE FILL_TABLE;
116
 
117
END GETSUBS;
118
 
119
PACKAGE BODY GETSUBS IS
120
 
121
-----------------------------------------------------------------------
122
--                                                                   --
123
--    PROCEDURE CALC_MAX_VALS CALCULATES THE VALUE FOR THE MACRO     --
124
--    READ FROM MACRO.DFS IF ITS LENGTH IS EQUAL OR NEARLY EQUAL TO  --
125
--    MAX_IN_LEN.  IT THEN RETURNS A FLAG SET TO TRUE IF A VALUE WAS --
126
--    CALCULATED, FALSE IF ONE WAS NOT.                              --
127
--                                                                   --
128
-----------------------------------------------------------------------
129
 
130
     PROCEDURE CALC_MAX_VALS(INDEX, LENGTH, MAX_IN_LEN : IN INTEGER;
131
                             CALCULATED : OUT BOOLEAN) IS
132
 
133
     BEGIN
134
 
135
          IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) = "BIG_ID1"
136
               THEN SYMBOL_TABLE (INDEX).MACRO_VALUE (1..MAX_IN_LEN) :=
137
               (1..(MAX_IN_LEN-1) => 'A') & "1";
138
               CALCULATED := TRUE;
139
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
140
               "BIG_ID2" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
141
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN-1) => 'A') & "2";
142
               CALCULATED := TRUE;
143
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
144
               "BIG_ID3" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
145
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN + 1)/2 => 'A') & "3" &
146
               ((MAX_IN_LEN + 1)/2 + 2..MAX_IN_LEN => 'A');
147
               CALCULATED := TRUE;
148
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
149
               "BIG_ID4" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
150
               (1..MAX_IN_LEN) := (1..(MAX_IN_LEN + 1)/2 => 'A') & "4" &
151
               ((MAX_IN_LEN + 1)/2 + 2..MAX_IN_LEN => 'A');
152
               CALCULATED := TRUE;
153
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
154
               "BIG_STRING1" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
155
               (1..(MAX_IN_LEN + 1)/2 + 2) :=
156
                          '"' & (1..(MAX_IN_LEN + 1)/2 => 'A') & '"';
157
               CALCULATED := TRUE;
158
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
159
               "BIG_STRING2" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
160
               (1..MAX_IN_LEN - (MAX_IN_LEN + 1)/2 + 2) :=
161
               '"' & (2..MAX_IN_LEN - (MAX_IN_LEN + 1)/2 => 'A') &
162
               '1' & '"';
163
               CALCULATED := TRUE;
164
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
165
               "MAX_STRING_LITERAL" THEN SYMBOL_TABLE (INDEX).
166
               MACRO_VALUE (1..MAX_IN_LEN) := '"' &
167
               (1..MAX_IN_LEN-2 => 'A') & '"';
168
               CALCULATED := TRUE;
169
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
170
               "BIG_INT_LIT" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
171
               (1..MAX_IN_LEN)  := (1..MAX_IN_LEN-3 => '0') & "298";
172
               CALCULATED := TRUE;
173
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
174
               "BIG_REAL_LIT" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
175
               (1..MAX_IN_LEN) := (1..MAX_IN_LEN-5 => '0') & "690.0";
176
               CALCULATED := TRUE;
177
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
178
               "MAX_LEN_INT_BASED_LITERAL" THEN
179
               SYMBOL_TABLE (INDEX).
180
               MACRO_VALUE (1..MAX_IN_LEN) := "2:" &
181
               (1..MAX_IN_LEN - 5 => '0') & "11:";
182
               CALCULATED := TRUE;
183
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
184
               "MAX_LEN_REAL_BASED_LITERAL" THEN SYMBOL_TABLE (INDEX).
185
               MACRO_VALUE (1..MAX_IN_LEN) := "16:" &
186
               (1..MAX_IN_LEN - 7 => '0') & "F.E:";
187
               CALCULATED := TRUE;
188
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
189
               "BLANKS" THEN SYMBOL_TABLE (INDEX).MACRO_VALUE
190
               (1..MAX_IN_LEN-20) := (1..MAX_IN_LEN-20 => ' ');
191
               CALCULATED := TRUE;
192
          ELSE
193
               CALCULATED := FALSE;
194
          END IF;
195
          IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
196
               "BLANKS" THEN SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
197
               MAX_IN_LEN - 20;
198
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
199
                "BIG_STRING1" THEN
200
               SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
201
                           (MAX_IN_LEN + 1)/2 + 2;
202
          ELSIF SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) =
203
                "BIG_STRING2" THEN
204
               SYMBOL_TABLE (INDEX).VALUE_LENGTH :=
205
                      MAX_IN_LEN - (MAX_IN_LEN + 1)/2 + 2;
206
          ELSE SYMBOL_TABLE (INDEX).VALUE_LENGTH := MAX_IN_LEN;
207
          END IF;
208
     END CALC_MAX_VALS;
209
 
210
-----------------------------------------------------------------------
211
--                                                                   --
212
--    PROCEDURE FILL_TABLE READS THE MACRO NAMES AND MACRO VALUES IN --
213
--    FROM MACRO.DFS AND STORES THEM IN THE SYMBOL TABLE.  PROCEDURE --
214
--    CALC_MAX_VALS IS CALLED TO DETERMINE IF THE MACRO VALUE SHOULD --
215
--    BE CALCULATED OR READ FROM MACRO.DFS.                          --
216
--                                                                   --
217
-----------------------------------------------------------------------
218
 
219
     PROCEDURE FILL_TABLE IS
220
 
221
          INFILE1 : FILE_TYPE;
222
          MACRO_FILE : CONSTANT STRING := "MACRO.DFS";
223
          A_LINE : VAL_STRING;
224
          I, INDEX, LENGTH, HOLD, A_LENGTH, NAME : INTEGER;
225
          MAX_IN_LEN : INTEGER := 1;
226
          CALCULATED : BOOLEAN;
227
 
228
     BEGIN
229
          INDEX := 1;
230
          BEGIN
231
               OPEN (INFILE1, IN_FILE, MACRO_FILE);
232
          EXCEPTION
233
               WHEN NAME_ERROR =>
234
                    PUT_LINE ("** ERROR: MACRO FILE " & MACRO_FILE &
235
                              " NOT FOUND.");
236
                    RAISE MAC_FILE;
237
          END;
238
          WHILE NOT END_OF_FILE (INFILE1) LOOP
239
               GET_LINE (INFILE1, A_LINE, A_LENGTH);
240
               IF A_LENGTH > 0 AND A_LINE (1..2) /= "--" AND
241
                  A_LINE (1) /= ' ' AND A_LINE (1) /= ASCII.HT THEN
242
                    I := 1;
243
                    WHILE I <= A_LENGTH AND THEN
244
                           ((A_LINE (I) IN 'A'..'Z') OR
245
                            (A_LINE (I) IN '0'..'9') OR
246
                            A_LINE (I) = '_') LOOP
247
                         I := I + 1;
248
                    END LOOP;
249
                    I := I - 1;
250
                    LENGTH := I;
251
                    BEGIN
252
                         SYMBOL_TABLE (INDEX).MACRO_NAME (1..LENGTH) :=
253
                              A_LINE (1..I);
254
                    EXCEPTION
255
                         WHEN CONSTRAINT_ERROR =>
256
                              PUT_LINE ("** ERROR: LINE LENGTH IS " &
257
                                        "GREATER THAN MAX_VAL_LENGTH.");
258
                              RAISE LINE_LEN;
259
                    END;
260
                    SYMBOL_TABLE (INDEX).NAME_LENGTH := I;
261
                    CALC_MAX_VALS (INDEX, LENGTH, MAX_IN_LEN,
262
                                   CALCULATED);
263
                    IF NOT CALCULATED THEN
264
                         I := I + 1;
265
                         WHILE A_LINE (I) = ' ' OR A_LINE (I) =
266
                           ASCII.HT LOOP
267
                              I := I + 1;
268
                              IF SYMBOL_TABLE (INDEX).MACRO_NAME
269
                                   (1..LENGTH) = "BLANKS" THEN
270
                                   EXIT;
271
                              END IF;
272
                         END LOOP;
273
                         HOLD := I;
274
 
275
-- MACRO VALUE BEGINS AT POSITION HOLD.
276
-- NOW FIND WHERE IT ENDS BY STARTING AT THE END OF THE INPUT
277
-- LINE AND SEARCHING BACKWARD FOR A NON-BLANK.
278
 
279
                         I := A_LENGTH;
280
                         WHILE I > HOLD AND THEN (A_LINE (I) = ' '
281
                            OR A_LINE(I) = ASCII.HT) LOOP
282
                              I := I - 1;
283
                         END LOOP;
284
                         LENGTH := I - HOLD + 1;
285
                         SYMBOL_TABLE (INDEX).MACRO_VALUE (1..LENGTH)
286
                              := A_LINE (HOLD..I);
287
                         SYMBOL_TABLE (INDEX).VALUE_LENGTH := LENGTH;
288
                         NAME := SYMBOL_TABLE (INDEX).NAME_LENGTH;
289
                         IF SYMBOL_TABLE (INDEX).MACRO_NAME (1..NAME) =
290
                              "MAX_IN_LEN" THEN MAX_IN_LEN :=
291
                              INTEGER'VALUE (SYMBOL_TABLE (INDEX).
292
                              MACRO_VALUE (1..LENGTH));
293
                         END IF;
294
                    END IF;
295
                    INDEX := INDEX + 1;
296
               END IF;
297
          END LOOP;
298
          NUM_MACROS := INDEX - 1;
299
          CLOSE (INFILE1);
300
     END FILL_TABLE;
301
 
302
BEGIN
303
     NULL;
304
END GETSUBS;
305
 
306
WITH TEXT_IO;
307
USE TEXT_IO;
308
WITH DEFS;
309
USE DEFS;
310
 
311
PACKAGE PARSEMAC IS
312
 
313
------------------------------------------------------------------------
314
--                                                                    --
315
--   THIS PACKAGE IS USED BY MACROSUB.ADA FOR FINDING A MACRO TO      --
316
--   SUBSTITUTE.  MACRO SUBSTITUTIONS ARE MADE IN *.TST TESTS IN THE  --
317
--   ACVC TEST SUITE.  THIS PROCEDURE IS CURRENTLY SET UP FOR ACVC    --
318
--   VERSION 1.10.                                                    --
319
--                                                                    --
320
------------------------------------------------------------------------
321
 
322
     PROCEDURE LOOK_FOR_MACRO (A_LINE : IN STRING;
323
                               A_LENGTH : IN INTEGER;
324
                               PTR : IN OUT INTEGER;
325
                               MACRO : OUT STRING;
326
                               MACRO_LEN : IN OUT INTEGER);
327
 
328
 
329
     PROCEDURE WHICH_MACRO (MACRO : IN STRING;
330
                            MACRO_LEN : IN INTEGER;
331
                            TEMP_MACRO : OUT STRING;
332
                            TEMP_MACRO_LEN : IN OUT INTEGER);
333
 
334
END PARSEMAC;
335
 
336
PACKAGE BODY PARSEMAC IS
337
 
338
-----------------------------------------------------------------------
339
--    PROCEDURE LOOK_FOR_MACRO LOOKS FOR A DOLLAR SIGN WHICH SIGNALS --
340
--    THE START OF A MACRO IN THE *.TST FILES.  IT THEN COUNTS       --
341
--    CHARACTERS UNTIL A <LETTER>, <NUMBER>, OR <_> IS NOT FOUND.    --
342
--    RETURN PARAMETERS SEND THE BEGINNING POINTER AND LENGTH OF THE --
343
--    MACRO BACK TO THE MAIN PROGRAM.  ALSO RETURNED IS THE MACRO    --
344
--    STRING.                                                        --
345
-----------------------------------------------------------------------
346
 
347
     PROCEDURE LOOK_FOR_MACRO (A_LINE : IN STRING;
348
                               A_LENGTH : IN INTEGER;
349
                               PTR : IN OUT INTEGER;
350
                               MACRO : OUT STRING;
351
                               MACRO_LEN : IN OUT INTEGER) IS
352
 
353
     II, J : INTEGER := INTEGER'LAST;
354
 
355
     BEGIN
356
          FOR I IN PTR..A_LENGTH LOOP
357
               IF A_LINE (I) = '$' THEN
358
                    II := I+1;
359
                    EXIT;
360
               END IF;
361
               II := I;
362
          END LOOP;
363
          IF II < A_LENGTH THEN    -- DOLLAR SIGN IS FOUND.
364
               J := II;
365
               WHILE J <= A_LENGTH AND THEN ((A_LINE(J) IN 'A'..'Z') OR
366
                      (A_LINE(J) IN '0'..'9') OR
367
                       A_LINE(J) = '_') LOOP
368
                       J := J+1;
369
               END LOOP;
370
               J := J-1;
371
               MACRO_LEN := (J-II+1);
372
               MACRO (1..MACRO_LEN) := A_LINE (II .. J);
373
                             -- DON'T INCLUDE THE DOLLAR SIGN
374
               PTR := J+1;
375
          ELSE
376
               MACRO_LEN := 0;
377
          END IF;
378
     RETURN;
379
     END LOOK_FOR_MACRO;
380
 
381
------------------------------------------------------------------------
382
--    PROCEDURE WHICH_MACRO COMPARES THE INPUT MACRO STRING TO A      --
383
--    VALUE READ FROM MACRO.DFS AND STORED IN THE SYMBOL TABLE AND    --
384
--    RETURNS THE MACRO SUBSTITUTION STRING BACK TO THE MAIN PROGRAM. --
385
------------------------------------------------------------------------
386
 
387
     PROCEDURE WHICH_MACRO (MACRO : IN STRING;
388
                            MACRO_LEN : IN INTEGER;
389
                            TEMP_MACRO : OUT STRING;
390
                            TEMP_MACRO_LEN : IN OUT INTEGER) IS
391
 
392
     BEGIN
393
          FOR INDEX IN 1 .. NUM_MACROS LOOP
394
               IF MACRO (1..MACRO_LEN) =
395
                  SYMBOL_TABLE (INDEX).MACRO_NAME
396
                      (1..SYMBOL_TABLE (INDEX).NAME_LENGTH) THEN
397
                    TEMP_MACRO_LEN :=
398
                      SYMBOL_TABLE (INDEX).VALUE_LENGTH;
399
                    TEMP_MACRO (1..TEMP_MACRO_LEN) :=
400
                      SYMBOL_TABLE (INDEX).MACRO_VALUE
401
                        (1..TEMP_MACRO_LEN);
402
                    EXIT;
403
               END IF;
404
               IF INDEX = NUM_MACROS THEN
405
                    PUT_LINE ("** ERROR: MACRO " & MACRO (1..MACRO_LEN)
406
                              & " NOT FOUND.  UPDATE PROGRAM.");
407
                    TEMP_MACRO_LEN := MACRO_LEN;
408
                    TEMP_MACRO (1..TEMP_MACRO_LEN) :=
409
                       MACRO (1..MACRO_LEN);
410
               END IF;
411
          END LOOP;
412
 
413
     END WHICH_MACRO;
414
 
415
BEGIN
416
     NULL;
417
END PARSEMAC;
418
 
419
WITH TEXT_IO, GETSUBS, PARSEMAC, DEFS;
420
USE TEXT_IO, GETSUBS, PARSEMAC, DEFS;
421
 
422
PROCEDURE MACROSUB IS
423
 
424
------------------------------------------------------------------------
425
--                                                                    --
426
--    MACROSUB IS THE MAIN PROGRAM THAT CALLS PROCEDURES IN TWO       --
427
--    PACKAGES, GETSUBS AND PARSEMAC.  THIS PROGRAM IS USED TO MAKE   --
428
--    THE MACRO SUBSTITUTIONS FOR TST TESTS IN THE ACVC TEST SUITE.   --
429
--                                                                    --
430
------------------------------------------------------------------------
431
 
432
     INFILE1, INFILE2, OUTFILE1     : FILE_TYPE;
433
     FNAME, MACRO                   : VAL_STRING;
434
     LENGTH, A_LENGTH, PTR,
435
     TEMP_MACRO_LENGTH, MACRO_LEN, FILE_COUNT : INTEGER := 0;
436
     A_LINE, TEMP_MACRO, TEMP_LINE, NEW_LINE : VAL_STRING;
437
     END_OF_LINE_SEARCH, FLAG       : BOOLEAN := FALSE;
438
     TESTS_FILE                     : CONSTANT STRING := "TSTTESTS.DAT";
439
     TSTTESTS,FILE_CRE              : EXCEPTION;
440
 
441
BEGIN
442
     PUT_LINE ("BEGINNING MACRO SUBSTITUTIONS.");
443
     FILL_TABLE;
444
     BEGIN
445
          OPEN (INFILE2, IN_FILE, TESTS_FILE);
446
     EXCEPTION
447
          WHEN NAME_ERROR =>
448
               PUT_LINE ("** ERROR: ERROR DURING OPENING OF " &
449
                         "TSTTESTS.DAT");
450
               RAISE TSTTESTS;
451
     END;
452
     WHILE NOT END_OF_FILE (INFILE2) LOOP
453
          GET_LINE (INFILE2, FNAME, LENGTH);
454
          FILE_COUNT := FILE_COUNT + 1;
455
          BEGIN
456
               OPEN (INFILE1, IN_FILE, FNAME(1..LENGTH));
457
          EXCEPTION
458
               WHEN NAME_ERROR =>
459
                    PUT_LINE ("** ERROR: ERROR DURING OPENING OF " &
460
                              FNAME(1..LENGTH) & ".");
461
                    FLAG := TRUE;
462
          END;
463
          IF NOT FLAG THEN
464
               PUT_LINE ("WORKING ON " & FNAME(1..LENGTH));
465
               IF FILE_COUNT = 70 THEN
466
                    PUT_LINE ("MACRO SUBSTITUTIONS HALF COMPLETED.");
467
               END IF;
468
               FOR I IN REVERSE 1 .. LENGTH LOOP
469
                    IF FNAME(I) = ';' THEN
470
                         LENGTH := I - 1;
471
                         EXIT;
472
                    END IF;
473
               END LOOP;
474
               IF FNAME (LENGTH-2..LENGTH) = "TST" THEN
475
                    FNAME (LENGTH-2..LENGTH) := "ADT";
476
               ELSIF FNAME (LENGTH-2..LENGTH) = "tst" THEN
477
                    FNAME (LENGTH-2..LENGTH) := "adt";
478
               END IF;
479
               BEGIN
480
                    CREATE (OUTFILE1, OUT_FILE, FNAME (1..LENGTH));
481
               EXCEPTION
482
                    WHEN OTHERS =>
483
                         PUT_LINE ("** ERROR: EXCEPTION RAISED DURING" &
484
                                   " ATTEMPTED CREATION OF " &
485
                                   FNAME(1..LENGTH) & ".");
486
                         RAISE FILE_CRE;
487
               END;
488
               WHILE NOT END_OF_FILE (INFILE1) LOOP
489
                    GET_LINE (INFILE1, A_LINE, A_LENGTH);
490
                    IF A_LENGTH > 0 AND A_LINE(1..2) /= "--" THEN
491
                         END_OF_LINE_SEARCH := FALSE;
492
                         PTR := 1;
493
                         WHILE NOT END_OF_LINE_SEARCH LOOP
494
                              LOOK_FOR_MACRO (A_LINE, A_LENGTH, PTR,
495
                                              MACRO, MACRO_LEN);
496
                              IF MACRO_LEN = 0 THEN
497
                                   END_OF_LINE_SEARCH := TRUE;
498
                              ELSE --  SEE WHICH MACRO IT IS
499
                                   WHICH_MACRO (MACRO, MACRO_LEN,
500
                                       TEMP_MACRO, TEMP_MACRO_LENGTH);
501
                              END IF;
502
                              IF NOT END_OF_LINE_SEARCH THEN
503
                                   IF PTR-MACRO_LEN-2 > 0 THEN
504
                                 -- IF MACRO IS NOT FIRST ON THE LINE
505
                                        NEW_LINE (1..PTR-MACRO_LEN-2)
506
                                         := A_LINE(1..PTR-MACRO_LEN -2);
507
                                 -- THE OLD LINE UNTIL THE DOLLAR SIGN
508
                                   END IF;
509
                                   NEW_LINE(PTR-MACRO_LEN-1 ..
510
                                            TEMP_MACRO_LENGTH +
511
                                            (PTR-MACRO_LEN) - 2) :=
512
                                       TEMP_MACRO(1..TEMP_MACRO_LENGTH);
513
                                   IF PTR <= A_LENGTH THEN
514
                                 -- IF MACRO IS NOT LAST ON THE LINE
515
                                        NEW_LINE (TEMP_MACRO_LENGTH +
516
                                             PTR-MACRO_LEN - 1 ..
517
                                             TEMP_MACRO_LENGTH - 1 +
518
                                             A_LENGTH - MACRO_LEN) :=
519
                                             A_LINE (PTR..A_LENGTH);
520
                                   ELSE
521
                                        END_OF_LINE_SEARCH := TRUE;
522
                                   END IF;
523
                                   A_LENGTH := A_LENGTH +
524
                                               TEMP_MACRO_LENGTH -
525
                                               MACRO_LEN - 1;
526
                                   A_LINE (1..A_LENGTH) :=
527
                                          NEW_LINE (1..A_LENGTH);
528
                                   PTR := PTR - MACRO_LEN +
529
                                          TEMP_MACRO_LENGTH - 1;
530
                              END IF;
531
                         END LOOP;
532
                    END IF;
533
                    PUT_LINE (OUTFILE1, A_LINE (1..A_LENGTH));
534
               END LOOP;
535
               CLOSE (OUTFILE1);
536
               CLOSE (INFILE1);
537
          ELSE
538
               FLAG := FALSE;
539
          END IF;
540
     END LOOP;
541
     CLOSE (INFILE2);
542
     PUT_LINE ("MACRO SUBSTITUTIONS COMPLETED.");
543
EXCEPTION
544
     WHEN MAC_FILE | LINE_LEN | TSTTESTS | FILE_CRE =>
545
          NULL;
546
     WHEN OTHERS =>
547
          PUT_LINE ("UNEXPECTED EXCEPTION RAISED");
548
END MACROSUB;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.