annotate gcc/ada/types.h @ 111:04ced10e8804

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