src/packrat.ads


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201


with

    Ada.Strings.Unbounded,
    Ada.Finalization;


package Packrat is


    type Result_Status is (Failure, Needs_More, Optional_More, Success);


    Parser_Error : exception;
    Lexer_Error  : exception;


    package Errors is


        subtype Error_Message is String
            with Dynamic_Predicate => Valid_Message (Error_Message);

        type Error_Info is record
            Symbol   : Ada.Strings.Unbounded.Unbounded_String;
            Position : Natural;
        end record;

        type Error_Info_Array is array (Positive range <>) of Error_Info;


        --  Note: No consideration is given to ordering of Error_Info items
        --        encoded into an Error_Message string.

        --  Note: Using "&" to join two Valid Error_Messages together
        --        will result in an Error_Message that is also Valid,
        --        but for best results Join should be used instead to
        --        prevent duplication of Error_Info in the message.


        function Valid_Identifier
               (Check : in String)
            return Boolean;

        function Valid_Identifier
               (Check : in Ada.Strings.Unbounded.Unbounded_String)
            return Boolean;

        function Valid_Identifier_Array
               (Check : in Error_Info_Array)
            return Boolean;

        function Valid_Message
               (Check : in String)
            return Boolean;

        function Debug_String
               (This : in Error_Message)
            return String;


        function Join
               (Left, Right : in Error_Message)
            return Error_Message;


        function Encode
               (Name : in String;
                Pos  : in Natural)
            return Error_Message
            with Pre => Valid_Identifier (Name);

        function Encode
               (Name : in Ada.Strings.Unbounded.Unbounded_String;
                Pos  : in Natural)
            return Error_Message
            with Pre => Valid_Identifier (Name);

        function Encode
               (Info : in Error_Info)
            return Error_Message
            with Pre => Valid_Identifier (Info.Symbol);

        function Encode_Array
               (Info : in Error_Info_Array)
            return Error_Message
            with Pre => Valid_Identifier_Array (Info);

        function Decode
               (Msg : in Error_Message)
            return Error_Info_Array;


    end Errors;


    generic
        type Label_Enum is (<>);
        type Element is private;
        type Element_Array is array (Positive range <>) of Element;
    package Tokens is


        type Token is new Ada.Finalization.Controlled with private;
        type Token_Array is array (Positive range <>) of Token;


        function Create
               (Ident  : in Label_Enum;
                Start  : in Positive;
                Finish : in Natural;
                Value  : in Element_Array)
            return Token;

        function "="
               (Left, Right : in Token)
            return Boolean;


        --  Note: The Start and Finish indices indicate where the token was found
        --        in whatever array it was lexed from. The Value does *not* have
        --        to correspond with whatever is found in the Start .. Finish range.


        function Initialized
               (This : in Token)
            return Boolean;

        function Debug_String
               (This : in Token)
            return String;


        function Label
               (This : in Token)
            return Label_Enum
            with Pre => Initialized (This);

        function Start
               (This : in Token)
            return Positive;

        function Finish
               (This : in Token)
            return Natural;

        function Value
               (This : in Token)
            return Element_Array
            with Pre => Initialized (This);


    private


        type Element_Array_Access is access Element_Array;


        type Token is new Ada.Finalization.Controlled with record
            Identifier  : Label_Enum;
            Start_At    : Positive;
            Finish_At   : Natural;
            Token_Value : Element_Array_Access;
        end record;


        overriding procedure Initialize
               (This : in out Token);

        overriding procedure Adjust
               (This : in out Token);

        overriding procedure Finalize
               (This : in out Token);


    end Tokens;


private


    function "+"
           (S : in String)
        return Ada.Strings.Unbounded.Unbounded_String
        renames Ada.Strings.Unbounded.To_Unbounded_String;

    function "-"
           (US : in Ada.Strings.Unbounded.Unbounded_String)
        return String
        renames Ada.Strings.Unbounded.To_String;


end Packrat;