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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [ada/] [acats/] [tests/] [c6/] [c67002a.ada] - Blame information for rev 720

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 720 jeremybenn
-- C67002A.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
-- CHECK THAT ALL OPERATOR SYMBOLS CAN BE USED IN (OVERLOADED)
26
--   FUNCTION SPECIFICATIONS WITH THE REQUIRED NUMBER OF PARAMETERS.
27
--   SUBTESTS ARE:
28
--        (A) THROUGH (P): "=", "AND", "OR", "XOR", "<", "<=",
29
--             ">", ">=", "&", "*", "/", "MOD", "REM", "**", "+", "-",
30
--             RESPECTIVELY.  ALL OF THESE HAVE TWO PARAMETERS.
31
--        (Q), (R), (S), AND (T): "+", "-", "NOT", "ABS", RESPECTIVELY,
32
--             WITH ONE PARAMETER.
33
 
34
-- CVP 5/7/81
35
-- JRK 6/1/81
36
-- CPP 6/25/84
37
 
38
WITH REPORT;
39
PROCEDURE C67002A IS
40
 
41
     USE REPORT;
42
 
43
BEGIN
44
     TEST ("C67002A", "USE OF OPERATOR SYMBOLS IN " &
45
           "(OVERLOADED) FUNCTION SPECIFICATIONS");
46
 
47
     -------------------------------------------------
48
 
49
     DECLARE -- (A)
50
          PACKAGE EQU IS
51
               TYPE  LP IS LIMITED PRIVATE;
52
               FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN;
53
          PRIVATE
54
               TYPE LP IS NEW INTEGER;
55
          END EQU;
56
          USE EQU;
57
 
58
          LP1, LP2 : LP;
59
 
60
          PACKAGE BODY EQU IS
61
               FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN IS
62
               BEGIN
63
                    RETURN LPA > LPB;
64
               END "=";
65
          BEGIN
66
               LP1 := LP (IDENT_INT (7));
67
               LP2 := LP (IDENT_INT (8));
68
          END EQU;
69
 
70
     BEGIN -- (A)
71
          IF (LP1 = LP2) OR NOT (LP2 = LP1) OR
72
             (LP1 = LP1) OR (LP2 /= LP1) THEN
73
               FAILED ("OVERLOADING OF ""="" OPERATOR DEFECTIVE");
74
          END IF;
75
     END; -- (A)
76
 
77
     -------------------------------------------------
78
 
79
     DECLARE -- (B)
80
          FUNCTION "AND" (I1, I2 : INTEGER) RETURN CHARACTER IS
81
          BEGIN
82
               IF I1 > I2 THEN
83
                    RETURN 'G';
84
               ELSE RETURN 'L';
85
               END IF;
86
          END "AND";
87
 
88
     BEGIN -- (B)
89
          IF (IDENT_INT (10) AND 1) /= 'G' OR
90
             (5 AND 10) /= 'L' THEN
91
               FAILED ("OVERLOADING OF ""AND"" OPERATOR DEFECTIVE");
92
          END IF;
93
     END; -- (B)
94
 
95
     -------------------------------------------------
96
 
97
     DECLARE -- (C)
98
          FUNCTION "OR" (I1, I2 : INTEGER) RETURN CHARACTER IS
99
          BEGIN
100
               IF I1 > I2 THEN
101
                    RETURN 'G';
102
               ELSE RETURN 'L';
103
               END IF;
104
          END "OR";
105
 
106
     BEGIN -- (C)
107
          IF (IDENT_INT (10) OR 1) /= 'G' OR
108
             (5 OR 10) /= 'L' THEN
109
               FAILED ("OVERLOADING OF ""OR"" OPERATOR DEFECTIVE");
110
          END IF;
111
     END; -- (C)
112
 
113
     -------------------------------------------------
114
 
115
     DECLARE -- (D)
116
          FUNCTION "XOR" (I1, I2 : INTEGER) RETURN CHARACTER IS
117
          BEGIN
118
               IF I1 > I2 THEN
119
                    RETURN 'G';
120
               ELSE RETURN 'L';
121
               END IF;
122
          END "XOR";
123
 
124
     BEGIN -- (D)
125
          IF (IDENT_INT (10) XOR 1) /= 'G' OR
126
             (5 XOR 10) /= 'L' THEN
127
               FAILED ("OVERLOADING OF ""XOR"" OPERATOR DEFECTIVE");
128
          END IF;
129
     END; -- (D)
130
 
131
     -------------------------------------------------
132
 
133
     DECLARE -- (E)
134
          FUNCTION "<" (I1, I2 : INTEGER) RETURN CHARACTER IS
135
          BEGIN
136
               IF I1 > I2 THEN
137
                    RETURN 'G';
138
               ELSE RETURN 'L';
139
               END IF;
140
          END "<";
141
 
142
     BEGIN -- (E)
143
          IF (IDENT_INT (10) < 1) /= 'G' OR
144
             (5 < 10) /= 'L' THEN
145
               FAILED ("OVERLOADING OF ""<"" OPERATOR DEFECTIVE");
146
          END IF;
147
     END; -- (E)
148
 
149
     -------------------------------------------------
150
 
151
     DECLARE -- (F)
152
          FUNCTION "<=" (I1, I2 : INTEGER) RETURN CHARACTER IS
153
          BEGIN
154
               IF I1 > I2 THEN
155
                    RETURN 'G';
156
               ELSE RETURN 'L';
157
               END IF;
158
          END "<=";
159
 
160
     BEGIN -- (F)
161
          IF (IDENT_INT (10) <= 1) /= 'G' OR
162
             (5 <= 10) /= 'L' THEN
163
               FAILED ("OVERLOADING OF ""<="" OPERATOR DEFECTIVE");
164
          END IF;
165
     END; -- (F)
166
 
167
     -------------------------------------------------
168
 
169
     DECLARE -- (G)
170
          FUNCTION ">" (I1, I2 : INTEGER) RETURN CHARACTER IS
171
          BEGIN
172
               IF I1 > I2 THEN
173
                    RETURN 'G';
174
               ELSE RETURN 'L';
175
               END IF;
176
          END ">";
177
 
178
     BEGIN -- (G)
179
          IF (IDENT_INT (10) > 1) /= 'G' OR
180
             (5 > 10) /= 'L' THEN
181
               FAILED ("OVERLOADING OF "">"" OPERATOR DEFECTIVE");
182
          END IF;
183
     END; -- (G)
184
 
185
     -------------------------------------------------
186
 
187
     DECLARE -- (H)
188
          FUNCTION ">=" (I1, I2 : INTEGER) RETURN CHARACTER IS
189
          BEGIN
190
               IF I1 > I2 THEN
191
                    RETURN 'G';
192
               ELSE RETURN 'L';
193
               END IF;
194
          END ">=";
195
 
196
     BEGIN -- (H)
197
          IF (IDENT_INT (10) >= 1) /= 'G' OR
198
             (5 >= 10) /= 'L' THEN
199
               FAILED ("OVERLOADING OF "">="" OPERATOR DEFECTIVE");
200
          END IF;
201
     END; -- (H)
202
 
203
     -------------------------------------------------
204
 
205
     DECLARE -- (I)
206
          FUNCTION "&" (I1, I2 : INTEGER) RETURN CHARACTER IS
207
          BEGIN
208
               IF I1 > I2 THEN
209
                    RETURN 'G';
210
               ELSE RETURN 'L';
211
               END IF;
212
          END "&";
213
 
214
     BEGIN -- (I)
215
          IF (IDENT_INT (10) & 1) /= 'G' OR
216
             (5 & 10) /= 'L' THEN
217
               FAILED ("OVERLOADING OF ""&"" OPERATOR DEFECTIVE");
218
          END IF;
219
     END; -- (I)
220
 
221
     -------------------------------------------------
222
 
223
     DECLARE -- (J)
224
          FUNCTION "*" (I1, I2 : INTEGER) RETURN CHARACTER IS
225
          BEGIN
226
               IF I1 > I2 THEN
227
                    RETURN 'G';
228
               ELSE RETURN 'L';
229
               END IF;
230
          END "*";
231
 
232
     BEGIN -- (J)
233
          IF (IDENT_INT (10) * 1) /= 'G' OR
234
             (5 * 10) /= 'L' THEN
235
               FAILED ("OVERLOADING OF ""*"" OPERATOR DEFECTIVE");
236
          END IF;
237
     END; -- (J)
238
 
239
     -------------------------------------------------
240
 
241
     DECLARE -- (K)
242
          FUNCTION "/" (I1, I2 : INTEGER) RETURN CHARACTER IS
243
          BEGIN
244
               IF I1 > I2 THEN
245
                    RETURN 'G';
246
               ELSE RETURN 'L';
247
               END IF;
248
          END "/";
249
 
250
     BEGIN -- (K)
251
          IF (IDENT_INT (10) / 1) /= 'G' OR
252
             (5 / 10) /= 'L' THEN
253
               FAILED ("OVERLOADING OF ""/"" OPERATOR DEFECTIVE");
254
          END IF;
255
     END; -- (K)
256
 
257
     -------------------------------------------------
258
 
259
     DECLARE -- (L)
260
          FUNCTION "MOD" (I1, I2 : INTEGER) RETURN CHARACTER IS
261
          BEGIN
262
               IF I1 > I2 THEN
263
                    RETURN 'G';
264
               ELSE RETURN 'L';
265
               END IF;
266
          END "MOD";
267
 
268
     BEGIN -- (L)
269
          IF (IDENT_INT (10) MOD 1) /= 'G' OR
270
             (5 MOD 10) /= 'L' THEN
271
               FAILED ("OVERLOADING OF ""MOD"" OPERATOR DEFECTIVE");
272
          END IF;
273
     END; -- (L)
274
 
275
     -------------------------------------------------
276
 
277
     DECLARE -- (M)
278
          FUNCTION "REM" (I1, I2 : INTEGER) RETURN CHARACTER IS
279
          BEGIN
280
               IF I1 > I2 THEN
281
                    RETURN 'G';
282
               ELSE RETURN 'L';
283
               END IF;
284
          END "REM";
285
 
286
     BEGIN -- (M)
287
          IF (IDENT_INT (10) REM 1) /= 'G' OR
288
             (5 REM 10) /= 'L' THEN
289
               FAILED ("OVERLOADING OF ""REM"" OPERATOR DEFECTIVE");
290
          END IF;
291
     END; -- (M)
292
 
293
     -------------------------------------------------
294
 
295
     DECLARE -- (N)
296
          FUNCTION "**" (I1, I2 : INTEGER) RETURN CHARACTER IS
297
          BEGIN
298
               IF I1 > I2 THEN
299
                    RETURN 'G';
300
               ELSE RETURN 'L';
301
               END IF;
302
          END "**";
303
 
304
     BEGIN -- (N)
305
          IF (IDENT_INT (10) ** 1) /= 'G' OR
306
             (5 ** 10) /= 'L' THEN
307
               FAILED ("OVERLOADING OF ""**"" OPERATOR DEFECTIVE");
308
          END IF;
309
     END; -- (N)
310
 
311
     -------------------------------------------------
312
 
313
     DECLARE -- (O)
314
          FUNCTION "+" (I1, I2 : INTEGER) RETURN CHARACTER IS
315
          BEGIN
316
               IF I1 > I2 THEN
317
                    RETURN 'G';
318
               ELSE RETURN 'L';
319
               END IF;
320
          END "+";
321
 
322
     BEGIN -- (O)
323
          IF (IDENT_INT (10) + 1) /= 'G' OR
324
             (5 + 10) /= 'L' THEN
325
               FAILED ("OVERLOADING OF ""+"" OPERATOR DEFECTIVE");
326
          END IF;
327
     END; -- (O)
328
 
329
     -------------------------------------------------
330
 
331
     DECLARE -- (P)
332
          FUNCTION "-" (I1, I2 : INTEGER) RETURN CHARACTER IS
333
          BEGIN
334
               IF I1 > I2 THEN
335
                    RETURN 'G';
336
               ELSE RETURN 'L';
337
               END IF;
338
          END "-";
339
 
340
     BEGIN -- (P)
341
          IF (IDENT_INT (10) - 1) /= 'G' OR
342
             (5 - 10) /= 'L' THEN
343
               FAILED ("OVERLOADING OF ""-"" OPERATOR DEFECTIVE");
344
          END IF;
345
     END; -- (P)
346
 
347
     -------------------------------------------------
348
 
349
     DECLARE -- (Q)
350
          FUNCTION "+" (I1 : INTEGER) RETURN CHARACTER IS
351
          BEGIN
352
               IF I1 < IDENT_INT (0) THEN
353
                    RETURN 'N';
354
               ELSE RETURN 'P';
355
               END IF;
356
          END "+";
357
 
358
     BEGIN -- (Q)
359
          IF (+ IDENT_INT(25) /= 'P') OR
360
             (+ (0-25) /= 'N') THEN
361
               FAILED ("OVERLOADING OF ""+"" " &
362
                       "OPERATOR (ONE OPERAND) DEFECTIVE");
363
          END IF;
364
     END; -- (Q)
365
 
366
     -------------------------------------------------
367
 
368
     DECLARE -- (R)
369
          FUNCTION "-" (I1 : INTEGER) RETURN CHARACTER IS
370
          BEGIN
371
               IF I1 < IDENT_INT (0) THEN
372
                    RETURN 'N';
373
               ELSE RETURN 'P';
374
               END IF;
375
          END "-";
376
 
377
     BEGIN -- (R)
378
          IF (- IDENT_INT(25) /= 'P') OR
379
             (- (0-25) /= 'N') THEN
380
               FAILED ("OVERLOADING OF ""-"" " &
381
                       "OPERATOR (ONE OPERAND) DEFECTIVE");
382
          END IF;
383
     END; -- (R)
384
 
385
     -------------------------------------------------
386
 
387
     DECLARE -- (S)
388
          FUNCTION "NOT" (I1 : INTEGER) RETURN CHARACTER IS
389
          BEGIN
390
               IF I1 < IDENT_INT (0) THEN
391
                    RETURN 'N';
392
               ELSE RETURN 'P';
393
               END IF;
394
          END "NOT";
395
 
396
     BEGIN -- (S)
397
          IF (NOT IDENT_INT(25) /= 'P') OR
398
             (NOT (0-25) /= 'N') THEN
399
               FAILED ("OVERLOADING OF ""NOT"" " &
400
                       "OPERATOR (ONE OPERAND) DEFECTIVE");
401
          END IF;
402
     END; -- (S)
403
 
404
     -------------------------------------------------
405
 
406
     DECLARE -- (T)
407
          FUNCTION "ABS" (I1 : INTEGER) RETURN CHARACTER IS
408
          BEGIN
409
               IF I1 < IDENT_INT (0) THEN
410
                    RETURN 'N';
411
               ELSE RETURN 'P';
412
               END IF;
413
          END "ABS";
414
 
415
     BEGIN -- (T)
416
          IF (ABS IDENT_INT(25) /= 'P') OR
417
             (ABS (0-25) /= 'N') THEN
418
               FAILED ("OVERLOADING OF ""ABS"" " &
419
                       "OPERATOR (ONE OPERAND) DEFECTIVE");
420
          END IF;
421
     END; -- (T)
422
 
423
     -------------------------------------------------
424
 
425
     RESULT;
426
END C67002A;

powered by: WebSVN 2.1.0

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