annotate gcc/ada/types.h @ 158:494b0b89df80 default tip

...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 25 May 2020 18:13:55 +0900
parents 1830386684a0
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 /****************************************************************************
kono
parents:
diff changeset
2 * *
kono
parents:
diff changeset
3 * GNAT COMPILER COMPONENTS *
kono
parents:
diff changeset
4 * *
kono
parents:
diff changeset
5 * T Y P E S *
kono
parents:
diff changeset
6 * *
kono
parents:
diff changeset
7 * C Header File *
kono
parents:
diff changeset
8 * *
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
9 * Copyright (C) 1992-2019, Free Software Foundation, Inc. *
111
kono
parents:
diff changeset
10 * *
kono
parents:
diff changeset
11 * GNAT is free software; you can redistribute it and/or modify it under *
kono
parents:
diff changeset
12 * terms of the GNU General Public License as published by the Free Soft- *
kono
parents:
diff changeset
13 * ware Foundation; either version 3, or (at your option) any later ver- *
kono
parents:
diff changeset
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
kono
parents:
diff changeset
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
kono
parents:
diff changeset
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
kono
parents:
diff changeset
17 * for more details. You should have received a copy of the GNU General *
kono
parents:
diff changeset
18 * Public License distributed with GNAT; see file COPYING3. If not, go to *
kono
parents:
diff changeset
19 * http://www.gnu.org/licenses for a complete copy of the license. *
kono
parents:
diff changeset
20 * *
kono
parents:
diff changeset
21 * GNAT was originally developed by the GNAT team at New York University. *
kono
parents:
diff changeset
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
kono
parents:
diff changeset
23 * *
kono
parents:
diff changeset
24 ****************************************************************************/
kono
parents:
diff changeset
25
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
26 /* This is the C header that corresponds to the Ada package specification for
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
27 Types. It was created manually from types.ads and must be kept synchronized
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
28 with changes in this file.
111
kono
parents:
diff changeset
29
kono
parents:
diff changeset
30 This package contains host independent type definitions which are used
kono
parents:
diff changeset
31 throughout the compiler modules. The comments in the C version are brief
kono
parents:
diff changeset
32 reminders of the purpose of each declaration. For complete documentation,
kono
parents:
diff changeset
33 see the Ada version of these definitions. */
kono
parents:
diff changeset
34
kono
parents:
diff changeset
35 /* Boolean Types: */
kono
parents:
diff changeset
36
kono
parents:
diff changeset
37 /* Boolean type (cannot use enum, because of bit field restriction on some
kono
parents:
diff changeset
38 compilers). */
kono
parents:
diff changeset
39 typedef unsigned char Boolean;
kono
parents:
diff changeset
40 #define False 0
kono
parents:
diff changeset
41 #define True 1
kono
parents:
diff changeset
42
kono
parents:
diff changeset
43 /* General Use Integer Types */
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 /* Signed 32-bit integer */
kono
parents:
diff changeset
46 typedef int Int;
kono
parents:
diff changeset
47
kono
parents:
diff changeset
48 /* Signed 16-bit integer */
kono
parents:
diff changeset
49 typedef short Short;
kono
parents:
diff changeset
50
kono
parents:
diff changeset
51 /* Non-negative Int values */
kono
parents:
diff changeset
52 typedef Int Nat;
kono
parents:
diff changeset
53
kono
parents:
diff changeset
54 /* Positive Int values */
kono
parents:
diff changeset
55 typedef Int Pos;
kono
parents:
diff changeset
56
kono
parents:
diff changeset
57 /* 8-bit unsigned integer */
kono
parents:
diff changeset
58 typedef unsigned char Byte;
kono
parents:
diff changeset
59
kono
parents:
diff changeset
60 /* 8-Bit Character and String Types: */
kono
parents:
diff changeset
61
kono
parents:
diff changeset
62 /* 8-bit character type */
kono
parents:
diff changeset
63 typedef char Char;
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 /* Graphic characters, as defined in ARM */
kono
parents:
diff changeset
66 typedef Char Graphic_Character;
kono
parents:
diff changeset
67
kono
parents:
diff changeset
68 /* Line terminator characters (LF, VT, FF, CR) */
kono
parents:
diff changeset
69 typedef Char Line_Terminator;
kono
parents:
diff changeset
70
kono
parents:
diff changeset
71 /* Characters with the upper bit set */
kono
parents:
diff changeset
72 typedef Char Upper_Half_Character;
kono
parents:
diff changeset
73
kono
parents:
diff changeset
74 /* String type built on Char (note that zero is an OK index) */
kono
parents:
diff changeset
75 typedef Char *Str;
kono
parents:
diff changeset
76
kono
parents:
diff changeset
77 /* Pointer to string of Chars */
kono
parents:
diff changeset
78 typedef Char *Str_Ptr;
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 /* Types for the fat pointer used for strings and the template it points to.
kono
parents:
diff changeset
81 The fat pointer is conceptually a couple of pointers, but it is wrapped
kono
parents:
diff changeset
82 up in a special record type. On the Ada side, the record is naturally
kono
parents:
diff changeset
83 aligned (i.e. given pointer alignment) on regular platforms, but it is
kono
parents:
diff changeset
84 given twice this alignment on strict-alignment platforms for performance
kono
parents:
diff changeset
85 reasons. On the C side, for the sake of portability and simplicity, we
kono
parents:
diff changeset
86 overalign it on all platforms (so the machine mode is always the same as
kono
parents:
diff changeset
87 on the Ada side) but arrange to pass it in an even scalar position as a
kono
parents:
diff changeset
88 parameter to functions (so the scalar parameter alignment is always the
kono
parents:
diff changeset
89 same as on the Ada side). */
kono
parents:
diff changeset
90 typedef struct { int Low_Bound, High_Bound; } String_Template;
kono
parents:
diff changeset
91 typedef struct { const char *Array; String_Template *Bounds; }
kono
parents:
diff changeset
92 __attribute ((aligned (sizeof (char *) * 2))) String_Pointer;
kono
parents:
diff changeset
93
kono
parents:
diff changeset
94 /* Types for Node/Entity Kinds: */
kono
parents:
diff changeset
95
kono
parents:
diff changeset
96 /* The reason that these are defined here in the C version, rather than in the
kono
parents:
diff changeset
97 corresponding packages is that the requirement for putting bodies of
kono
parents:
diff changeset
98 inlined stuff IN the C header changes the dependencies. Both sinfo.h
kono
parents:
diff changeset
99 and einfo.h now reference routines defined in tree.h.
kono
parents:
diff changeset
100
kono
parents:
diff changeset
101 Note: these types would more naturally be defined as unsigned char, but
kono
parents:
diff changeset
102 once again, the annoying restriction on bit fields for some compilers
kono
parents:
diff changeset
103 bites us! */
kono
parents:
diff changeset
104
kono
parents:
diff changeset
105 typedef unsigned int Node_Kind;
kono
parents:
diff changeset
106 typedef unsigned int Entity_Kind;
kono
parents:
diff changeset
107
kono
parents:
diff changeset
108 /* Types used for Text Buffer Handling: */
kono
parents:
diff changeset
109
kono
parents:
diff changeset
110 /* Type used for subscripts in text buffer. */
kono
parents:
diff changeset
111 typedef Int Text_Ptr;
kono
parents:
diff changeset
112
kono
parents:
diff changeset
113 /* Text buffer used to hold source file or library information file. */
kono
parents:
diff changeset
114 typedef Char *Text_Buffer;
kono
parents:
diff changeset
115
kono
parents:
diff changeset
116 /* Pointer to text buffer. */
kono
parents:
diff changeset
117 typedef Char *Text_Buffer_Ptr;
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 /* Types used for Source Input Handling: */
kono
parents:
diff changeset
120
kono
parents:
diff changeset
121 /* Line number type, used for storing all line numbers. */
kono
parents:
diff changeset
122 typedef Int Line_Number_Type;
kono
parents:
diff changeset
123
kono
parents:
diff changeset
124 /* Column number type, used for storing all column numbers. */
kono
parents:
diff changeset
125 typedef Int Column_Number_Type;
kono
parents:
diff changeset
126
kono
parents:
diff changeset
127 /* Type used to store text of a source file. */
kono
parents:
diff changeset
128 typedef Text_Buffer Source_Buffer;
kono
parents:
diff changeset
129
kono
parents:
diff changeset
130 /* Pointer to source buffer. */
kono
parents:
diff changeset
131 typedef Text_Buffer_Ptr Source_Buffer_Ptr;
kono
parents:
diff changeset
132
kono
parents:
diff changeset
133 /* Type used for source location. */
kono
parents:
diff changeset
134 typedef Text_Ptr Source_Ptr;
kono
parents:
diff changeset
135
kono
parents:
diff changeset
136 /* Value used to indicate no source position set. */
kono
parents:
diff changeset
137 #define No_Location -1
kono
parents:
diff changeset
138
kono
parents:
diff changeset
139 /* Used for Sloc in all nodes in the representation of package Standard. */
kono
parents:
diff changeset
140 #define Standard_Location -2
kono
parents:
diff changeset
141
kono
parents:
diff changeset
142 /* Instance identifiers */
kono
parents:
diff changeset
143 typedef Nat Instance_Id;
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 /* Type used for union of all possible ID values covering all ranges */
kono
parents:
diff changeset
146 typedef int Union_Id;
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 /* Range definitions for Tree Data: */
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 #define List_Low_Bound -100000000
kono
parents:
diff changeset
151 #define List_High_Bound 0
kono
parents:
diff changeset
152
kono
parents:
diff changeset
153 #define Node_Low_Bound 0
kono
parents:
diff changeset
154 #define Node_High_Bound 99999999
kono
parents:
diff changeset
155
kono
parents:
diff changeset
156 #define Elist_Low_Bound 100000000
kono
parents:
diff changeset
157 #define Elist_High_Bound 199999999
kono
parents:
diff changeset
158
kono
parents:
diff changeset
159 #define Elmt_Low_Bound 200000000
kono
parents:
diff changeset
160 #define Elmt_High_Bound 299999999
kono
parents:
diff changeset
161
kono
parents:
diff changeset
162 #define Names_Low_Bound 300000000
kono
parents:
diff changeset
163 #define Names_High_Bound 399999999
kono
parents:
diff changeset
164
kono
parents:
diff changeset
165 #define Strings_Low_Bound 400000000
kono
parents:
diff changeset
166 #define Strings_High_Bound 499999999
kono
parents:
diff changeset
167
kono
parents:
diff changeset
168 #define Ureal_Low_Bound 500000000
kono
parents:
diff changeset
169 #define Ureal_High_Bound 599999999
kono
parents:
diff changeset
170
kono
parents:
diff changeset
171 #define Uint_Low_Bound 600000000
kono
parents:
diff changeset
172 #define Uint_Table_Start 2000000000
kono
parents:
diff changeset
173 #define Uint_High_Bound 2099999999
kono
parents:
diff changeset
174
kono
parents:
diff changeset
175 SUBTYPE (List_Range, Int, List_Low_Bound, List_High_Bound)
kono
parents:
diff changeset
176 SUBTYPE (Node_Range, Int, Node_Low_Bound, Node_High_Bound)
kono
parents:
diff changeset
177 SUBTYPE (Elist_Range, Int, Elist_Low_Bound, Elist_High_Bound)
kono
parents:
diff changeset
178 SUBTYPE (Elmt_Range, Int, Elmt_Low_Bound, Elmt_High_Bound)
kono
parents:
diff changeset
179 SUBTYPE (Names_Range, Int, Names_Low_Bound, Names_High_Bound)
kono
parents:
diff changeset
180 SUBTYPE (Strings_Range, Int, Strings_Low_Bound, Strings_High_Bound)
kono
parents:
diff changeset
181 SUBTYPE (Uint_Range, Int, Uint_Low_Bound, Uint_High_Bound)
kono
parents:
diff changeset
182 SUBTYPE (Ureal_Range, Int, Ureal_Low_Bound, Ureal_High_Bound)
kono
parents:
diff changeset
183
kono
parents:
diff changeset
184 /* Types for Names_Table Package: */
kono
parents:
diff changeset
185
kono
parents:
diff changeset
186 typedef Int Name_Id;
kono
parents:
diff changeset
187
kono
parents:
diff changeset
188 /* Name_Id value for no name present. */
kono
parents:
diff changeset
189 #define No_Name Names_Low_Bound
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 /* Name_Id value for bad name. */
kono
parents:
diff changeset
192 #define Error_Name (Names_Low_Bound + 1)
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 /* First subscript of names table. */
kono
parents:
diff changeset
195 #define First_Name_Id (Names_Low_Bound + 2)
kono
parents:
diff changeset
196
kono
parents:
diff changeset
197 /* Types for Tree Package: */
kono
parents:
diff changeset
198
kono
parents:
diff changeset
199 /* Subscript of nodes table entry. */
kono
parents:
diff changeset
200 typedef Int Node_Id;
kono
parents:
diff changeset
201
kono
parents:
diff changeset
202 /* Used in semantics for Node_Id value referencing an entity. */
kono
parents:
diff changeset
203 typedef Node_Id Entity_Id;
kono
parents:
diff changeset
204
kono
parents:
diff changeset
205 /* Null node. */
kono
parents:
diff changeset
206 #define Empty 0
kono
parents:
diff changeset
207
kono
parents:
diff changeset
208 /* Error node. */
kono
parents:
diff changeset
209 #define Error 1
kono
parents:
diff changeset
210
kono
parents:
diff changeset
211 /* Subscript of first allocated node. */
kono
parents:
diff changeset
212 #define First_Node_Id Empty
kono
parents:
diff changeset
213
kono
parents:
diff changeset
214 /* Subscript of entry in lists table. */
kono
parents:
diff changeset
215 typedef Int List_Id;
kono
parents:
diff changeset
216
kono
parents:
diff changeset
217 /* Indicates absence of a list. */
kono
parents:
diff changeset
218 #define No_List 0
kono
parents:
diff changeset
219
kono
parents:
diff changeset
220 /* Error list. */
kono
parents:
diff changeset
221 #define Error_List List_Low_Bound
kono
parents:
diff changeset
222
kono
parents:
diff changeset
223 /* Subscript of first allocated list header. */
kono
parents:
diff changeset
224 #define First_List_Id Error_List
kono
parents:
diff changeset
225
kono
parents:
diff changeset
226 /* Element list Id, subscript value of entry in lists table. */
kono
parents:
diff changeset
227 typedef Int Elist_Id;
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 /* Used to indicate absence of an element list. */
kono
parents:
diff changeset
230 #define No_Elist Elist_Low_Bound
kono
parents:
diff changeset
231
kono
parents:
diff changeset
232 /* Subscript of first allocated elist header */
kono
parents:
diff changeset
233 #define First_Elist_Id (No_Elist + 1)
kono
parents:
diff changeset
234
kono
parents:
diff changeset
235 /* Element Id, subscript value of entry in elements table. */
kono
parents:
diff changeset
236 typedef Int Elmt_Id;
kono
parents:
diff changeset
237
kono
parents:
diff changeset
238 /* Used to indicate absence of a list element. */
kono
parents:
diff changeset
239 #define No_Elmt Elmt_Low_Bound
kono
parents:
diff changeset
240
kono
parents:
diff changeset
241 /* Subscript of first allocated element */
kono
parents:
diff changeset
242 #define First_Elmt_Id (No_Elmt + 1)
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 /* Types for String_Table Package: */
kono
parents:
diff changeset
245
kono
parents:
diff changeset
246 /* Subscript of strings table entry. */
kono
parents:
diff changeset
247 typedef Int String_Id;
kono
parents:
diff changeset
248
kono
parents:
diff changeset
249 /* Used to indicate missing string Id. */
kono
parents:
diff changeset
250 #define No_String Strings_Low_Bound
kono
parents:
diff changeset
251
kono
parents:
diff changeset
252 /* Subscript of first entry in strings table. */
kono
parents:
diff changeset
253 #define First_String_Id (No_String + 1)
kono
parents:
diff changeset
254
kono
parents:
diff changeset
255 /* Types for Uint_Support Package: */
kono
parents:
diff changeset
256
kono
parents:
diff changeset
257 /* Type used for representation of universal integers. */
kono
parents:
diff changeset
258 typedef Int Uint;
kono
parents:
diff changeset
259
kono
parents:
diff changeset
260 /* Used to indicate missing Uint value. */
kono
parents:
diff changeset
261 #define No_Uint Uint_Low_Bound
kono
parents:
diff changeset
262
kono
parents:
diff changeset
263 /* Base value used to represent Uint values. */
kono
parents:
diff changeset
264 #define Base 32768
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 /* Minimum and maximum integers directly representable as Uint values */
kono
parents:
diff changeset
267 #define Min_Direct (-(Base - 1))
kono
parents:
diff changeset
268 #define Max_Direct ((Base - 1) * (Base - 1))
kono
parents:
diff changeset
269
kono
parents:
diff changeset
270 #define Uint_Direct_Bias (Uint_Low_Bound + Base)
kono
parents:
diff changeset
271 #define Uint_Direct_First (Uint_Direct_Bias + Min_Direct)
kono
parents:
diff changeset
272 #define Uint_Direct_Last (Uint_Direct_Bias + Max_Direct)
kono
parents:
diff changeset
273
kono
parents:
diff changeset
274 /* Define range of direct biased values */
kono
parents:
diff changeset
275 SUBTYPE (Uint_Direct, Uint, Uint_Direct_First, Uint_Direct_Last)
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 /* Constants in Uint format. */
kono
parents:
diff changeset
278 #define Uint_0 (Uint_Direct_Bias + 0)
kono
parents:
diff changeset
279 #define Uint_1 (Uint_Direct_Bias + 1)
kono
parents:
diff changeset
280 #define Uint_2 (Uint_Direct_Bias + 2)
kono
parents:
diff changeset
281 #define Uint_10 (Uint_Direct_Bias + 10)
kono
parents:
diff changeset
282 #define Uint_16 (Uint_Direct_Bias + 16)
kono
parents:
diff changeset
283
kono
parents:
diff changeset
284 #define Uint_Minus_1 (Uint_Direct_Bias - 1)
kono
parents:
diff changeset
285
kono
parents:
diff changeset
286 /* Types for Ureal_Support Package: */
kono
parents:
diff changeset
287
kono
parents:
diff changeset
288 /* Type used for representation of universal reals. */
kono
parents:
diff changeset
289 typedef Int Ureal;
kono
parents:
diff changeset
290
kono
parents:
diff changeset
291 /* Used to indicate missing Uint value. */
kono
parents:
diff changeset
292 #define No_Ureal Ureal_Low_Bound
kono
parents:
diff changeset
293
kono
parents:
diff changeset
294 /* Subscript of first entry in Ureal table. */
kono
parents:
diff changeset
295 #define Ureal_First_Entry (No_Ureal + 1)
kono
parents:
diff changeset
296
kono
parents:
diff changeset
297 /* Character Code Type: */
kono
parents:
diff changeset
298
kono
parents:
diff changeset
299 /* Character code value, intended to be 32 bits. */
kono
parents:
diff changeset
300 typedef unsigned Char_Code;
kono
parents:
diff changeset
301
kono
parents:
diff changeset
302 /* Types Used for Library Management: */
kono
parents:
diff changeset
303
kono
parents:
diff changeset
304 /* Unit number. */
kono
parents:
diff changeset
305 typedef Int Unit_Number_Type;
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 /* Unit number value for main unit. */
kono
parents:
diff changeset
308 #define Main_Unit 0
kono
parents:
diff changeset
309
145
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
310 /* Type used to index the source file table. */
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
311 typedef Nat Source_File_Index;
1830386684a0 gcc-9.2.0
anatofuz
parents: 131
diff changeset
312
111
kono
parents:
diff changeset
313 /* Type used for lines table. */
kono
parents:
diff changeset
314 typedef Source_Ptr *Lines_Table_Type;
kono
parents:
diff changeset
315
kono
parents:
diff changeset
316 /* Type used for pointer to lines table. */
kono
parents:
diff changeset
317 typedef Source_Ptr *Lines_Table_Ptr;
kono
parents:
diff changeset
318
kono
parents:
diff changeset
319 /* Length of time stamp value. */
kono
parents:
diff changeset
320 #define Time_Stamp_Length 22
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 /* Type used to represent time stamp. */
kono
parents:
diff changeset
323 typedef Char *Time_Stamp_Type;
kono
parents:
diff changeset
324
kono
parents:
diff changeset
325 /* Name_Id synonym used for file names. */
kono
parents:
diff changeset
326 typedef Name_Id File_Name_Type;
kono
parents:
diff changeset
327
kono
parents:
diff changeset
328 /* Constant used to indicate no file found. */
kono
parents:
diff changeset
329 #define No_File No_Name
kono
parents:
diff changeset
330
kono
parents:
diff changeset
331 /* Name_Id synonym used for unit names. */
kono
parents:
diff changeset
332 typedef Name_Id Unit_Name_Type;
kono
parents:
diff changeset
333
kono
parents:
diff changeset
334 /* Definitions for mechanism type and values */
kono
parents:
diff changeset
335 typedef Int Mechanism_Type;
kono
parents:
diff changeset
336 #define Default 0
kono
parents:
diff changeset
337 #define By_Copy (-1)
kono
parents:
diff changeset
338 #define By_Reference (-2)
kono
parents:
diff changeset
339 #define By_Descriptor (-3)
kono
parents:
diff changeset
340 #define By_Descriptor_UBS (-4)
kono
parents:
diff changeset
341 #define By_Descriptor_UBSB (-5)
kono
parents:
diff changeset
342 #define By_Descriptor_UBA (-6)
kono
parents:
diff changeset
343 #define By_Descriptor_S (-7)
kono
parents:
diff changeset
344 #define By_Descriptor_SB (-8)
kono
parents:
diff changeset
345 #define By_Descriptor_A (-9)
kono
parents:
diff changeset
346 #define By_Descriptor_NCA (-10)
kono
parents:
diff changeset
347 #define By_Descriptor_Last (-10)
kono
parents:
diff changeset
348 #define By_Short_Descriptor (-11)
kono
parents:
diff changeset
349 #define By_Short_Descriptor_UBS (-12)
kono
parents:
diff changeset
350 #define By_Short_Descriptor_UBSB (-13)
kono
parents:
diff changeset
351 #define By_Short_Descriptor_UBA (-14)
kono
parents:
diff changeset
352 #define By_Short_Descriptor_S (-15)
kono
parents:
diff changeset
353 #define By_Short_Descriptor_SB (-16)
kono
parents:
diff changeset
354 #define By_Short_Descriptor_A (-17)
kono
parents:
diff changeset
355 #define By_Short_Descriptor_NCA (-18)
kono
parents:
diff changeset
356 #define By_Short_Descriptor_Last (-18)
kono
parents:
diff changeset
357
kono
parents:
diff changeset
358 /* Definitions of Reason codes for Raise_xxx_Error nodes */
kono
parents:
diff changeset
359 #define CE_Access_Check_Failed 0
kono
parents:
diff changeset
360 #define CE_Access_Parameter_Is_Null 1
kono
parents:
diff changeset
361 #define CE_Discriminant_Check_Failed 2
kono
parents:
diff changeset
362 #define CE_Divide_By_Zero 3
kono
parents:
diff changeset
363 #define CE_Explicit_Raise 4
kono
parents:
diff changeset
364 #define CE_Index_Check_Failed 5
kono
parents:
diff changeset
365 #define CE_Invalid_Data 6
kono
parents:
diff changeset
366 #define CE_Length_Check_Failed 7
kono
parents:
diff changeset
367 #define CE_Null_Exception_Id 8
kono
parents:
diff changeset
368 #define CE_Null_Not_Allowed 9
kono
parents:
diff changeset
369 #define CE_Overflow_Check_Failed 10
kono
parents:
diff changeset
370 #define CE_Partition_Check_Failed 11
kono
parents:
diff changeset
371 #define CE_Range_Check_Failed 12
kono
parents:
diff changeset
372 #define CE_Tag_Check_Failed 13
kono
parents:
diff changeset
373
kono
parents:
diff changeset
374 #define PE_Access_Before_Elaboration 14
kono
parents:
diff changeset
375 #define PE_Accessibility_Check_Failed 15
kono
parents:
diff changeset
376 #define PE_Address_Of_Intrinsic 16
kono
parents:
diff changeset
377 #define PE_Aliased_Parameters 17
kono
parents:
diff changeset
378 #define PE_All_Guards_Closed 18
kono
parents:
diff changeset
379 #define PE_Bad_Predicated_Generic_Type 19
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
380 #define PE_Build_In_Place_Mismatch 37
111
kono
parents:
diff changeset
381 #define PE_Current_Task_In_Entry_Body 20
kono
parents:
diff changeset
382 #define PE_Duplicated_Entry_Address 21
kono
parents:
diff changeset
383 #define PE_Explicit_Raise 22
kono
parents:
diff changeset
384 #define PE_Finalize_Raised_Exception 23
kono
parents:
diff changeset
385 #define PE_Implicit_Return 24
kono
parents:
diff changeset
386 #define PE_Misaligned_Address_Value 25
kono
parents:
diff changeset
387 #define PE_Missing_Return 26
kono
parents:
diff changeset
388 #define PE_Non_Transportable_Actual 31
kono
parents:
diff changeset
389 #define PE_Overlaid_Controlled_Object 27
kono
parents:
diff changeset
390 #define PE_Potentially_Blocking_Operation 28
kono
parents:
diff changeset
391 #define PE_Stream_Operation_Not_Allowed 36
kono
parents:
diff changeset
392 #define PE_Stubbed_Subprogram_Called 29
kono
parents:
diff changeset
393 #define PE_Unchecked_Union_Restriction 30
kono
parents:
diff changeset
394
kono
parents:
diff changeset
395 #define SE_Empty_Storage_Pool 32
kono
parents:
diff changeset
396 #define SE_Explicit_Raise 33
kono
parents:
diff changeset
397 #define SE_Infinite_Recursion 34
kono
parents:
diff changeset
398 #define SE_Object_Too_Large 35
kono
parents:
diff changeset
399
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
400 #define LAST_REASON_CODE 37