[Ada] Fully implement general form static predicates

This patch implements static predicates allowing all comparisons,
membership tests, linked by OR/NOT/AND/AND-THEN/OR-ELSE/XOR.

The following is a more extensive test, note that loops are
only allowed for the static predicate case, so that the fact
that the loop compiles shows that the static predicate has
been properly recognized:

     1. with Text_IO; use Text_IO;
     2. procedure Predicate_Loops is
     3.    type Int is range 1 .. 10;
     4.
     5.    subtype P1 is Int with
     6.      predicate =>
     7.        P1 in 3 | 5 .. 7 | 10 | 5 .. 6 | 6;
     8.
     9.    subtype P2 is Int with
    10.      predicate => P2 > 6;
    11.
    12.    subtype P3 is Int with
    13.      predicate => ((P3 > 6) and P3 < 9);
    14.
    15.    subtype P4 is Int with
    16.      predicate => (P4 in P2) and P4 < 10;
    17.
    18.    subtype P5 is Int with
    19.      predicate => P5 < 3 or P5 > 8;
    20.
    21.    subtype P6 is P5 with
                   |
        >>> info: "P6" inherits predicate from "P5" at line 18

    22.      predicate => P6 /= 1 and P6 /= 10;
    23.
    24.    subtype P7 is Int with
    25.      predicate => Boolean'(P7 not in 1 .. 7);
    26.
    27.    subtype P8 is Int with
    28.      predicate => not (P8 = 3 or else P8 in 5 .. 10);
    29.
    30.    subtype P9 is Int with
    31.      predicate => P9 in 1 .. 8 xor P9 in 3 .. 10;
    32.
    33.    type Enum is (A,B,C,D,E,F,G,H,I,J);
    34.
    35.    subtype E1 is Enum with
    36.      predicate =>
    37.        E1 in C | E .. G | J | E .. F | F;
    38.
    39.    subtype E2 is Enum with
    40.      predicate => E2 > F;
    41.
    42.    subtype E3 is Enum with
    43.      predicate => ((E3 > F) and E3 < I);
    44.
    45.    subtype E4 is Enum with
    46.      predicate => (E4 in E2) and E4 < J;
    47.
    48.    subtype E5 is Enum with
    49.      predicate => E5 < C or E5 > H;
    50.
    51.    subtype E6 is E5 with
                   |
        >>> info: "E6" inherits predicate from "E5" at line 48

    52.      predicate => E6 /= A and E6 /= J;
    53.
    54.    subtype E7 is Enum with
    55.      predicate => Boolean'(E7 not in A .. G);
    56.
    57.    subtype E8 is Enum with
    58.      predicate => not (E8 = C or else E8 in E .. J);
    59.
    60.    subtype E9 is Enum with
    61.      predicate => E9 in A .. H xor E9 in C .. J;
    62.
    63.    subtype T1 is Int with
    64.      predicate => True;
    65.
    66.    subtype T2 is Int with
    67.      predicate => False;
    68.
    69.    subtype T3 is Enum with
    70.      predicate => True;
    71.
    72.    subtype T4 is Enum with
    73.      predicate => False;
    74.
    75.
    76. begin
    77.    for J in P1 loop
    78.       Put_Line ("P1:" & J'Img);
    79.    end loop;
    80.
    81.    for J in P2 loop
    82.       Put_Line ("P2:" & J'Img);
    83.    end loop;
    84.
    85.    for J in P3 loop
    86.       Put_Line ("P3:" & J'Img);
    87.    end loop;
    88.
    89.    for J in P4 loop
    90.       Put_Line ("P4:" & J'Img);
    91.    end loop;
    92.
    93.    for J in P5 loop
    94.       Put_Line ("P5:" & J'Img);
    95.    end loop;
    96.
    97.    for J in P6 loop
    98.       Put_Line ("P6:" & J'Img);
    99.    end loop;
   100.
   101.    for J in P7 loop
   102.       Put_Line ("P7:" & J'Img);
   103.    end loop;
   104.
   105.    for J in P8 loop
   106.       Put_Line ("P8:" & J'Img);
   107.    end loop;
   108.
   109.    for J in P9 loop
   110.       Put_Line ("P9:" & J'Img);
   111.    end loop;
   112.
   113.    for J in E1 loop
   114.       Put_Line ("E1:" & J'Img);
   115.    end loop;
   116.
   117.    for J in E2 loop
   118.       Put_Line ("E2:" & J'Img);
   119.    end loop;
   120.
   121.    for J in E3 loop
   122.       Put_Line ("E3:" & J'Img);
   123.    end loop;
   124.
   125.    for J in E4 loop
   126.       Put_Line ("E4:" & J'Img);
   127.    end loop;
   128.
   129.    for J in E5 loop
   130.       Put_Line ("E5:" & J'Img);
   131.    end loop;
   132.
   133.    for J in E6 loop
   134.       Put_Line ("E6:" & J'Img);
   135.    end loop;
   136.
   137.    for J in E7 loop
   138.       Put_Line ("E7:" & J'Img);
   139.    end loop;
   140.
   141.    for J in E8 loop
   142.       Put_Line ("E8:" & J'Img);
   143.    end loop;
   144.
   145.    for J in E9 loop
   146.       Put_Line ("E9:" & J'Img);
   147.    end loop;
   148.
   149.    for J in T1 loop
   150.       Put_Line ("T1:" & J'Img);
   151.    end loop;
   152.
   153.    for J in T2 loop
   154.       Put_Line ("T2:" & J'Img);
   155.    end loop;
   156.
   157.    for J in T3 loop
   158.       Put_Line ("T3:" & J'Img);
   159.    end loop;
   160.
   161.    for J in T4 loop
   162.       Put_Line ("T4:" & J'Img);
   163.    end loop;
   164.
   165. end Predicate_Loops;

The output of this program is:

P1: 3
P1: 5
P1: 6
P1: 7
P1: 10
P2: 7
P2: 8
P2: 9
P2: 10
P3: 7
P3: 8
P4: 7
P4: 8
P4: 9
P5: 1
P5: 2
P5: 9
P5: 10
P6: 2
P6: 9
P7: 8
P7: 9
P7: 10
P8: 1
P8: 2
P8: 4
P9: 1
P9: 2
P9: 9
P9: 10
E1:C
E1:E
E1:F
E1:G
E1:J
E2:G
E2:H
E2:I
E2:J
E3:G
E3:H
E4:G
E4:H
E4:I
E5:A
E5:B
E5:I
E5:J
E6:B
E6:I
E7:H
E7:I
E7:J
E8:A
E8:B
E8:D
E9:A
E9:B
E9:I
E9:J
T1: 1
T1: 2
T1: 3
T1: 4
T1: 5
T1: 6
T1: 7
T1: 8
T1: 9
T1: 10
T3:A
T3:B
T3:C
T3:D
T3:E
T3:F
T3:G
T3:H
T3:I
T3:J

Tested on x86_64-pc-linux-gnu, committed on trunk

2010-10-25  Robert Dewar  <dewar@adacore.com>

	* exp_ch5.adb (Expand_Predicated_Loop): Remove code for loop through
	non-static predicate, since we agree not to allow this.
	(Expand_Predicated_Loop): Properlay handle false predicate (null
	list in Static_Predicate field.
	* sem_ch13.adb (Build_Static_Predicate): Extensive changes to clean up
	handling of more general predicate forms.

[Ada] Fully implement general form static predicates

Commit Message

Patch