]>
Commit | Line | Data |
---|---|---|
996ae0b0 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT COMPILER COMPONENTS -- | |
4 | -- -- | |
5 | -- S I N F O -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
fbf5a39b | 9 | -- Copyright (C) 1992-2003, Free Software Foundation, Inc. -- |
996ae0b0 RK |
10 | -- -- |
11 | -- GNAT is free software; you can redistribute it and/or modify it under -- | |
12 | -- terms of the GNU General Public License as published by the Free Soft- -- | |
13 | -- ware Foundation; either version 2, or (at your option) any later ver- -- | |
14 | -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
15 | -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |
16 | -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- | |
17 | -- for more details. You should have received a copy of the GNU General -- | |
18 | -- Public License distributed with GNAT; see file COPYING. If not, write -- | |
19 | -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -- | |
20 | -- MA 02111-1307, USA. -- | |
21 | -- -- | |
22 | -- As a special exception, if other files instantiate generics from this -- | |
23 | -- unit, or you link this unit with other files to produce an executable, -- | |
24 | -- this unit does not by itself cause the resulting executable to be -- | |
25 | -- covered by the GNU General Public License. This exception does not -- | |
26 | -- however invalidate any other reasons why the executable file might be -- | |
27 | -- covered by the GNU Public License. -- | |
28 | -- -- | |
29 | -- GNAT was originally developed by the GNAT team at New York University. -- | |
71ff80dc | 30 | -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
996ae0b0 RK |
31 | -- -- |
32 | ------------------------------------------------------------------------------ | |
33 | ||
34 | -- This package defines the structure of the abstract syntax tree. The Tree | |
35 | -- package provides a basic tree structure. Sinfo describes how this | |
36 | -- structure is used to represent the syntax of an Ada program. | |
37 | ||
38 | -- Note: the grammar used here is taken from Version 5.95 of the RM, dated | |
39 | -- November 1994. The grammar in the RM is followed very closely in the tree | |
40 | -- design, and is repeated as part of this source file. | |
41 | ||
42 | -- The tree contains not only the full syntactic representation of the | |
43 | -- program, but also the results of semantic analysis. In particular, the | |
44 | -- nodes for defining identifiers, defining character literals and defining | |
45 | -- operator symbols, collectively referred to as entities, represent what | |
46 | -- would normally be regarded as the symbol table information. In addition | |
47 | -- a number of the tree nodes contain semantic information. | |
48 | ||
49 | -- WARNING: There is a C version of this package. Any changes to this | |
50 | -- source file must be properly reflected in this C header file sinfo.h | |
51 | -- which is created automatically from sinfo.ads using xsinfo.spt. | |
52 | ||
53 | with Types; use Types; | |
54 | with Uintp; use Uintp; | |
55 | with Urealp; use Urealp; | |
56 | ||
57 | package Sinfo is | |
58 | ||
59 | --------------------------------- | |
60 | -- Making Changes to This File -- | |
61 | --------------------------------- | |
62 | ||
63 | -- If changes are made to this file, a number of related steps must be | |
64 | -- carried out to ensure consistency. First, if a field access function | |
65 | -- is added, it appears in seven places: | |
66 | ||
67 | -- The documentation associated with the node | |
68 | -- The spec of the access function in sinfo.ads | |
69 | -- The body of the access function in sinfo.adb | |
70 | -- The pragma Inline at the end of sinfo.ads for the access function | |
71 | -- The spec of the set procedure in sinfo.ads | |
72 | -- The body of the set procedure in sinfo.adb | |
73 | -- The pragma Inline at the end of sinfo.ads for the set procedure | |
74 | ||
75 | -- The field chosen must be consistent in all places, and, for a node | |
76 | -- that is a subexpression, must not overlap any of the standard | |
fbf5a39b | 77 | -- expression fields. |
996ae0b0 RK |
78 | |
79 | -- In addition, if any of the standard expression fields is changed, then | |
80 | -- the utiliy program which creates the Treeprs spec (in file treeprs.ads) | |
81 | -- must be updated appropriately, since it special cases expression fields. | |
82 | ||
83 | -- If a new tree node is added, then the following changes are made | |
84 | ||
85 | -- Add it to the documentation in the appropriate place | |
86 | -- Add its fields to this documentation section | |
87 | -- Define it in the appropriate classification in Node_Kind | |
fbf5a39b AC |
88 | -- In the body (sinfo), add entries to the access functions for all |
89 | -- its fields (except standard expression fields) to include the new | |
90 | -- node in the checks. | |
996ae0b0 RK |
91 | -- Add an appropriate section to the case statement in sprint.adb |
92 | -- Add an appropriate section to the case statement in sem.adb | |
93 | -- Add an appropraite section to the case statement in exp_util.adb | |
94 | -- (Insert_Actions procedure) | |
95 | -- For a subexpression, add an appropriate sections to the case | |
96 | -- statement in sem_eval.adb | |
97 | -- For a subexpression, add an appropriate sections to the case | |
98 | -- statement in sem_res.adb | |
99 | ||
100 | -- Finally, four utility programs must be run: | |
101 | ||
102 | -- Run CSinfo to check that you have made the changes consistently. | |
103 | -- It checks most of the rules given above, with clear error messages. | |
104 | -- This utility reads sinfo.ads and sinfo.adb and generates a report | |
105 | -- to standard output. | |
106 | ||
107 | -- Run XSinfo to create a-sinfo.h, the corresponding C header. This | |
108 | -- utility reads sinfo.ads and generates a-sinfo.h. Note that it | |
109 | -- does not need to read sinfo.adb, since the contents of the body | |
110 | -- are algorithmically determinable from the spec. | |
111 | ||
112 | -- Run XTreeprs to create treeprs.ads, an updated version of | |
113 | -- the module that is used to drive the tree print routine. This | |
114 | -- utility reads (but does not modify) treeprs.adt, the template | |
115 | -- that provides the basic structure of the file, and then fills | |
116 | -- in the data from the comments in sinfo.ads. | |
117 | ||
118 | -- Run XNmake to create nmake.ads and nmake.adb, the package body | |
119 | -- and spec of the Nmake package which contains functions for | |
120 | -- constructing nodes. | |
121 | ||
122 | -- Note: sometime we could write a utility that actually generated the | |
123 | -- body of sinfo from the spec instead of simply checking it, since, as | |
124 | -- noted above, the contents of the body can be determined from the spec. | |
125 | ||
126 | -------------------------------- | |
127 | -- Implicit Nodes in the Tree -- | |
128 | -------------------------------- | |
129 | ||
130 | -- Generally the structure of the tree very closely follows the grammar | |
131 | -- as defined in the RM. However, certain nodes are omitted to save | |
132 | -- space and simplify semantic processing. Two general classes of such | |
133 | -- omitted nodes are as follows: | |
134 | ||
135 | -- If the only possibilities for a non-terminal are one or more other | |
136 | -- non terminals (i.e. the rule is a "skinny" rule), then usually the | |
137 | -- corresponding node is omitted from the tree, and the target construct | |
138 | -- appears directly. For example, a real type definition is either a | |
139 | -- floating point definition or a fixed point definition. No explicit | |
140 | -- node appears for real type definition. Instead either the floating | |
141 | -- point definition or fixed point definition appears directly. | |
142 | ||
143 | -- If a non-terminal corresponds to a list of some other non-terminal | |
144 | -- (possibly with separating punctuation), then usually it is omitted | |
145 | -- from the tree, and a list of components appears instead. For | |
146 | -- example, sequence of statements does not appear explicitly in the | |
147 | -- tree. Instead a list of statements appears directly. | |
148 | ||
149 | -- Some additional cases of omitted nodes occur and are documented | |
150 | -- individually. In particular, many nodes are omitted in the tree | |
151 | -- generated for an expression. | |
152 | ||
153 | ------------------------------------------- | |
154 | -- Handling of Defining Identifier Lists -- | |
155 | ------------------------------------------- | |
156 | ||
157 | -- In several declarative forms in the syntax, lists of defining | |
158 | -- identifiers appear (object declarations, component declarations, | |
159 | -- number declarations etc.) | |
160 | ||
161 | -- The semantics of such statements are equivalent to a series of | |
162 | -- identical declarations of single defining identifiers (except that | |
163 | -- conformance checks require the same grouping of identifiers in the | |
164 | -- parameter case). | |
165 | ||
166 | -- To simplify semantic processing, the parser breaks down such multiple | |
167 | -- declaration cases into sequences of single declarations, duplicating | |
168 | -- type and initialization information as required. The flags More_Ids | |
169 | -- and Prev_Ids are used to record the original form of the source in | |
170 | -- the case where the original source used a list of names, More_Ids | |
171 | -- being set on all but the last name and Prev_Ids being set on all | |
172 | -- but the first name. These flags are used to reconstruct the original | |
173 | -- source (e.g. in the Sprint package), and also are included in the | |
174 | -- conformance checks, but otherwise have no semantic significance. | |
175 | ||
176 | -- Note: the reason that we use More_Ids and Prev_Ids rather than | |
177 | -- First_Name and Last_Name flags is so that the flags are off in the | |
178 | -- normal one identifier case, which minimizes tree print output. | |
179 | ||
180 | ----------------------- | |
181 | -- Use of Node Lists -- | |
182 | ----------------------- | |
183 | ||
184 | -- With a few exceptions, if a construction of the form {non-terminal} | |
185 | -- appears in the tree, lists are used in the corresponding tree node | |
186 | -- (see package Nlists for handling of node lists). In this case a field | |
187 | -- of the parent node points to a list of nodes for the non-terminal. The | |
188 | -- field name for such fields has a plural name which always ends in "s". | |
189 | -- For example, a case statement has a field Alternatives pointing to a | |
190 | -- list of case statement alternative nodes. | |
191 | ||
192 | -- Only fields pointing to lists have names ending in "s", so generally | |
193 | -- the structure is strongly typed, fields not ending in s point to | |
194 | -- single nodes, and fields ending in s point to lists. | |
195 | ||
196 | -- The following example shows how a traversal of a list is written. We | |
197 | -- suppose here that Stmt points to a N_Case_Statement node which has | |
198 | -- a list field called Alternatives: | |
199 | ||
200 | -- Alt := First (Alternatives (Stmt)); | |
201 | -- while Present (Alt) loop | |
202 | -- .. | |
203 | -- -- processing for case statement alternative Alt | |
204 | -- .. | |
205 | -- Alt := Next (Alt); | |
206 | -- end loop; | |
207 | ||
208 | -- The Present function tests for Empty, which in this case signals the | |
209 | -- end of the list. First returns Empty immediately if the list is empty. | |
210 | -- Present is defined in Atree, First and Next are defined in Nlists. | |
211 | ||
212 | -- The exceptions to this rule occur with {DEFINING_IDENTIFIERS} in all | |
213 | -- contexts, which is handled as described in the previous section, and | |
214 | -- with {,library_unit_NAME} in the N_With_Clause mode, which is handled | |
215 | -- using the First_Name and Last_Name flags, as further detailed in the | |
216 | -- description of the N_With_Clause node. | |
217 | ||
218 | ------------- | |
219 | -- Pragmas -- | |
220 | ------------- | |
221 | ||
222 | -- Pragmas can appear in many different context, but are not included | |
223 | -- in the grammar. Still they must appear in the tree, so they can be | |
224 | -- properly processed. | |
225 | ||
226 | -- Two approaches are used. In some cases, an extra field is defined | |
227 | -- in an appropriate node that contains a list of pragmas appearing | |
228 | -- in the expected context. For example pragmas can appear before an | |
229 | -- Accept_Alternative in a Selective_Accept_Statement, and these pragmas | |
230 | -- appear in the Pragmas_Before field of the N_Accept_Alternative node. | |
231 | ||
232 | -- The other approach is to simply allow pragmas to appear in syntactic | |
233 | -- lists where the grammar (of course) does not include the possibility. | |
234 | -- For example, the Variants field of an N_Variant_Part node points to | |
235 | -- a list that can contain both N_Pragma and N_Variant nodes. | |
236 | ||
237 | -- To make processing easier in the latter case, the Nlists package | |
238 | -- provides a set of routines (First_Non_Pragma, Last_Non_Pragma, | |
239 | -- Next_Non_Pragma, Prev_Non_Pragma) that allow such lists to be | |
240 | -- handled ignoring all pragmas. | |
241 | ||
242 | -- In the case of the variants list, we can either write: | |
243 | ||
244 | -- Variant := First (Variants (N)); | |
245 | -- while Present (Variant) loop | |
246 | -- ... | |
247 | -- Alt := Next (Alt); | |
248 | -- end loop; | |
249 | ||
250 | -- or | |
251 | ||
252 | -- Variant := First_Non_Pragma (Variants (N)); | |
253 | -- while Present (Variant) loop | |
254 | -- ... | |
255 | -- Alt := Next_Non_Pragma (Alt); | |
256 | -- end loop; | |
257 | ||
258 | -- In the first form of the loop, Variant can either be an N_Pragma or | |
259 | -- an N_Variant node. In the second form, Variant can only be N_Variant | |
260 | -- since all pragmas are skipped. | |
261 | ||
262 | --------------------- | |
263 | -- Optional Fields -- | |
264 | --------------------- | |
265 | ||
266 | -- Fields which correspond to a section of the syntax enclosed in square | |
267 | -- brackets are generally omitted (and the corresponding field set to | |
268 | -- Empty for a node, or No_List for a list). The documentation of such | |
269 | -- fields notes these cases. One exception to this rule occurs in the | |
270 | -- case of possibly empty statement sequences (such as the sequence of | |
271 | -- statements in an entry call alternative). Such cases appear in the | |
272 | -- syntax rules as [SEQUENCE_OF_STATEMENTS] and the fields corresponding | |
273 | -- to such optional statement sequences always contain an empty list (not | |
274 | -- No_List) if no statements are present. | |
275 | ||
276 | -- Note: the utility program that constructs the body and spec of the | |
277 | -- Nmake package relies on the format of the comments to determine if | |
278 | -- a field should have a default value in the corresponding make routine. | |
279 | -- The rule is that if the first line of the description of the field | |
280 | -- contains the string "(set to xxx if", then a default value of xxx is | |
281 | -- provided for this field in the corresponding Make_yyy routine. | |
282 | ||
283 | ----------------------------------- | |
284 | -- Note on Body/Spec Terminology -- | |
285 | ----------------------------------- | |
286 | ||
287 | -- In informal discussions about Ada, it is customary to refer to package | |
288 | -- and subprogram specs and bodies. However, this is not technically | |
289 | -- correct, what is normally referred to as a spec or specification is in | |
290 | -- fact a package declaration or subprogram declaration. We are careful | |
291 | -- in GNAT to use the correct terminology and in particular, the full | |
292 | -- word specification is never used as an incorrect substitute for | |
293 | -- declaration. The structure and terminology used in the tree also | |
294 | -- reflects the grammar and thus uses declaration and specification in | |
295 | -- the technically correct manner. | |
296 | ||
297 | -- However, there are contexts in which the informal terminology is | |
298 | -- useful. We have the word "body" to refer to the Interp_Etype declared by | |
299 | -- the declaration of a unit body, and in some contexts we need a | |
300 | -- similar term to refer to the entity declared by the package or | |
301 | -- subprogram declaration, and simply using declaration can be confusing | |
302 | -- since the body also has a declaration. | |
303 | ||
304 | -- An example of such a context is the link between the package body | |
305 | -- and its declaration. With_Declaration is confusing, since | |
306 | -- the package body itself is a declaration. | |
307 | ||
308 | -- To deal with this problem, we reserve the informal term Spec, i.e. | |
309 | -- the popular abbreviation used in this context, to refer to the entity | |
310 | -- declared by the package or subprogram declaration. So in the above | |
311 | -- example case, the field in the body is called With_Spec. | |
312 | ||
313 | -- Another important context for the use of the word Spec is in error | |
314 | -- messages, where a hyper-correct use of declaration would be confusing | |
315 | -- to a typical Ada programmer, and even for an expert programmer can | |
316 | -- cause confusion since the body has a declaration as well. | |
317 | ||
318 | -- So, to summarize: | |
319 | ||
320 | -- Declaration always refers to the syntactic entity that is called | |
321 | -- a declaration. In particular, subprogram declaration | |
322 | -- and package declaration are used to describe the | |
323 | -- syntactic entity that includes the semicolon. | |
324 | ||
325 | -- Specification always refers to the syntactic entity that is called | |
326 | -- a specification. In particular, the terms procedure | |
327 | -- specification, function specification, package | |
328 | -- specification, subprogram specification always refer | |
329 | -- to the syntactic entity that has no semicolon. | |
330 | ||
331 | -- Spec is an informal term, used to refer to the entity | |
332 | -- that is declared by a task declaration, protected | |
333 | -- declaration, generic declaration, subprogram | |
334 | -- declaration or package declaration. | |
335 | ||
336 | -- This convention is followed throughout the GNAT documentation | |
337 | -- both internal and external, and in all error message text. | |
338 | ||
339 | ------------------------ | |
340 | -- Internal Use Nodes -- | |
341 | ------------------------ | |
342 | ||
343 | -- These are Node_Kind settings used in the internal implementation | |
344 | -- which are not logically part of the specification. | |
345 | ||
346 | -- N_Unused_At_Start | |
347 | -- Completely unused entry at the start of the enumeration type. This | |
348 | -- is inserted so that no legitimate value is zero, which helps to get | |
349 | -- better debugging behavior, since zero is a likely uninitialized value). | |
350 | ||
351 | -- N_Unused_At_End | |
352 | -- Completely unused entry at the end of the enumeration type. This is | |
353 | -- handy so that arrays with Node_Kind as the index type have an extra | |
354 | -- entry at the end (see for example the use of the Pchar_Pos_Array in | |
355 | -- Treepr, where the extra entry provides the limit value when dealing | |
356 | -- with the last used entry in the array). | |
357 | ||
358 | ----------------------------------------- | |
359 | -- Note on the settings of Sloc fields -- | |
360 | ----------------------------------------- | |
361 | ||
362 | -- The Sloc field of nodes that come from the source is set by the | |
363 | -- parser. For internal nodes, and nodes generated during expansion | |
364 | -- the Sloc is usually set in the call to the constructor for the node. | |
365 | -- In general the Sloc value chosen for an internal node is the Sloc of | |
366 | -- the source node whose processing is responsible for the expansion. For | |
367 | -- example, the Sloc of an inherited primitive operation is the Sloc of | |
368 | -- the corresponding derived type declaration. | |
369 | ||
370 | -- For the nodes of a generic instantiation, the Sloc value is encoded | |
371 | -- to represent both the original Sloc in the generic unit, and the Sloc | |
372 | -- of the instantiation itself. See Sinput.ads for details. | |
373 | ||
374 | -- Subprogram instances create two callable entities: one is the visible | |
375 | -- subprogram instance, and the other is an anonymous subprogram nested | |
376 | -- within a wrapper package that contains the renamings for the actuals. | |
377 | -- Both of these entities have the Sloc of the defining entity in the | |
378 | -- instantiation node. This simplifies some ASIS queries. | |
379 | ||
380 | ----------------------- | |
381 | -- Field Definitions -- | |
382 | ----------------------- | |
383 | ||
384 | -- In the following node definitions, all fields, both syntactic and | |
385 | -- semantic, are documented. The one exception is in the case of entities | |
07fc65c4 | 386 | -- (defining indentifiers, character literals and operator symbols), |
996ae0b0 RK |
387 | -- where the usage of the fields depends on the entity kind. Entity |
388 | -- fields are fully documented in the separate package Einfo. | |
389 | ||
390 | -- In the node definitions, three common sets of fields are abbreviated | |
391 | -- to save both space in the documentation, and also space in the string | |
392 | -- (defined in Tree_Print_Strings) used to print trees. The following | |
393 | -- abbreviations are used: | |
394 | ||
395 | -- Note: the utility program that creates the Treeprs spec (in the file | |
396 | -- treeprs.ads) knows about the special fields here, so it must be | |
397 | -- modified if any change is made to these fields. | |
398 | ||
399 | -- "plus fields for binary operator" | |
400 | -- Chars (Name1) Name_Id for the operator | |
401 | -- Left_Opnd (Node2) left operand expression | |
402 | -- Right_Opnd (Node3) right operand expression | |
403 | -- Entity (Node4-Sem) defining entity for operator | |
3e542a58 | 404 | -- Associated_Node (Node4-Sem) for generic processing |
996ae0b0 RK |
405 | -- Do_Overflow_Check (Flag17-Sem) set if overflow check needed |
406 | -- Has_Private_View (Flag11-Sem) set in generic units. | |
407 | ||
408 | -- "plus fields for unary operator" | |
409 | -- Chars (Name1) Name_Id for the operator | |
410 | -- Right_Opnd (Node3) right operand expression | |
411 | -- Entity (Node4-Sem) defining entity for operator | |
3e542a58 | 412 | -- Associated_Node (Node4-Sem) for generic processing |
996ae0b0 RK |
413 | -- Do_Overflow_Check (Flag17-Sem) set if overflow check needed |
414 | -- Has_Private_View (Flag11-Sem) set in generic units. | |
415 | ||
416 | -- "plus fields for expression" | |
417 | -- Paren_Count number of parentheses levels | |
418 | -- Etype (Node5-Sem) type of the expression | |
419 | -- Is_Overloaded (Flag5-Sem) >1 type interpretation exists | |
420 | -- Is_Static_Expression (Flag6-Sem) set for static expression | |
421 | -- Raises_Constraint_Error (Flag7-Sem) evaluation raises CE | |
422 | -- Must_Not_Freeze (Flag8-Sem) set if must not freeze | |
423 | -- Do_Range_Check (Flag9-Sem) set if a range check needed | |
424 | -- Assignment_OK (Flag15-Sem) set if modification is OK | |
425 | -- Is_Controlling_Actual (Flag16-Sem) set for controlling argument | |
426 | ||
427 | -- Note: see under (EXPRESSION) for further details on the use of | |
428 | -- the Paren_Count field to record the number of parentheses levels. | |
429 | ||
430 | -- Node_Kind is the type used in the Nkind field to indicate the node | |
431 | -- kind. The actual definition of this type is given later (the reason | |
432 | -- for this is that we want the descriptions ordered by logical chapter | |
433 | -- in the RM, but the type definition is reordered to facilitate the | |
434 | -- definition of some subtype ranges. The individual descriptions of | |
435 | -- the nodes show how the various fields are used in each node kind, | |
436 | -- as well as providing logical names for the fields. Functions and | |
437 | -- procedures are provided for accessing and setting these fields | |
438 | -- using these logical names. | |
439 | ||
440 | ----------------------- | |
441 | -- Gigi Restrictions -- | |
442 | ----------------------- | |
443 | ||
444 | -- The tree passed to Gigi is more restricted than the general tree form. | |
445 | -- For example, as a result of expansion, most of the tasking nodes can | |
446 | -- never appear. For each node to which either a complete or partial | |
447 | -- restriction applies, a note entitled "Gigi restriction" appears which | |
448 | -- documents the restriction. | |
449 | ||
450 | -- Note that most of these restrictions apply only to trees generated when | |
451 | -- code is being generated, since they involved expander actions that | |
452 | -- destroy the tree. | |
453 | ||
454 | ------------------------ | |
455 | -- Common Flag Fields -- | |
456 | ------------------------ | |
457 | ||
458 | -- The following flag fields appear in all nodes | |
459 | ||
460 | -- Analyzed | |
461 | -- This flag is used to indicate that a node (and all its children | |
462 | -- have been analyzed. It is used to avoid reanalysis of a node that | |
463 | -- has already been analyzed, both for efficiency and functional | |
464 | -- correctness reasons. | |
465 | ||
466 | -- Error_Posted | |
467 | -- This flag is used to avoid multiple error messages being posted | |
468 | -- on or referring to the same node. This flag is set if an error | |
469 | -- message refers to a node or is posted on its source location, | |
470 | -- and has the effect of inhibiting further messages involving | |
471 | -- this same node. | |
472 | ||
473 | -- Comes_From_Source | |
474 | -- This flag is on for any nodes built by the scanner or parser from | |
475 | -- the source program, and off for any nodes built by the analyzer or | |
476 | -- expander. It indicates that a node comes from the original source. | |
477 | -- This flag is defined in Atree. | |
478 | ||
479 | -- Has_Dynamic_Length_Check and Has_Dynamic_Range_Check also appear on | |
480 | -- all nodes. They are fully described in the next section. | |
481 | ||
482 | ------------------------------------ | |
483 | -- Description of Semantic Fields -- | |
484 | ------------------------------------ | |
485 | ||
486 | -- The meaning of the syntactic fields is generally clear from their | |
487 | -- names without any further description, since the names are chosen | |
488 | -- to correspond very closely to the syntax in the reference manual. | |
489 | -- This section describes the usage of the semantic fields, which are | |
490 | -- used to contain additional information determined during semantic | |
491 | -- analysis. | |
492 | ||
493 | -- ABE_Is_Certain (Flag18-Sem) | |
494 | -- This flag is set in an instantiation node or a call node is | |
495 | -- determined to be sure to raise an ABE. This is used to trigger | |
496 | -- special handling of such cases, particularly in the instantiation | |
497 | -- case where we avoid instantiating the body if this flag is set. | |
498 | -- This flag is also present in an N_Formal_Package_Declaration_Node | |
499 | -- since formal package declarations are treated like instantiations, | |
500 | -- but it is always set to False in this context. | |
501 | ||
502 | -- Accept_Handler_Records (List5-Sem) | |
503 | -- This field is present only in an N_Accept_Alternative node. It is | |
504 | -- used to temporarily hold the exception handler records from an | |
505 | -- accept statement in a selective accept. These exception handlers | |
506 | -- will eventually be placed in the Handler_Records list of the | |
507 | -- procedure built for this accept (see Expand_N_Selective_Accept | |
508 | -- procedure in Exp_Ch9 for further details). | |
509 | ||
510 | -- Access_Types_To_Process (Elist2-Sem) | |
511 | -- Present in N_Freeze_Entity nodes for Incomplete or private types. | |
512 | -- Contains the list of access types which may require specific | |
513 | -- treatment when the nature of the type completion is completely | |
514 | -- known. An example of such treatement is the generation of the | |
515 | -- associated_final_chain. | |
516 | ||
517 | -- Actions (List1-Sem) | |
518 | -- This field contains a sequence of actions that are associated | |
519 | -- with the node holding the field. See the individual node types | |
520 | -- for details of how this field is used, as well as the description | |
521 | -- of the specific use for a particular node type. | |
522 | ||
523 | -- Activation_Chain_Entity (Node3-Sem) | |
524 | -- This is used in tree nodes representing task activators (blocks, | |
525 | -- subprogram bodies, package declarations, and task bodies). It is | |
526 | -- initially Empty, and then gets set to point to the entity for the | |
527 | -- declared Activation_Chain variable when the first task is declared. | |
528 | -- When tasks are declared in the corresponding declarative region | |
529 | -- this entity is located by name (its name is always _Chain) and | |
530 | -- the declared tasks are added to the chain. | |
531 | ||
532 | -- Acts_As_Spec (Flag4-Sem) | |
533 | -- A flag set in the N_Subprogram_Body node for a subprogram body | |
534 | -- which is acting as its own spec. This flag also appears in the | |
535 | -- compilation unit node at the library level for such a subprogram | |
536 | -- (see further description in spec of Lib package). | |
537 | ||
538 | -- Aggregate_Bounds (Node3-Sem) | |
539 | -- Present in array N_Aggregate nodes. If the aggregate contains | |
540 | -- component associations this field points to an N_Range node whose | |
541 | -- bounds give the lowest and highest discrete choice values. If the | |
542 | -- named aggregate contains a dynamic or null choice this field is | |
543 | -- empty. If the aggregate contains positional elements this field | |
544 | -- points to an N_Integer_Literal node giving the number of positional | |
545 | -- elements. Note that if the aggregate contains positional elements | |
546 | -- and an other choice the N_Integer_Literal only accounts for the | |
547 | -- number of positional elements. | |
548 | ||
549 | -- All_Others (Flag11-Sem) | |
550 | -- Present in an N_Others_Choice node. This flag is set in the case | |
07fc65c4 GB |
551 | -- of an others exception where all exceptions are to be caught, even |
552 | -- those that are not normally handled (in particular the tasking abort | |
553 | -- signal). This is used for translation of the at end handler into | |
996ae0b0 RK |
554 | -- a normal exception handler. |
555 | ||
556 | -- Assignment_OK (Flag15-Sem) | |
557 | -- This flag is set in a subexpression node for an object, indicating | |
558 | -- that the associated object can be modified, even if this would not | |
559 | -- normally be permissible (either by direct assignment, or by being | |
560 | -- passed as an out or in-out parameter). This is used by the expander | |
561 | -- for a number of purposes, including initialzation of constants and | |
562 | -- limited type objects (such as tasks), setting discriminant fields, | |
563 | -- setting tag values, etc. N_Object_Declaration nodes also have this | |
564 | -- flag defined. Here it is used to indicate that an initialization | |
565 | -- expression is valid, even where it would normally not be allowed | |
566 | -- (e.g. where the type involved is limited). | |
567 | ||
3e542a58 RD |
568 | -- Associated_Node (Node4-Sem) |
569 | -- Present in nodes that can denote an entity: identifiers, character | |
3b9a13c4 RD |
570 | -- literals, operator symbols, expanded names, operator nodes and |
571 | -- attribute reference nodes (all these nodes have an Entity field). | |
572 | -- This field is also present in N_Aggregate, N_Selected_Component, | |
573 | -- and N_Extension_Aggregate nodes. This field is used during generic | |
3e542a58 RD |
574 | -- processing to relate nodes in the original template to nodes in the |
575 | -- generic copy. It overlaps the Entity field, and is used to capture | |
576 | -- global references in the analyzed copy and place them in the template. | |
3b9a13c4 | 577 | -- See description in Sem_Ch12 for further details on this usage. |
3e542a58 | 578 | |
996ae0b0 RK |
579 | -- At_End_Proc (Node1) |
580 | -- This field is present in an N_Handled_Sequence_Of_Statements node. | |
581 | -- It contains an identifier reference for the cleanup procedure to | |
582 | -- be called. See description of this node for further details. | |
583 | ||
584 | -- Backwards_OK (Flag6-Sem) | |
585 | -- A flag present in the N_Assignment_Statement node. It is used only | |
586 | -- if the type being assigned is an array type, and is set if analysis | |
587 | -- determines that it is definitely safe to do the copy backwards, i.e. | |
588 | -- starting at the highest addressed element. Note that if neither of | |
589 | -- the flags Forwards_OK or Backwards_OK is set, it means that the | |
590 | -- front end could not determine that either direction is definitely | |
591 | -- safe, and a runtime check is required. | |
592 | ||
593 | -- Body_To_Inline (Node3-Sem) | |
594 | -- present in subprogram declarations. Denotes analyzed but unexpanded | |
595 | -- body of subprogram, to be used when inlining calls. Present when the | |
596 | -- subprogram has an Inline pragma and inlining is enabled. If the | |
597 | -- declaration is completed by a renaming_as_body, and the renamed en- | |
598 | -- tity is a subprogram, the Body_To_Inline is the name of that entity, | |
599 | -- which is used directly in later calls to the original subprogram. | |
600 | ||
601 | -- Body_Required (Flag13-Sem) | |
602 | -- A flag that appears in the N_Compilation_Unit node indicating that | |
603 | -- the corresponding unit requires a body. For the package case, this | |
604 | -- indicates that a completion is required. In Ada 95, if the flag | |
605 | -- is not set for the package case, then a body may not be present. | |
606 | -- In Ada 83, if the flag is not set for the package case, then a | |
607 | -- body is optional. For a subprogram declaration, the flag is set | |
608 | -- except in the case where a pragma Import or Interface applies, | |
609 | -- in which case no body is permitted (in Ada 83 or Ada 95). | |
610 | ||
611 | -- By_Ref (Flag5-Sem) | |
612 | -- A flag present in the N_Return_Statement_Node. It is set when the | |
613 | -- returned expression is already allocated on the secondary stack | |
614 | -- and thus the result is passed by reference rather than copied | |
615 | -- another time. | |
616 | ||
fbf5a39b AC |
617 | -- Check_Address_Alignment (Flag11-Sem) |
618 | -- A flag present in N_Attribute_Definition clause for a 'Address | |
619 | -- attribute definition. This flag is set if a dynamic check should | |
620 | -- be generated at the freeze point for the entity to which this | |
621 | -- address clause applies. The reason that we need this flag is that | |
622 | -- we want to check for range checks being suppressed at the point | |
623 | -- where the attribute definition clause is given, rather than | |
624 | -- testing this at the freeze point. | |
625 | ||
996ae0b0 RK |
626 | -- Compile_Time_Known_Aggregate (Flag18-Sem) |
627 | -- Present in N_Aggregate nodes. Set for aggregates which can be | |
628 | -- fully evaluated at compile time without raising constraint error. | |
629 | -- Such aggregates can be passed as is to Gigi without any expansion. | |
630 | -- See Sem_Aggr for the specific conditions under which an aggregate | |
631 | -- has this flag set. See also the flag Static_Processing_OK. | |
632 | ||
633 | -- Condition_Actions (List3-Sem) | |
634 | -- This field appears in else-if nodes and in the iteration scheme | |
635 | -- node for while loops. This field is only used during semantic | |
636 | -- processing to temporarily hold actions inserted into the tree. | |
637 | -- In the tree passed to gigi, the condition actions field is always | |
638 | -- set to No_List. For details on how this field is used, see the | |
639 | -- routine Insert_Actions in package Exp_Util, and also the expansion | |
640 | -- routines for the relevant nodes. | |
641 | ||
642 | -- Controlling_Argument (Node1-Sem) | |
643 | -- This field is set in procedure and function call nodes if the call | |
644 | -- is a dispatching call (it is Empty for a non-dispatching call). | |
645 | -- It indicates the source of the controlling tag for the call. For | |
646 | -- Procedure calls, the Controlling_Argument is one of the actuals. | |
647 | -- For a function that has a dispatching result, it is an entity in | |
648 | -- the context of the call that can provide a tag, or else it is the | |
649 | -- tag of the root type of the class. | |
650 | ||
651 | -- Conversion_OK (Flag14-Sem) | |
652 | -- A flag set on type conversion nodes to indicate that the conversion | |
653 | -- is to be considered as being valid, even though it is the case that | |
654 | -- the conversion is not valid Ada. This is used for the Enum_Rep, | |
655 | -- Fixed_Value and Integer_Value attributes, for internal conversions | |
656 | -- done for fixed-point operations, and for certain conversions for | |
657 | -- calls to initialization procedures. If Conversion_OK is set, then | |
658 | -- Etype must be set (the analyzer assumes that Etype has been set). | |
659 | -- For the case of fixed-point operands, it also indicates that the | |
660 | -- conversion is to be a direct conversion of the underlying integer | |
661 | -- result, with no regard to the small operand. | |
662 | ||
663 | -- Corresponding_Body (Node5-Sem) | |
fbf5a39b AC |
664 | -- This field is set in subprogram declarations, package declarations, |
665 | -- entry declarations of protected types, and in generic units. It | |
666 | -- points to the defining entity for the corresponding body (NOT the | |
667 | -- node for the body itself). | |
996ae0b0 RK |
668 | |
669 | -- Corresponding_Generic_Association (Node5-Sem) | |
670 | -- This field is defined for object declarations and object renaming | |
671 | -- declarations. It is set for the declarations within an instance that | |
672 | -- map generic formals to their actuals. If set, the field points to | |
673 | -- a generic_association which is the original parent of the expression | |
674 | -- or name appearing in the declaration. This simplifies ASIS queries. | |
675 | ||
676 | -- Corresponding_Integer_Value (Uint4-Sem) | |
677 | -- This field is set in real literals of fixed-point types (it is not | |
678 | -- used for floating-point types). It contains the integer value used | |
679 | -- to represent the fixed-point value. It is also set on the universal | |
680 | -- real literals used to represent bounds of fixed-point base types | |
681 | -- and their first named subtypes. | |
682 | ||
683 | -- Corresponding_Spec (Node5-Sem) | |
684 | -- This field is set in subprogram, package, task, and protected body | |
685 | -- nodes, where it points to the defining entity in the corresponding | |
686 | -- spec. The attribute is also set in N_With_Clause nodes, where | |
687 | -- it points to the defining entity for the with'ed spec, and in | |
688 | -- a subprogram renaming declaration when it is a Renaming_As_Body. | |
689 | -- The field is Empty if there is no corresponding spec, as in the | |
690 | -- case of a subprogram body that serves as its own spec. | |
691 | ||
692 | -- Corresponding_Stub (Node3-Sem) | |
693 | -- This field is present in an N_Subunit node. It holds the node in | |
694 | -- the parent unit that is the stub declaration for the subunit. it is | |
695 | -- set when analysis of the stub forces loading of the proper body. If | |
696 | -- expansion of the proper body creates new declarative nodes, they are | |
697 | -- inserted at the point of the corresponding_stub. | |
698 | ||
699 | -- Dcheck_Function (Node5-Sem) | |
700 | -- This field is present in an N_Variant node, It references the entity | |
701 | -- for the discriminant checking function for the variant. | |
702 | ||
703 | -- Debug_Statement (Node3) | |
704 | -- This field is present in an N_Pragma node. It is used only for | |
705 | -- a Debug pragma or pragma Assert with a second parameter. The | |
706 | -- parameter is of the form of an expression, as required by the | |
707 | -- pragma syntax, but is actually a procedure call. To simplify | |
708 | -- semantic processing, the parser creates a copy of the argument | |
709 | -- rearranged into a procedure call statement and places it in the | |
710 | -- Debug_Statement field. Note that this field is considered a | |
711 | -- syntactic field, since it is created by the parser. | |
712 | ||
713 | -- Default_Expression (Node5-Sem) | |
714 | -- This field is Empty if there is no default expression. If there | |
715 | -- is a simple default expression (one with no side effects), then | |
716 | -- this field simply contains a copy of the Expression field (both | |
717 | -- point to the tree for the default expression). Default_Expression | |
718 | -- is used for conformance checking. | |
719 | ||
720 | -- Delay_Finalize_Attach (Flag14-Sem) | |
721 | -- This flag is present in an N_Object_Declaration node. If it is set, | |
722 | -- then in the case of a controlled type being declared and initialized, | |
723 | -- the normal code for attaching the result to the appropriate local | |
724 | -- finalization list is suppressed. This is used for functions that | |
725 | -- return controlled types without using the secondary stack, where | |
726 | -- it is the caller who must do the attachment. | |
727 | ||
728 | -- Discr_Check_Funcs_Built (Flag11-Sem) | |
729 | -- This flag is present in N_Full_Type_Declaration nodes. It is set when | |
730 | -- discriminant checking functions are constructed. The purpose is to | |
731 | -- avoid attempting to set these functions more than once. | |
732 | ||
996ae0b0 RK |
733 | -- Do_Accessibility_Check (Flag13-Sem) |
734 | -- This flag is set on N_Parameter_Specification nodes to indicate | |
735 | -- that an accessibility check is required for the parameter. It is | |
736 | -- not yet decided who takes care of this check (TBD ???). | |
737 | ||
738 | -- Do_Discriminant_Check (Flag13-Sem) | |
739 | -- This flag is set on N_Selected_Component nodes to indicate that a | |
740 | -- discriminant check is required using the discriminant check routine | |
fbf5a39b AC |
741 | -- associated with the selector. The actual check is generated by the |
742 | -- expander when processing selected components. | |
996ae0b0 RK |
743 | |
744 | -- Do_Division_Check (Flag13-Sem) | |
745 | -- This flag is set on a division operator (/ mod rem) to indicate | |
746 | -- that a zero divide check is required. The actual check is dealt | |
747 | -- with by the backend (all the front end does is to set the flag). | |
748 | ||
749 | -- Do_Length_Check (Flag4-Sem) | |
750 | -- This flag is set in an N_Assignment_Statement, N_Op_And, N_Op_Or, | |
751 | -- N_Op_Xor, or N_Type_Conversion node to indicate that a length check | |
752 | -- is required. It is not determined who deals with this flag (???). | |
753 | ||
754 | -- Do_Overflow_Check (Flag17-Sem) | |
755 | -- This flag is set on an operator where an overflow check is required | |
756 | -- on the operation. The actual check is dealt with by the backend | |
757 | -- (all the front end does is to set the flag). The other cases where | |
758 | -- this flag is used is on a Type_Conversion node and for attribute | |
759 | -- reference nodes. For a type conversion, it means that the conversion | |
760 | -- is from one base type to another, and the value may not fit in the | |
761 | -- target base type. See also the description of Do_Range_Check for | |
762 | -- this case. The only attribute references which use this flag are | |
763 | -- Pred and Succ, where it means that the result should be checked | |
764 | -- for going outside the base range. | |
765 | ||
766 | -- Do_Range_Check (Flag9-Sem) | |
767 | -- This flag is set on an expression which appears in a context where | |
768 | -- a range check is required. The target type is clear from the | |
769 | -- context. The contexts in which this flag can appear are limited to | |
770 | -- the following. | |
771 | ||
772 | -- Right side of an assignment. In this case the target type is | |
773 | -- taken from the left side of the assignment, which is referenced | |
774 | -- by the Name of the N_Assignment_Statement node. | |
775 | ||
776 | -- Subscript expressions in an indexed component. In this case the | |
777 | -- target type is determined from the type of the array, which is | |
778 | -- referenced by the Prefix of the N_Indexed_Component node. | |
779 | ||
780 | -- Argument expression for a parameter, appearing either directly | |
781 | -- in the Parameter_Associations list of a call or as the Expression | |
782 | -- of an N_Parameter_Association node that appears in this list. In | |
783 | -- either case, the check is against the type of the formal. Note | |
784 | -- that the flag is relevant only in IN and IN OUT parameters, and | |
785 | -- will be ignored for OUT parameters, where no check is required | |
786 | -- in the call, and if a check is required on the return, it is | |
787 | -- generated explicitly with a type conversion. | |
788 | ||
789 | -- Initialization expression for the initial value in an object | |
790 | -- declaration. In this case the Do_Range_Check flag is set on | |
791 | -- the initialization expression, and the check is against the | |
792 | -- range of the type of the object being declared. | |
793 | ||
794 | -- The expression of a type conversion. In this case the range check | |
795 | -- is against the target type of the conversion. See also the use of | |
796 | -- Do_Overflow_Check on a type conversion. The distinction is that | |
fbf5a39b | 797 | -- the overflow check protects against a value that is outside the |
996ae0b0 RK |
798 | -- range of the target base type, whereas a range check checks that |
799 | -- the resulting value (which is a value of the base type of the | |
800 | -- target type), satisfies the range constraint of the target type. | |
801 | ||
802 | -- Note: when a range check is required in contexts other than those | |
803 | -- listed above (e.g. in a return statement), an additional type | |
804 | -- conversion node is introduced to represent the required check. | |
805 | ||
806 | -- Do_Storage_Check (Flag17-Sem) | |
807 | -- This flag is set in an N_Allocator node to indicate that a storage | |
808 | -- check is required for the allocation, or in an N_Subprogram_Body | |
809 | -- node to indicate that a stack check is required in the subprogram | |
810 | -- prolog. The N_Allocator case is handled by the routine that expands | |
811 | -- the call to the runtime routine. The N_Subprogram_Body case is | |
812 | -- handled by the backend, and all the semantics does is set the flag. | |
813 | ||
814 | -- Do_Tag_Check (Flag13-Sem) | |
815 | -- This flag is set on an N_Assignment_Statement, N_Function_Call, | |
816 | -- N_Procedure_Call_Statement, N_Type_Conversion or N_Return_Statememt | |
817 | -- node to indicate that the tag check can be suppressed. It is not | |
818 | -- yet decided how this flag is used (TBD ???). | |
819 | ||
820 | -- Elaborate_Present (Flag4-Sem) | |
821 | -- This flag is set in the N_With_Clause node to indicate that a | |
822 | -- pragma Elaborate pragma appears for the with'ed units. | |
823 | ||
824 | -- Elaborate_All_Present (Flag15-Sem) | |
825 | -- This flag is set in the N_With_Clause node to indicate that a | |
826 | -- pragma Elaborate_All pragma appears for the with'ed units. | |
827 | ||
828 | -- Elaboration_Boolean (Node2-Sem) | |
829 | -- This field is present in function and procedure specification | |
830 | -- nodes. If set, it points to the entity for a Boolean flag that | |
831 | -- must be tested for certain calls to check for access before | |
832 | -- elaboration. See body of Sem_Elab for further details. This | |
833 | -- field is Empty if no elaboration boolean is required. | |
834 | ||
835 | -- Else_Actions (List3-Sem) | |
836 | -- This field is present in conditional expression nodes. During code | |
837 | -- expansion we use the Insert_Actions procedure (in Exp_Util) to insert | |
838 | -- actions at an appropriate place in the tree to get elaborated at the | |
839 | -- right time. For conditional expressions, we have to be sure that the | |
840 | -- actions for the Else branch are only elaborated if the condition is | |
841 | -- False. The Else_Actions field is used as a temporary parking place | |
842 | -- for these actions. The final tree is always rewritten to eliminate | |
843 | -- the need for this field, so in the tree passed to Gigi, this field | |
844 | -- is always set to No_List. | |
845 | ||
846 | -- Enclosing_Variant (Node2-Sem) | |
847 | -- This field is present in the N_Variant node and identifies the | |
848 | -- Node_Id corresponding to the immediately enclosing variant when | |
849 | -- the variant is nested, and N_Empty otherwise. Set during semantic | |
850 | -- processing of the variant part of a record type. | |
851 | ||
852 | -- Entity (Node4-Sem) | |
853 | -- Appears in all direct names (identifier, character literal, | |
854 | -- operator symbol), as well as expanded names, and attributes that | |
855 | -- denote entities, such as 'Class. Points to the entity for the | |
856 | -- corresponding defining occurrence. Set after name resolution. | |
857 | -- In the case of identifiers in a WITH list, the corresponding | |
858 | -- defining occurrence is in a separately compiled file, and this | |
859 | -- pointer must be set using the library Load procedure. Note that | |
860 | -- during name resolution, the value in Entity may be temporarily | |
3e542a58 RD |
861 | -- incorrect (e.g. during overload resolution, Entity is initially |
862 | -- set to the first possible correct interpretation, and then later | |
863 | -- modified if necessary to contain the correct value after resolution). | |
864 | -- Note that Associated_Node overlays this field during the processing | |
865 | -- of generics. See Sem_Ch12 for further details. | |
996ae0b0 RK |
866 | |
867 | -- Etype (Node5-Sem) | |
868 | -- Appears in all expression nodes, all direct names, and all | |
869 | -- entities. Points to the entity for the related type. Set after | |
870 | -- type resolution. Normally this is the actual subtype of the | |
871 | -- expression. However, in certain contexts such as the right side | |
872 | -- of an assignment, subscripts, arguments to calls, returned value | |
873 | -- in a function, initial value etc. it is the desired target type. | |
874 | -- In the event that this is different from the actual type, the | |
875 | -- Do_Range_Check flag will be set if a range check is required. | |
876 | -- Note: if the Is_Overloaded flag is set, then Etype points to | |
877 | -- an essentially arbitrary choice from the possible set of types. | |
878 | ||
879 | -- Exception_Junk (Flag11-Sem) | |
880 | -- This flag is set in a various nodes appearing in a statement | |
881 | -- sequence to indicate that the corresponding node is an artifact | |
882 | -- of the generated code for exception handling, and should be | |
883 | -- ignored when analyzing the control flow of the relevant sequence | |
884 | -- of statements (e.g. to check that it does not end with a bad | |
885 | -- return statement). | |
886 | ||
887 | -- Expansion_Delayed (Flag11-Sem) | |
888 | -- Set on aggregates and extension aggregates that need a top-down | |
889 | -- rather than bottom up expansion. Typically aggregate expansion | |
890 | -- happens bottom up. For nested aggregates the expansion is delayed | |
891 | -- until the enclosing aggregate itself is expanded, e.g. in the context | |
892 | -- of a declaration. To delay it we set this flag. This is done to | |
893 | -- avoid creating a temporary for each level of a nested aggregates, | |
894 | -- and also to prevent the premature generation of constraint checks. | |
895 | -- This is also a requirement if we want to generate the proper | |
896 | -- attachment to the internal finalization lists (for record with | |
897 | -- controlled components). Top down expansion of aggregates is also | |
898 | -- used for in-place array aggregate assignment or initialization. | |
899 | -- When the full context is known, the target of the assignment or | |
900 | -- initialization is used to generate the left-hand side of individual | |
901 | -- assignment to each sub-component. | |
902 | ||
903 | -- First_Inlined_Subprogram (Node3-Sem) | |
904 | -- Present in the N_Compilation_Unit node for the main program. Points | |
905 | -- to a chain of entities for subprograms that are to be inlined. The | |
906 | -- Next_Inlined_Subprogram field of these entities is used as a link | |
907 | -- pointer with Empty marking the end of the list. This field is Empty | |
908 | -- if there are no inlined subprograms or inlining is not active. | |
909 | ||
910 | -- First_Named_Actual (Node4-Sem) | |
911 | -- Present in procedure call statement and function call nodes, and | |
912 | -- also in Intrinsic nodes. Set during semantic analysis to point to | |
913 | -- the first named parameter where parameters are ordered by declaration | |
914 | -- order (as opposed to the actual order in the call which may be | |
915 | -- different due to named associations). Note: this field points to the | |
916 | -- explicit actual parameter itself, not the N_Parameter_Association | |
917 | -- node (its parent). | |
918 | ||
919 | -- First_Real_Statement (Node2-Sem) | |
920 | -- Present in N_Handled_Sequence_Of_Statements node. Normally set to | |
921 | -- Empty. Used only when declarations are moved into the statement | |
922 | -- part of a construct as a result of wrapping an AT END handler that | |
923 | -- is required to cover the declarations. In this case, this field is | |
924 | -- used to remember the location in the statements list of the first | |
925 | -- real statement, i.e. the statement that used to be first in the | |
926 | -- statement list before the declarations were prepended. | |
927 | ||
928 | -- First_Subtype_Link (Node5-Sem) | |
929 | -- Present in N_Freeze_Entity node for an anonymous base type that | |
930 | -- is implicitly created by the declaration of a first subtype. It | |
931 | -- points to the entity for the first subtype. | |
932 | ||
933 | -- Float_Truncate (Flag11-Sem) | |
934 | -- A flag present in type conversion nodes. This is used for float | |
935 | -- to integer conversions where truncation is required rather than | |
936 | -- rounding. Note that Gigi does not handle type conversions from real | |
937 | -- to integer with rounding (see Expand_N_Type_Conversion). | |
938 | ||
939 | -- Forwards_OK (Flag5-Sem) | |
940 | -- A flag present in the N_Assignment_Statement node. It is used only | |
941 | -- if the type being assigned is an array type, and is set if analysis | |
942 | -- determines that it is definitely safe to do the copy forwards, i.e. | |
943 | -- starting at the lowest addressed element. Note that if neither of | |
944 | -- the flags Forwards_OK or Backwards_OK is set, it means that the | |
945 | -- front end could not determine that either direction is definitely | |
946 | -- safe, and a runtime check is required. | |
947 | ||
948 | -- From_At_Mod (Flag4-Sem) | |
949 | -- This flag is set on the attribute definition clause node that is | |
950 | -- generated by a transformation of an at mod phrase in a record | |
951 | -- representation clause. This is used to give slightly different | |
952 | -- (Ada 83 compatible) semantics to such a clause, namely it is | |
953 | -- used to specify a minimum acceptable alignment for the base type | |
954 | -- and all subtypes. In Ada 95 terms, the actual alignment of the | |
955 | -- base type and all subtypes must be a multiple of the given value, | |
956 | -- and the representation clause is considered to be type specific | |
957 | -- instead of subtype specific. | |
958 | ||
959 | -- Generic_Parent (Node5-Sem) | |
960 | -- Generic_parent is defined on declaration nodes that are instances. | |
961 | -- The value of Generic_Parent is the generic entity from which the | |
962 | -- instance is obtained. Generic_Parent is also defined for the renaming | |
963 | -- declarations and object declarations created for the actuals in an | |
964 | -- instantiation. The generic parent of such a declaration is the | |
965 | -- corresponding generic association in the Instantiation node. | |
966 | ||
967 | -- Generic_Parent_Type (Node4-Sem) | |
968 | -- Generic_Parent_Type is defined on Subtype_Declaration nodes for | |
969 | -- the actuals of formal private and derived types. Within the instance, | |
970 | -- the operations on the actual are those inherited from the parent. | |
971 | -- For a formal private type, the parent type is the generic type | |
972 | -- itself. The Generic_Parent_Type is also used in an instance to | |
973 | -- determine whether a private operation overrides an inherited one. | |
974 | ||
975 | -- Handler_List_Entry (Node2-Sem) | |
976 | -- This field is present in N_Object_Declaration nodes. It is set only | |
977 | -- for the Handler_Record entry generated for an exception in zero cost | |
978 | -- exception handling mode. It references the corresponding item in the | |
979 | -- handler list, and is used to delete this entry if the corresponding | |
980 | -- handler is deleted during optimization. For further details on why | |
981 | -- this is required, see Exp_Ch11.Remove_Handler_Entries. | |
982 | ||
983 | -- Has_Dynamic_Length_Check (Flag10-Sem) | |
984 | -- This flag is present on all nodes. It is set to indicate that one | |
985 | -- of the routines in unit Checks has generated a length check action | |
986 | -- which has been inserted at the flagged node. This is used to avoid | |
987 | -- the generation of duplicate checks. | |
988 | ||
989 | -- Has_Dynamic_Range_Check (Flag12-Sem) | |
990 | -- This flag is present on all nodes. It is set to indicate that one | |
991 | -- of the routines in unit Checks has generated a range check action | |
992 | -- which has been inserted at the flagged node. This is used to avoid | |
993 | -- the generation of duplicate checks. | |
994 | ||
995 | -- Has_No_Elaboration_Code (Flag17-Sem) | |
996 | -- A flag that appears in the N_Compilation_Unit node to indicate | |
997 | -- whether or not elaboration code is present for this unit. It is | |
998 | -- initially set true for subprogram specs and bodies and for all | |
999 | -- generic units and false for non-generic package specs and bodies. | |
1000 | -- Gigi may set the flag in the non-generic package case if it | |
1001 | -- determines that no elaboration code is generated. Note that this | |
1002 | -- flag is not related to the Is_Preelaborated status, there can be | |
1003 | -- preelaborated packages that generate elaboration code, and non- | |
1004 | -- preelaborated packages which do not generate elaboration code. | |
1005 | ||
1006 | -- Has_Priority_Pragma (Flag6-Sem) | |
1007 | -- A flag present in N_Subprogram_Body, N_Task_Definition and | |
1008 | -- N_Protected_Definition nodes to flag the presence of either | |
1009 | -- a Priority or Interrupt_Priority pragma in the declaration | |
1010 | -- sequence (public or private in the task and protected cases) | |
1011 | ||
1012 | -- Has_Private_View (Flag11-Sem) | |
1013 | -- A flag present in generic nodes that have an entity, to indicate | |
1014 | -- that the node has a private type. Used to exchange private | |
1015 | -- and full declarations if the visibility at instantiation is | |
1016 | -- different from the visibility at generic definition. | |
1017 | ||
1018 | -- Has_Storage_Size_Pragma (Flag5-Sem) | |
1019 | -- A flag present in an N_Task_Definition node to flag the presence | |
1020 | -- of a Storage_Size pragma | |
1021 | ||
1022 | -- Has_Task_Info_Pragma (Flag7-Sem) | |
1023 | -- A flag present in an N_Task_Definition node to flag the presence | |
1024 | -- of a Task_Info pragma. Used to detect duplicate pragmas. | |
1025 | ||
1026 | -- Has_Task_Name_Pragma (Flag8-Sem) | |
1027 | -- A flag present in N_Task_Definition nodes to flag the presence | |
1028 | -- of a Task_Name pragma in the declaration sequence for the task. | |
1029 | ||
1030 | -- Has_Wide_Character (Flag11-Sem) | |
1031 | -- Present in string literals, set if any wide character (i.e. a | |
1032 | -- character code outside the Character range) appears in the string. | |
1033 | ||
1034 | -- Hidden_By_Use_Clause (Elist4-Sem) | |
1035 | -- An entity list present in use clauses that appear within | |
1036 | -- instantiations. For the resolution of local entities, entities | |
1037 | -- introduced by these use clauses have priority over global ones, | |
1038 | -- and outer entities must be explicitly hidden/restored on exit. | |
1039 | ||
fbf5a39b | 1040 | -- Implicit_With (Flag16-Sem) |
996ae0b0 RK |
1041 | -- This flag is set in the N_With_Clause node that is implicitly |
1042 | -- generated for runtime units that are loaded by the expander, and | |
1043 | -- also for package System, if it is loaded implicitly by a use of | |
1044 | -- the 'Address or 'Tag attribute | |
1045 | ||
1046 | -- Includes_Infinities (Flag11-Sem) | |
1047 | -- This flag is present in N_Range nodes. It is set for the range | |
1048 | -- of unconstrained float types defined in Standard, which include | |
1049 | -- not only the given range of values, but also legtitimately can | |
1050 | -- include infinite values. This flag is false for any float type | |
1051 | -- for which an explicit range is given by the programmer, even if | |
1052 | -- that range is identical to the range for float. | |
1053 | ||
1054 | -- Instance_Spec (Node5-Sem) | |
1055 | -- This field is present in generic instantiation nodes, and also in | |
1056 | -- formal package declaration nodes (formal package declarations are | |
1057 | -- treated in a manner very similar to package instantiations). It | |
1058 | -- points to the node for the spec of the instance, inserted as part | |
1059 | -- of the semantic processing for instantiations in Sem_Ch12. | |
1060 | ||
1061 | -- Is_Asynchronous_Call_Block (Flag7-Sem) | |
1062 | -- A flag set in a Block_Statement node to indicate that it is the | |
1063 | -- expansion of an asynchronous entry call. Such a block needs a | |
1064 | -- cleanup handler to assure that the call is cancelled. | |
1065 | ||
1066 | -- Is_Component_Left_Opnd (Flag13-Sem) | |
1067 | -- Is_Component_Right_Opnd (Flag14-Sem) | |
1068 | -- Present in concatenation nodes, to indicate that the corresponding | |
1069 | -- operand is of the component type of the result. Used in resolving | |
1070 | -- concatenation nodes in instances. | |
1071 | ||
1072 | -- Is_Controlling_Actual (Flag16-Sem) | |
1073 | -- This flag is set on in an expression that is a controlling argument | |
1074 | -- in a dispatching call. It is off in all other cases. See Sem_Disp | |
1075 | -- for details of its use. | |
1076 | ||
fbf5a39b AC |
1077 | -- Is_In_Discriminant_Check (Flag11-Sem) |
1078 | -- This flag is present in a selected component, and is used to | |
1079 | -- indicate that the reference occurs within a discriminant check. | |
1080 | -- The significance is that optimizations based on assuming that | |
1081 | -- the discriminant check has a correct value cannot be performed | |
1082 | -- in this case (or the disriminant check may be optimized away!) | |
1083 | ||
996ae0b0 RK |
1084 | -- Is_Machine_Number (Flag11-Sem) |
1085 | -- This flag is set in an N_Real_Literal node to indicate that the | |
1086 | -- value is a machine number. This avoids some unnecessary cases | |
1087 | -- of converting real literals to machine numbers. | |
1088 | ||
fbf5a39b AC |
1089 | -- Is_Null_Loop (Flag16-Sem) |
1090 | -- This flag is set in an N_Loop_Statement node if the corresponding | |
1091 | -- loop can be determined to be null at compile time. This is used to | |
1092 | -- suppress any warnings that would otherwise be issued inside the | |
1093 | -- loop since they are probably not useful. | |
1094 | ||
996ae0b0 RK |
1095 | -- Is_Power_Of_2_For_Shift (Flag13-Sem) |
1096 | -- A flag present only in N_Op_Expon nodes. It is set when the | |
1097 | -- exponentiation is of the forma 2 ** N, where the type of N is | |
1098 | -- an unsigned integral subtype whose size does not exceed the size | |
1099 | -- of Standard_Integer (i.e. a type that can be safely converted to | |
1100 | -- Natural), and the exponentiation appears as the right operand of | |
1101 | -- an integer multiplication or an integer division where the dividend | |
1102 | -- is unsigned. It is also required that overflow checking is off for | |
1103 | -- both the exponentiation and the multiply/divide node. If this set | |
1104 | -- of conditions holds, and the flag is set, then the division or | |
1105 | -- multiplication can be (and is) converted to a shift. | |
1106 | ||
1107 | -- Is_Overloaded (Flag5-Sem) | |
1108 | -- A flag present in all expression nodes. Used temporarily during | |
1109 | -- overloading determination. The setting of this flag is not | |
1110 | -- relevant once overloading analysis is complete. | |
1111 | ||
1112 | -- Is_Protected_Subprogram_Body (Flag7-Sem) | |
1113 | -- A flag set in a Subprogram_Body block to indicate that it is the | |
1114 | -- implemenation of a protected subprogram. Such a body needs a | |
1115 | -- cleanup handler to make sure that the associated protected object | |
1116 | -- is unlocked when the subprogram completes. | |
1117 | ||
1118 | -- Is_Static_Expression (Flag6-Sem) | |
1119 | -- Indicates that an expression is a static expression (RM 4.9). See | |
1120 | -- spec of package Sem_Eval for full details on the use of this flag. | |
1121 | ||
1122 | -- Is_Subprogram_Descriptor (Flag16-Sem) | |
1123 | -- Present in N_Object_Declaration, and set only for the object | |
1124 | -- declaration generated for a subprogram descriptor in fast exception | |
1125 | -- mode. See Exp_Ch11 for details of use. | |
1126 | ||
1127 | -- Is_Task_Allocation_Block (Flag6-Sem) | |
1128 | -- A flag set in a Block_Statement node to indicate that it is the | |
1129 | -- expansion of a task allocator, or the allocator of an object | |
1130 | -- containing tasks. Such a block requires a cleanup handler to call | |
1131 | -- Expunge_Unactivted_Tasks to complete any tasks that have been | |
1132 | -- allocated but not activated when the allocator completes abnormally. | |
1133 | ||
1134 | -- Is_Task_Master (Flag5-Sem) | |
1135 | -- A flag set in a Subprogram_Body, Block_Statement or Task_Body node | |
1136 | -- to indicate that the construct is a task master (i.e. has declared | |
1137 | -- tasks or declares an access to a task type). | |
1138 | ||
1139 | -- Itype (Node1-Sem) | |
1140 | -- Used in N_Itype_Reference node to reference an itype for which it | |
1141 | -- is important to ensure that it is defined. See description of this | |
1142 | -- node for further details. | |
1143 | ||
1144 | -- Kill_Range_Check (Flag11-Sem) | |
1145 | -- Used in an N_Unchecked_Type_Conversion node to indicate that the | |
1146 | -- result should not be subjected to range checks. This is used for | |
1147 | -- the implementation of Normalize_Scalars. | |
1148 | ||
1149 | -- Label_Construct (Node2-Sem) | |
1150 | -- Used in an N_Implicit_Label_Declaration node. Refers to an N_Label, | |
1151 | -- N_Block_Statement or N_Loop_Statement node to which the label | |
1152 | -- declaration applies. This is not currently used in the compiler | |
1153 | -- itself, but it is useful in the implementation of ASIS queries. | |
1154 | ||
1155 | -- Library_Unit (Node4-Sem) | |
1156 | -- In a stub node, the Library_Unit field points to the compilation unit | |
1157 | -- node of the corresponding subunit. | |
1158 | -- | |
1159 | -- In a with clause node, the Library_Unit field points to the spec | |
1160 | -- of the with'ed unit. | |
1161 | -- | |
1162 | -- In a compilation unit node, the use of this field depends on | |
1163 | -- the unit type: | |
1164 | -- | |
1165 | -- For a subprogram body, the Library_Unit field points to the | |
1166 | -- compilation unit node of the corresponding spec, unless | |
1167 | -- Acts_As_Spec is set, in which case it points to itself. | |
1168 | -- | |
1169 | -- For a package body, the Library_Unit field points to the | |
1170 | -- compilation unit node of the corresponding spec. | |
1171 | -- | |
1172 | -- For a subprogram spec to which pragma Inline applies, the | |
1173 | -- Library_Unit field points to the compilation unit node of | |
1174 | -- the corresponding body, if inlining is active. | |
1175 | -- | |
1176 | -- For a generic declaration, the Library_Unit field points | |
1177 | -- to the compilation unit node of the corresponding generic body. | |
1178 | -- | |
1179 | -- For a subunit, the Library_Unit field points to the compilation | |
1180 | -- unit node of the parent body. | |
1181 | -- | |
1182 | -- Note that this field is not used to hold the parent pointer for a | |
1183 | -- child unit (which might in any case need to use it for some other | |
1184 | -- purpose as described above). Instead for a child unit, implicit | |
1185 | -- with's are generated for all parents. | |
1186 | ||
1187 | -- Loop_Actions (List2-Sem) | |
1188 | -- A list present in Component_Association nodes in array aggregates. | |
1189 | -- Used to collect actions that must be executed within the loop because | |
1190 | -- they may need to be evaluated anew each time through. | |
1191 | ||
fbf5a39b AC |
1192 | -- Limited_View_Installed (Flag18-Sem) |
1193 | -- Present in With_Clauses and in package specifications. If set on a | |
1194 | -- with_clause, it indicates that this clause has created the current | |
1195 | -- limited view of the designated package. On a package specification, | |
1196 | -- it indicates that the limited view has already been created because | |
1197 | -- the package is mentioned in a limited_with_clause in the closure of | |
1198 | -- the unit being compiled. | |
1199 | ||
07fc65c4 GB |
1200 | -- Must_Be_Byte_Aligned (Flag14-Sem) |
1201 | -- This flag is present in N_Attribute_Reference nodes. It can be set | |
1202 | -- only for the Address and Unrestricted_Access attributes. If set it | |
1203 | -- means that the object for which the address/access is given must be | |
1204 | -- on a byte (more accurately a storage unit) boundary. If necessary, | |
1205 | -- a copy of the object is to be made before taking the address (this | |
1206 | -- copy is in the current scope on the stack frame). This is used for | |
fbf5a39b | 1207 | -- certain cases of code generated by the expander that passes |
07fc65c4 | 1208 | -- parameters by address. |
fbf5a39b AC |
1209 | -- |
1210 | -- The reason the copy is not made by the front end is that the back | |
1211 | -- end has more information about type layout and may be able to (but | |
1212 | -- is not guaranteed to) prevent making unnecessary copies. | |
07fc65c4 | 1213 | |
996ae0b0 RK |
1214 | -- Must_Not_Freeze (Flag8-Sem) |
1215 | -- A flag present in all expression nodes. Normally expressions cause | |
1216 | -- freezing as described in the RM. If this flag is set, then this | |
1217 | -- is inhibited. This is used by the analyzer and expander to label | |
1218 | -- nodes that are created by semantic analysis or expansion and which | |
1219 | -- must not cause freezing even though they normally would. This flag | |
1220 | -- is also present in an N_Subtype_Indication node, since we also use | |
1221 | -- these in calls to Freeze_Expression. | |
1222 | ||
1223 | -- Next_Entity (Node2-Sem) | |
1224 | -- Present in defining identifiers, defining character literals and | |
1225 | -- defining operator symbols (i.e. in all entities). The entities of | |
1226 | -- a scope are chained, and this field is used as the forward pointer | |
1227 | -- for this list. See Einfo for further details. | |
1228 | ||
1229 | -- Next_Named_Actual (Node4-Sem) | |
1230 | -- Present in parameter association node. Set during semantic | |
1231 | -- analysis to point to the next named parameter, where parameters | |
1232 | -- are ordered by declaration order (as opposed to the actual order | |
1233 | -- in the call, which may be different due to named associations). | |
1234 | -- Not that this field points to the explicit actual parameter itself, | |
1235 | -- not to the N_Parameter_Association node (its parent). | |
1236 | ||
1237 | -- Next_Rep_Item (Node4-Sem) | |
1238 | -- Present in pragma nodes and attribute definition nodes. Used to | |
1239 | -- link representation items that apply to an entity. See description | |
1240 | -- of First_Rep_Item field in Einfo for full details. | |
1241 | ||
1242 | -- Next_Use_Clause (Node3-Sem) | |
1243 | -- While use clauses are active during semantic processing, they | |
1244 | -- are chained from the scope stack entry, using Next_Use_Clause | |
1245 | -- as a link pointer, with Empty marking the end of the list. The | |
1246 | -- head pointer is in the scope stack entry (First_Use_Clause). At | |
1247 | -- the end of semantic processing (i.e. when Gigi sees the tree, | |
1248 | -- the contents of this field is undefined and should not be read). | |
1249 | ||
1250 | -- No_Ctrl_Actions (Flag7-Sem) | |
1251 | -- Present in N_Assignment_Statement to indicate that no finalize nor | |
1252 | -- nor adjust should take place on this assignment eventhough the rhs | |
fbf5a39b | 1253 | -- is controlled. This is used in init procs and aggregate expansions |
996ae0b0 RK |
1254 | -- where the generated assignments are more initialisations than real |
1255 | -- assignments. | |
1256 | ||
1257 | -- No_Entities_Ref_In_Spec (Flag8-Sem) | |
1258 | -- Present in N_With_Clause nodes. Set if the with clause is on the | |
1259 | -- package or subprogram spec where the main unit is the corresponding | |
1260 | -- body, and no entities of the with'ed unit are referenced by the spec | |
1261 | -- (an entity may still be referenced in the body, so this flag is used | |
1262 | -- to generate the proper message (see Sem_Util.Check_Unused_Withs for | |
1263 | -- full details) | |
1264 | ||
1265 | -- No_Initialization (Flag13-Sem) | |
1266 | -- Present in N_Object_Declaration & N_Allocator to indicate | |
1267 | -- that the object must not be initialized (by Initialize or a | |
fbf5a39b | 1268 | -- call to an init proc). This is needed for controlled aggregates. |
996ae0b0 RK |
1269 | -- When the Object declaration has an expression, this flag means |
1270 | -- that this expression should not be taken into account (needed | |
1271 | -- for in place initialization with aggregates) | |
1272 | ||
fbf5a39b AC |
1273 | -- No_Truncation (Flag17-Sem) |
1274 | -- Present in N_Unchecked_Type_Conversion node. This flag has an effect | |
1275 | -- only if the RM_Size of the source is greater than the RM_Size of the | |
1276 | -- target for scalar operands. Normally in such a case we truncate some | |
1277 | -- higher order bits of the source, and then sign/zero extend the result | |
1278 | -- to form the output value. But if this flag is set, then we do not do | |
1279 | -- any truncation, so for example, if an 8 bit input is converted to a | |
1280 | -- 5 bit result which is in fact stored in 8 bits, then the high order | |
1281 | -- three bits of the target result will be copied from the source. This | |
1282 | -- is used for properly setting out of range values for use by pragmas | |
1283 | -- Initialize_Scalars and Normalize_Scalars. | |
1284 | ||
996ae0b0 RK |
1285 | -- OK_For_Stream (Flag4-Sem) |
1286 | -- Present in N_Attribute_Definition clauses for stream attributes. If | |
1287 | -- set, indicates that the attribute is permitted even though the type | |
1288 | -- involved is a limited type. In the case of a protected type, the | |
1289 | -- result is to stream all components (including discriminants) in | |
1290 | -- lexical order. For other limited types, the effect is simply to | |
1291 | -- use the corresponding stream routine for the full type. This flag | |
1292 | -- is used for internally generated code, where the streaming of these | |
1293 | -- types is required, even though not normally allowed by the language. | |
1294 | ||
1295 | -- Original_Discriminant (Node2-Sem) | |
1296 | -- Present in identifiers. Used in references to discriminants that | |
1297 | -- appear in generic units. Because the names of the discriminants | |
fbf5a39b | 1298 | -- may be different in an instance, we use this field to recover the |
996ae0b0 RK |
1299 | -- position of the discriminant in the original type, and replace it |
1300 | -- with the discriminant at the same position in the instantiated type. | |
1301 | ||
fbf5a39b AC |
1302 | -- Original_Entity (Node2-Sem) |
1303 | -- Present in numeric literals. Used to denote the named number that | |
1304 | -- has been constant-folded into the given literal. If literal is from | |
1305 | -- source, or the result of some other constant-folding operation, then | |
1306 | -- Original_Entity is empty. This field is needed to handle properly | |
1307 | -- named numbers in generic units, where the Associated_Node field | |
1308 | -- interferes with the Entity field, making it impossible to preserve | |
1309 | -- the original entity at the point of instantiation (ASIS problem). | |
1310 | ||
996ae0b0 RK |
1311 | -- Others_Discrete_Choices (List1-Sem) |
1312 | -- When a case statement or variant is analyzed, the semantic checks | |
1313 | -- determine the actual list of choices that correspond to an others | |
1314 | -- choice. This list is materialized for later use by the expander | |
1315 | -- and the Others_Discrete_Choices field of an N_Others_Choice node | |
1316 | -- points to this materialized list of choices, which is in standard | |
1317 | -- format for a list of discrete choices, except that of course it | |
1318 | -- cannot contain an N_Others_Choice entry. | |
1319 | ||
1320 | -- Parameter_List_Truncated (Flag17-Sem) | |
1321 | -- Present in N_Function_Call and N_Procedure_Call_Statement nodes. | |
1322 | -- Set (for OpenVMS ports of GNAT only) if the parameter list is | |
1323 | -- truncated as a result of a First_Optional_Parameter specification | |
1324 | -- in an Import_Function, Import_Procedure, or Import_Valued_Procedure | |
1325 | -- pragma. The truncation is done by the expander by removing trailing | |
1326 | -- parameters from the argument list, in accordance with the set of | |
1327 | -- rules allowing such parameter removal. In particular, parameters | |
1328 | -- can be removed working from the end of the parameter list backwards | |
1329 | -- up to and including the entry designated by First_Optional_Parameter | |
1330 | -- in the Import pragma. Parameters can be removed if they are implicit | |
1331 | -- and the default value is a known-at-compile-time value, including | |
1332 | -- the use of the Null_Parameter attribute, or if explicit parameter | |
1333 | -- values are present that match the corresponding defaults. | |
1334 | ||
1335 | -- Parent_Spec (Node4-Sem) | |
1336 | -- For a library unit that is a child unit spec (package or subprogram | |
1337 | -- declaration, generic declaration or instantiation, or library level | |
1338 | -- rename, this field points to the compilation unit node for the parent | |
1339 | -- package specification. This field is Empty for library bodies (the | |
1340 | -- parent spec in this case can be found from the corresponding spec). | |
1341 | ||
1342 | -- Present_Expr (Uint3-Sem) | |
1343 | -- Present in an N_Variant node. This has a meaningful value only after | |
1344 | -- Gigi has back annotated the tree with representation information. | |
1345 | -- At this point, it contains a reference to a gcc expression that | |
1346 | -- depends on the values of one or more discriminants. Give a set of | |
1347 | -- discriminant values, this expression evaluates to False (zero) if | |
1348 | -- variant is not present, and True (non-zero) if it is present. See | |
1349 | -- unit Repinfo for further details on gigi back annotation. This | |
1350 | -- field is used during ASIS processing (data decomposition annex) | |
1351 | -- to determine if a field is present or not. | |
1352 | ||
1353 | -- Print_In_Hex (Flag13-Sem) | |
1354 | -- Set on an N_Integer_Literal node to indicate that the value should | |
1355 | -- be printed in hexadecimal in the sprint listing. Has no effect on | |
1356 | -- legality or semantics of program, only on the displayed output. | |
1357 | -- This is used to clarify output from the packed array cases. | |
1358 | ||
1359 | -- Procedure_To_Call (Node4-Sem) | |
1360 | -- Present in N_Allocator. N_Free_Statement, and N_Return_Statement | |
1361 | -- nodes. References the entity for the declaration of the procedure | |
1362 | -- to be called to accomplish the required operation (i.e. for the | |
1363 | -- Allocate procedure in the case of N_Allocator and N_Return_Statement | |
1364 | -- (for allocating the return value), and for the Deallocate procedure | |
1365 | -- in the case of N_Free_Statement. | |
1366 | ||
1367 | -- Raises_Constraint_Error (Flag7-Sem) | |
1368 | -- Set on an expression whose evaluation will definitely fail a | |
1369 | -- constraint error check. In the case of static expressions, this | |
1370 | -- flag must be set accurately (and if it is set, the expression is | |
1371 | -- typically illegal unless it appears as a non-elaborated branch of | |
1372 | -- a short-circuit form). For a non-static expression, this flag may | |
1373 | -- be set whenever an expression (e.g. an aggregate) is known to raise | |
1374 | -- constraint error. If set, the expression definitely will raise CE | |
1375 | -- if elaborated at runtime. If not set, the expression may or may | |
1376 | -- not raise CE. In other words, on static expressions, the flag is | |
1377 | -- set accurately, on non-static expressions it is set conservatively. | |
1378 | ||
1379 | -- Redundant_Use (Flag13-Sem) | |
1380 | -- A flag present in nodes that can appear as an operand in a use | |
1381 | -- clause or use type clause (identifiers, expanded names, attribute | |
1382 | -- references). Set to indicate that a use is redundant (and therefore | |
1383 | -- need not be undone on scope exit). | |
1384 | ||
1385 | -- Return_Type (Node2-Sem) | |
1386 | -- Present in N_Return_Statement node. For a procedure, this is set | |
1387 | -- to Standard_Void_Type. For a function it references the entity | |
1388 | -- for the returned type. | |
1389 | ||
1390 | -- Rounded_Result (Flag18-Sem) | |
1391 | -- Present in N_Type_Conversion, N_Op_Divide and N_Op_Multiply nodes. | |
1392 | -- Used in the fixed-point cases to indicate that the result must be | |
1393 | -- rounded as a result of the use of the 'Round attribute. Also used | |
1394 | -- for integer N_Op_Divide nodes to indicate that the result should | |
1395 | -- be rounded to the nearest integer (breaking ties away from zero), | |
1396 | -- rather than truncated towards zero as usual. These rounded integer | |
1397 | -- operations are the result of expansion of rounded fixed-point | |
1398 | -- divide, conersion and multiplication operations. | |
1399 | ||
1400 | -- Scope (Node3-Sem) | |
1401 | -- Present in defining identifiers, defining character literals and | |
1402 | -- defining operator symbols (i.e. in all entities). The entities of | |
1403 | -- a scope all use this field to reference the corresponding scope | |
1404 | -- entity. See Einfo for further details. | |
1405 | ||
1406 | -- Shift_Count_OK (Flag4-Sem) | |
1407 | -- A flag present in shift nodes to indicate that the shift count is | |
1408 | -- known to be in range, i.e. is in the range from zero to word length | |
1409 | -- minus one. If this flag is not set, then the shift count may be | |
1410 | -- outside this range, i.e. larger than the word length, and the code | |
1411 | -- must ensure that such shift counts give the appropriate result. | |
1412 | ||
1413 | -- Source_Type (Node1-Sem) | |
1414 | -- Used in an N_Validate_Unchecked_Conversion node to point to the | |
1415 | -- source type entity for the unchecked conversion instantiation | |
1416 | -- which gigi must do size validation for. | |
1417 | ||
1418 | -- Static_Processing_OK (Flag4-Sem) | |
1419 | -- Present in N_Aggregate nodes. When the Compile_Time_Known_Aggregate | |
1420 | -- flag is set, the full value of the aggregate can be determined at | |
1421 | -- compile time and the aggregate can be passed as is to the back-end. | |
1422 | -- In this event it is irrelevant whether this flag is set or not. | |
1423 | -- However, if the Compile_Time_Known_Aggregate flag is not set but | |
1424 | -- Static_Processing_OK is set, the aggregate can (but need not) be | |
1425 | -- converted into a compile time known aggregate by the expander. | |
1426 | -- See Sem_Aggr for the specific conditions under which an aggregate | |
1427 | -- has its Static_Processing_OK flag set. | |
1428 | ||
1429 | -- Storage_Pool (Node1-Sem) | |
1430 | -- Present in N_Allocator, N_Free_Statement and N_Return_Statement | |
1431 | -- nodes. References the entity for the storage pool to be used for | |
1432 | -- the allocate or free call or for the allocation of the returned | |
1433 | -- value from a function. Empty indicates that the global default | |
1434 | -- default pool is to be used. Note that in the case of a return | |
1435 | -- statement, this field is set only if the function returns a | |
1436 | -- value of a type whose size is not known at compile time on the | |
1437 | -- secondary stack. It is never set on targets for which the target | |
1438 | -- parameter Targparm.Functions_Return_By_DSP_On_Target is True. | |
1439 | ||
1440 | -- Target_Type (Node2-Sem) | |
1441 | -- Used in an N_Validate_Unchecked_Conversion node to point to the | |
1442 | -- target type entity for the unchecked conversion instantiation | |
1443 | -- which gigi must do size validation for. | |
1444 | ||
1445 | -- Task_Body_Procedure (Node2-Sem) | |
1446 | -- Present in task type declaration nodes. Points to the entity for | |
1447 | -- the task body procedure (as further described in Exp_Ch9, task | |
1448 | -- bodies are expanded into procedures). A convenient function to | |
1449 | -- retrieve this field is Sem_Util.Get_Task_Body_Procedure. | |
1450 | ||
1451 | -- Then_Actions (List3-Sem) | |
1452 | -- This field is present in conditional expression nodes. During code | |
1453 | -- expansion we use the Insert_Actions procedure (in Exp_Util) to insert | |
1454 | -- actions at an appropriate place in the tree to get elaborated at the | |
1455 | -- right time. For conditional expressions, we have to be sure that the | |
1456 | -- actions for the Then branch are only elaborated if the condition is | |
1457 | -- True. The Then_Actions field is used as a temporary parking place | |
1458 | -- for these actions. The final tree is always rewritten to eliminate | |
1459 | -- the need for this field, so in the tree passed to Gigi, this field | |
1460 | -- is always set to No_List. | |
1461 | ||
1462 | -- Treat_Fixed_As_Integer (Flag14-Sem) | |
1463 | -- This flag appears in operator nodes for divide, multiply, mod and | |
1464 | -- rem on fixed-point operands. It indicates that the operands are | |
1465 | -- to be treated as integer values, ignoring small values. This flag | |
1466 | -- is only set as a result of expansion of fixed-point operations. | |
1467 | -- Typically a fixed-point multplication in the source generates | |
1468 | -- subsidiary multiplication and division operations that work with | |
1469 | -- the underlying integer values and have this flag set. Note that | |
1470 | -- this flag is not needed on other arithmetic operations (add, neg, | |
1471 | -- subtract etc) since in these cases it is always the case that fixed | |
1472 | -- is treated as integer. The Etype field MUST be set if this flag | |
1473 | -- is set. The analyzer knows to leave such nodes alone, and whoever | |
1474 | -- makes them must set the correct Etype value. | |
1475 | ||
1476 | -- TSS_Elist (Elist3-Sem) | |
1477 | -- Present in N_Freeze_Entity nodes. Holds an element list containing | |
1478 | -- entries for each TSS (type support subprogram) associated with the | |
1479 | -- frozen type. The elements of the list are the entities for the | |
1480 | -- subprograms (see package Exp_TSS for further details). Set to | |
1481 | -- No_Elist if there are no type support subprograms for the type | |
1482 | -- or if the freeze node is not for a type. | |
1483 | ||
1484 | -- Unreferenced_In_Spec (Flag7-Sem) | |
1485 | -- Present in N_With_Clause nodes. Set if the with clause is on the | |
1486 | -- package or subprogram spec where the main unit is the corresponding | |
1487 | -- body, and is not referenced by the spec (it may still be referenced | |
1488 | -- by the body, so this flag is used to generate the proper message | |
1489 | -- (see Sem_Util.Check_Unused_Withs for details) | |
1490 | ||
1491 | -- Was_Originally_Stub (Flag13-Sem) | |
1492 | -- This flag is set in the node for a proper body that replaces a | |
1493 | -- stub. During the analysis procedure, stubs in some situations | |
1494 | -- get rewritten by the corresponding bodies, and we set this flag | |
1495 | -- to remember that this happened. Note that it is not good enough | |
1496 | -- to rely on the use of Original_Tree here because of the case of | |
1497 | -- nested instantiations where the substituted node can be copied. | |
1498 | ||
1499 | -- Zero_Cost_Handling (Flag5-Sem) | |
1500 | -- This flag is set in all handled sequence of statement and exception | |
1501 | -- handler nodes if eceptions are to be handled using the zero-cost | |
1502 | -- mechanism (see Ada.Exceptions and System.Exceptions in files | |
1503 | -- a-except.ads/adb and s-except.ads for full details). What gigi | |
1504 | -- needs to do for such a handler is simply to put the code in the | |
1505 | -- handler somewhere. The front end has generated all necessary labels. | |
1506 | ||
1507 | -------------------------------------------------- | |
1508 | -- Note on Use of End_Label and End_Span Fields -- | |
1509 | -------------------------------------------------- | |
1510 | ||
1511 | -- Several constructs have end lines: | |
1512 | ||
1513 | -- Loop Statement end loop [loop_IDENTIFIER]; | |
1514 | -- Package Specification end [[PARENT_UNIT_NAME .] IDENTIFIER] | |
1515 | -- Task Definition end [task_IDENTIFIER] | |
1516 | -- Protected Definition end [protected_IDENTIFIER] | |
1517 | -- Protected Body end [protected_IDENTIFIER] | |
1518 | ||
1519 | -- Block Statement end [block_IDENTIFIER]; | |
1520 | -- Subprogram Body end [DESIGNATOR]; | |
1521 | -- Package Body end [[PARENT_UNIT_NAME .] IDENTIFIER]; | |
1522 | -- Task Body end [task_IDENTIFIER]; | |
1523 | -- Accept Statement end [entry_IDENTIFIER]]; | |
1524 | -- Entry Body end [entry_IDENTIFIER]; | |
1525 | ||
1526 | -- If Statement end if; | |
1527 | -- Case Statement end case; | |
1528 | ||
1529 | -- Record Definition end record; | |
07fc65c4 | 1530 | -- Enumeration Definition ); |
996ae0b0 RK |
1531 | |
1532 | -- The End_Label and End_Span fields are used to mark the locations | |
1533 | -- of these lines, and also keep track of the label in the case where | |
1534 | -- a label is present. | |
1535 | ||
1536 | -- For the first group above, the End_Label field of the corresponding | |
1537 | -- node is used to point to the label identifier. In the case where | |
1538 | -- there is no label in the source, the parser supplies a dummy | |
1539 | -- identifier (with Comes_From_Source set to False), and the Sloc | |
1540 | -- of this dummy identifier marks the location of the token following | |
1541 | -- the END token. | |
1542 | ||
1543 | -- For the second group, the use of End_Label is similar, but the | |
1544 | -- End_Label is found in the N_Handled_Sequence_Of_Statements node. | |
1545 | -- This is done simply because in some cases there is no room in | |
1546 | -- the parent node. | |
1547 | ||
1548 | -- For the third group, there is never any label, and instead of | |
1549 | -- using End_Label, we use the End_Span field which gives the | |
1550 | -- location of the token following END, relative to the starting | |
1551 | -- Sloc of the construct, i.e. add Sloc (Node) + End_Span (Node) | |
1552 | -- to get the Sloc of the IF or CASE following the End_Label. | |
1553 | ||
1554 | -- The record definition case is handled specially, we treat it | |
1555 | -- as though it required an optional label which is never present, | |
1556 | -- and so the parser always builds a dummy identifier with Comes | |
1557 | -- From Source set False. The reason we do this, rather than using | |
1558 | -- End_Span in this case, is that we want to generate a cross-ref | |
1559 | -- entry for the end of a record, since it represents a scope for | |
1560 | -- name declaration purposes. | |
1561 | ||
07fc65c4 GB |
1562 | -- The enumeration definition case is handled in an exactly similar |
1563 | -- manner, building a dummy identifier to get a cross-reference. | |
1564 | ||
996ae0b0 RK |
1565 | -- Note: the reason we store the difference as a Uint, instead of |
1566 | -- storing the Source_Ptr value directly, is that Source_Ptr values | |
1567 | -- cannot be distinguished from other types of values, and we count | |
1568 | -- on all general use fields being self describing. To make things | |
1569 | -- easier for clients, note that we provide function End_Location, | |
1570 | -- and procedure Set_End_Location to allow access to the logical | |
1571 | -- value (which is the Source_Ptr value for the end token). | |
1572 | ||
1573 | --------------------- | |
1574 | -- Syntactic Nodes -- | |
1575 | --------------------- | |
1576 | ||
1577 | --------------------- | |
1578 | -- 2.3 Identifier -- | |
1579 | --------------------- | |
1580 | ||
1581 | -- IDENTIFIER ::= IDENTIFIER_LETTER {[UNDERLINE] LETTER_OR_DIGIT} | |
1582 | -- LETTER_OR_DIGIT ::= IDENTIFIER_LETTER | DIGIT | |
1583 | ||
1584 | -- An IDENTIFIER shall not be a reserved word | |
1585 | ||
1586 | -- In the Ada grammar identifiers are the bottom level tokens which | |
1587 | -- have very few semantics. Actual program identifiers are direct | |
1588 | -- names. If we were being 100% honest with the grammar, then we would | |
1589 | -- have a node called N_Direct_Name which would point to an identifier. | |
1590 | -- However, that's too many extra nodes, so we just use the N_Identifier | |
1591 | -- node directly as a direct name, and it contains the expression fields | |
1592 | -- and Entity field that correspond to its use as a direct name. In | |
1593 | -- those few cases where identifiers appear in contexts where they are | |
1594 | -- not direct names (pragmas, pragma argument associations, attribute | |
1595 | -- references and attribute definition clauses), the Chars field of the | |
1596 | -- node contains the Name_Id for the identifier name. | |
1597 | ||
1598 | -- Note: in GNAT, a reserved word can be treated as an identifier | |
1599 | -- in two cases. First, an incorrect use of a reserved word as an | |
1600 | -- identifier is diagnosed and then treated as a normal identifier. | |
1601 | -- Second, an attribute designator of the form of a reserved word | |
1602 | -- (access, delta, digits, range) is treated as an identifier. | |
1603 | ||
1604 | -- Note: The set of letters that is permitted in an identifier depends | |
1605 | -- on the character set in use. See package Csets for full details. | |
1606 | ||
1607 | -- N_Identifier | |
1608 | -- Sloc points to identifier | |
1609 | -- Chars (Name1) contains the Name_Id for the identifier | |
1610 | -- Entity (Node4-Sem) | |
3e542a58 | 1611 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
1612 | -- Original_Discriminant (Node2-Sem) |
1613 | -- Redundant_Use (Flag13-Sem) | |
1614 | -- Has_Private_View (Flag11-Sem) (set in generic units) | |
1615 | -- plus fields for expression | |
1616 | ||
1617 | -------------------------- | |
1618 | -- 2.4 Numeric Literal -- | |
1619 | -------------------------- | |
1620 | ||
1621 | -- NUMERIC_LITERAL ::= DECIMAL_LITERAL | BASED_LITERAL | |
1622 | ||
1623 | ---------------------------- | |
1624 | -- 2.4.1 Decimal Literal -- | |
1625 | ---------------------------- | |
1626 | ||
1627 | -- DECIMAL_LITERAL ::= NUMERAL [.NUMERAL] [EXPONENT] | |
1628 | ||
1629 | -- NUMERAL ::= DIGIT {[UNDERLINE] DIGIT} | |
1630 | ||
1631 | -- EXPONENT ::= E [+] NUMERAL | E - NUMERAL | |
1632 | ||
1633 | -- Decimal literals appear in the tree as either integer literal nodes | |
1634 | -- or real literal nodes, depending on whether a period is present. | |
1635 | ||
1636 | -- Note: literal nodes appear as a result of direct use of literals | |
1637 | -- in the source program, and also as the result of evaluating | |
1638 | -- expressions at compile time. In the latter case, it is possible | |
1639 | -- to construct real literals that have no syntactic representation | |
1640 | -- using the standard literal format. Such literals are listed by | |
1641 | -- Sprint using the notation [numerator / denominator]. | |
1642 | ||
1643 | -- N_Integer_Literal | |
1644 | -- Sloc points to literal | |
fbf5a39b AC |
1645 | -- Original_Entity (Node2-Sem) If not Empty, holds Named_Number that |
1646 | -- has been constant-folded into its literal value. | |
996ae0b0 RK |
1647 | -- Intval (Uint3) contains integer value of literal |
1648 | -- plus fields for expression | |
1649 | -- Print_In_Hex (Flag13-Sem) | |
1650 | ||
1651 | -- N_Real_Literal | |
1652 | -- Sloc points to literal | |
fbf5a39b AC |
1653 | -- Original_Entity (Node2-Sem) If not Empty, holds Named_Number that |
1654 | -- has been constant-folded into its literal value. | |
996ae0b0 RK |
1655 | -- Realval (Ureal3) contains real value of literal |
1656 | -- Corresponding_Integer_Value (Uint4-Sem) | |
1657 | -- Is_Machine_Number (Flag11-Sem) | |
1658 | -- plus fields for expression | |
1659 | ||
1660 | -------------------------- | |
1661 | -- 2.4.2 Based Literal -- | |
1662 | -------------------------- | |
1663 | ||
1664 | -- BASED_LITERAL ::= | |
1665 | -- BASE # BASED_NUMERAL [.BASED_NUMERAL] # [EXPONENT] | |
1666 | ||
1667 | -- BASE ::= NUMERAL | |
1668 | ||
1669 | -- BASED_NUMERAL ::= | |
1670 | -- EXTENDED_DIGIT {[UNDERLINE] EXTENDED_DIGIT} | |
1671 | ||
1672 | -- EXTENDED_DIGIT ::= DIGIT | A | B | C | D | E | F | |
1673 | ||
1674 | -- Based literals appear in the tree as either integer literal nodes | |
1675 | -- or real literal nodes, depending on whether a period is present. | |
1676 | ||
1677 | ---------------------------- | |
1678 | -- 2.5 Character Literal -- | |
1679 | ---------------------------- | |
1680 | ||
1681 | -- CHARACTER_LITERAL ::= ' GRAPHIC_CHARACTER ' | |
1682 | ||
1683 | -- N_Character_Literal | |
1684 | -- Sloc points to literal | |
1685 | -- Chars (Name1) contains the Name_Id for the identifier | |
1686 | -- Char_Literal_Value (Char_Code2) contains the literal value | |
1687 | -- Entity (Node4-Sem) | |
3e542a58 | 1688 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
1689 | -- Has_Private_View (Flag11-Sem) set in generic units. |
1690 | -- plus fields for expression | |
1691 | ||
1692 | -- Note: the Entity field will be missing (and set to Empty) for | |
1693 | -- character literals whose type is Standard.Wide_Character or | |
1694 | -- Standard.Character or a type derived from one of these two. | |
1695 | -- In this case the character literal stands for its own coding. | |
1696 | -- The reason we take this irregular short cut is to avoid the | |
1697 | -- need to build lots of junk defining character literal nodes. | |
1698 | ||
1699 | ------------------------- | |
1700 | -- 2.6 String Literal -- | |
1701 | ------------------------- | |
1702 | ||
1703 | -- STRING LITERAL ::= "{STRING_ELEMENT}" | |
1704 | ||
1705 | -- A STRING_ELEMENT is either a pair of quotation marks ("), or a | |
1706 | -- single GRAPHIC_CHARACTER other than a quotation mark. | |
1707 | ||
1708 | -- N_String_Literal | |
1709 | -- Sloc points to literal | |
1710 | -- Strval (Str3) contains Id of string value | |
1711 | -- Has_Wide_Character (Flag11-Sem) | |
1712 | -- plus fields for expression | |
1713 | ||
1714 | ------------------ | |
1715 | -- 2.7 Comment -- | |
1716 | ------------------ | |
1717 | ||
1718 | -- A COMMENT starts with two adjacent hyphens and extends up to the | |
1719 | -- end of the line. A COMMENT may appear on any line of a program. | |
1720 | ||
1721 | -- Comments are skipped by the scanner and do not appear in the tree. | |
1722 | -- It is possible to reconstruct the position of comments with respect | |
1723 | -- to the elements of the tree by using the source position (Sloc) | |
1724 | -- pointers that appear in every tree node. | |
1725 | ||
1726 | ----------------- | |
1727 | -- 2.8 Pragma -- | |
1728 | ----------------- | |
1729 | ||
1730 | -- PRAGMA ::= pragma IDENTIFIER | |
1731 | -- [(PRAGMA_ARGUMENT_ASSOCIATION {, PRAGMA_ARGUMENT_ASSOCIATION})]; | |
1732 | ||
1733 | -- Note that a pragma may appear in the tree anywhere a declaration | |
1734 | -- or a statement may appear, as well as in some other situations | |
1735 | -- which are explicitly documented. | |
1736 | ||
1737 | -- N_Pragma | |
1738 | -- Sloc points to PRAGMA | |
1739 | -- Chars (Name1) identifier name from pragma identifier | |
1740 | -- Pragma_Argument_Associations (List2) (set to No_List if none) | |
1741 | -- Debug_Statement (Node3) (set to Empty if not Debug, Assert) | |
1742 | -- Next_Rep_Item (Node4-Sem) | |
1743 | ||
1744 | -------------------------------------- | |
1745 | -- 2.8 Pragma Argument Association -- | |
1746 | -------------------------------------- | |
1747 | ||
1748 | -- PRAGMA_ARGUMENT_ASSOCIATION ::= | |
1749 | -- [pragma_argument_IDENTIFIER =>] NAME | |
1750 | -- | [pragma_argument_IDENTIFIER =>] EXPRESSION | |
1751 | ||
1752 | -- N_Pragma_Argument_Association | |
1753 | -- Sloc points to first token in association | |
1754 | -- Chars (Name1) (set to No_Name if no pragma argument identifier) | |
1755 | -- Expression (Node3) | |
1756 | ||
1757 | ------------------------ | |
1758 | -- 2.9 Reserved Word -- | |
1759 | ------------------------ | |
1760 | ||
1761 | -- Reserved words are parsed by the scanner, and returned as the | |
1762 | -- corresponding token types (e.g. PACKAGE is returned as Tok_Package) | |
1763 | ||
1764 | ---------------------------- | |
1765 | -- 3.1 Basic Declaration -- | |
1766 | ---------------------------- | |
1767 | ||
1768 | -- BASIC_DECLARATION ::= | |
1769 | -- TYPE_DECLARATION | SUBTYPE_DECLARATION | |
1770 | -- | OBJECT_DECLARATION | NUMBER_DECLARATION | |
1771 | -- | SUBPROGRAM_DECLARATION | ABSTRACT_SUBPROGRAM_DECLARATION | |
1772 | -- | PACKAGE_DECLARATION | RENAMING_DECLARATION | |
1773 | -- | EXCEPTION_DECLARATION | GENERIC_DECLARATION | |
1774 | -- | GENERIC_INSTANTIATION | |
1775 | ||
1776 | -- Basic declaration also includes IMPLICIT_LABEL_DECLARATION | |
1777 | -- see further description in section on semantic nodes. | |
1778 | ||
1779 | -- Also, in the tree that is constructed, a pragma may appear | |
1780 | -- anywhere that a declaration may appear. | |
1781 | ||
1782 | ------------------------------ | |
1783 | -- 3.1 Defining Identifier -- | |
1784 | ------------------------------ | |
1785 | ||
1786 | -- DEFINING_IDENTIFIER ::= IDENTIFIER | |
1787 | ||
1788 | -- A defining identifier is an entity, which has additional fields | |
1789 | -- depending on the setting of the Ekind field. These additional | |
1790 | -- fields are defined (and access subprograms declared) in package | |
1791 | -- Einfo. | |
1792 | ||
1793 | -- Note: N_Defining_Identifier is an extended node whose fields are | |
1794 | -- deliberate layed out to match the layout of fields in an ordinary | |
1795 | -- N_Identifier node allowing for easy alteration of an identifier | |
1796 | -- node into a defining identifier node. For details, see procedure | |
1797 | -- Sinfo.CN.Change_Identifier_To_Defining_Identifier. | |
1798 | ||
1799 | -- N_Defining_Identifier | |
1800 | -- Sloc points to identifier | |
1801 | -- Chars (Name1) contains the Name_Id for the identifier | |
1802 | -- Next_Entity (Node2-Sem) | |
1803 | -- Scope (Node3-Sem) | |
1804 | -- Etype (Node5-Sem) | |
1805 | ||
1806 | ----------------------------- | |
1807 | -- 3.2.1 Type Declaration -- | |
1808 | ----------------------------- | |
1809 | ||
1810 | -- TYPE_DECLARATION ::= | |
1811 | -- FULL_TYPE_DECLARATION | |
1812 | -- | INCOMPLETE_TYPE_DECLARATION | |
1813 | -- | PRIVATE_TYPE_DECLARATION | |
1814 | -- | PRIVATE_EXTENSION_DECLARATION | |
1815 | ||
1816 | ---------------------------------- | |
1817 | -- 3.2.1 Full Type Declaration -- | |
1818 | ---------------------------------- | |
1819 | ||
1820 | -- FULL_TYPE_DECLARATION ::= | |
1821 | -- type DEFINING_IDENTIFIER [KNOWN_DISCRIMINANT_PART] | |
1822 | -- is TYPE_DEFINITION; | |
1823 | -- | TASK_TYPE_DECLARATION | |
1824 | -- | PROTECTED_TYPE_DECLARATION | |
1825 | ||
1826 | -- The full type declaration node is used only for the first case. The | |
1827 | -- second case (concurrent type declaration), is represented directly | |
1828 | -- by a task type declaration or a protected type declaration. | |
1829 | ||
1830 | -- N_Full_Type_Declaration | |
1831 | -- Sloc points to TYPE | |
1832 | -- Defining_Identifier (Node1) | |
1833 | -- Discriminant_Specifications (List4) (set to No_List if none) | |
1834 | -- Type_Definition (Node3) | |
1835 | -- Discr_Check_Funcs_Built (Flag11-Sem) | |
1836 | ||
1837 | ---------------------------- | |
1838 | -- 3.2.1 Type Definition -- | |
1839 | ---------------------------- | |
1840 | ||
1841 | -- TYPE_DEFINITION ::= | |
1842 | -- ENUMERATION_TYPE_DEFINITION | INTEGER_TYPE_DEFINITION | |
1843 | -- | REAL_TYPE_DEFINITION | ARRAY_TYPE_DEFINITION | |
1844 | -- | RECORD_TYPE_DEFINITION | ACCESS_TYPE_DEFINITION | |
1845 | -- | DERIVED_TYPE_DEFINITION | |
1846 | ||
1847 | -------------------------------- | |
1848 | -- 3.2.2 Subtype Declaration -- | |
1849 | -------------------------------- | |
1850 | ||
1851 | -- SUBTYPE_DECLARATION ::= | |
1852 | -- subtype DEFINING_IDENTIFIER is SUBTYPE_INDICATION; | |
1853 | ||
1854 | -- The subtype indication field is set to Empty for subtypes | |
1855 | -- declared in package Standard (Positive, Natural). | |
1856 | ||
1857 | -- N_Subtype_Declaration | |
1858 | -- Sloc points to SUBTYPE | |
1859 | -- Defining_Identifier (Node1) | |
1860 | -- Subtype_Indication (Node5) | |
1861 | -- Generic_Parent_Type (Node4-Sem) (set for an actual derived type). | |
1862 | -- Exception_Junk (Flag11-Sem) | |
1863 | ||
1864 | ------------------------------- | |
1865 | -- 3.2.2 Subtype Indication -- | |
1866 | ------------------------------- | |
1867 | ||
1868 | -- SUBTYPE_INDICATION ::= SUBTYPE_MARK [CONSTRAINT] | |
1869 | ||
1870 | -- Note: if no constraint is present, the subtype indication appears | |
1871 | -- directly in the tree as a subtype mark. The N_Subtype_Indication | |
1872 | -- node is used only if a constraint is present. | |
1873 | ||
1874 | -- Note: the reason that this node has expression fields is that a | |
1875 | -- subtype indication can appear as an operand of a membership test. | |
1876 | ||
1877 | -- N_Subtype_Indication | |
1878 | -- Sloc points to first token of subtype mark | |
1879 | -- Subtype_Mark (Node4) | |
1880 | -- Constraint (Node3) | |
1881 | -- Etype (Node5-Sem) | |
1882 | -- Must_Not_Freeze (Flag8-Sem) | |
1883 | ||
1884 | -- Note: Etype is a copy of the Etype field of the Subtype_Mark. The | |
1885 | -- reason for this redundancy is so that in a list of array index types, | |
1886 | -- the Etype can be uniformly accessed to determine the subscript type. | |
1887 | -- This means that no Itype is constructed for the actual subtype that | |
1888 | -- is created by the subtype indication. If such an Itype is required, | |
1889 | -- it is constructed in the context in which the indication appears. | |
1890 | ||
1891 | ------------------------- | |
1892 | -- 3.2.2 Subtype Mark -- | |
1893 | ------------------------- | |
1894 | ||
1895 | -- SUBTYPE_MARK ::= subtype_NAME | |
1896 | ||
1897 | ----------------------- | |
1898 | -- 3.2.2 Constraint -- | |
1899 | ----------------------- | |
1900 | ||
1901 | -- CONSTRAINT ::= SCALAR_CONSTRAINT | COMPOSITE_CONSTRAINT | |
1902 | ||
1903 | ------------------------------ | |
1904 | -- 3.2.2 Scalar Constraint -- | |
1905 | ------------------------------ | |
1906 | ||
1907 | -- SCALAR_CONSTRAINT ::= | |
1908 | -- RANGE_CONSTRAINT | DIGITS_CONSTRAINT | DELTA_CONSTRAINT | |
1909 | ||
1910 | --------------------------------- | |
1911 | -- 3.2.2 Composite Constraint -- | |
1912 | --------------------------------- | |
1913 | ||
1914 | -- COMPOSITE_CONSTRAINT ::= | |
1915 | -- INDEX_CONSTRAINT | DISCRIMINANT_CONSTRAINT | |
1916 | ||
1917 | ------------------------------- | |
1918 | -- 3.3.1 Object Declaration -- | |
1919 | ------------------------------- | |
1920 | ||
1921 | -- OBJECT_DECLARATION ::= | |
1922 | -- DEFINING_IDENTIFIER_LIST : [aliased] [constant] | |
1923 | -- SUBTYPE_INDICATION [:= EXPRESSION]; | |
1924 | -- | DEFINING_IDENTIFIER_LIST : [aliased] [constant] | |
1925 | -- ARRAY_TYPE_DEFINITION [:= EXPRESSION]; | |
1926 | -- | SINGLE_TASK_DECLARATION | |
1927 | -- | SINGLE_PROTECTED_DECLARATION | |
1928 | ||
1929 | -- Note: aliased is not permitted in Ada 83 mode | |
1930 | ||
1931 | -- The N_Object_Declaration node is only for the first two cases. | |
1932 | -- Single task declaration is handled by P_Task (9.1) | |
1933 | -- Single protected declaration is handled by P_protected (9.5) | |
1934 | ||
1935 | -- Although the syntax allows multiple identifiers in the list, the | |
1936 | -- semantics is as though successive declarations were given with | |
1937 | -- identical type definition and expression components. To simplify | |
1938 | -- semantic processing, the parser represents a multiple declaration | |
1939 | -- case as a sequence of single declarations, using the More_Ids and | |
1940 | -- Prev_Ids flags to preserve the original source form as described | |
1941 | -- in the section on "Handling of Defining Identifier Lists". | |
1942 | ||
1943 | -- Note: if a range check is required for the initialization | |
1944 | -- expression then the Do_Range_Check flag is set in the Expression, | |
1945 | -- with the check being done against the type given by the object | |
1946 | -- definition, which is also the Etype of the defining identifier. | |
1947 | ||
1948 | -- Note: the contents of the Expression field must be ignored (i.e. | |
1949 | -- treated as though it were Empty) if No_Initialization is set True. | |
1950 | ||
fbf5a39b AC |
1951 | -- Note: the back end places some restrictions on the form of the |
1952 | -- Expression field. If the object being declared is Atomic, then | |
1953 | -- the Expression may not have the form of an aggregate (since this | |
1954 | -- might cause the back end to generate separate assignments). It | |
1955 | -- also cannot be a reference to an object marked as a true constant | |
1956 | -- (Is_True_Constant flag set), where the object is itself initalized | |
1957 | -- with an aggregate. If necessary the front end must generate an | |
1958 | -- extra temporary (with Is_True_Constant set False), and initialize | |
1959 | -- this temporary as required (the temporary itself is not atomic). | |
1960 | ||
996ae0b0 RK |
1961 | -- N_Object_Declaration |
1962 | -- Sloc points to first identifier | |
1963 | -- Defining_Identifier (Node1) | |
1964 | -- Aliased_Present (Flag4) set if ALIASED appears | |
1965 | -- Constant_Present (Flag17) set if CONSTANT appears | |
1966 | -- Object_Definition (Node4) subtype indication/array type definition | |
1967 | -- Expression (Node3) (set to Empty if not present) | |
1968 | -- Handler_List_Entry (Node2-Sem) | |
1969 | -- Corresponding_Generic_Association (Node5-Sem) | |
1970 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
1971 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
1972 | -- No_Initialization (Flag13-Sem) | |
1973 | -- Assignment_OK (Flag15-Sem) | |
1974 | -- Exception_Junk (Flag11-Sem) | |
1975 | -- Delay_Finalize_Attach (Flag14-Sem) | |
1976 | -- Is_Subprogram_Descriptor (Flag16-Sem) | |
1977 | ||
1978 | ------------------------------------- | |
1979 | -- 3.3.1 Defining Identifier List -- | |
1980 | ------------------------------------- | |
1981 | ||
1982 | -- DEFINING_IDENTIFIER_LIST ::= | |
1983 | -- DEFINING_IDENTIFIER {, DEFINING_IDENTIFIER} | |
1984 | ||
1985 | ------------------------------- | |
1986 | -- 3.3.2 Number Declaration -- | |
1987 | ------------------------------- | |
1988 | ||
1989 | -- NUMBER_DECLARATION ::= | |
1990 | -- DEFINING_IDENTIFIER_LIST : constant := static_EXPRESSION; | |
1991 | ||
1992 | -- Although the syntax allows multiple identifiers in the list, the | |
1993 | -- semantics is as though successive declarations were given with | |
1994 | -- identical expressions. To simplify semantic processing, the parser | |
1995 | -- represents a multiple declaration case as a sequence of single | |
1996 | -- declarations, using the More_Ids and Prev_Ids flags to preserve | |
1997 | -- the original source form as described in the section on "Handling | |
1998 | -- of Defining Identifier Lists". | |
1999 | ||
2000 | -- N_Number_Declaration | |
2001 | -- Sloc points to first identifier | |
2002 | -- Defining_Identifier (Node1) | |
2003 | -- Expression (Node3) | |
2004 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
2005 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
2006 | ||
2007 | ---------------------------------- | |
2008 | -- 3.4 Derived Type Definition -- | |
2009 | ---------------------------------- | |
2010 | ||
2011 | -- DERIVED_TYPE_DEFINITION ::= | |
2012 | -- [abstract] new parent_SUBTYPE_INDICATION [RECORD_EXTENSION_PART] | |
2013 | ||
2014 | -- Note: ABSTRACT, record extension part not permitted in Ada 83 mode | |
2015 | ||
2016 | -- Note: a record extension part is required if ABSTRACT is present | |
2017 | ||
2018 | -- N_Derived_Type_Definition | |
2019 | -- Sloc points to NEW | |
2020 | -- Abstract_Present (Flag4) | |
2021 | -- Subtype_Indication (Node5) | |
2022 | -- Record_Extension_Part (Node3) (set to Empty if not present) | |
2023 | ||
2024 | --------------------------- | |
2025 | -- 3.5 Range Constraint -- | |
2026 | --------------------------- | |
2027 | ||
2028 | -- RANGE_CONSTRAINT ::= range RANGE | |
2029 | ||
2030 | -- N_Range_Constraint | |
2031 | -- Sloc points to RANGE | |
2032 | -- Range_Expression (Node4) | |
2033 | ||
2034 | ---------------- | |
2035 | -- 3.5 Range -- | |
2036 | ---------------- | |
2037 | ||
2038 | -- RANGE ::= | |
2039 | -- RANGE_ATTRIBUTE_REFERENCE | |
2040 | -- | SIMPLE_EXPRESSION .. SIMPLE_EXPRESSION | |
2041 | ||
2042 | -- Note: the case of a range given as a range attribute reference | |
2043 | -- appears directly in the tree as an attribute reference. | |
2044 | ||
2045 | -- Note: the field name for a reference to a range is Range_Expression | |
2046 | -- rather than Range, because range is a reserved keyword in Ada! | |
2047 | ||
2048 | -- Note: the reason that this node has expression fields is that a | |
2049 | -- range can appear as an operand of a membership test. The Etype | |
2050 | -- field is the type of the range (we do NOT construct an implicit | |
2051 | -- subtype to represent the range exactly). | |
2052 | ||
2053 | -- N_Range | |
2054 | -- Sloc points to .. | |
2055 | -- Low_Bound (Node1) | |
2056 | -- High_Bound (Node2) | |
2057 | -- Includes_Infinities (Flag11) | |
2058 | -- plus fields for expression | |
2059 | ||
2060 | -- Note: if the range appears in a context, such as a subtype | |
2061 | -- declaration, where range checks are required on one or both of | |
2062 | -- the expression fields, then type conversion nodes are inserted | |
2063 | -- to represent the required checks. | |
2064 | ||
2065 | ---------------------------------------- | |
2066 | -- 3.5.1 Enumeration Type Definition -- | |
2067 | ---------------------------------------- | |
2068 | ||
2069 | -- ENUMERATION_TYPE_DEFINITION ::= | |
2070 | -- (ENUMERATION_LITERAL_SPECIFICATION | |
2071 | -- {, ENUMERATION_LITERAL_SPECIFICATION}) | |
2072 | ||
2073 | -- Note: the Literals field in the node described below is null for | |
2074 | -- the case of the standard types CHARACTER and WIDE_CHARACTER, for | |
2075 | -- which special processing handles these types as special cases. | |
2076 | ||
2077 | -- N_Enumeration_Type_Definition | |
2078 | -- Sloc points to left parenthesis | |
2079 | -- Literals (List1) (Empty for CHARACTER or WIDE_CHARACTER) | |
07fc65c4 | 2080 | -- End_Label (Node4) (set to Empty if internally generated record) |
996ae0b0 RK |
2081 | |
2082 | ---------------------------------------------- | |
2083 | -- 3.5.1 Enumeration Literal Specification -- | |
2084 | ---------------------------------------------- | |
2085 | ||
2086 | -- ENUMERATION_LITERAL_SPECIFICATION ::= | |
2087 | -- DEFINING_IDENTIFIER | DEFINING_CHARACTER_LITERAL | |
2088 | ||
2089 | --------------------------------------- | |
2090 | -- 3.5.1 Defining Character Literal -- | |
2091 | --------------------------------------- | |
2092 | ||
2093 | -- DEFINING_CHARACTER_LITERAL ::= CHARACTER_LITERAL | |
2094 | ||
2095 | -- A defining character literal is an entity, which has additional | |
2096 | -- fields depending on the setting of the Ekind field. These | |
2097 | -- additional fields are defined (and access subprograms declared) | |
2098 | -- in package Einfo. | |
2099 | ||
2100 | -- Note: N_Defining_Character_Literal is an extended node whose fields | |
2101 | -- are deliberate layed out to match the layout of fields in an ordinary | |
2102 | -- N_Character_Literal node allowing for easy alteration of a character | |
2103 | -- literal node into a defining character literal node. For details, see | |
2104 | -- Sinfo.CN.Change_Character_Literal_To_Defining_Character_Literal. | |
2105 | ||
2106 | -- N_Defining_Character_Literal | |
2107 | -- Sloc points to literal | |
2108 | -- Chars (Name1) contains the Name_Id for the identifier | |
2109 | -- Next_Entity (Node2-Sem) | |
2110 | -- Scope (Node3-Sem) | |
2111 | -- Etype (Node5-Sem) | |
2112 | ||
2113 | ------------------------------------ | |
2114 | -- 3.5.4 Integer Type Definition -- | |
2115 | ------------------------------------ | |
2116 | ||
2117 | -- Note: there is an error in this rule in the latest version of the | |
2118 | -- grammar, so we have retained the old rule pending clarification. | |
2119 | ||
2120 | -- INTEGER_TYPE_DEFINITION ::= | |
2121 | -- SIGNED_INTEGER_TYPE_DEFINITION | |
2122 | -- MODULAR_TYPE_DEFINITION | |
2123 | ||
2124 | ------------------------------------------- | |
2125 | -- 3.5.4 Signed Integer Type Definition -- | |
2126 | ------------------------------------------- | |
2127 | ||
2128 | -- SIGNED_INTEGER_TYPE_DEFINITION ::= | |
2129 | -- range static_SIMPLE_EXPRESSION .. static_SIMPLE_EXPRESSION | |
2130 | ||
2131 | -- Note: the Low_Bound and High_Bound fields are set to Empty for | |
2132 | -- integer types defined in package Standard. | |
2133 | ||
2134 | -- N_Signed_Integer_Type_Definition | |
2135 | -- Sloc points to RANGE | |
2136 | -- Low_Bound (Node1) | |
2137 | -- High_Bound (Node2) | |
2138 | ||
2139 | ----------------------------------------- | |
2140 | -- 3.5.4 Unsigned Range Specification -- | |
2141 | ----------------------------------------- | |
2142 | ||
2143 | -- MODULAR_TYPE_DEFINITION ::= mod static_EXPRESSION | |
2144 | ||
2145 | -- N_Modular_Type_Definition | |
2146 | -- Sloc points to MOD | |
2147 | -- Expression (Node3) | |
2148 | ||
2149 | --------------------------------- | |
2150 | -- 3.5.6 Real Type Definition -- | |
2151 | --------------------------------- | |
2152 | ||
2153 | -- REAL_TYPE_DEFINITION ::= | |
2154 | -- FLOATING_POINT_DEFINITION | FIXED_POINT_DEFINITION | |
2155 | ||
2156 | -------------------------------------- | |
2157 | -- 3.5.7 Floating Point Definition -- | |
2158 | -------------------------------------- | |
2159 | ||
2160 | -- FLOATING_POINT_DEFINITION ::= | |
2161 | -- digits static_SIMPLE_EXPRESSION [REAL_RANGE_SPECIFICATION] | |
2162 | ||
2163 | -- Note: The Digits_Expression and Real_Range_Specifications fields | |
2164 | -- are set to Empty for floating-point types declared in Standard. | |
2165 | ||
2166 | -- N_Floating_Point_Definition | |
2167 | -- Sloc points to DIGITS | |
2168 | -- Digits_Expression (Node2) | |
2169 | -- Real_Range_Specification (Node4) (set to Empty if not present) | |
2170 | ||
2171 | ------------------------------------- | |
2172 | -- 3.5.7 Real Range Specification -- | |
2173 | ------------------------------------- | |
2174 | ||
2175 | -- REAL_RANGE_SPECIFICATION ::= | |
2176 | -- range static_SIMPLE_EXPRESSION .. static_SIMPLE_EXPRESSION | |
2177 | ||
2178 | -- N_Real_Range_Specification | |
2179 | -- Sloc points to RANGE | |
2180 | -- Low_Bound (Node1) | |
2181 | -- High_Bound (Node2) | |
2182 | ||
2183 | ----------------------------------- | |
2184 | -- 3.5.9 Fixed Point Definition -- | |
2185 | ----------------------------------- | |
2186 | ||
2187 | -- FIXED_POINT_DEFINITION ::= | |
2188 | -- ORDINARY_FIXED_POINT_DEFINITION | DECIMAL_FIXED_POINT_DEFINITION | |
2189 | ||
2190 | -------------------------------------------- | |
2191 | -- 3.5.9 Ordinary Fixed Point Definition -- | |
2192 | -------------------------------------------- | |
2193 | ||
2194 | -- ORDINARY_FIXED_POINT_DEFINITION ::= | |
2195 | -- delta static_EXPRESSION REAL_RANGE_SPECIFICATION | |
2196 | ||
2197 | -- Note: In Ada 83, the EXPRESSION must be a SIMPLE_EXPRESSION | |
2198 | ||
2199 | -- Note: the Delta_Expression and Real_Range_Specification fields | |
2200 | -- are set to Empty for fixed point types declared in Standard. | |
2201 | ||
2202 | -- N_Ordinary_Fixed_Point_Definition | |
2203 | -- Sloc points to DELTA | |
2204 | -- Delta_Expression (Node3) | |
2205 | -- Real_Range_Specification (Node4) | |
2206 | ||
2207 | ------------------------------------------- | |
2208 | -- 3.5.9 Decimal Fixed Point Definition -- | |
2209 | ------------------------------------------- | |
2210 | ||
2211 | -- DECIMAL_FIXED_POINT_DEFINITION ::= | |
2212 | -- delta static_EXPRESSION | |
2213 | -- digits static_EXPRESSION [REAL_RANGE_SPECIFICATION] | |
2214 | ||
2215 | -- Note: decimal types are not permitted in Ada 83 mode | |
2216 | ||
2217 | -- N_Decimal_Fixed_Point_Definition | |
2218 | -- Sloc points to DELTA | |
2219 | -- Delta_Expression (Node3) | |
2220 | -- Digits_Expression (Node2) | |
2221 | -- Real_Range_Specification (Node4) (set to Empty if not present) | |
2222 | ||
2223 | ------------------------------ | |
2224 | -- 3.5.9 Digits Constraint -- | |
2225 | ------------------------------ | |
2226 | ||
2227 | -- DIGITS_CONSTRAINT ::= | |
2228 | -- digits static_EXPRESSION [RANGE_CONSTRAINT] | |
2229 | ||
2230 | -- Note: in Ada 83, the EXPRESSION must be a SIMPLE_EXPRESSION | |
2231 | -- Note: in Ada 95, reduced accuracy subtypes are obsolescent | |
2232 | ||
2233 | -- N_Digits_Constraint | |
2234 | -- Sloc points to DIGITS | |
2235 | -- Digits_Expression (Node2) | |
2236 | -- Range_Constraint (Node4) (set to Empty if not present) | |
2237 | ||
2238 | -------------------------------- | |
2239 | -- 3.6 Array Type Definition -- | |
2240 | -------------------------------- | |
2241 | ||
2242 | -- ARRAY_TYPE_DEFINITION ::= | |
2243 | -- UNCONSTRAINED_ARRAY_DEFINITION | CONSTRAINED_ARRAY_DEFINITION | |
2244 | ||
2245 | ----------------------------------------- | |
2246 | -- 3.6 Unconstrained Array Definition -- | |
2247 | ----------------------------------------- | |
2248 | ||
2249 | -- UNCONSTRAINED_ARRAY_DEFINITION ::= | |
2250 | -- array (INDEX_SUBTYPE_DEFINITION {, INDEX_SUBTYPE_DEFINITION}) of | |
2251 | -- COMPONENT_DEFINITION | |
2252 | ||
2253 | -- Note: dimensionality of array is indicated by number of entries in | |
2254 | -- the Subtype_Marks list, which has one entry for each dimension. | |
2255 | ||
2256 | -- N_Unconstrained_Array_Definition | |
2257 | -- Sloc points to ARRAY | |
2258 | -- Subtype_Marks (List2) | |
2259 | -- Aliased_Present (Flag4) from component definition | |
2260 | -- Subtype_Indication (Node5) from component definition | |
2261 | ||
2262 | ----------------------------------- | |
2263 | -- 3.6 Index Subtype Definition -- | |
2264 | ----------------------------------- | |
2265 | ||
2266 | -- INDEX_SUBTYPE_DEFINITION ::= SUBTYPE_MARK range <> | |
2267 | ||
2268 | -- There is no explicit node in the tree for an index subtype | |
2269 | -- definition since the N_Unconstrained_Array_Definition node | |
2270 | -- incorporates the type marks which appear in this context. | |
2271 | ||
2272 | --------------------------------------- | |
2273 | -- 3.6 Constrained Array Definition -- | |
2274 | --------------------------------------- | |
2275 | ||
2276 | -- CONSTRAINED_ARRAY_DEFINITION ::= | |
2277 | -- array (DISCRETE_SUBTYPE_DEFINITION | |
2278 | -- {, DISCRETE_SUBTYPE_DEFINITION}) | |
2279 | -- of COMPONENT_DEFINITION | |
2280 | ||
2281 | -- Note: dimensionality of array is indicated by number of entries | |
2282 | -- in the Discrete_Subtype_Definitions list, which has one entry | |
2283 | -- for each dimension. | |
2284 | ||
2285 | -- N_Constrained_Array_Definition | |
2286 | -- Sloc points to ARRAY | |
2287 | -- Discrete_Subtype_Definitions (List2) | |
2288 | -- Aliased_Present (Flag4) from component definition | |
2289 | -- Subtype_Indication (Node5) from component definition | |
2290 | ||
2291 | -------------------------------------- | |
2292 | -- 3.6 Discrete Subtype Definition -- | |
2293 | -------------------------------------- | |
2294 | ||
2295 | -- DISCRETE_SUBTYPE_DEFINITION ::= | |
2296 | -- discrete_SUBTYPE_INDICATION | RANGE | |
2297 | ||
2298 | ------------------------------- | |
2299 | -- 3.6 Component Definition -- | |
2300 | ------------------------------- | |
2301 | ||
2302 | -- COMPONENT_DEFINITION ::= [aliased] SUBTYPE_INDICATION | |
2303 | ||
2304 | -- There is no explicit node in the tree for a component definition. | |
2305 | -- Instead the subtype indication appears directly, and the ALIASED | |
2306 | -- indication (Aliased_Present flag) is in the parent node. | |
2307 | ||
2308 | -- Note: although the syntax does not permit a component definition to | |
2309 | -- be an anonymous array (and the parser will diagnose such an attempt | |
2310 | -- with an appropriate message), it is possible for anonymous arrays | |
2311 | -- to appear as component definitions. The semantics and back end handle | |
2312 | -- this case properly, and the expander in fact generates such cases. | |
2313 | ||
2314 | ----------------------------- | |
2315 | -- 3.6.1 Index Constraint -- | |
2316 | ----------------------------- | |
2317 | ||
2318 | -- INDEX_CONSTRAINT ::= (DISCRETE_RANGE {, DISCRETE_RANGE}) | |
2319 | ||
2320 | -- It is not in general possible to distinguish between discriminant | |
2321 | -- constraints and index constraints at parse time, since a simple | |
2322 | -- name could be either the subtype mark of a discrete range, or an | |
2323 | -- expression in a discriminant association with no name. Either | |
2324 | -- entry appears simply as the name, and the semantic parse must | |
2325 | -- distinguish between the two cases. Thus we use a common tree | |
2326 | -- node format for both of these constraint types. | |
2327 | ||
2328 | -- See Discriminant_Constraint for format of node | |
2329 | ||
2330 | --------------------------- | |
2331 | -- 3.6.1 Discrete Range -- | |
2332 | --------------------------- | |
2333 | ||
2334 | -- DISCRETE_RANGE ::= discrete_SUBTYPE_INDICATION | RANGE | |
2335 | ||
2336 | ---------------------------- | |
2337 | -- 3.7 Discriminant Part -- | |
2338 | ---------------------------- | |
2339 | ||
2340 | -- DISCRIMINANT_PART ::= | |
2341 | -- UNKNOWN_DISCRIMINANT_PART | KNOWN_DISCRIMINANT_PART | |
2342 | ||
2343 | ------------------------------------ | |
2344 | -- 3.7 Unknown Discriminant Part -- | |
2345 | ------------------------------------ | |
2346 | ||
2347 | -- UNKNOWN_DISCRIMINANT_PART ::= (<>) | |
2348 | ||
2349 | -- Note: unknown discriminant parts are not permitted in Ada 83 mode | |
2350 | ||
2351 | -- There is no explicit node in the tree for an unknown discriminant | |
2352 | -- part. Instead the Unknown_Discriminants_Present flag is set in the | |
2353 | -- parent node. | |
2354 | ||
2355 | ---------------------------------- | |
2356 | -- 3.7 Known Discriminant Part -- | |
2357 | ---------------------------------- | |
2358 | ||
2359 | -- KNOWN_DISCRIMINANT_PART ::= | |
2360 | -- (DISCRIMINANT_SPECIFICATION {; DISCRIMINANT_SPECIFICATION}) | |
2361 | ||
2362 | ------------------------------------- | |
2363 | -- 3.7 Discriminant Specification -- | |
2364 | ------------------------------------- | |
2365 | ||
2366 | -- DISCRIMINANT_SPECIFICATION ::= | |
2367 | -- DEFINING_IDENTIFIER_LIST : SUBTYPE_MARK | |
2368 | -- [:= DEFAULT_EXPRESSION] | |
2369 | -- | DEFINING_IDENTIFIER_LIST : ACCESS_DEFINITION | |
2370 | -- [:= DEFAULT_EXPRESSION] | |
2371 | ||
2372 | -- Although the syntax allows multiple identifiers in the list, the | |
2373 | -- semantics is as though successive specifications were given with | |
2374 | -- identical type definition and expression components. To simplify | |
2375 | -- semantic processing, the parser represents a multiple declaration | |
2376 | -- case as a sequence of single specifications, using the More_Ids and | |
2377 | -- Prev_Ids flags to preserve the original source form as described | |
2378 | -- in the section on "Handling of Defining Identifier Lists". | |
2379 | ||
2380 | -- N_Discriminant_Specification | |
2381 | -- Sloc points to first identifier | |
2382 | -- Defining_Identifier (Node1) | |
2383 | -- Discriminant_Type (Node5) subtype mark or | |
2384 | -- access parameter definition | |
2385 | -- Expression (Node3) (set to Empty if no default expression) | |
2386 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
2387 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
2388 | ||
2389 | ----------------------------- | |
2390 | -- 3.7 Default Expression -- | |
2391 | ----------------------------- | |
2392 | ||
2393 | -- DEFAULT_EXPRESSION ::= EXPRESSION | |
2394 | ||
2395 | ------------------------------------ | |
2396 | -- 3.7.1 Discriminant Constraint -- | |
2397 | ------------------------------------ | |
2398 | ||
2399 | -- DISCRIMINANT_CONSTRAINT ::= | |
2400 | -- (DISCRIMINANT_ASSOCIATION {, DISCRIMINANT_ASSOCIATION}) | |
2401 | ||
2402 | -- It is not in general possible to distinguish between discriminant | |
2403 | -- constraints and index constraints at parse time, since a simple | |
2404 | -- name could be either the subtype mark of a discrete range, or an | |
2405 | -- expression in a discriminant association with no name. Either | |
2406 | -- entry appears simply as the name, and the semantic parse must | |
2407 | -- distinguish between the two cases. Thus we use a common tree | |
2408 | -- node format for both of these constraint types. | |
2409 | ||
2410 | -- N_Index_Or_Discriminant_Constraint | |
2411 | -- Sloc points to left paren | |
2412 | -- Constraints (List1) points to list of discrete ranges or | |
2413 | -- discriminant associations | |
2414 | ||
2415 | ------------------------------------- | |
2416 | -- 3.7.1 Discriminant Association -- | |
2417 | ------------------------------------- | |
2418 | ||
2419 | -- DISCRIMINANT_ASSOCIATION ::= | |
2420 | -- [discriminant_SELECTOR_NAME | |
2421 | -- {| discriminant_SELECTOR_NAME} =>] EXPRESSION | |
2422 | ||
2423 | -- Note: a discriminant association that has no selector name list | |
2424 | -- appears directly as an expression in the tree. | |
2425 | ||
2426 | -- N_Discriminant_Association | |
2427 | -- Sloc points to first token of discriminant association | |
2428 | -- Selector_Names (List1) (always non-empty, since if no selector | |
2429 | -- names are present, this node is not used, see comment above) | |
2430 | -- Expression (Node3) | |
2431 | ||
2432 | --------------------------------- | |
2433 | -- 3.8 Record Type Definition -- | |
2434 | --------------------------------- | |
2435 | ||
2436 | -- RECORD_TYPE_DEFINITION ::= | |
2437 | -- [[abstract] tagged] [limited] RECORD_DEFINITION | |
2438 | ||
2439 | -- Note: ABSTRACT, TAGGED, LIMITED are not permitted in Ada 83 mode | |
2440 | ||
2441 | -- There is no explicit node in the tree for a record type definition. | |
2442 | -- Instead the flags for Tagged_Present and Limited_Present appear in | |
2443 | -- the N_Record_Definition node for a record definition appearing in | |
2444 | -- the context of a record type definition. | |
2445 | ||
2446 | ---------------------------- | |
2447 | -- 3.8 Record Definition -- | |
2448 | ---------------------------- | |
2449 | ||
2450 | -- RECORD_DEFINITION ::= | |
2451 | -- record | |
2452 | -- COMPONENT_LIST | |
2453 | -- end record | |
2454 | -- | null record | |
2455 | ||
2456 | -- Note: the Abstract_Present, Tagged_Present and Limited_Present | |
2457 | -- flags appear only for a record definition appearing in a record | |
2458 | -- type definition. | |
2459 | ||
2460 | -- Note: the NULL RECORD case is not permitted in Ada 83 | |
2461 | ||
2462 | -- N_Record_Definition | |
2463 | -- Sloc points to RECORD or NULL | |
2464 | -- End_Label (Node4) (set to Empty if internally generated record) | |
2465 | -- Abstract_Present (Flag4) | |
2466 | -- Tagged_Present (Flag15) | |
2467 | -- Limited_Present (Flag17) | |
2468 | -- Component_List (Node1) empty in null record case | |
2469 | -- Null_Present (Flag13) set in null record case | |
2470 | ||
2471 | ------------------------- | |
2472 | -- 3.8 Component List -- | |
2473 | ------------------------- | |
2474 | ||
2475 | -- COMPONENT_LIST ::= | |
2476 | -- COMPONENT_ITEM {COMPONENT_ITEM} | |
2477 | -- | {COMPONENT_ITEM} VARIANT_PART | |
2478 | -- | null; | |
2479 | ||
2480 | -- N_Component_List | |
2481 | -- Sloc points to first token of component list | |
2482 | -- Component_Items (List3) | |
2483 | -- Variant_Part (Node4) (set to Empty if no variant part) | |
2484 | -- Null_Present (Flag13) | |
2485 | ||
2486 | ------------------------- | |
2487 | -- 3.8 Component Item -- | |
2488 | ------------------------- | |
2489 | ||
2490 | -- COMPONENT_ITEM ::= COMPONENT_DECLARATION | REPRESENTATION_CLAUSE | |
2491 | ||
2492 | -- Note: A component item can also be a pragma, and in the tree | |
2493 | -- that is obtained after semantic processing, a component item | |
2494 | -- can be an N_Null node resulting from a non-recognized pragma. | |
2495 | ||
2496 | -------------------------------- | |
2497 | -- 3.8 Component Declaration -- | |
2498 | -------------------------------- | |
2499 | ||
2500 | -- COMPONENT_DECLARATION ::= | |
2501 | -- DEFINING_IDENTIFIER_LIST : COMPONENT_DEFINITION | |
2502 | -- [:= DEFAULT_EXPRESSION] | |
2503 | ||
2504 | -- Note: although the syntax does not permit a component definition to | |
2505 | -- be an anonymous array (and the parser will diagnose such an attempt | |
2506 | -- with an appropriate message), it is possible for anonymous arrays | |
2507 | -- to appear as component definitions. The semantics and back end handle | |
2508 | -- this case properly, and the expander in fact generates such cases. | |
2509 | ||
2510 | -- Although the syntax allows multiple identifiers in the list, the | |
2511 | -- semantics is as though successive declarations were given with the | |
2512 | -- same component definition and expression components. To simplify | |
2513 | -- semantic processing, the parser represents a multiple declaration | |
2514 | -- case as a sequence of single declarations, using the More_Ids and | |
2515 | -- Prev_Ids flags to preserve the original source form as described | |
2516 | -- in the section on "Handling of Defining Identifier Lists". | |
2517 | ||
2518 | -- N_Component_Declaration | |
2519 | -- Sloc points to first identifier | |
2520 | -- Defining_Identifier (Node1) | |
2521 | -- Aliased_Present (Flag4) from component definition | |
2522 | -- Subtype_Indication (Node5) from component definition | |
2523 | -- Expression (Node3) (set to Empty if no default expression) | |
2524 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
2525 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
2526 | ||
2527 | ------------------------- | |
2528 | -- 3.8.1 Variant Part -- | |
2529 | ------------------------- | |
2530 | ||
2531 | -- VARIANT_PART ::= | |
2532 | -- case discriminant_DIRECT_NAME is | |
2533 | -- VARIANT | |
2534 | -- {VARIANT} | |
2535 | -- end case; | |
2536 | ||
2537 | -- Note: the variants list can contain pragmas as well as variants. | |
2538 | -- In a properly formed program there is at least one variant. | |
2539 | ||
2540 | -- N_Variant_Part | |
2541 | -- Sloc points to CASE | |
2542 | -- Name (Node2) | |
2543 | -- Variants (List1) | |
2544 | ||
2545 | -------------------- | |
2546 | -- 3.8.1 Variant -- | |
2547 | -------------------- | |
2548 | ||
2549 | -- VARIANT ::= | |
2550 | -- when DISCRETE_CHOICE_LIST => | |
2551 | -- COMPONENT_LIST | |
2552 | ||
2553 | -- N_Variant | |
2554 | -- Sloc points to WHEN | |
2555 | -- Discrete_Choices (List4) | |
2556 | -- Component_List (Node1) | |
2557 | -- Enclosing_Variant (Node2-Sem) | |
2558 | -- Present_Expr (Uint3-Sem) | |
2559 | -- Dcheck_Function (Node5-Sem) | |
2560 | ||
2561 | --------------------------------- | |
2562 | -- 3.8.1 Discrete Choice List -- | |
2563 | --------------------------------- | |
2564 | ||
2565 | -- DISCRETE_CHOICE_LIST ::= DISCRETE_CHOICE {| DISCRETE_CHOICE} | |
2566 | ||
2567 | ---------------------------- | |
2568 | -- 3.8.1 Discrete Choice -- | |
2569 | ---------------------------- | |
2570 | ||
2571 | -- DISCRETE_CHOICE ::= EXPRESSION | DISCRETE_RANGE | others | |
2572 | ||
2573 | -- Note: in Ada 83 mode, the expression must be a simple expression | |
2574 | ||
2575 | -- The only choice that appears explicitly is the OTHERS choice, as | |
2576 | -- defined here. Other cases of discrete choice (expression and | |
2577 | -- discrete range) appear directly. This production is also used | |
2578 | -- for the OTHERS possibility of an exception choice. | |
2579 | ||
2580 | -- Note: in accordance with the syntax, the parser does not check that | |
2581 | -- OTHERS appears at the end on its own in a choice list context. This | |
2582 | -- is a semantic check. | |
2583 | ||
2584 | -- N_Others_Choice | |
2585 | -- Sloc points to OTHERS | |
2586 | -- Others_Discrete_Choices (List1-Sem) | |
2587 | -- All_Others (Flag11-Sem) | |
2588 | ||
2589 | ---------------------------------- | |
2590 | -- 3.9.1 Record Extension Part -- | |
2591 | ---------------------------------- | |
2592 | ||
2593 | -- RECORD_EXTENSION_PART ::= with RECORD_DEFINITION | |
2594 | ||
2595 | -- Note: record extension parts are not permitted in Ada 83 mode | |
2596 | ||
2597 | ---------------------------------- | |
2598 | -- 3.10 Access Type Definition -- | |
2599 | ---------------------------------- | |
2600 | ||
2601 | -- ACCESS_TYPE_DEFINITION ::= | |
2602 | -- ACCESS_TO_OBJECT_DEFINITION | |
2603 | -- | ACCESS_TO_SUBPROGRAM_DEFINITION | |
2604 | ||
2605 | --------------------------------------- | |
2606 | -- 3.10 Access To Object Definition -- | |
2607 | --------------------------------------- | |
2608 | ||
2609 | -- ACCESS_TO_OBJECT_DEFINITION ::= | |
2610 | -- access [GENERAL_ACCESS_MODIFIER] SUBTYPE_INDICATION | |
2611 | ||
2612 | -- N_Access_To_Object_Definition | |
2613 | -- Sloc points to ACCESS | |
2614 | -- All_Present (Flag15) | |
2615 | -- Subtype_Indication (Node5) | |
2616 | -- Constant_Present (Flag17) | |
2617 | ||
2618 | ----------------------------------- | |
2619 | -- 3.10 General Access Modifier -- | |
2620 | ----------------------------------- | |
2621 | ||
2622 | -- GENERAL_ACCESS_MODIFIER ::= all | constant | |
2623 | ||
2624 | -- Note: general access modifiers are not permitted in Ada 83 mode | |
2625 | ||
2626 | -- There is no explicit node in the tree for general access modifier. | |
2627 | -- Instead the All_Present or Constant_Present flags are set in the | |
2628 | -- parent node. | |
2629 | ||
2630 | ------------------------------------------- | |
2631 | -- 3.10 Access To Subprogram Definition -- | |
2632 | ------------------------------------------- | |
2633 | ||
2634 | -- ACCESS_TO_SUBPROGRAM_DEFINITION | |
2635 | -- access [protected] procedure PARAMETER_PROFILE | |
2636 | -- | access [protected] function PARAMETER_AND_RESULT_PROFILE | |
2637 | ||
2638 | -- Note: access to subprograms are not permitted in Ada 83 mode | |
2639 | ||
2640 | -- N_Access_Function_Definition | |
2641 | -- Sloc points to ACCESS | |
2642 | -- Protected_Present (Flag15) | |
2643 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
2644 | -- Subtype_Mark (Node4) result subtype | |
2645 | ||
2646 | -- N_Access_Procedure_Definition | |
2647 | -- Sloc points to ACCESS | |
2648 | -- Protected_Present (Flag15) | |
2649 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
2650 | ||
2651 | ----------------------------- | |
2652 | -- 3.10 Access Definition -- | |
2653 | ----------------------------- | |
2654 | ||
2655 | -- ACCESS_DEFINITION ::= access SUBTYPE_MARK | |
2656 | ||
2657 | -- N_Access_Definition | |
2658 | -- Sloc points to ACCESS | |
2659 | -- Subtype_Mark (Node4) | |
2660 | ||
2661 | ----------------------------------------- | |
2662 | -- 3.10.1 Incomplete Type Declaration -- | |
2663 | ----------------------------------------- | |
2664 | ||
2665 | -- INCOMPLETE_TYPE_DECLARATION ::= | |
2666 | -- type DEFINING_IDENTIFIER [DISCRIMINANT_PART]; | |
2667 | ||
2668 | -- N_Incomplete_Type_Declaration | |
2669 | -- Sloc points to TYPE | |
2670 | -- Defining_Identifier (Node1) | |
2671 | -- Discriminant_Specifications (List4) (set to No_List if no | |
2672 | -- discriminant part, or if the discriminant part is an | |
2673 | -- unknown discriminant part) | |
2674 | -- Unknown_Discriminants_Present (Flag13) set if (<>) discriminant | |
2675 | ||
2676 | ---------------------------- | |
2677 | -- 3.11 Declarative Part -- | |
2678 | ---------------------------- | |
2679 | ||
2680 | -- DECLARATIVE_PART ::= {DECLARATIVE_ITEM} | |
2681 | ||
2682 | -- Note: although the parser enforces the syntactic requirement that | |
2683 | -- a declarative part can contain only declarations, the semantic | |
2684 | -- processing may add statements to the list of actions in a | |
2685 | -- declarative part, so the code generator should be prepared | |
2686 | -- to accept a statement in this position. | |
2687 | ||
2688 | ---------------------------- | |
2689 | -- 3.11 Declarative Item -- | |
2690 | ---------------------------- | |
2691 | ||
2692 | -- DECLARATIVE_ITEM ::= BASIC_DECLARATIVE_ITEM | BODY | |
2693 | ||
2694 | ---------------------------------- | |
2695 | -- 3.11 Basic Declarative Item -- | |
2696 | ---------------------------------- | |
2697 | ||
2698 | -- BASIC_DECLARATIVE_ITEM ::= | |
2699 | -- BASIC_DECLARATION | REPRESENTATION_CLAUSE | USE_CLAUSE | |
2700 | ||
2701 | ---------------- | |
2702 | -- 3.11 Body -- | |
2703 | ---------------- | |
2704 | ||
2705 | -- BODY ::= PROPER_BODY | BODY_STUB | |
2706 | ||
2707 | ----------------------- | |
2708 | -- 3.11 Proper Body -- | |
2709 | ----------------------- | |
2710 | ||
2711 | -- PROPER_BODY ::= | |
2712 | -- SUBPROGRAM_BODY | PACKAGE_BODY | TASK_BODY | PROTECTED_BODY | |
2713 | ||
2714 | --------------- | |
2715 | -- 4.1 Name -- | |
2716 | --------------- | |
2717 | ||
2718 | -- NAME ::= | |
2719 | -- DIRECT_NAME | EXPLICIT_DEREFERENCE | |
2720 | -- | INDEXED_COMPONENT | SLICE | |
2721 | -- | SELECTED_COMPONENT | ATTRIBUTE_REFERENCE | |
2722 | -- | TYPE_CONVERSION | FUNCTION_CALL | |
2723 | -- | CHARACTER_LITERAL | |
2724 | ||
2725 | ---------------------- | |
2726 | -- 4.1 Direct Name -- | |
2727 | ---------------------- | |
2728 | ||
2729 | -- DIRECT_NAME ::= IDENTIFIER | OPERATOR_SYMBOL | |
2730 | ||
2731 | ----------------- | |
2732 | -- 4.1 Prefix -- | |
2733 | ----------------- | |
2734 | ||
2735 | -- PREFIX ::= NAME | IMPLICIT_DEREFERENCE | |
2736 | ||
2737 | ------------------------------- | |
2738 | -- 4.1 Explicit Dereference -- | |
2739 | ------------------------------- | |
2740 | ||
2741 | -- EXPLICIT_DEREFERENCE ::= NAME . all | |
2742 | ||
2743 | -- N_Explicit_Dereference | |
2744 | -- Sloc points to ALL | |
2745 | -- Prefix (Node3) | |
996ae0b0 RK |
2746 | -- plus fields for expression |
2747 | ||
2748 | ------------------------------- | |
2749 | -- 4.1 Implicit Dereference -- | |
2750 | ------------------------------- | |
2751 | ||
2752 | -- IMPLICIT_DEREFERENCE ::= NAME | |
2753 | ||
2754 | ------------------------------ | |
2755 | -- 4.1.1 Indexed Component -- | |
2756 | ------------------------------ | |
2757 | ||
2758 | -- INDEXED_COMPONENT ::= PREFIX (EXPRESSION {, EXPRESSION}) | |
2759 | ||
2760 | -- Note: the parser may generate this node in some situations where it | |
2761 | -- should be a function call. The semantic pass must correct this | |
2762 | -- misidentification (which is inevitable at the parser level). | |
2763 | ||
2764 | -- N_Indexed_Component | |
2765 | -- Sloc contains a copy of the Sloc value of the Prefix | |
2766 | -- Prefix (Node3) | |
2767 | -- Expressions (List1) | |
996ae0b0 RK |
2768 | -- plus fields for expression |
2769 | ||
2770 | -- Note: if any of the subscripts requires a range check, then the | |
2771 | -- Do_Range_Check flag is set on the corresponding expression, with | |
2772 | -- the index type being determined from the type of the Prefix, which | |
2773 | -- references the array being indexed. | |
2774 | ||
2775 | -- Note: in a fully analyzed and expanded indexed component node, and | |
2776 | -- hence in any such node that gigi sees, if the prefix is an access | |
2777 | -- type, then an explicit dereference operation has been inserted. | |
2778 | ||
2779 | ------------------ | |
2780 | -- 4.1.2 Slice -- | |
2781 | ------------------ | |
2782 | ||
2783 | -- SLICE ::= PREFIX (DISCRETE_RANGE) | |
2784 | ||
2785 | -- Note: an implicit subtype is created to describe the resulting | |
2786 | -- type, so that the bounds of this type are the bounds of the slice. | |
2787 | ||
2788 | -- N_Slice | |
2789 | -- Sloc points to first token of prefix | |
2790 | -- Prefix (Node3) | |
2791 | -- Discrete_Range (Node4) | |
996ae0b0 RK |
2792 | -- plus fields for expression |
2793 | ||
2794 | ------------------------------- | |
2795 | -- 4.1.3 Selected Component -- | |
2796 | ------------------------------- | |
2797 | ||
2798 | -- SELECTED_COMPONENT ::= PREFIX . SELECTOR_NAME | |
2799 | ||
2800 | -- Note: selected components that are semantically expanded names get | |
2801 | -- changed during semantic processing into the separate N_Expanded_Name | |
2802 | -- node. See description of this node in the section on semantic nodes. | |
2803 | ||
2804 | -- N_Selected_Component | |
2805 | -- Sloc points to period | |
2806 | -- Prefix (Node3) | |
2807 | -- Selector_Name (Node2) | |
3e542a58 | 2808 | -- Associated_Node (Node4-Sem) |
996ae0b0 | 2809 | -- Do_Discriminant_Check (Flag13-Sem) |
fbf5a39b | 2810 | -- Is_In_Discriminant_Check (Flag11-Sem) |
996ae0b0 RK |
2811 | -- plus fields for expression |
2812 | ||
2813 | -------------------------- | |
2814 | -- 4.1.3 Selector Name -- | |
2815 | -------------------------- | |
2816 | ||
2817 | -- SELECTOR_NAME ::= IDENTIFIER | CHARACTER_LITERAL | OPERATOR_SYMBOL | |
2818 | ||
2819 | -------------------------------- | |
2820 | -- 4.1.4 Attribute Reference -- | |
2821 | -------------------------------- | |
2822 | ||
2823 | -- ATTRIBUTE_REFERENCE ::= PREFIX ' ATTRIBUTE_DESIGNATOR | |
2824 | ||
2825 | -- Note: the syntax is quite ambiguous at this point. Consider: | |
2826 | ||
2827 | -- A'Length (X) X is part of the attribute designator | |
2828 | -- A'Pos (X) X is an explicit actual parameter of function A'Pos | |
2829 | -- A'Class (X) X is the expression of a type conversion | |
2830 | ||
2831 | -- It would be possible for the parser to distinguish these cases | |
2832 | -- by looking at the attribute identifier. However, that would mean | |
2833 | -- more work in introducing new implementation defined attributes, | |
2834 | -- and also it would mean that special processing for attributes | |
2835 | -- would be scattered around, instead of being centralized in the | |
2836 | -- semantic routine that handles an N_Attribute_Reference node. | |
2837 | -- Consequently, the parser in all the above cases stores the | |
2838 | -- expression (X in these examples) as a single element list in | |
2839 | -- in the Expressions field of the N_Attribute_Reference node. | |
2840 | ||
2841 | -- Similarly, for attributes like Max which take two arguments, | |
2842 | -- we store the two arguments as a two element list in the | |
2843 | -- Expressions field. Of course it is clear at parse time that | |
2844 | -- this case is really a function call with an attribute as the | |
2845 | -- prefix, but it turns out to be convenient to handle the two | |
2846 | -- argument case in a similar manner to the one argument case, | |
2847 | -- and indeed in general the parser will accept any number of | |
2848 | -- expressions in this position and store them as a list in the | |
2849 | -- attribute reference node. This allows for future addition of | |
2850 | -- attributes that take more than two arguments. | |
2851 | ||
2852 | -- Note: named associates are not permitted in function calls where | |
2853 | -- the function is an attribute (see RM 6.4(3)) so it is legitimate | |
2854 | -- to skip the normal subprogram argument processing. | |
2855 | ||
2856 | -- Note: for the attributes whose designators are technically keywords, | |
2857 | -- i.e. digits, access, delta, range, the Attribute_Name field contains | |
2858 | -- the corresponding name, even though no identifier is involved. | |
2859 | ||
2860 | -- The flag OK_For_Stream is used in generated code to indicate that | |
2861 | -- a stream attribute is permissible for a limited type, and results | |
2862 | -- in the use of the stream attribute for the underlying full type, | |
2863 | -- or in the case of a protected type, the components (including any | |
2864 | -- disriminants) are merely streamed in order. | |
2865 | ||
2866 | -- See Exp_Attr for a complete description of which attributes are | |
2867 | -- passed onto Gigi, and which are handled entirely by the front end. | |
2868 | ||
2869 | -- Gigi restriction: For the Pos attribute, the prefix cannot be | |
2870 | -- a non-standard enumeration type or a nonzero/zero semantics | |
2871 | -- boolean type, so the value is simply the stored representation. | |
2872 | ||
07fc65c4 GB |
2873 | -- Note: In generated code, the Address and Unrestricted_Access |
2874 | -- attributes can be applied to any expression, and the meaning is | |
2875 | -- to create an object containing the value (the object is in the | |
2876 | -- current stack frame), and pass the address of this value. If the | |
2877 | -- Must_Be_Byte_Aligned flag is set, then the object whose address | |
2878 | -- is taken must be on a byte (storage unit) boundary, and if it is | |
2879 | -- not (or may not be), then the generated code must create a copy | |
2880 | -- that is byte aligned, and pass the address of this copy. | |
2881 | ||
996ae0b0 RK |
2882 | -- N_Attribute_Reference |
2883 | -- Sloc points to apostrophe | |
2884 | -- Prefix (Node3) | |
2885 | -- Attribute_Name (Name2) identifier name from attribute designator | |
2886 | -- Expressions (List1) (set to No_List if no associated expressions) | |
2887 | -- Entity (Node4-Sem) used if the attribute yields a type | |
3e542a58 | 2888 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
2889 | -- Do_Overflow_Check (Flag17-Sem) |
2890 | -- Redundant_Use (Flag13-Sem) | |
2891 | -- OK_For_Stream (Flag4-Sem) | |
07fc65c4 | 2892 | -- Must_Be_Byte_Aligned (Flag14) |
996ae0b0 RK |
2893 | -- plus fields for expression |
2894 | ||
2895 | --------------------------------- | |
2896 | -- 4.1.4 Attribute Designator -- | |
2897 | --------------------------------- | |
2898 | ||
2899 | -- ATTRIBUTE_DESIGNATOR ::= | |
2900 | -- IDENTIFIER [(static_EXPRESSION)] | |
2901 | -- | access | delta | digits | |
2902 | ||
2903 | -- There is no explicit node in the tree for an attribute designator. | |
2904 | -- Instead the Attribute_Name and Expressions fields of the parent | |
2905 | -- node (N_Attribute_Reference node) hold the information. | |
2906 | ||
2907 | -- Note: if ACCESS, DELTA or DIGITS appears in an attribute | |
2908 | -- designator, then they are treated as identifiers internally | |
2909 | -- rather than the keywords of the same name. | |
2910 | ||
2911 | -------------------------------------- | |
2912 | -- 4.1.4 Range Attribute Reference -- | |
2913 | -------------------------------------- | |
2914 | ||
2915 | -- RANGE_ATTRIBUTE_REFERENCE ::= PREFIX ' RANGE_ATTRIBUTE_DESIGNATOR | |
2916 | ||
2917 | -- A range attribute reference is represented in the tree using the | |
2918 | -- normal N_Attribute_Reference node. | |
2919 | ||
2920 | --------------------------------------- | |
2921 | -- 4.1.4 Range Attribute Designator -- | |
2922 | --------------------------------------- | |
2923 | ||
2924 | -- RANGE_ATTRIBUTE_DESIGNATOR ::= Range [(static_EXPRESSION)] | |
2925 | ||
2926 | -- A range attribute designator is represented in the tree using the | |
2927 | -- normal N_Attribute_Reference node. | |
2928 | ||
2929 | -------------------- | |
2930 | -- 4.3 Aggregate -- | |
2931 | -------------------- | |
2932 | ||
2933 | -- AGGREGATE ::= | |
2934 | -- RECORD_AGGREGATE | EXTENSION_AGGREGATE | ARRAY_AGGREGATE | |
2935 | ||
2936 | ----------------------------- | |
2937 | -- 4.3.1 Record Aggregate -- | |
2938 | ----------------------------- | |
2939 | ||
2940 | -- RECORD_AGGREGATE ::= (RECORD_COMPONENT_ASSOCIATION_LIST) | |
2941 | ||
2942 | -- N_Aggregate | |
2943 | -- Sloc points to left parenthesis | |
2944 | -- Expressions (List1) (set to No_List if none or null record case) | |
2945 | -- Component_Associations (List2) (set to No_List if none) | |
2946 | -- Null_Record_Present (Flag17) | |
2947 | -- Aggregate_Bounds (Node3-Sem) | |
3e542a58 | 2948 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
2949 | -- Static_Processing_OK (Flag4-Sem) |
2950 | -- Compile_Time_Known_Aggregate (Flag18-Sem) | |
2951 | -- Expansion_Delayed (Flag11-Sem) | |
2952 | -- plus fields for expression | |
2953 | ||
2954 | -- Note: this structure is used for both record and array aggregates | |
2955 | -- since the two cases are not separable by the parser. The parser | |
2956 | -- makes no attempt to enforce consistency here, so it is up to the | |
2957 | -- semantic phase to make sure that the aggregate is consistent (i.e. | |
2958 | -- that it is not a "half-and-half" case that mixes record and array | |
2959 | -- syntax. In particular, for a record aggregate, the expressions | |
2960 | -- field will be set if there are positional associations. | |
2961 | ||
2962 | -- Note: gigi/gcc can handle array aggregates correctly providing that | |
2963 | -- they are entirely positional, and the array subtype involved has a | |
2964 | -- known at compile time length and is not bit packed, or a convention | |
2965 | -- Fortran array with more than one dimension. If these conditions | |
2966 | -- are not met, then the front end must translate the aggregate into | |
2967 | -- an appropriate set of assignments into a temporary. | |
2968 | ||
2969 | -- Note: for the record aggregate case, gigi/gcc can handle all cases | |
2970 | -- of record aggregates, including those for packed, and rep-claused | |
2971 | -- records, and also variant records, providing that there are no | |
2972 | -- variable length fields whose size is not known at runtime, and | |
2973 | -- providing that the aggregate is presented in fully named form. | |
2974 | ||
2975 | ---------------------------------------------- | |
2976 | -- 4.3.1 Record Component Association List -- | |
2977 | ---------------------------------------------- | |
2978 | ||
2979 | -- RECORD_COMPONENT_ASSOCIATION_LIST ::= | |
2980 | -- RECORD_COMPONENT_ASSOCIATION {, RECORD_COMPONENT_ASSOCIATION} | |
2981 | -- | null record | |
2982 | ||
2983 | -- There is no explicit node in the tree for a record component | |
2984 | -- association list. Instead the Null_Record_Present flag is set in | |
2985 | -- the parent node for the NULL RECORD case. | |
2986 | ||
2987 | ------------------------------------------------------ | |
2988 | -- 4.3.1 Record Component Association (also 4.3.3) -- | |
2989 | ------------------------------------------------------ | |
2990 | ||
2991 | -- RECORD_COMPONENT_ASSOCIATION ::= | |
2992 | -- [COMPONENT_CHOICE_LIST =>] EXPRESSION | |
2993 | ||
2994 | -- N_Component_Association | |
2995 | -- Sloc points to first selector name | |
2996 | -- Choices (List1) | |
2997 | -- Loop_Actions (List2-Sem) | |
2998 | -- Expression (Node3) | |
2999 | ||
3000 | -- Note: this structure is used for both record component associations | |
3001 | -- and array component associations, since the two cases aren't always | |
3002 | -- separable by the parser. The choices list may represent either a | |
3003 | -- list of selector names in the record aggregate case, or a list of | |
3004 | -- discrete choices in the array aggregate case or an N_Others_Choice | |
3005 | -- node (which appears as a singleton list). | |
3006 | ||
3007 | ------------------------------------ | |
3008 | -- 4.3.1 Commponent Choice List -- | |
3009 | ------------------------------------ | |
3010 | ||
3011 | -- COMPONENT_CHOICE_LIST ::= | |
3012 | -- component_SELECTOR_NAME {| component_SELECTOR_NAME} | |
3013 | -- | others | |
3014 | ||
3015 | -- The entries of a component choice list appear in the Choices list | |
3016 | -- of the associated N_Component_Association, as either selector | |
3017 | -- names, or as an N_Others_Choice node. | |
3018 | ||
3019 | -------------------------------- | |
3020 | -- 4.3.2 Extension Aggregate -- | |
3021 | -------------------------------- | |
3022 | ||
3023 | -- EXTENSION_AGGREGATE ::= | |
3024 | -- (ANCESTOR_PART with RECORD_COMPONENT_ASSOCIATION_LIST) | |
3025 | ||
3026 | -- Note: extension aggregates are not permitted in Ada 83 mode | |
3027 | ||
3028 | -- N_Extension_Aggregate | |
3029 | -- Sloc points to left parenthesis | |
3030 | -- Ancestor_Part (Node3) | |
3e542a58 | 3031 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
3032 | -- Expressions (List1) (set to No_List if none or null record case) |
3033 | -- Component_Associations (List2) (set to No_List if none) | |
3034 | -- Null_Record_Present (Flag17) | |
3035 | -- Expansion_Delayed (Flag11-Sem) | |
3036 | -- plus fields for expression | |
3037 | ||
3038 | -------------------------- | |
3039 | -- 4.3.2 Ancestor Part -- | |
3040 | -------------------------- | |
3041 | ||
3042 | -- ANCESTOR_PART ::= EXPRESSION | SUBTYPE_MARK | |
3043 | ||
3044 | ---------------------------- | |
3045 | -- 4.3.3 Array Aggregate -- | |
3046 | ---------------------------- | |
3047 | ||
3048 | -- ARRAY_AGGREGATE ::= | |
3049 | -- POSITIONAL_ARRAY_AGGREGATE | NAMED_ARRAY_AGGREGATE | |
3050 | ||
3051 | --------------------------------------- | |
3052 | -- 4.3.3 Positional Array Aggregate -- | |
3053 | --------------------------------------- | |
3054 | ||
3055 | -- POSITIONAL_ARRAY_AGGREGATE ::= | |
3056 | -- (EXPRESSION, EXPRESSION {, EXPRESSION}) | |
3057 | -- | (EXPRESSION {, EXPRESSION}, others => EXPRESSION) | |
3058 | ||
3059 | -- See Record_Aggregate (4.3.1) for node structure | |
3060 | ||
3061 | ---------------------------------- | |
3062 | -- 4.3.3 Named Array Aggregate -- | |
3063 | ---------------------------------- | |
3064 | ||
3065 | -- NAMED_ARRAY_AGGREGATE ::= | |
3066 | -- | (ARRAY_COMPONENT_ASSOCIATION {, ARRAY_COMPONENT_ASSOCIATION}) | |
3067 | ||
3068 | -- See Record_Aggregate (4.3.1) for node structure | |
3069 | ||
3070 | ---------------------------------------- | |
3071 | -- 4.3.3 Array Component Association -- | |
3072 | ---------------------------------------- | |
3073 | ||
3074 | -- ARRAY_COMPONENT_ASSOCIATION ::= | |
3075 | -- DISCRETE_CHOICE_LIST => EXPRESSION | |
3076 | ||
3077 | -- See Record_Component_Association (4.3.1) for node structure | |
3078 | ||
3079 | -------------------------------------------------- | |
3080 | -- 4.4 Expression/Relation/Term/Factor/Primary -- | |
3081 | -------------------------------------------------- | |
3082 | ||
3083 | -- EXPRESSION ::= | |
3084 | -- RELATION {and RELATION} | RELATION {and then RELATION} | |
3085 | -- | RELATION {or RELATION} | RELATION {or else RELATION} | |
3086 | -- | RELATION {xor RELATION} | |
3087 | ||
3088 | -- RELATION ::= | |
3089 | -- SIMPLE_EXPRESSION [RELATIONAL_OPERATOR SIMPLE_EXPRESSION] | |
3090 | -- | SIMPLE_EXPRESSION [not] in RANGE | |
3091 | -- | SIMPLE_EXPRESSION [not] in SUBTYPE_MARK | |
3092 | ||
3093 | -- SIMPLE_EXPRESSION ::= | |
3094 | -- [UNARY_ADDING_OPERATOR] TERM {BINARY_ADDING_OPERATOR TERM} | |
3095 | ||
3096 | -- TERM ::= FACTOR {MULTIPLYING_OPERATOR FACTOR} | |
3097 | ||
3098 | -- FACTOR ::= PRIMARY [** PRIMARY] | abs PRIMARY | not PRIMARY | |
3099 | ||
3100 | -- No nodes are generated for any of these constructs. Instead, the | |
3101 | -- node for the operator appears directly. When we refer to an | |
3102 | -- expression in this description, we mean any of the possible | |
3103 | -- consistuent components of an expression (e.g. identifier is | |
3104 | -- an example of an expression). | |
3105 | ||
3106 | ------------------ | |
3107 | -- 4.4 Primary -- | |
3108 | ------------------ | |
3109 | ||
3110 | -- PRIMARY ::= | |
3111 | -- NUMERIC_LITERAL | null | |
3112 | -- | STRING_LITERAL | AGGREGATE | |
3113 | -- | NAME | QUALIFIED_EXPRESSION | |
3114 | -- | ALLOCATOR | (EXPRESSION) | |
3115 | ||
3116 | -- Usually there is no explicit node in the tree for primary. Instead | |
3117 | -- the constituent (e.g. AGGREGATE) appears directly. There are two | |
3118 | -- exceptions. First, there is an explicit node for a null primary. | |
3119 | ||
3120 | -- N_Null | |
3121 | -- Sloc points to NULL | |
3122 | -- plus fields for expression | |
3123 | ||
3124 | -- Second, the case of (EXPRESSION) is handled specially. Ada requires | |
3125 | -- that the parser keep track of which subexpressions are enclosed | |
3126 | -- in parentheses, and how many levels of parentheses are used. This | |
3127 | -- information is required for optimization purposes, and also for | |
3128 | -- some semantic checks (e.g. (((1))) in a procedure spec does not | |
3129 | -- conform with ((((1)))) in the body). | |
3130 | ||
3131 | -- The parentheses are recorded by keeping a Paren_Count field in every | |
3132 | -- subexpression node (it is actually present in all nodes, but only | |
3133 | -- used in subexpression nodes). This count records the number of | |
3134 | -- levels of parentheses. If the number of levels in the source exceeds | |
3135 | -- the maximum accomodated by this count, then the count is simply left | |
3136 | -- at the maximum value. This means that there are some pathalogical | |
3137 | -- cases of failure to detect conformance failures (e.g. an expression | |
3138 | -- with 500 levels of parens will conform with one with 501 levels), | |
3139 | -- but we do not need to lose sleep over this. | |
3140 | ||
3141 | -- Historical note: in versions of GNAT prior to 1.75, there was a node | |
3142 | -- type N_Parenthesized_Expression used to accurately record unlimited | |
3143 | -- numbers of levels of parentheses. However, it turned out to be a | |
3144 | -- real nuisance to have to take into account the possible presence of | |
3145 | -- this node during semantic analysis, since basically parentheses have | |
3146 | -- zero relevance to semantic analysis. | |
3147 | ||
3148 | -- Note: the level of parentheses always present in things like | |
3149 | -- aggregates does not count, only the parentheses in the primary | |
3150 | -- (EXPRESSION) affect the setting of the Paren_Count field. | |
3151 | ||
3152 | -- 2nd Note: the contents of the Expression field must be ignored (i.e. | |
3153 | -- treated as though it were Empty) if No_Initialization is set True. | |
3154 | ||
3155 | -------------------------------------- | |
3156 | -- 4.5 Short Circuit Control Forms -- | |
3157 | -------------------------------------- | |
3158 | ||
3159 | -- EXPRESSION ::= | |
3160 | -- RELATION {and then RELATION} | RELATION {or else RELATION} | |
3161 | ||
3162 | -- Gigi restriction: For both these control forms, the operand and | |
3163 | -- result types are always Standard.Boolean. The expander inserts the | |
3164 | -- required conversion operations where needed to ensure this is the | |
3165 | -- case. | |
3166 | ||
3167 | -- N_And_Then | |
3168 | -- Sloc points to AND of AND THEN | |
3169 | -- Left_Opnd (Node2) | |
3170 | -- Right_Opnd (Node3) | |
3171 | -- Actions (List1-Sem) | |
3172 | -- plus fields for expression | |
3173 | ||
3174 | -- N_Or_Else | |
3175 | -- Sloc points to OR of OR ELSE | |
3176 | -- Left_Opnd (Node2) | |
3177 | -- Right_Opnd (Node3) | |
3178 | -- Actions (List1-Sem) | |
3179 | -- plus fields for expression | |
3180 | ||
3181 | -- Note: The Actions field is used to hold actions associated with | |
3182 | -- the right hand operand. These have to be treated specially since | |
3183 | -- they are not unconditionally executed. See Insert_Actions for a | |
3184 | -- more detailed description of how these actions are handled. | |
3185 | ||
3186 | --------------------------- | |
3187 | -- 4.5 Membership Tests -- | |
3188 | --------------------------- | |
3189 | ||
3190 | -- RELATION ::= | |
3191 | -- SIMPLE_EXPRESSION [not] in RANGE | |
3192 | -- | SIMPLE_EXPRESSION [not] in SUBTYPE_MARK | |
3193 | ||
3194 | -- Note: although the grammar above allows only a range or a | |
3195 | -- subtype mark, the parser in fact will accept any simple | |
3196 | -- expression in place of a subtype mark. This means that the | |
3197 | -- semantic analyzer must be prepared to deal with, and diagnose | |
3198 | -- a simple expression other than a name for the right operand. | |
3199 | -- This simplifies error recovery in the parser. | |
3200 | ||
3201 | -- N_In | |
3202 | -- Sloc points to IN | |
3203 | -- Left_Opnd (Node2) | |
3204 | -- Right_Opnd (Node3) | |
3205 | -- plus fields for expression | |
3206 | ||
3207 | -- N_Not_In | |
3208 | -- Sloc points to NOT of NOT IN | |
3209 | -- Left_Opnd (Node2) | |
3210 | -- Right_Opnd (Node3) | |
3211 | -- plus fields for expression | |
3212 | ||
3213 | -------------------- | |
3214 | -- 4.5 Operators -- | |
3215 | -------------------- | |
3216 | ||
3217 | -- LOGICAL_OPERATOR ::= and | or | xor | |
3218 | ||
3219 | -- RELATIONAL_OPERATOR ::= = | /= | < | <= | > | >= | |
3220 | ||
3221 | -- BINARY_ADDING_OPERATOR ::= + | - | & | |
3222 | ||
3223 | -- UNARY_ADDING_OPERATOR ::= + | - | |
3224 | ||
3225 | -- MULTIPLYING_OPERATOR ::= * | / | mod | rem | |
3226 | ||
3227 | -- HIGHEST_PRECEDENCE_OPERATOR ::= ** | abs | not | |
3228 | ||
3229 | -- Sprint syntax if Treat_Fixed_As_Integer is set: | |
3230 | ||
3231 | -- x #* y | |
3232 | -- x #/ y | |
3233 | -- x #mod y | |
3234 | -- x #rem y | |
3235 | ||
3236 | -- Gigi restriction: For * / mod rem with fixed-point operands, Gigi | |
3237 | -- will only be given nodes with the Treat_Fixed_As_Integer flag set. | |
3238 | -- All handling of smalls for multiplication and division is handled | |
3239 | -- by the front end (mod and rem result only from expansion). Gigi | |
3240 | -- thus never needs to worry about small values (for other operators | |
3241 | -- operating on fixed-point, e.g. addition, the small value does not | |
3242 | -- have any semantic effect anyway, these are always integer operations. | |
3243 | ||
3244 | -- Gigi restriction: For all operators taking Boolean operands, the | |
3245 | -- type is always Standard.Boolean. The expander inserts the required | |
3246 | -- conversion operations where needed to ensure this is the case. | |
3247 | ||
3248 | -- N_Op_And | |
3249 | -- Sloc points to AND | |
3250 | -- Do_Length_Check (Flag4-Sem) | |
3251 | -- plus fields for binary operator | |
3252 | -- plus fields for expression | |
3253 | ||
3254 | -- N_Op_Or | |
3255 | -- Sloc points to OR | |
3256 | -- Do_Length_Check (Flag4-Sem) | |
3257 | -- plus fields for binary operator | |
3258 | -- plus fields for expression | |
3259 | ||
3260 | -- N_Op_Xor | |
3261 | -- Sloc points to XOR | |
3262 | -- Do_Length_Check (Flag4-Sem) | |
3263 | -- plus fields for binary operator | |
3264 | -- plus fields for expression | |
3265 | ||
3266 | -- N_Op_Eq | |
3267 | -- Sloc points to = | |
3268 | -- plus fields for binary operator | |
3269 | -- plus fields for expression | |
3270 | ||
3271 | -- N_Op_Ne | |
3272 | -- Sloc points to /= | |
3273 | -- plus fields for binary operator | |
3274 | -- plus fields for expression | |
3275 | ||
3276 | -- N_Op_Lt | |
3277 | -- Sloc points to < | |
3278 | -- plus fields for binary operator | |
3279 | -- plus fields for expression | |
3280 | ||
3281 | -- N_Op_Le | |
3282 | -- Sloc points to <= | |
3283 | -- plus fields for binary operator | |
3284 | -- plus fields for expression | |
3285 | ||
3286 | -- N_Op_Gt | |
3287 | -- Sloc points to > | |
3288 | -- plus fields for binary operator | |
3289 | -- plus fields for expression | |
3290 | ||
3291 | -- N_Op_Ge | |
3292 | -- Sloc points to >= | |
3293 | -- plus fields for binary operator | |
3294 | -- plus fields for expression | |
3295 | ||
3296 | -- N_Op_Add | |
3297 | -- Sloc points to + (binary) | |
3298 | -- plus fields for binary operator | |
3299 | -- plus fields for expression | |
3300 | ||
3301 | -- N_Op_Subtract | |
3302 | -- Sloc points to - (binary) | |
3303 | -- plus fields for binary operator | |
3304 | -- plus fields for expression | |
3305 | ||
3306 | -- N_Op_Concat | |
3307 | -- Sloc points to & | |
3308 | -- Is_Component_Left_Opnd (Flag13-Sem) | |
3309 | -- Is_Component_Right_Opnd (Flag14-Sem) | |
3310 | -- plus fields for binary operator | |
3311 | -- plus fields for expression | |
3312 | ||
3313 | -- N_Op_Multiply | |
3314 | -- Sloc points to * | |
3315 | -- Treat_Fixed_As_Integer (Flag14-Sem) | |
3316 | -- Rounded_Result (Flag18-Sem) | |
3317 | -- plus fields for binary operator | |
3318 | -- plus fields for expression | |
3319 | ||
3320 | -- N_Op_Divide | |
3321 | -- Sloc points to / | |
3322 | -- Treat_Fixed_As_Integer (Flag14-Sem) | |
3323 | -- Do_Division_Check (Flag13-Sem) | |
3324 | -- Rounded_Result (Flag18-Sem) | |
3325 | -- plus fields for binary operator | |
3326 | -- plus fields for expression | |
3327 | ||
3328 | -- N_Op_Mod | |
3329 | -- Sloc points to MOD | |
3330 | -- Treat_Fixed_As_Integer (Flag14-Sem) | |
3331 | -- Do_Division_Check (Flag13-Sem) | |
3332 | -- plus fields for binary operator | |
3333 | -- plus fields for expression | |
3334 | ||
3335 | -- N_Op_Rem | |
3336 | -- Sloc points to REM | |
3337 | -- Treat_Fixed_As_Integer (Flag14-Sem) | |
3338 | -- Do_Division_Check (Flag13-Sem) | |
3339 | -- plus fields for binary operator | |
3340 | -- plus fields for expression | |
3341 | ||
3342 | -- N_Op_Expon | |
3343 | -- Is_Power_Of_2_For_Shift (Flag13-Sem) | |
3344 | -- Sloc points to ** | |
3345 | -- plus fields for binary operator | |
3346 | -- plus fields for expression | |
3347 | ||
3348 | -- N_Op_Plus | |
3349 | -- Sloc points to + (unary) | |
3350 | -- plus fields for unary operator | |
3351 | -- plus fields for expression | |
3352 | ||
3353 | -- N_Op_Minus | |
3354 | -- Sloc points to - (unary) | |
3355 | -- plus fields for unary operator | |
3356 | -- plus fields for expression | |
3357 | ||
3358 | -- N_Op_Abs | |
3359 | -- Sloc points to ABS | |
3360 | -- plus fields for unary operator | |
3361 | -- plus fields for expression | |
3362 | ||
3363 | -- N_Op_Not | |
3364 | -- Sloc points to NOT | |
3365 | -- plus fields for unary operator | |
3366 | -- plus fields for expression | |
3367 | ||
3368 | -- See also shift operators in section B.2 | |
3369 | ||
3370 | -- Note on fixed-point operations passed to Gigi: For adding operators, | |
3371 | -- the semantics is to treat these simply as integer operations, with | |
3372 | -- the small values being ignored (the bounds are already stored in | |
3373 | -- units of small, so that constraint checking works as usual). For the | |
3374 | -- case of multiply/divide/rem/mod operations, Gigi will only see fixed | |
3375 | -- point operands if the Treat_Fixed_As_Integer flag is set and will | |
3376 | -- thus treat these nodes in identical manner, ignoring small values. | |
3377 | ||
3378 | -------------------------- | |
3379 | -- 4.6 Type Conversion -- | |
3380 | -------------------------- | |
3381 | ||
3382 | -- TYPE_CONVERSION ::= | |
3383 | -- SUBTYPE_MARK (EXPRESSION) | SUBTYPE_MARK (NAME) | |
3384 | ||
3385 | -- In the (NAME) case, the name is stored as the expression | |
3386 | ||
3387 | -- Note: the parser never generates a type conversion node, since it | |
3388 | -- looks like an indexed component which is generated by preference. | |
3389 | -- The semantic pass must correct this misidentification. | |
3390 | ||
3391 | -- Gigi handles conversions that involve no change in the root type, | |
3392 | -- and also all conversions from integer to floating-point types. | |
3393 | -- Conversions from floating-point to integer are only handled in | |
3394 | -- the case where Float_Truncate flag set. Other conversions from | |
3395 | -- floating-point to integer (involving rounding) and all conversions | |
3396 | -- involving fixed-point types are handled by the expander. | |
3397 | ||
3398 | -- Sprint syntax if Float_Truncate set: X^(Y) | |
3399 | -- Sprint syntax if Conversion_OK set X?(Y) | |
3400 | -- Sprint syntax if both flags set X?^(Y) | |
3401 | ||
3402 | -- Note: If either the operand or result type is fixed-point, Gigi will | |
3403 | -- only see a type conversion node with Conversion_OK set. The front end | |
3404 | -- takes care of all handling of small's for fixed-point conversions. | |
3405 | ||
3406 | -- N_Type_Conversion | |
3407 | -- Sloc points to first token of subtype mark | |
3408 | -- Subtype_Mark (Node4) | |
3409 | -- Expression (Node3) | |
996ae0b0 RK |
3410 | -- Do_Tag_Check (Flag13-Sem) |
3411 | -- Do_Length_Check (Flag4-Sem) | |
fbf5a39b | 3412 | -- Do_Overflow_Check (Flag17-Sem) |
996ae0b0 RK |
3413 | -- Float_Truncate (Flag11-Sem) |
3414 | -- Rounded_Result (Flag18-Sem) | |
3415 | -- Conversion_OK (Flag14-Sem) | |
3416 | -- plus fields for expression | |
3417 | ||
3418 | -- Note: if a range check is required, then the Do_Range_Check flag | |
3419 | -- is set in the Expression with the check being done against the | |
3420 | -- target type range (after the base type conversion, if any). | |
3421 | ||
3422 | ------------------------------- | |
3423 | -- 4.7 Qualified Expression -- | |
3424 | ------------------------------- | |
3425 | ||
3426 | -- QUALIFIED_EXPRESSION ::= | |
3427 | -- SUBTYPE_MARK ' (EXPRESSION) | SUBTYPE_MARK ' AGGREGATE | |
3428 | ||
3429 | -- Note: the parentheses in the (EXPRESSION) case are deemed to enclose | |
3430 | -- the expression, so the Expression field of this node always points | |
3431 | -- to a parenthesized expression in this case (i.e. Paren_Count will | |
3432 | -- always be non-zero for the referenced expression if it is not an | |
3433 | -- aggregate). | |
3434 | ||
3435 | -- N_Qualified_Expression | |
3436 | -- Sloc points to apostrophe | |
3437 | -- Subtype_Mark (Node4) | |
3438 | -- Expression (Node3) expression or aggregate | |
3439 | -- plus fields for expression | |
3440 | ||
3441 | -------------------- | |
3442 | -- 4.8 Allocator -- | |
3443 | -------------------- | |
3444 | ||
3445 | -- ALLOCATOR ::= | |
3446 | -- new SUBTYPE_INDICATION | new QUALIFIED_EXPRESSION | |
3447 | ||
3448 | -- Sprint syntax (when storage pool present) | |
3449 | -- new xxx (storage_pool = pool) | |
3450 | ||
3451 | -- N_Allocator | |
3452 | -- Sloc points to NEW | |
3453 | -- Expression (Node3) subtype indication or qualified expression | |
3454 | -- Storage_Pool (Node1-Sem) | |
3455 | -- Procedure_To_Call (Node4-Sem) | |
3456 | -- No_Initialization (Flag13-Sem) | |
3457 | -- Do_Storage_Check (Flag17-Sem) | |
3458 | -- plus fields for expression | |
3459 | ||
3460 | --------------------------------- | |
3461 | -- 5.1 Sequence Of Statements -- | |
3462 | --------------------------------- | |
3463 | ||
3464 | -- SEQUENCE_OF_STATEMENTS ::= STATEMENT {STATEMENT} | |
3465 | ||
3466 | -- Note: Although the parser will not accept a declaration as a | |
3467 | -- statement, the semantic analyzer may insert declarations (e.g. | |
3468 | -- declarations of implicit types needed for execution of other | |
3469 | -- statements) into a sequence of statements, so the code genmerator | |
3470 | -- should be prepared to accept a declaration where a statement is | |
3471 | -- expected. Note also that pragmas can appear as statements. | |
3472 | ||
3473 | -------------------- | |
3474 | -- 5.1 Statement -- | |
3475 | -------------------- | |
3476 | ||
3477 | -- STATEMENT ::= | |
3478 | -- {LABEL} SIMPLE_STATEMENT | {LABEL} COMPOUND_STATEMENT | |
3479 | ||
3480 | -- There is no explicit node in the tree for a statement. Instead, the | |
3481 | -- individual statement appears directly. Labels are treated as a | |
3482 | -- kind of statement, i.e. they are linked into a statement list at | |
3483 | -- the point they appear, so the labeled statement appears following | |
3484 | -- the label or labels in the statement list. | |
3485 | ||
3486 | --------------------------- | |
3487 | -- 5.1 Simple Statement -- | |
3488 | --------------------------- | |
3489 | ||
3490 | -- SIMPLE_STATEMENT ::= NULL_STATEMENT | |
3491 | -- | ASSIGNMENT_STATEMENT | EXIT_STATEMENT | |
3492 | -- | GOTO_STATEMENT | PROCEDURE_CALL_STATEMENT | |
3493 | -- | RETURN_STATEMENT | ENTRY_CALL_STATEMENT | |
3494 | -- | REQUEUE_STATEMENT | DELAY_STATEMENT | |
3495 | -- | ABORT_STATEMENT | RAISE_STATEMENT | |
3496 | -- | CODE_STATEMENT | |
3497 | ||
3498 | ----------------------------- | |
3499 | -- 5.1 Compound Statement -- | |
3500 | ----------------------------- | |
3501 | ||
3502 | -- COMPOUND_STATEMENT ::= | |
3503 | -- IF_STATEMENT | CASE_STATEMENT | |
3504 | -- | LOOP_STATEMENT | BLOCK_STATEMENT | |
3505 | -- | ACCEPT_STATEMENT | SELECT_STATEMENT | |
3506 | ||
3507 | ------------------------- | |
3508 | -- 5.1 Null Statement -- | |
3509 | ------------------------- | |
3510 | ||
3511 | -- NULL_STATEMENT ::= null; | |
3512 | ||
3513 | -- N_Null_Statement | |
3514 | -- Sloc points to NULL | |
3515 | ||
3516 | ---------------- | |
3517 | -- 5.1 Label -- | |
3518 | ---------------- | |
3519 | ||
3520 | -- LABEL ::= <<label_STATEMENT_IDENTIFIER>> | |
3521 | ||
3522 | -- Note that the occurrence of a label is not a defining identifier, | |
3523 | -- but rather a referencing occurrence. The defining occurrence is | |
3524 | -- in the implicit label declaration which occurs in the innermost | |
3525 | -- enclosing block. | |
3526 | ||
3527 | -- N_Label | |
3528 | -- Sloc points to << | |
3529 | -- Identifier (Node1) direct name of statement identifier | |
3530 | -- Exception_Junk (Flag11-Sem) | |
3531 | ||
3532 | ------------------------------- | |
3533 | -- 5.1 Statement Identifier -- | |
3534 | ------------------------------- | |
3535 | ||
07fc65c4 | 3536 | -- STATEMENT_INDENTIFIER ::= DIRECT_NAME |
996ae0b0 RK |
3537 | |
3538 | -- The IDENTIFIER of a STATEMENT_IDENTIFIER shall be an identifier | |
3539 | -- (not an OPERATOR_SYMBOL) | |
3540 | ||
3541 | ------------------------------- | |
3542 | -- 5.2 Assignment Statement -- | |
3543 | ------------------------------- | |
3544 | ||
3545 | -- ASSIGNMENT_STATEMENT ::= | |
3546 | -- variable_NAME := EXPRESSION; | |
3547 | ||
3548 | -- N_Assignment_Statement | |
3549 | -- Sloc points to := | |
3550 | -- Name (Node2) | |
3551 | -- Expression (Node3) | |
3552 | -- Do_Tag_Check (Flag13-Sem) | |
3553 | -- Do_Length_Check (Flag4-Sem) | |
3554 | -- Forwards_OK (Flag5-Sem) | |
3555 | -- Backwards_OK (Flag6-Sem) | |
3556 | -- No_Ctrl_Actions (Flag7-Sem) | |
3557 | ||
3558 | -- Note: if a range check is required, then the Do_Range_Check flag | |
3559 | -- is set in the Expression (right hand side), with the check being | |
3560 | -- done against the type of the Name (left hand side). | |
3561 | ||
fbf5a39b AC |
3562 | -- Note: the back end places some restrictions on the form of the |
3563 | -- Expression field. If the object being assigned to is Atomic, then | |
3564 | -- the Expression may not have the form of an aggregate (since this | |
3565 | -- might cause the back end to generate separate assignments). It | |
3566 | -- also cannot be a reference to an object marked as a true constant | |
3567 | -- (Is_True_Constant flag set), where the object is itself initalized | |
3568 | -- with an aggregate. If necessary the front end must generate an | |
3569 | -- extra temporary (with Is_True_Constant set False), and initialize | |
3570 | -- this temporary as required (the temporary itself is not atomic). | |
3571 | ||
996ae0b0 RK |
3572 | ----------------------- |
3573 | -- 5.3 If Statement -- | |
3574 | ----------------------- | |
3575 | ||
3576 | -- IF_STATEMENT ::= | |
3577 | -- if CONDITION then | |
3578 | -- SEQUENCE_OF_STATEMENTS | |
3579 | -- {elsif CONDITION then | |
3580 | -- SEQUENCE_OF_STATEMENTS} | |
3581 | -- [else | |
3582 | -- SEQUENCE_OF_STATEMENTS] | |
3583 | -- end if; | |
3584 | ||
3585 | -- Gigi restriction: This expander ensures that the type of the | |
3586 | -- Condition fields is always Standard.Boolean, even if the type | |
3587 | -- in the source is some non-standard boolean type. | |
3588 | ||
3589 | -- N_If_Statement | |
3590 | -- Sloc points to IF | |
3591 | -- Condition (Node1) | |
3592 | -- Then_Statements (List2) | |
3593 | -- Elsif_Parts (List3) (set to No_List if none present) | |
3594 | -- Else_Statements (List4) (set to No_List if no else part present) | |
3595 | -- End_Span (Uint5) (set to No_Uint if expander generated) | |
3596 | ||
3597 | -- N_Elsif_Part | |
3598 | -- Sloc points to ELSIF | |
3599 | -- Condition (Node1) | |
3600 | -- Then_Statements (List2) | |
3601 | -- Condition_Actions (List3-Sem) | |
3602 | ||
3603 | -------------------- | |
3604 | -- 5.3 Condition -- | |
3605 | -------------------- | |
3606 | ||
3607 | -- CONDITION ::= boolean_EXPRESSION | |
3608 | ||
3609 | ------------------------- | |
3610 | -- 5.4 Case Statement -- | |
3611 | ------------------------- | |
3612 | ||
3613 | -- CASE_STATEMENT ::= | |
3614 | -- case EXPRESSION is | |
3615 | -- CASE_STATEMENT_ALTERNATIVE | |
3616 | -- {CASE_STATEMENT_ALTERNATIVE} | |
3617 | -- end case; | |
3618 | ||
3619 | -- Note: the Alternatives can contain pragmas. These only occur at | |
3620 | -- the start of the list, since any pragmas occurring after the first | |
3621 | -- alternative are absorbed into the corresponding statement sequence. | |
3622 | ||
3623 | -- N_Case_Statement | |
3624 | -- Sloc points to CASE | |
3625 | -- Expression (Node3) | |
3626 | -- Alternatives (List4) | |
3627 | -- End_Span (Uint5) (set to No_Uint if expander generated) | |
3628 | ||
3629 | ------------------------------------- | |
3630 | -- 5.4 Case Statement Alternative -- | |
3631 | ------------------------------------- | |
3632 | ||
3633 | -- CASE_STATEMENT_ALTERNATIVE ::= | |
3634 | -- when DISCRETE_CHOICE_LIST => | |
3635 | -- SEQUENCE_OF_STATEMENTS | |
3636 | ||
3637 | -- N_Case_Statement_Alternative | |
3638 | -- Sloc points to WHEN | |
3639 | -- Discrete_Choices (List4) | |
3640 | -- Statements (List3) | |
3641 | ||
3642 | ------------------------- | |
3643 | -- 5.5 Loop Statement -- | |
3644 | ------------------------- | |
3645 | ||
3646 | -- LOOP_STATEMENT ::= | |
3647 | -- [loop_STATEMENT_IDENTIFIER :] | |
3648 | -- [ITERATION_SCHEME] loop | |
3649 | -- SEQUENCE_OF_STATEMENTS | |
3650 | -- end loop [loop_IDENTIFIER]; | |
3651 | ||
3652 | -- Note: The occurrence of a loop label is not a defining identifier | |
3653 | -- but rather a referencing occurrence. The defining occurrence is in | |
3654 | -- the implicit label declaration which occurs in the innermost | |
3655 | -- enclosing block. | |
3656 | ||
3657 | -- Note: there is always a loop statement identifier present in | |
3658 | -- the tree, even if none was given in the source. In the case where | |
3659 | -- no loop identifier is given in the source, the parser creates | |
3660 | -- a name of the form _Loop_n, where n is a decimal integer (the | |
3661 | -- two underlines ensure that the loop names created in this manner | |
3662 | -- do not conflict with any user defined identifiers), and the flag | |
3663 | -- Has_Created_Identifier is set to True. The only exception to the | |
3664 | -- rule that all loop statement nodes have identifiers occurs for | |
3665 | -- loops constructed by the expander, and the semantic analyzer will | |
3666 | -- create and supply dummy loop identifiers in these cases. | |
3667 | ||
3668 | -- N_Loop_Statement | |
3669 | -- Sloc points to LOOP | |
3670 | -- Identifier (Node1) loop identifier (set to Empty if no identifier) | |
3671 | -- Iteration_Scheme (Node2) (set to Empty if no iteration scheme) | |
3672 | -- Statements (List3) | |
3673 | -- End_Label (Node4) | |
3674 | -- Has_Created_Identifier (Flag15) | |
fbf5a39b | 3675 | -- Is_Null_Loop (Flag16) |
996ae0b0 RK |
3676 | |
3677 | -------------------------- | |
3678 | -- 5.5 Iteration Scheme -- | |
3679 | -------------------------- | |
3680 | ||
3681 | -- ITERATION_SCHEME ::= | |
3682 | -- while CONDITION | for LOOP_PARAMETER_SPECIFICATION | |
3683 | ||
3684 | -- Gigi restriction: This expander ensures that the type of the | |
3685 | -- Condition field is always Standard.Boolean, even if the type | |
3686 | -- in the source is some non-standard boolean type. | |
3687 | ||
3688 | -- N_Iteration_Scheme | |
3689 | -- Sloc points to WHILE or FOR | |
3690 | -- Condition (Node1) (set to Empty if FOR case) | |
3691 | -- Condition_Actions (List3-Sem) | |
3692 | -- Loop_Parameter_Specification (Node4) (set to Empty if WHILE case) | |
3693 | ||
3694 | --------------------------------------- | |
3695 | -- 5.5 Loop parameter specification -- | |
3696 | --------------------------------------- | |
3697 | ||
3698 | -- LOOP_PARAMETER_SPECIFICATION ::= | |
3699 | -- DEFINING_IDENTIFIER in [reverse] DISCRETE_SUBTYPE_DEFINITION | |
3700 | ||
3701 | -- N_Loop_Parameter_Specification | |
3702 | -- Sloc points to first identifier | |
3703 | -- Defining_Identifier (Node1) | |
3704 | -- Reverse_Present (Flag15) | |
3705 | -- Discrete_Subtype_Definition (Node4) | |
3706 | ||
3707 | -------------------------- | |
3708 | -- 5.6 Block Statement -- | |
3709 | -------------------------- | |
3710 | ||
3711 | -- BLOCK_STATEMENT ::= | |
3712 | -- [block_STATEMENT_IDENTIFIER:] | |
3713 | -- [declare | |
3714 | -- DECLARATIVE_PART] | |
3715 | -- begin | |
3716 | -- HANDLED_SEQUENCE_OF_STATEMENTS | |
3717 | -- end [block_IDENTIFIER]; | |
3718 | ||
3719 | -- Note that the occurrence of a block identifier is not a defining | |
3720 | -- identifier, but rather a referencing occurrence. The defining | |
3721 | -- occurrence is in the implicit label declaration which occurs in | |
3722 | -- the innermost enclosing block. | |
3723 | ||
3724 | -- Note: there is always a block statement identifier present in | |
3725 | -- the tree, even if none was given in the source. In the case where | |
3726 | -- no block identifier is given in the source, the parser creates | |
3727 | -- a name of the form _Block_n, where n is a decimal integer (the | |
3728 | -- two underlines ensure that the block names created in this manner | |
3729 | -- do not conflict with any user defined identifiers), and the flag | |
3730 | -- Has_Created_Identifier is set to True. The only exception to the | |
3731 | -- rule that all loop statement nodes have identifiers occurs for | |
3732 | -- blocks constructed by the expander, and the semantic analyzer | |
3733 | -- creates and supplies dummy names for the blocks). | |
3734 | ||
3735 | -- N_Block_Statement | |
3736 | -- Sloc points to DECLARE or BEGIN | |
3737 | -- Identifier (Node1) block direct name (set to Empty if not present) | |
3738 | -- Declarations (List2) (set to No_List if no DECLARE part) | |
3739 | -- Handled_Statement_Sequence (Node4) | |
3740 | -- Is_Task_Master (Flag5-Sem) | |
3741 | -- Activation_Chain_Entity (Node3-Sem) | |
3742 | -- Has_Created_Identifier (Flag15) | |
3743 | -- Is_Task_Allocation_Block (Flag6) | |
3744 | -- Is_Asynchronous_Call_Block (Flag7) | |
3745 | ||
3746 | ------------------------- | |
3747 | -- 5.7 Exit Statement -- | |
3748 | ------------------------- | |
3749 | ||
3750 | -- EXIT_STATEMENT ::= exit [loop_NAME] [when CONDITION]; | |
3751 | ||
3752 | -- Gigi restriction: This expander ensures that the type of the | |
3753 | -- Condition field is always Standard.Boolean, even if the type | |
3754 | -- in the source is some non-standard boolean type. | |
3755 | ||
3756 | -- N_Exit_Statement | |
3757 | -- Sloc points to EXIT | |
3758 | -- Name (Node2) (set to Empty if no loop name present) | |
3759 | -- Condition (Node1) (set to Empty if no when part present) | |
3760 | ||
3761 | ------------------------- | |
3762 | -- 5.9 Goto Statement -- | |
3763 | ------------------------- | |
3764 | ||
3765 | -- GOTO_STATEMENT ::= goto label_NAME; | |
3766 | ||
3767 | -- N_Goto_Statement | |
3768 | -- Sloc points to GOTO | |
3769 | -- Name (Node2) | |
3770 | -- Exception_Junk (Flag11-Sem) | |
3771 | ||
3772 | --------------------------------- | |
3773 | -- 6.1 Subprogram Declaration -- | |
3774 | --------------------------------- | |
3775 | ||
3776 | -- SUBPROGRAM_DECLARATION ::= SUBPROGRAM_SPECIFICATION; | |
3777 | ||
3778 | -- N_Subprogram_Declaration | |
3779 | -- Sloc points to FUNCTION or PROCEDURE | |
3780 | -- Specification (Node1) | |
3781 | -- Body_To_Inline (Node3-Sem) | |
3782 | -- Corresponding_Body (Node5-Sem) | |
3783 | -- Parent_Spec (Node4-Sem) | |
3784 | ||
3785 | ------------------------------------------ | |
3786 | -- 6.1 Abstract Subprogram Declaration -- | |
3787 | ------------------------------------------ | |
3788 | ||
3789 | -- ABSTRACT_SUBPROGRAM_DECLARATION ::= | |
3790 | -- SUBPROGRAM_SPECIFICATION is abstract; | |
3791 | ||
3792 | -- N_Abstract_Subprogram_Declaration | |
3793 | -- Sloc points to ABSTRACT | |
3794 | -- Specification (Node1) | |
3795 | ||
3796 | ----------------------------------- | |
3797 | -- 6.1 Subprogram Specification -- | |
3798 | ----------------------------------- | |
3799 | ||
3800 | -- SUBPROGRAM_SPECIFICATION ::= | |
3801 | -- procedure DEFINING_PROGRAM_UNIT_NAME PARAMETER_PROFILE | |
3802 | -- | function DEFINING_DESIGNATOR PARAMETER_AND_RESULT_PROFILE | |
3803 | ||
3804 | -- Note: there are no separate nodes for the profiles, instead the | |
3805 | -- information appears directly in the following nodes. | |
3806 | ||
3807 | -- N_Function_Specification | |
3808 | -- Sloc points to FUNCTION | |
3809 | -- Defining_Unit_Name (Node1) (the designator) | |
3810 | -- Elaboration_Boolean (Node2-Sem) | |
3811 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
3812 | -- Subtype_Mark (Node4) for return type | |
3813 | -- Generic_Parent (Node5-Sem) | |
3814 | ||
3815 | -- N_Procedure_Specification | |
3816 | -- Sloc points to PROCEDURE | |
3817 | -- Defining_Unit_Name (Node1) | |
3818 | -- Elaboration_Boolean (Node2-Sem) | |
3819 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
3820 | -- Generic_Parent (Node5-Sem) | |
3821 | ||
3822 | --------------------- | |
3823 | -- 6.1 Designator -- | |
3824 | --------------------- | |
3825 | ||
3826 | -- DESIGNATOR ::= | |
3827 | -- [PARENT_UNIT_NAME .] IDENTIFIER | OPERATOR_SYMBOL | |
3828 | ||
3829 | -- Designators that are simply identifiers or operator symbols appear | |
3830 | -- directly in the tree in this form. The following node is used only | |
3831 | -- in the case where the designator has a parent unit name component. | |
3832 | ||
3833 | -- N_Designator | |
3834 | -- Sloc points to period | |
3835 | -- Name (Node2) holds the parent unit name. Note that this is always | |
3836 | -- non-Empty, since this node is only used for the case where a | |
3837 | -- parent library unit package name is present. | |
3838 | -- Identifier (Node1) | |
3839 | ||
3840 | -- Note that the identifier can also be an operator symbol here. | |
3841 | ||
3842 | ------------------------------ | |
3843 | -- 6.1 Defining Designator -- | |
3844 | ------------------------------ | |
3845 | ||
3846 | -- DEFINING_DESIGNATOR ::= | |
3847 | -- DEFINING_PROGRAM_UNIT_NAME | DEFINING_OPERATOR_SYMBOL | |
3848 | ||
3849 | ------------------------------------- | |
3850 | -- 6.1 Defining Program Unit Name -- | |
3851 | ------------------------------------- | |
3852 | ||
3853 | -- DEFINING_PROGRAM_UNIT_NAME ::= | |
3854 | -- [PARENT_UNIT_NAME .] DEFINING_IDENTIFIER | |
3855 | ||
3856 | -- The parent unit name is present only in the case of a child unit | |
3857 | -- name (permissible only for Ada 95 for a library level unit, i.e. | |
3858 | -- a unit at scope level one). If no such name is present, the defining | |
3859 | -- program unit name is represented simply as the defining identifier. | |
3860 | -- In the child unit case, the following node is used to represent the | |
3861 | -- child unit name. | |
3862 | ||
3863 | -- N_Defining_Program_Unit_Name | |
3864 | -- Sloc points to period | |
3865 | -- Name (Node2) holds the parent unit name. Note that this is always | |
3866 | -- non-Empty, since this node is only used for the case where a | |
3867 | -- parent unit name is present. | |
3868 | -- Defining_Identifier (Node1) | |
3869 | ||
3870 | -------------------------- | |
3871 | -- 6.1 Operator Symbol -- | |
3872 | -------------------------- | |
3873 | ||
3874 | -- OPERATOR_SYMBOL ::= STRING_LITERAL | |
3875 | ||
3876 | -- Note: the fields of the N_Operator_Symbol node are laid out to | |
3877 | -- match the corresponding fields of an N_Character_Literal node. This | |
3878 | -- allows easy conversion of the operator symbol node into a character | |
3879 | -- literal node in the case where a string constant of the form of an | |
3880 | -- operator symbol is scanned out as such, but turns out semantically | |
3881 | -- to be a string literal that is not an operator. For details see | |
3882 | -- Sinfo.CN.Change_Operator_Symbol_To_String_Literal. | |
3883 | ||
3884 | -- N_Operator_Symbol | |
3885 | -- Sloc points to literal | |
3886 | -- Chars (Name1) contains the Name_Id for the operator symbol | |
3887 | -- Strval (Str3) Id of string value. This is used if the operator | |
3888 | -- symbol turns out to be a normal string after all. | |
3889 | -- Entity (Node4-Sem) | |
3e542a58 | 3890 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
3891 | -- Has_Private_View (Flag11-Sem) set in generic units. |
3892 | -- Etype (Node5-Sem) | |
3893 | ||
3894 | -- Note: the Strval field may be set to No_String for generated | |
3895 | -- operator symbols that are known not to be string literals | |
3896 | -- semantically. | |
3897 | ||
3898 | ----------------------------------- | |
3899 | -- 6.1 Defining Operator Symbol -- | |
3900 | ----------------------------------- | |
3901 | ||
3902 | -- DEFINING_OPERATOR_SYMBOL ::= OPERATOR_SYMBOL | |
3903 | ||
3904 | -- A defining operator symbol is an entity, which has additional | |
3905 | -- fields depending on the setting of the Ekind field. These | |
3906 | -- additional fields are defined (and access subprograms declared) | |
3907 | -- in package Einfo. | |
3908 | ||
3909 | -- Note: N_Defining_Operator_Symbol is an extended node whose fields | |
3910 | -- are deliberately layed out to match the layout of fields in an | |
3911 | -- ordinary N_Operator_Symbol node allowing for easy alteration of | |
3912 | -- an operator symbol node into a defining operator symbol node. | |
3913 | -- See Sinfo.CN.Change_Operator_Symbol_To_Defining_Operator_Symbol | |
3914 | -- for further details. | |
3915 | ||
3916 | -- N_Defining_Operator_Symbol | |
3917 | -- Sloc points to literal | |
3918 | -- Chars (Name1) contains the Name_Id for the operator symbol | |
3919 | -- Next_Entity (Node2-Sem) | |
3920 | -- Scope (Node3-Sem) | |
3921 | -- Etype (Node5-Sem) | |
3922 | ||
3923 | ---------------------------- | |
3924 | -- 6.1 Parameter Profile -- | |
3925 | ---------------------------- | |
3926 | ||
3927 | -- PARAMETER_PROFILE ::= [FORMAL_PART] | |
3928 | ||
3929 | --------------------------------------- | |
3930 | -- 6.1 Parameter and Result Profile -- | |
3931 | --------------------------------------- | |
3932 | ||
3933 | -- PARAMETER_AND_RESULT_PROFILE ::= [FORMAL_PART] return SUBTYPE_MARK | |
3934 | ||
3935 | -- There is no explicit node in the tree for a parameter and result | |
3936 | -- profile. Instead the information appears directly in the parent. | |
3937 | ||
3938 | ---------------------- | |
3939 | -- 6.1 Formal part -- | |
3940 | ---------------------- | |
3941 | ||
3942 | -- FORMAL_PART ::= | |
3943 | -- (PARAMETER_SPECIFICATION {; PARAMETER_SPECIFICATION}) | |
3944 | ||
3945 | ---------------------------------- | |
3946 | -- 6.1 Parameter specification -- | |
3947 | ---------------------------------- | |
3948 | ||
3949 | -- PARAMETER_SPECIFICATION ::= | |
3950 | -- DEFINING_IDENTIFIER_LIST : MODE SUBTYPE_MARK | |
3951 | -- [:= DEFAULT_EXPRESSION] | |
3952 | -- | DEFINING_IDENTIFIER_LIST : ACCESS_DEFINITION | |
3953 | -- [:= DEFAULT_EXPRESSION] | |
3954 | ||
3955 | -- Although the syntax allows multiple identifiers in the list, the | |
3956 | -- semantics is as though successive specifications were given with | |
3957 | -- identical type definition and expression components. To simplify | |
3958 | -- semantic processing, the parser represents a multiple declaration | |
3959 | -- case as a sequence of single Specifications, using the More_Ids and | |
3960 | -- Prev_Ids flags to preserve the original source form as described | |
3961 | -- in the section on "Handling of Defining Identifier Lists". | |
3962 | ||
3963 | -- N_Parameter_Specification | |
3964 | -- Sloc points to first identifier | |
3965 | -- Defining_Identifier (Node1) | |
3966 | -- In_Present (Flag15) | |
3967 | -- Out_Present (Flag17) | |
3968 | -- Parameter_Type (Node2) subtype mark or access definition | |
3969 | -- Expression (Node3) (set to Empty if no default expression present) | |
3970 | -- Do_Accessibility_Check (Flag13-Sem) | |
3971 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
3972 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
3973 | -- Default_Expression (Node5-Sem) | |
3974 | ||
3975 | --------------- | |
3976 | -- 6.1 Mode -- | |
3977 | --------------- | |
3978 | ||
3979 | -- MODE ::= [in] | in out | out | |
3980 | ||
3981 | -- There is no explicit node in the tree for the Mode. Instead the | |
3982 | -- In_Present and Out_Present flags are set in the parent node to | |
3983 | -- record the presence of keywords specifying the mode. | |
3984 | ||
3985 | -------------------------- | |
3986 | -- 6.3 Subprogram Body -- | |
3987 | -------------------------- | |
3988 | ||
3989 | -- SUBPROGRAM_BODY ::= | |
3990 | -- SUBPROGRAM_SPECIFICATION is | |
3991 | -- DECLARATIVE_PART | |
3992 | -- begin | |
3993 | -- HANDLED_SEQUENCE_OF_STATEMENTS | |
3994 | -- end [DESIGNATOR]; | |
3995 | ||
3996 | -- N_Subprogram_Body | |
3997 | -- Sloc points to FUNCTION or PROCEDURE | |
3998 | -- Specification (Node1) | |
3999 | -- Declarations (List2) | |
4000 | -- Handled_Statement_Sequence (Node4) | |
4001 | -- Activation_Chain_Entity (Node3-Sem) | |
4002 | -- Corresponding_Spec (Node5-Sem) | |
4003 | -- Acts_As_Spec (Flag4-Sem) | |
4004 | -- Bad_Is_Detected (Flag15) used only by parser | |
4005 | -- Do_Storage_Check (Flag17-Sem) | |
4006 | -- Has_Priority_Pragma (Flag6-Sem) | |
4007 | -- Is_Protected_Subprogram_Body (Flag7-Sem) | |
4008 | -- Is_Task_Master (Flag5-Sem) | |
4009 | -- Was_Originally_Stub (Flag13-Sem) | |
4010 | ||
4011 | ----------------------------------- | |
4012 | -- 6.4 Procedure Call Statement -- | |
4013 | ----------------------------------- | |
4014 | ||
4015 | -- PROCEDURE_CALL_STATEMENT ::= | |
4016 | -- procedure_NAME; | procedure_PREFIX ACTUAL_PARAMETER_PART; | |
4017 | ||
4018 | -- Note: the reason that a procedure call has expression fields is | |
4019 | -- that it semantically resembles an expression, e.g. overloading is | |
4020 | -- allowed and a type is concocted for semantic processing purposes. | |
4021 | -- Certain of these fields, such as Parens are not relevant, but it | |
4022 | -- is easier to just supply all of them together! | |
4023 | ||
4024 | -- N_Procedure_Call_Statement | |
4025 | -- Sloc points to first token of name or prefix | |
4026 | -- Name (Node2) stores name or prefix | |
4027 | -- Parameter_Associations (List3) (set to No_List if no | |
4028 | -- actual parameter part) | |
4029 | -- First_Named_Actual (Node4-Sem) | |
4030 | -- Controlling_Argument (Node1-Sem) (set to Empty if not dispatching) | |
4031 | -- Do_Tag_Check (Flag13-Sem) | |
4032 | -- Parameter_List_Truncated (Flag17-Sem) | |
4033 | -- ABE_Is_Certain (Flag18-Sem) | |
4034 | -- plus fields for expression | |
4035 | ||
4036 | -- If any IN parameter requires a range check, then the corresponding | |
4037 | -- argument expression has the Do_Range_Check flag set, and the range | |
4038 | -- check is done against the formal type. Note that this argument | |
4039 | -- expression may appear directly in the Parameter_Associations list, | |
4040 | -- or may be a descendent of an N_Parameter_Association node that | |
4041 | -- appears in this list. | |
4042 | ||
4043 | ------------------------ | |
4044 | -- 6.4 Function Call -- | |
4045 | ------------------------ | |
4046 | ||
4047 | -- FUNCTION_CALL ::= | |
4048 | -- function_NAME | function_PREFIX ACTUAL_PARAMETER_PART | |
4049 | ||
4050 | -- Note: the parser may generate an indexed component node or simply | |
4051 | -- a name node instead of a function call node. The semantic pass must | |
4052 | -- correct this misidentification. | |
4053 | ||
4054 | -- N_Function_Call | |
4055 | -- Sloc points to first token of name or prefix | |
4056 | -- Name (Node2) stores name or prefix | |
4057 | -- Parameter_Associations (List3) (set to No_List if no | |
4058 | -- actual parameter part) | |
4059 | -- First_Named_Actual (Node4-Sem) | |
4060 | -- Controlling_Argument (Node1-Sem) (set to Empty if not dispatching) | |
4061 | -- Do_Tag_Check (Flag13-Sem) | |
4062 | -- Parameter_List_Truncated (Flag17-Sem) | |
4063 | -- ABE_Is_Certain (Flag18-Sem) | |
4064 | -- plus fields for expression | |
4065 | ||
4066 | -------------------------------- | |
4067 | -- 6.4 Actual Parameter Part -- | |
4068 | -------------------------------- | |
4069 | ||
4070 | -- ACTUAL_PARAMETER_PART ::= | |
4071 | -- (PARAMETER_ASSOCIATION {,PARAMETER_ASSOCIATION}) | |
4072 | ||
4073 | -------------------------------- | |
4074 | -- 6.4 Parameter Association -- | |
4075 | -------------------------------- | |
4076 | ||
4077 | -- PARAMETER_ASSOCIATION ::= | |
4078 | -- [formal_parameter_SELECTOR_NAME =>] EXPLICIT_ACTUAL_PARAMETER | |
4079 | ||
4080 | -- Note: the N_Parameter_Association node is built only if a formal | |
4081 | -- parameter selector name is present, otherwise the parameter | |
4082 | -- association appears in the tree simply as the node for the | |
4083 | -- explicit actual parameter. | |
4084 | ||
4085 | -- N_Parameter_Association | |
4086 | -- Sloc points to formal parameter | |
4087 | -- Selector_Name (Node2) (always non-Empty, since this node is | |
4088 | -- only used if a formal parameter selector name is present) | |
4089 | -- Explicit_Actual_Parameter (Node3) | |
4090 | -- Next_Named_Actual (Node4-Sem) | |
4091 | ||
4092 | --------------------------- | |
4093 | -- 6.4 Actual Parameter -- | |
4094 | --------------------------- | |
4095 | ||
4096 | -- EXPLICIT_ACTUAL_PARAMETER ::= EXPRESSION | variable_NAME | |
4097 | ||
4098 | --------------------------- | |
4099 | -- 6.5 Return Statement -- | |
4100 | --------------------------- | |
4101 | ||
4102 | -- RETURN_STATEMENT ::= return [EXPRESSION]; | |
4103 | ||
4104 | -- N_Return_Statement | |
4105 | -- Sloc points to RETURN | |
4106 | -- Expression (Node3) (set to Empty if no expression present) | |
4107 | -- Storage_Pool (Node1-Sem) | |
4108 | -- Procedure_To_Call (Node4-Sem) | |
4109 | -- Do_Tag_Check (Flag13-Sem) | |
4110 | -- Return_Type (Node2-Sem) | |
4111 | -- By_Ref (Flag5-Sem) | |
4112 | ||
4113 | -- Note: if a range check is required, then Do_Range_Check is set | |
4114 | -- on the Expression. The range check is against Return_Type. | |
4115 | ||
4116 | ------------------------------ | |
4117 | -- 7.1 Package Declaration -- | |
4118 | ------------------------------ | |
4119 | ||
4120 | -- PACKAGE_DECLARATION ::= PACKAGE_SPECIFICATION; | |
4121 | ||
4122 | -- Note: the activation chain entity for a package spec is used for | |
4123 | -- all tasks declared in the package spec, or in the package body. | |
4124 | ||
4125 | -- N_Package_Declaration | |
4126 | -- Sloc points to PACKAGE | |
4127 | -- Specification (Node1) | |
4128 | -- Corresponding_Body (Node5-Sem) | |
4129 | -- Parent_Spec (Node4-Sem) | |
4130 | -- Activation_Chain_Entity (Node3-Sem) | |
4131 | ||
4132 | -------------------------------- | |
4133 | -- 7.1 Package Specification -- | |
4134 | -------------------------------- | |
4135 | ||
4136 | -- PACKAGE_SPECIFICATION ::= | |
4137 | -- package DEFINING_PROGRAM_UNIT_NAME is | |
4138 | -- {BASIC_DECLARATIVE_ITEM} | |
4139 | -- [private | |
4140 | -- {BASIC_DECLARATIVE_ITEM}] | |
4141 | -- end [[PARENT_UNIT_NAME .] IDENTIFIER] | |
4142 | ||
4143 | -- N_Package_Specification | |
4144 | -- Sloc points to PACKAGE | |
4145 | -- Defining_Unit_Name (Node1) | |
4146 | -- Visible_Declarations (List2) | |
4147 | -- Private_Declarations (List3) (set to No_List if no private | |
4148 | -- part present) | |
4149 | -- End_Label (Node4) | |
4150 | -- Generic_Parent (Node5-Sem) | |
fbf5a39b | 4151 | -- Limited_View_Installed (Flag18-Sem) |
996ae0b0 RK |
4152 | |
4153 | ----------------------- | |
4154 | -- 7.1 Package Body -- | |
4155 | ----------------------- | |
4156 | ||
4157 | -- PACKAGE_BODY ::= | |
4158 | -- package body DEFINING_PROGRAM_UNIT_NAME is | |
4159 | -- DECLARATIVE_PART | |
4160 | -- [begin | |
4161 | -- HANDLED_SEQUENCE_OF_STATEMENTS] | |
4162 | -- end [[PARENT_UNIT_NAME .] IDENTIFIER]; | |
4163 | ||
4164 | -- N_Package_Body | |
4165 | -- Sloc points to PACKAGE | |
4166 | -- Defining_Unit_Name (Node1) | |
4167 | -- Declarations (List2) | |
4168 | -- Handled_Statement_Sequence (Node4) (set to Empty if no HSS present) | |
4169 | -- Corresponding_Spec (Node5-Sem) | |
4170 | -- Was_Originally_Stub (Flag13-Sem) | |
4171 | ||
4172 | -- Note: if a source level package does not contain a handled sequence | |
4173 | -- of statements, then the parser supplies a dummy one with a null | |
4174 | -- sequence of statements. Comes_From_Source will be False in this | |
4175 | -- constructed sequence. The reason we need this is for the End_Label | |
4176 | -- field in the HSS. | |
4177 | ||
4178 | ----------------------------------- | |
4179 | -- 7.4 Private Type Declaration -- | |
4180 | ----------------------------------- | |
4181 | ||
4182 | -- PRIVATE_TYPE_DECLARATION ::= | |
4183 | -- type DEFINING_IDENTIFIER [DISCRIMINANT_PART] | |
4184 | -- is [[abstract] tagged] [limited] private; | |
4185 | ||
4186 | -- Note: TAGGED is not permitted in Ada 83 mode | |
4187 | ||
4188 | -- N_Private_Type_Declaration | |
4189 | -- Sloc points to TYPE | |
4190 | -- Defining_Identifier (Node1) | |
4191 | -- Discriminant_Specifications (List4) (set to No_List if no | |
4192 | -- discriminant part) | |
4193 | -- Unknown_Discriminants_Present (Flag13) set if (<>) discriminant | |
4194 | -- Abstract_Present (Flag4) | |
4195 | -- Tagged_Present (Flag15) | |
4196 | -- Limited_Present (Flag17) | |
4197 | ||
4198 | ---------------------------------------- | |
4199 | -- 7.4 Private Extension Declaration -- | |
4200 | ---------------------------------------- | |
4201 | ||
4202 | -- PRIVATE_EXTENSION_DECLARATION ::= | |
4203 | -- type DEFINING_IDENTIFIER [DISCRIMINANT_PART] is | |
4204 | -- [abstract] new ancestor_SUBTYPE_INDICATION with private; | |
4205 | ||
4206 | -- Note: private extension declarations are not allowed in Ada 83 mode | |
4207 | ||
4208 | -- N_Private_Extension_Declaration | |
4209 | -- Sloc points to TYPE | |
4210 | -- Defining_Identifier (Node1) | |
4211 | -- Discriminant_Specifications (List4) (set to No_List if no | |
4212 | -- discriminant part) | |
4213 | -- Unknown_Discriminants_Present (Flag13) set if (<>) discriminant | |
4214 | -- Abstract_Present (Flag4) | |
4215 | -- Subtype_Indication (Node5) | |
4216 | ||
4217 | --------------------- | |
4218 | -- 8.4 Use Clause -- | |
4219 | --------------------- | |
4220 | ||
4221 | -- USE_CLAUSE ::= USE_PACKAGE_CLAUSE | USE_TYPE_CLAUSE | |
4222 | ||
4223 | ----------------------------- | |
4224 | -- 8.4 Use Package Clause -- | |
4225 | ----------------------------- | |
4226 | ||
4227 | -- USE_PACKAGE_CLAUSE ::= use package_NAME {, package_NAME}; | |
4228 | ||
4229 | -- N_Use_Package_Clause | |
4230 | -- Sloc points to USE | |
4231 | -- Names (List2) | |
4232 | -- Next_Use_Clause (Node3-Sem) | |
4233 | -- Hidden_By_Use_Clause (Elist4-Sem) | |
4234 | ||
4235 | -------------------------- | |
4236 | -- 8.4 Use Type Clause -- | |
4237 | -------------------------- | |
4238 | ||
4239 | -- USE_TYPE_CLAUSE ::= use type SUBTYPE_MARK {, SUBTYPE_MARK}; | |
4240 | ||
4241 | -- Note: use type clause is not permitted in Ada 83 mode | |
4242 | ||
4243 | -- N_Use_Type_Clause | |
4244 | -- Sloc points to USE | |
4245 | -- Subtype_Marks (List2) | |
4246 | -- Next_Use_Clause (Node3-Sem) | |
4247 | -- Hidden_By_Use_Clause (Elist4-Sem) | |
4248 | ||
4249 | ------------------------------- | |
4250 | -- 8.5 Renaming Declaration -- | |
4251 | ------------------------------- | |
4252 | ||
4253 | -- RENAMING_DECLARATION ::= | |
4254 | -- OBJECT_RENAMING_DECLARATION | |
4255 | -- | EXCEPTION_RENAMING_DECLARATION | |
4256 | -- | PACKAGE_RENAMING_DECLARATION | |
4257 | -- | SUBPROGRAM_RENAMING_DECLARATION | |
4258 | -- | GENERIC_RENAMING_DECLARATION | |
4259 | ||
4260 | -------------------------------------- | |
4261 | -- 8.5 Object Renaming Declaration -- | |
4262 | -------------------------------------- | |
4263 | ||
4264 | -- OBJECT_RENAMING_DECLARATION ::= | |
4265 | -- DEFINING_IDENTIFIER : SUBTYPE_MARK renames object_NAME; | |
4266 | ||
4267 | -- N_Object_Renaming_Declaration | |
4268 | -- Sloc points to first identifier | |
4269 | -- Defining_Identifier (Node1) | |
4270 | -- Subtype_Mark (Node4) | |
4271 | -- Name (Node2) | |
4272 | -- Corresponding_Generic_Association (Node5-Sem) | |
4273 | ||
4274 | ----------------------------------------- | |
4275 | -- 8.5 Exception Renaming Declaration -- | |
4276 | ----------------------------------------- | |
4277 | ||
4278 | -- EXCEPTION_RENAMING_DECLARATION ::= | |
4279 | -- DEFINING_IDENTIFIER : exception renames exception_NAME; | |
4280 | ||
4281 | -- N_Exception_Renaming_Declaration | |
4282 | -- Sloc points to first identifier | |
4283 | -- Defining_Identifier (Node1) | |
4284 | -- Name (Node2) | |
4285 | ||
4286 | --------------------------------------- | |
4287 | -- 8.5 Package Renaming Declaration -- | |
4288 | --------------------------------------- | |
4289 | ||
4290 | -- PACKAGE_RENAMING_DECLARATION ::= | |
4291 | -- package DEFINING_PROGRAM_UNIT_NAME renames package_NAME; | |
4292 | ||
4293 | -- N_Package_Renaming_Declaration | |
4294 | -- Sloc points to PACKAGE | |
4295 | -- Defining_Unit_Name (Node1) | |
4296 | -- Name (Node2) | |
4297 | -- Parent_Spec (Node4-Sem) | |
4298 | ||
4299 | ------------------------------------------ | |
4300 | -- 8.5 Subprogram Renaming Declaration -- | |
4301 | ------------------------------------------ | |
4302 | ||
4303 | -- SUBPROGRAM_RENAMING_DECLARATION ::= | |
4304 | -- SUBPROGRAM_SPECIFICATION renames callable_entity_NAME; | |
4305 | ||
4306 | -- N_Subprogram_Renaming_Declaration | |
4307 | -- Sloc points to RENAMES | |
4308 | -- Specification (Node1) | |
4309 | -- Name (Node2) | |
4310 | -- Parent_Spec (Node4-Sem) | |
4311 | -- Corresponding_Spec (Node5-Sem) | |
4312 | ||
4313 | ----------------------------------------- | |
4314 | -- 8.5.5 Generic Renaming Declaration -- | |
4315 | ----------------------------------------- | |
4316 | ||
4317 | -- GENERIC_RENAMING_DECLARATION ::= | |
4318 | -- generic package DEFINING_PROGRAM_UNIT_NAME | |
4319 | -- renames generic_package_NAME | |
4320 | -- | generic procedure DEFINING_PROGRAM_UNIT_NAME | |
4321 | -- renames generic_procedure_NAME | |
4322 | -- | generic function DEFINING_PROGRAM_UNIT_NAME | |
4323 | -- renames generic_function_NAME | |
4324 | ||
4325 | -- N_Generic_Package_Renaming_Declaration | |
4326 | -- Sloc points to GENERIC | |
4327 | -- Defining_Unit_Name (Node1) | |
4328 | -- Name (Node2) | |
4329 | -- Parent_Spec (Node4-Sem) | |
4330 | ||
4331 | -- N_Generic_Procedure_Renaming_Declaration | |
4332 | -- Sloc points to GENERIC | |
4333 | -- Defining_Unit_Name (Node1) | |
4334 | -- Name (Node2) | |
4335 | -- Parent_Spec (Node4-Sem) | |
4336 | ||
4337 | -- N_Generic_Function_Renaming_Declaration | |
4338 | -- Sloc points to GENERIC | |
4339 | -- Defining_Unit_Name (Node1) | |
4340 | -- Name (Node2) | |
4341 | -- Parent_Spec (Node4-Sem) | |
4342 | ||
4343 | -------------------------------- | |
4344 | -- 9.1 Task Type Declaration -- | |
4345 | -------------------------------- | |
4346 | ||
4347 | -- TASK_TYPE_DECLARATION ::= | |
4348 | -- task type DEFINING_IDENTIFIER [KNOWN_DISCRIMINANT_PART] | |
4349 | -- [is TASK_DEFINITITION]; | |
4350 | ||
4351 | -- N_Task_Type_Declaration | |
4352 | -- Sloc points to TASK | |
4353 | -- Defining_Identifier (Node1) | |
4354 | -- Task_Body_Procedure (Node2-Sem) | |
4355 | -- Discriminant_Specifications (List4) (set to No_List if no | |
4356 | -- discriminant part) | |
4357 | -- Task_Definition (Node3) (set to Empty if not present) | |
4358 | -- Corresponding_Body (Node5-Sem) | |
4359 | ||
4360 | ---------------------------------- | |
4361 | -- 9.1 Single Task Declaration -- | |
4362 | ---------------------------------- | |
4363 | ||
4364 | -- SINGLE_TASK_DECLARATION ::= | |
4365 | -- task DEFINING_IDENTIFIER [is TASK_DEFINITION]; | |
4366 | ||
4367 | -- N_Single_Task_Declaration | |
4368 | -- Sloc points to TASK | |
4369 | -- Defining_Identifier (Node1) | |
4370 | -- Task_Definition (Node3) (set to Empty if not present) | |
4371 | ||
4372 | -------------------------- | |
4373 | -- 9.1 Task Definition -- | |
4374 | -------------------------- | |
4375 | ||
4376 | -- TASK_DEFINITION ::= | |
4377 | -- {TASK_ITEM} | |
4378 | -- [private | |
4379 | -- {TASK_ITEM}] | |
4380 | -- end [task_IDENTIFIER] | |
4381 | ||
4382 | -- Note: as a result of semantic analysis, the list of task items can | |
4383 | -- include implicit type declarations resulting from entry families. | |
4384 | ||
4385 | -- N_Task_Definition | |
4386 | -- Sloc points to first token of task definition | |
4387 | -- Visible_Declarations (List2) | |
4388 | -- Private_Declarations (List3) (set to No_List if no private part) | |
4389 | -- End_Label (Node4) | |
4390 | -- Has_Priority_Pragma (Flag6-Sem) | |
4391 | -- Has_Storage_Size_Pragma (Flag5-Sem) | |
4392 | -- Has_Task_Info_Pragma (Flag7-Sem) | |
4393 | -- Has_Task_Name_Pragma (Flag8-Sem) | |
4394 | ||
4395 | -------------------- | |
4396 | -- 9.1 Task Item -- | |
4397 | -------------------- | |
4398 | ||
4399 | -- TASK_ITEM ::= ENTRY_DECLARATION | REPRESENTATION_CLAUSE | |
4400 | ||
4401 | -------------------- | |
4402 | -- 9.1 Task Body -- | |
4403 | -------------------- | |
4404 | ||
4405 | -- TASK_BODY ::= | |
4406 | -- task body task_DEFINING_IDENTIFIER is | |
4407 | -- DECLARATIVE_PART | |
4408 | -- begin | |
4409 | -- HANDLED_SEQUENCE_OF_STATEMENTS | |
4410 | -- end [task_IDENTIFIER]; | |
4411 | ||
4412 | -- Gigi restriction: This node never appears. | |
4413 | ||
4414 | -- N_Task_Body | |
4415 | -- Sloc points to TASK | |
4416 | -- Defining_Identifier (Node1) | |
4417 | -- Declarations (List2) | |
4418 | -- Handled_Statement_Sequence (Node4) | |
4419 | -- Is_Task_Master (Flag5-Sem) | |
4420 | -- Activation_Chain_Entity (Node3-Sem) | |
4421 | -- Corresponding_Spec (Node5-Sem) | |
4422 | -- Was_Originally_Stub (Flag13-Sem) | |
4423 | ||
4424 | ------------------------------------- | |
4425 | -- 9.4 Protected Type Declaration -- | |
4426 | ------------------------------------- | |
4427 | ||
4428 | -- PROTECTED_TYPE_DECLARATION ::= | |
4429 | -- protected type DEFINING_IDENTIFIER [KNOWN_DISCRIMINANT_PART] | |
4430 | -- is PROTECTED_DEFINITION; | |
4431 | ||
4432 | -- Note: protected type declarations are not permitted in Ada 83 mode | |
4433 | ||
4434 | -- N_Protected_Type_Declaration | |
4435 | -- Sloc points to PROTECTED | |
4436 | -- Defining_Identifier (Node1) | |
4437 | -- Discriminant_Specifications (List4) (set to No_List if no | |
4438 | -- discriminant part) | |
4439 | -- Protected_Definition (Node3) | |
4440 | -- Corresponding_Body (Node5-Sem) | |
4441 | ||
4442 | --------------------------------------- | |
4443 | -- 9.4 Single Protected Declaration -- | |
4444 | --------------------------------------- | |
4445 | ||
4446 | -- SINGLE_PROTECTED_DECLARATION ::= | |
4447 | -- protected DEFINING_IDENTIFIER is PROTECTED_DEFINITION; | |
4448 | ||
4449 | -- Note: single protected declarations are not allowed in Ada 83 mode | |
4450 | ||
4451 | -- N_Single_Protected_Declaration | |
4452 | -- Sloc points to PROTECTED | |
4453 | -- Defining_Identifier (Node1) | |
4454 | -- Protected_Definition (Node3) | |
4455 | ||
4456 | ------------------------------- | |
4457 | -- 9.4 Protected Definition -- | |
4458 | ------------------------------- | |
4459 | ||
4460 | -- PROTECTED_DEFINITION ::= | |
4461 | -- {PROTECTED_OPERATION_DECLARATION} | |
4462 | -- [private | |
4463 | -- {PROTECTED_ELEMENT_DECLARATION}] | |
4464 | -- end [protected_IDENTIFIER] | |
4465 | ||
4466 | -- N_Protected_Definition | |
4467 | -- Sloc points to first token of protected definition | |
4468 | -- Visible_Declarations (List2) | |
4469 | -- Private_Declarations (List3) (set to No_List if no private part) | |
4470 | -- End_Label (Node4) | |
4471 | -- Has_Priority_Pragma (Flag6-Sem) | |
4472 | ||
4473 | ------------------------------------------ | |
4474 | -- 9.4 Protected Operation Declaration -- | |
4475 | ------------------------------------------ | |
4476 | ||
4477 | -- PROTECTED_OPERATION_DECLARATION ::= | |
4478 | -- SUBPROGRAM_DECLARATION | |
4479 | -- | ENTRY_DECLARATION | |
4480 | -- | REPRESENTATION_CLAUSE | |
4481 | ||
4482 | ---------------------------------------- | |
4483 | -- 9.4 Protected Element Declaration -- | |
4484 | ---------------------------------------- | |
4485 | ||
4486 | -- PROTECTED_ELEMENT_DECLARATION ::= | |
4487 | -- PROTECTED_OPERATION_DECLARATION | COMPONENT_DECLARATION | |
4488 | ||
4489 | ------------------------- | |
4490 | -- 9.4 Protected Body -- | |
4491 | ------------------------- | |
4492 | ||
4493 | -- PROTECTED_BODY ::= | |
4494 | -- protected body DEFINING_IDENTIFIER is | |
4495 | -- {PROTECTED_OPERATION_ITEM} | |
4496 | -- end [protected_IDENTIFIER]; | |
4497 | ||
4498 | -- Note: protected bodies are not allowed in Ada 83 mode | |
4499 | ||
4500 | -- Gigi restriction: This node never appears. | |
4501 | ||
4502 | -- N_Protected_Body | |
4503 | -- Sloc points to PROTECTED | |
4504 | -- Defining_Identifier (Node1) | |
4505 | -- Declarations (List2) protected operation items (and pragmas) | |
4506 | -- End_Label (Node4) | |
4507 | -- Corresponding_Spec (Node5-Sem) | |
4508 | -- Was_Originally_Stub (Flag13-Sem) | |
4509 | ||
4510 | ----------------------------------- | |
4511 | -- 9.4 Protected Operation Item -- | |
4512 | ----------------------------------- | |
4513 | ||
4514 | -- PROTECTED_OPERATION_ITEM ::= | |
4515 | -- SUBPROGRAM_DECLARATION | |
4516 | -- | SUBPROGRAM_BODY | |
4517 | -- | ENTRY_BODY | |
4518 | -- | REPRESENTATION_CLAUSE | |
4519 | ||
4520 | ------------------------------ | |
4521 | -- 9.5.2 Entry Declaration -- | |
4522 | ------------------------------ | |
4523 | ||
4524 | -- ENTRY_DECLARATION ::= | |
4525 | -- entry DEFINING_IDENTIFIER | |
4526 | -- [(DISCRETE_SUBTYPE_DEFINITION)] PARAMETER_PROFILE; | |
4527 | ||
4528 | -- N_Entry_Declaration | |
4529 | -- Sloc points to ENTRY | |
4530 | -- Defining_Identifier (Node1) | |
4531 | -- Discrete_Subtype_Definition (Node4) (set to Empty if not present) | |
4532 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
fbf5a39b | 4533 | -- Corresponding_Body (Node5-Sem) |
996ae0b0 RK |
4534 | |
4535 | ----------------------------- | |
4536 | -- 9.5.2 Accept statement -- | |
4537 | ----------------------------- | |
4538 | ||
4539 | -- ACCEPT_STATEMENT ::= | |
4540 | -- accept entry_DIRECT_NAME | |
4541 | -- [(ENTRY_INDEX)] PARAMETER_PROFILE [do | |
4542 | -- HANDLED_SEQUENCE_OF_STATEMENTS | |
4543 | -- end [entry_IDENTIFIER]]; | |
4544 | ||
4545 | -- Gigi restriction: This node never appears. | |
4546 | ||
4547 | -- Note: there are no explicit declarations allowed in an accept | |
4548 | -- statement. However, the implicit declarations for any statement | |
4549 | -- identifiers (labels and block/loop identifiers) are declarations | |
4550 | -- that belong logically to the accept statement, and that is why | |
4551 | -- there is a Declarations field in this node. | |
4552 | ||
4553 | -- N_Accept_Statement | |
4554 | -- Sloc points to ACCEPT | |
4555 | -- Entry_Direct_Name (Node1) | |
4556 | -- Entry_Index (Node5) (set to Empty if not present) | |
4557 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
4558 | -- Handled_Statement_Sequence (Node4) | |
4559 | -- Declarations (List2) (set to No_List if no declarations) | |
4560 | ||
4561 | ------------------------ | |
4562 | -- 9.5.2 Entry Index -- | |
4563 | ------------------------ | |
4564 | ||
4565 | -- ENTRY_INDEX ::= EXPRESSION | |
4566 | ||
4567 | ----------------------- | |
4568 | -- 9.5.2 Entry Body -- | |
4569 | ----------------------- | |
4570 | ||
4571 | -- ENTRY_BODY ::= | |
4572 | -- entry DEFINING_IDENTIFIER ENTRY_BODY_FORMAL_PART ENTRY_BARRIER is | |
4573 | -- DECLARATIVE_PART | |
4574 | -- begin | |
4575 | -- HANDLED_SEQUENCE_OF_STATEMENTS | |
4576 | -- end [entry_IDENTIFIER]; | |
4577 | ||
4578 | -- ENTRY_BARRIER ::= when CONDITION | |
4579 | ||
4580 | -- Note: we store the CONDITION of the ENTRY_BARRIER in the node for | |
4581 | -- the ENTRY_BODY_FORMAL_PART to avoid the N_Entry_Body node getting | |
4582 | -- too full (it would otherwise have too many fields) | |
4583 | ||
4584 | -- Gigi restriction: This node never appears. | |
4585 | ||
4586 | -- N_Entry_Body | |
4587 | -- Sloc points to ENTRY | |
4588 | -- Defining_Identifier (Node1) | |
4589 | -- Entry_Body_Formal_Part (Node5) | |
4590 | -- Declarations (List2) | |
4591 | -- Handled_Statement_Sequence (Node4) | |
4592 | -- Activation_Chain_Entity (Node3-Sem) | |
4593 | ||
4594 | ----------------------------------- | |
4595 | -- 9.5.2 Entry Body Formal Part -- | |
4596 | ----------------------------------- | |
4597 | ||
4598 | -- ENTRY_BODY_FORMAL_PART ::= | |
4599 | -- [(ENTRY_INDEX_SPECIFICATION)] PARAMETER_PROFILE | |
4600 | ||
4601 | -- Note that an entry body formal part node is present even if it is | |
4602 | -- empty. This reflects the grammar, in which it is the components of | |
4603 | -- the entry body formal part that are optional, not the entry body | |
4604 | -- formal part itself. Also this means that the barrier condition | |
4605 | -- always has somewhere to be stored. | |
4606 | ||
4607 | -- Gigi restriction: This node never appears. | |
4608 | ||
4609 | -- N_Entry_Body_Formal_Part | |
4610 | -- Sloc points to first token | |
4611 | -- Entry_Index_Specification (Node4) (set to Empty if not present) | |
4612 | -- Parameter_Specifications (List3) (set to No_List if no formal part) | |
4613 | -- Condition (Node1) from entry barrier of entry body | |
4614 | ||
4615 | -------------------------- | |
4616 | -- 9.5.2 Entry Barrier -- | |
4617 | -------------------------- | |
4618 | ||
4619 | -- ENTRY_BARRIER ::= when CONDITION | |
4620 | ||
4621 | -------------------------------------- | |
4622 | -- 9.5.2 Entry Index Specification -- | |
4623 | -------------------------------------- | |
4624 | ||
4625 | -- ENTRY_INDEX_SPECIFICATION ::= | |
4626 | -- for DEFINING_IDENTIFIER in DISCRETE_SUBTYPE_DEFINITION | |
4627 | ||
4628 | -- Gigi restriction: This node never appears. | |
4629 | ||
4630 | -- N_Entry_Index_Specification | |
4631 | -- Sloc points to FOR | |
4632 | -- Defining_Identifier (Node1) | |
4633 | -- Discrete_Subtype_Definition (Node4) | |
4634 | ||
4635 | --------------------------------- | |
4636 | -- 9.5.3 Entry Call Statement -- | |
4637 | --------------------------------- | |
4638 | ||
4639 | -- ENTRY_CALL_STATEMENT ::= entry_NAME [ACTUAL_PARAMETER_PART]; | |
4640 | ||
4641 | -- The parser may generate a procedure call for this construct. The | |
4642 | -- semantic pass must correct this misidentification where needed. | |
4643 | ||
4644 | -- Gigi restriction: This node never appears. | |
4645 | ||
4646 | -- N_Entry_Call_Statement | |
4647 | -- Sloc points to first token of name | |
4648 | -- Name (Node2) | |
4649 | -- Parameter_Associations (List3) (set to No_List if no | |
4650 | -- actual parameter part) | |
4651 | -- First_Named_Actual (Node4-Sem) | |
4652 | ||
4653 | ------------------------------ | |
4654 | -- 9.5.4 Requeue Statement -- | |
4655 | ------------------------------ | |
4656 | ||
4657 | -- REQUEUE_STATEMENT ::= requeue entry_NAME [with abort]; | |
4658 | ||
4659 | -- Note: requeue statements are not permitted in Ada 83 mode | |
4660 | ||
4661 | -- Gigi restriction: This node never appears. | |
4662 | ||
4663 | -- N_Requeue_Statement | |
4664 | -- Sloc points to REQUEUE | |
4665 | -- Name (Node2) | |
4666 | -- Abort_Present (Flag15) | |
4667 | ||
4668 | -------------------------- | |
4669 | -- 9.6 Delay Statement -- | |
4670 | -------------------------- | |
4671 | ||
4672 | -- DELAY_STATEMENT ::= | |
4673 | -- DELAY_UNTIL_STATEMENT | |
4674 | -- | DELAY_RELATIVE_STATEMENT | |
4675 | ||
4676 | -------------------------------- | |
4677 | -- 9.6 Delay Until Statement -- | |
4678 | -------------------------------- | |
4679 | ||
4680 | -- DELAY_UNTIL_STATEMENT ::= delay until delay_EXPRESSION; | |
4681 | ||
4682 | -- Note: delay until statements are not permitted in Ada 83 mode | |
4683 | ||
4684 | -- Gigi restriction: This node never appears. | |
4685 | ||
4686 | -- N_Delay_Until_Statement | |
4687 | -- Sloc points to DELAY | |
4688 | -- Expression (Node3) | |
4689 | ||
4690 | ----------------------------------- | |
4691 | -- 9.6 Delay Relative Statement -- | |
4692 | ----------------------------------- | |
4693 | ||
4694 | -- DELAY_RELATIVE_STATEMENT ::= delay delay_EXPRESSION; | |
4695 | ||
4696 | -- Gigi restriction: This node never appears. | |
4697 | ||
4698 | -- N_Delay_Relative_Statement | |
4699 | -- Sloc points to DELAY | |
4700 | -- Expression (Node3) | |
4701 | ||
4702 | --------------------------- | |
4703 | -- 9.7 Select Statement -- | |
4704 | --------------------------- | |
4705 | ||
4706 | -- SELECT_STATEMENT ::= | |
4707 | -- SELECTIVE_ACCEPT | |
4708 | -- | TIMED_ENTRY_CALL | |
4709 | -- | CONDITIONAL_ENTRY_CALL | |
4710 | -- | ASYNCHRONOUS_SELECT | |
4711 | ||
4712 | ----------------------------- | |
4713 | -- 9.7.1 Selective Accept -- | |
4714 | ----------------------------- | |
4715 | ||
4716 | -- SELECTIVE_ACCEPT ::= | |
4717 | -- select | |
4718 | -- [GUARD] | |
4719 | -- SELECT_ALTERNATIVE | |
4720 | -- {or | |
4721 | -- [GUARD] | |
4722 | -- SELECT_ALTERNATIVE} | |
4723 | -- [else | |
4724 | -- SEQUENCE_OF_STATEMENTS] | |
4725 | -- end select; | |
4726 | ||
4727 | -- Gigi restriction: This node never appears. | |
4728 | ||
4729 | -- Note: the guard expression, if present, appears in the node for | |
4730 | -- the select alternative. | |
4731 | ||
4732 | -- N_Selective_Accept | |
4733 | -- Sloc points to SELECT | |
4734 | -- Select_Alternatives (List1) | |
4735 | -- Else_Statements (List4) (set to No_List if no else part) | |
4736 | ||
4737 | ------------------ | |
4738 | -- 9.7.1 Guard -- | |
4739 | ------------------ | |
4740 | ||
4741 | -- GUARD ::= when CONDITION => | |
4742 | ||
4743 | -- As noted above, the CONDITION that is part of a GUARD is included | |
4744 | -- in the node for the select alernative for convenience. | |
4745 | ||
4746 | ------------------------------- | |
4747 | -- 9.7.1 Select Alternative -- | |
4748 | ------------------------------- | |
4749 | ||
4750 | -- SELECT_ALTERNATIVE ::= | |
4751 | -- ACCEPT_ALTERNATIVE | |
4752 | -- | DELAY_ALTERNATIVE | |
4753 | -- | TERMINATE_ALTERNATIVE | |
4754 | ||
4755 | ------------------------------- | |
4756 | -- 9.7.1 Accept Alternative -- | |
4757 | ------------------------------- | |
4758 | ||
4759 | -- ACCEPT_ALTERNATIVE ::= | |
4760 | -- ACCEPT_STATEMENT [SEQUENCE_OF_STATEMENTS] | |
4761 | ||
4762 | -- Gigi restriction: This node never appears. | |
4763 | ||
4764 | -- N_Accept_Alternative | |
4765 | -- Sloc points to ACCEPT | |
4766 | -- Accept_Statement (Node2) | |
4767 | -- Condition (Node1) from the guard (set to Empty if no guard present) | |
4768 | -- Statements (List3) (set to Empty_List if no statements) | |
4769 | -- Pragmas_Before (List4) pragmas before alt (set to No_List if none) | |
4770 | -- Accept_Handler_Records (List5-Sem) | |
4771 | ||
4772 | ------------------------------ | |
4773 | -- 9.7.1 Delay Alternative -- | |
4774 | ------------------------------ | |
4775 | ||
4776 | -- DELAY_ALTERNATIVE ::= | |
4777 | -- DELAY_STATEMENT [SEQUENCE_OF_STATEMENTS] | |
4778 | ||
4779 | -- Gigi restriction: This node never appears. | |
4780 | ||
4781 | -- N_Delay_Alternative | |
4782 | -- Sloc points to DELAY | |
4783 | -- Delay_Statement (Node2) | |
4784 | -- Condition (Node1) from the guard (set to Empty if no guard present) | |
4785 | -- Statements (List3) (set to Empty_List if no statements) | |
4786 | -- Pragmas_Before (List4) pragmas before alt (set to No_List if none) | |
4787 | ||
4788 | ---------------------------------- | |
4789 | -- 9.7.1 Terminate Alternative -- | |
4790 | ---------------------------------- | |
4791 | ||
4792 | -- TERMINATE_ALTERNATIVE ::= terminate; | |
4793 | ||
4794 | -- Gigi restriction: This node never appears. | |
4795 | ||
4796 | -- N_Terminate_Alternative | |
4797 | -- Sloc points to TERMINATE | |
4798 | -- Condition (Node1) from the guard (set to Empty if no guard present) | |
4799 | -- Pragmas_Before (List4) pragmas before alt (set to No_List if none) | |
4800 | -- Pragmas_After (List5) pragmas after alt (set to No_List if none) | |
4801 | ||
4802 | ----------------------------- | |
4803 | -- 9.7.2 Timed Entry Call -- | |
4804 | ----------------------------- | |
4805 | ||
4806 | -- TIMED_ENTRY_CALL ::= | |
4807 | -- select | |
4808 | -- ENTRY_CALL_ALTERNATIVE | |
4809 | -- or | |
4810 | -- DELAY_ALTERNATIVE | |
4811 | -- end select; | |
4812 | ||
4813 | -- Gigi restriction: This node never appears. | |
4814 | ||
4815 | -- N_Timed_Entry_Call | |
4816 | -- Sloc points to SELECT | |
4817 | -- Entry_Call_Alternative (Node1) | |
4818 | -- Delay_Alternative (Node4) | |
4819 | ||
4820 | ----------------------------------- | |
4821 | -- 9.7.2 Entry Call Alternative -- | |
4822 | ----------------------------------- | |
4823 | ||
4824 | -- ENTRY_CALL_ALTERNATIVE ::= | |
4825 | -- ENTRY_CALL_STATEMENT [SEQUENCE_OF_STATEMENTS] | |
4826 | ||
4827 | -- Gigi restriction: This node never appears. | |
4828 | ||
4829 | -- N_Entry_Call_Alternative | |
4830 | -- Sloc points to first token of entry call statement | |
4831 | -- Entry_Call_Statement (Node1) | |
4832 | -- Statements (List3) (set to Empty_List if no statements) | |
4833 | -- Pragmas_Before (List4) pragmas before alt (set to No_List if none) | |
4834 | ||
4835 | ----------------------------------- | |
4836 | -- 9.7.3 Conditional Entry Call -- | |
4837 | ----------------------------------- | |
4838 | ||
4839 | -- CONDITIONAL_ENTRY_CALL ::= | |
4840 | -- select | |
4841 | -- ENTRY_CALL_ALTERNATIVE | |
4842 | -- else | |
4843 | -- SEQUENCE_OF_STATEMENTS | |
4844 | -- end select; | |
4845 | ||
4846 | -- Gigi restriction: This node never appears. | |
4847 | ||
4848 | -- N_Conditional_Entry_Call | |
4849 | -- Sloc points to SELECT | |
4850 | -- Entry_Call_Alternative (Node1) | |
4851 | -- Else_Statements (List4) | |
4852 | ||
4853 | -------------------------------- | |
4854 | -- 9.7.4 Asynchronous Select -- | |
4855 | -------------------------------- | |
4856 | ||
4857 | -- ASYNCHRONOUS_SELECT ::= | |
4858 | -- select | |
4859 | -- TRIGGERING_ALTERNATIVE | |
4860 | -- then abort | |
4861 | -- ABORTABLE_PART | |
4862 | -- end select; | |
4863 | ||
4864 | -- Note: asynchronous select is not permitted in Ada 83 mode | |
4865 | ||
4866 | -- Gigi restriction: This node never appears. | |
4867 | ||
4868 | -- N_Asynchronous_Select | |
4869 | -- Sloc points to SELECT | |
4870 | -- Triggering_Alternative (Node1) | |
4871 | -- Abortable_Part (Node2) | |
4872 | ||
4873 | ----------------------------------- | |
4874 | -- 9.7.4 Triggering Alternative -- | |
4875 | ----------------------------------- | |
4876 | ||
4877 | -- TRIGGERING_ALTERNATIVE ::= | |
4878 | -- TRIGGERING_STATEMENT [SEQUENCE_OF_STATEMENTS] | |
4879 | ||
4880 | -- Gigi restriction: This node never appears. | |
4881 | ||
4882 | -- N_Triggering_Alternative | |
4883 | -- Sloc points to first token of triggering statement | |
4884 | -- Triggering_Statement (Node1) | |
4885 | -- Statements (List3) (set to Empty_List if no statements) | |
4886 | -- Pragmas_Before (List4) pragmas before alt (set to No_List if none) | |
4887 | ||
4888 | --------------------------------- | |
4889 | -- 9.7.4 Triggering Statement -- | |
4890 | --------------------------------- | |
4891 | ||
4892 | -- TRIGGERING_STATEMENT ::= ENTRY_CALL_STATEMENT | DELAY_STATEMENT | |
4893 | ||
4894 | --------------------------- | |
4895 | -- 9.7.4 Abortable Part -- | |
4896 | --------------------------- | |
4897 | ||
4898 | -- ABORTABLE_PART ::= SEQUENCE_OF_STATEMENTS | |
4899 | ||
4900 | -- Gigi restriction: This node never appears. | |
4901 | ||
4902 | -- N_Abortable_Part | |
4903 | -- Sloc points to ABORT | |
4904 | -- Statements (List3) | |
4905 | ||
4906 | -------------------------- | |
4907 | -- 9.8 Abort Statement -- | |
4908 | -------------------------- | |
4909 | ||
4910 | -- ABORT_STATEMENT ::= abort task_NAME {, task_NAME}; | |
4911 | ||
4912 | -- Gigi restriction: This node never appears. | |
4913 | ||
4914 | -- N_Abort_Statement | |
4915 | -- Sloc points to ABORT | |
4916 | -- Names (List2) | |
4917 | ||
4918 | ------------------------- | |
4919 | -- 10.1.1 Compilation -- | |
4920 | ------------------------- | |
4921 | ||
4922 | -- COMPILATION ::= {COMPILATION_UNIT} | |
4923 | ||
4924 | -- There is no explicit node in the tree for a compilation, since in | |
4925 | -- general the compiler is processing only a single compilation unit | |
4926 | -- at a time. It is possible to parse multiple units in syntax check | |
4927 | -- only mode, but they the trees are discarded in any case. | |
4928 | ||
4929 | ------------------------------ | |
4930 | -- 10.1.1 Compilation Unit -- | |
4931 | ------------------------------ | |
4932 | ||
4933 | -- COMPILATION_UNIT ::= | |
4934 | -- CONTEXT_CLAUSE LIBRARY_ITEM | |
4935 | -- | CONTEXT_CLAUSE SUBUNIT | |
4936 | ||
4937 | -- The N_Compilation_Unit node itself respresents the above syntax. | |
4938 | -- However, there are two additional items not reflected in the above | |
4939 | -- syntax. First we have the global declarations that are added by the | |
4940 | -- code generator. These are outer level declarations (so they cannot | |
4941 | -- be represented as being inside the units). An example is the wrapper | |
4942 | -- subprograms that are created to do ABE checking. As always a list of | |
4943 | -- declarations can contain actions as well (i.e. statements), and such | |
4944 | -- statements are executed as part of the elaboration of the unit. Note | |
4945 | -- that all such declarations are elaborated before the library unit. | |
4946 | ||
4947 | -- Similarly, certain actions need to be elaborated at the completion | |
4948 | -- of elaboration of the library unit (notably the statement that sets | |
4949 | -- the Boolean flag indicating that elaboration is complete). | |
4950 | ||
4951 | -- The third item not reflected in the syntax is pragmas that appear | |
4952 | -- after the compilation unit. As always pragmas are a problem since | |
4953 | -- they are not part of the formal syntax, but can be stuck into the | |
4954 | -- source following a set of ad hoc rules, and we have to find an ad | |
4955 | -- hoc way of sticking them into the tree. For pragmas that appear | |
4956 | -- before the library unit, we just consider them to be part of the | |
4957 | -- context clause, and pragmas can appear in the Context_Items list | |
4958 | -- of the compilation unit. However, pragmas can also appear after | |
4959 | -- the library item. | |
4960 | ||
4961 | -- To deal with all these problems, we create an auxiliary node for | |
4962 | -- a compilation unit, referenced from the N_Compilation_Unit node | |
4963 | -- that contains these three items. | |
4964 | ||
4965 | -- N_Compilation_Unit | |
4966 | -- Sloc points to first token of defining unit name | |
4967 | -- Library_Unit (Node4-Sem) corresponding/parent spec/body | |
4968 | -- Context_Items (List1) context items and pragmas preceding unit | |
4969 | -- Private_Present (Flag15) set if library unit has private keyword | |
4970 | -- Unit (Node2) library item or subunit | |
4971 | -- Aux_Decls_Node (Node5) points to the N_Compilation_Unit_Aux node | |
4972 | -- Has_No_Elaboration_Code (Flag17-Sem) | |
4973 | -- Body_Required (Flag13-Sem) set for spec if body is required | |
4974 | -- Acts_As_Spec (Flag4-Sem) flag for subprogram body with no spec | |
4975 | -- First_Inlined_Subprogram (Node3-Sem) | |
4976 | ||
4977 | -- N_Compilation_Unit_Aux | |
4978 | -- Sloc is a copy of the Sloc from the N_Compilation_Unit node | |
4979 | -- Declarations (List2) (set to No_List if no global declarations) | |
4980 | -- Actions (List1) (set to No_List if no actions) | |
4981 | -- Pragmas_After (List5) pragmas after unit (set to No_List if none) | |
fbf5a39b | 4982 | -- Config_Pragmas (List4) config pragmas (set to Empty_List if none) |
996ae0b0 RK |
4983 | |
4984 | -------------------------- | |
4985 | -- 10.1.1 Library Item -- | |
4986 | -------------------------- | |
4987 | ||
4988 | -- LIBRARY_ITEM ::= | |
4989 | -- [private] LIBRARY_UNIT_DECLARATION | |
4990 | -- | LIBRARY_UNIT_BODY | |
4991 | -- | [private] LIBRARY_UNIT_RENAMING_DECLARATION | |
4992 | ||
4993 | -- Note: PRIVATE is not allowed in Ada 83 mode | |
4994 | ||
4995 | -- There is no explicit node in the tree for library item, instead | |
4996 | -- the declaration or body, and the flag for private if present, | |
4997 | -- appear in the N_Compilation_Unit clause. | |
4998 | ||
4999 | ---------------------------------------- | |
5000 | -- 10.1.1 Library Unit Declararation -- | |
5001 | ---------------------------------------- | |
5002 | ||
5003 | -- LIBRARY_UNIT_DECLARATION ::= | |
5004 | -- SUBPROGRAM_DECLARATION | PACKAGE_DECLARATION | |
5005 | -- | GENERIC_DECLARATION | GENERIC_INSTANTIATION | |
5006 | ||
5007 | ------------------------------------------------- | |
5008 | -- 10.1.1 Library Unit Renaming Declararation -- | |
5009 | ------------------------------------------------- | |
5010 | ||
5011 | -- LIBRARY_UNIT_RENAMING_DECLARATION ::= | |
5012 | -- PACKAGE_RENAMING_DECLARATION | |
5013 | -- | GENERIC_RENAMING_DECLARATION | |
5014 | -- | SUBPROGRAM_RENAMING_DECLARATION | |
5015 | ||
5016 | ------------------------------- | |
5017 | -- 10.1.1 Library unit body -- | |
5018 | ------------------------------- | |
5019 | ||
5020 | -- LIBRARY_UNIT_BODY ::= SUBPROGRAM_BODY | PACKAGE_BODY | |
5021 | ||
5022 | ------------------------------ | |
5023 | -- 10.1.1 Parent Unit Name -- | |
5024 | ------------------------------ | |
5025 | ||
5026 | -- PARENT_UNIT_NAME ::= NAME | |
5027 | ||
5028 | ---------------------------- | |
5029 | -- 10.1.2 Context clause -- | |
5030 | ---------------------------- | |
5031 | ||
5032 | -- CONTEXT_CLAUSE ::= {CONTEXT_ITEM} | |
5033 | ||
5034 | -- The context clause can include pragmas, and any pragmas that appear | |
5035 | -- before the context clause proper (i.e. all configuration pragmas, | |
5036 | -- also appear at the front of this list). | |
5037 | ||
5038 | -------------------------- | |
5039 | -- 10.1.2 Context_Item -- | |
5040 | -------------------------- | |
5041 | ||
5042 | -- CONTEXT_ITEM ::= WITH_CLAUSE | USE_CLAUSE | WITH_TYPE_CLAUSE | |
5043 | ||
5044 | ------------------------- | |
5045 | -- 10.1.2 With clause -- | |
5046 | ------------------------- | |
5047 | ||
5048 | -- WITH_CLAUSE ::= | |
5049 | -- with library_unit_NAME {,library_unit_NAME}; | |
5050 | ||
5051 | -- A separate With clause is built for each name, so that we have | |
5052 | -- a Corresponding_Spec field for each with'ed spec. The flags | |
5053 | -- First_Name and Last_Name are used to reconstruct the exact | |
5054 | -- source form. When a list of names appears in one with clause, | |
5055 | -- the first name in the list has First_Name set, and the last | |
5056 | -- has Last_Name set. If the with clause has only one name, then | |
5057 | -- both of the flags First_Name and Last_Name are set in this name. | |
5058 | ||
5059 | -- Note: in the case of implicit with's that are installed by the | |
5060 | -- Rtsfind routine, Implicit_With is set, and the Sloc is typically | |
5061 | -- set to Standard_Location, but it is incorrect to test the Sloc | |
5062 | -- to find out if a with clause is implicit, test the flag instead. | |
5063 | ||
5064 | -- N_With_Clause | |
5065 | -- Sloc points to first token of library unit name | |
5066 | -- Name (Node2) | |
5067 | -- Library_Unit (Node4-Sem) | |
5068 | -- Corresponding_Spec (Node5-Sem) | |
5069 | -- First_Name (Flag5) (set to True if first name or only one name) | |
5070 | -- Last_Name (Flag6) (set to True if last name or only one name) | |
5071 | -- Context_Installed (Flag13-Sem) | |
5072 | -- Elaborate_Present (Flag4-Sem) | |
5073 | -- Elaborate_All_Present (Flag15-Sem) | |
fbf5a39b AC |
5074 | -- Implicit_With (Flag16-Sem) |
5075 | -- Limited_Present (Flag17) set if LIMITED is present | |
5076 | -- Limited_View_Installed (Flag18-Sem) | |
996ae0b0 RK |
5077 | -- Unreferenced_In_Spec (Flag7-Sem) |
5078 | -- No_Entities_Ref_In_Spec (Flag8-Sem) | |
5079 | ||
5080 | ---------------------- | |
5081 | -- With_Type clause -- | |
5082 | ---------------------- | |
5083 | ||
5084 | -- This is a GNAT extension, used to implement mutually recursive | |
5085 | -- types declared in different packages. | |
5086 | ||
5087 | -- WITH_TYPE_CLAUSE ::= | |
5088 | -- with type type_NAME is access | with type type_NAME is tagged | |
5089 | ||
5090 | -- N_With_Type_Clause | |
5091 | -- Sloc points to first token of type name | |
5092 | -- Name (Node2) | |
5093 | -- Tagged_Present (Flag15) | |
5094 | ||
5095 | --------------------- | |
5096 | -- 10.2 Body stub -- | |
5097 | --------------------- | |
5098 | ||
5099 | -- BODY_STUB ::= | |
5100 | -- SUBPROGRAM_BODY_STUB | |
5101 | -- | PACKAGE_BODY_STUB | |
5102 | -- | TASK_BODY_STUB | |
5103 | -- | PROTECTED_BODY_STUB | |
5104 | ||
5105 | ---------------------------------- | |
5106 | -- 10.1.3 Subprogram Body Stub -- | |
5107 | ---------------------------------- | |
5108 | ||
5109 | -- SUBPROGRAM_BODY_STUB ::= | |
5110 | -- SUBPROGRAM_SPECIFICATION is separate; | |
5111 | ||
5112 | -- N_Subprogram_Body_Stub | |
5113 | -- Sloc points to FUNCTION or PROCEDURE | |
5114 | -- Specification (Node1) | |
5115 | -- Library_Unit (Node4-Sem) points to the subunit | |
5116 | -- Corresponding_Body (Node5-Sem) | |
5117 | ||
5118 | ------------------------------- | |
5119 | -- 10.1.3 Package Body Stub -- | |
5120 | ------------------------------- | |
5121 | ||
5122 | -- PACKAGE_BODY_STUB ::= | |
5123 | -- package body DEFINING_IDENTIFIER is separate; | |
5124 | ||
5125 | -- N_Package_Body_Stub | |
5126 | -- Sloc points to PACKAGE | |
5127 | -- Defining_Identifier (Node1) | |
5128 | -- Library_Unit (Node4-Sem) points to the subunit | |
5129 | -- Corresponding_Body (Node5-Sem) | |
5130 | ||
5131 | ---------------------------- | |
5132 | -- 10.1.3 Task Body Stub -- | |
5133 | ---------------------------- | |
5134 | ||
5135 | -- TASK_BODY_STUB ::= | |
5136 | -- task body DEFINING_IDENTIFIER is separate; | |
5137 | ||
5138 | -- N_Task_Body_Stub | |
5139 | -- Sloc points to TASK | |
5140 | -- Defining_Identifier (Node1) | |
5141 | -- Library_Unit (Node4-Sem) points to the subunit | |
5142 | -- Corresponding_Body (Node5-Sem) | |
5143 | ||
5144 | --------------------------------- | |
5145 | -- 10.1.3 Protected Body Stub -- | |
5146 | --------------------------------- | |
5147 | ||
5148 | -- PROTECTED_BODY_STUB ::= | |
5149 | -- protected body DEFINING_IDENTIFIER is separate; | |
5150 | ||
5151 | -- Note: protected body stubs are not allowed in Ada 83 mode | |
5152 | ||
5153 | -- N_Protected_Body_Stub | |
5154 | -- Sloc points to PROTECTED | |
5155 | -- Defining_Identifier (Node1) | |
5156 | -- Library_Unit (Node4-Sem) points to the subunit | |
5157 | -- Corresponding_Body (Node5-Sem) | |
5158 | ||
5159 | --------------------- | |
5160 | -- 10.1.3 Subunit -- | |
5161 | --------------------- | |
5162 | ||
5163 | -- SUBUNIT ::= separate (PARENT_UNIT_NAME) PROPER_BODY | |
5164 | ||
5165 | -- N_Subunit | |
5166 | -- Sloc points to SEPARATE | |
5167 | -- Name (Node2) is the name of the parent unit | |
5168 | -- Proper_Body (Node1) is the subunit body | |
5169 | -- Corresponding_Stub (Node3-Sem) is the stub declaration for the unit. | |
5170 | ||
5171 | --------------------------------- | |
5172 | -- 11.1 Exception Declaration -- | |
5173 | --------------------------------- | |
5174 | ||
5175 | -- EXCEPTION_DECLARATION ::= DEFINING_IDENTIFIER_LIST : exception; | |
5176 | ||
5177 | -- For consistency with object declarations etc, the parser converts | |
5178 | -- the case of multiple identifiers being declared to a series of | |
5179 | -- declarations in which the expression is copied, using the More_Ids | |
5180 | -- and Prev_Ids flags to remember the souce form as described in the | |
5181 | -- section on "Handling of Defining Identifier Lists". | |
5182 | ||
5183 | -- N_Exception_Declaration | |
5184 | -- Sloc points to EXCEPTION | |
5185 | -- Defining_Identifier (Node1) | |
5186 | -- Expression (Node3-Sem) | |
5187 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
5188 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
5189 | ||
5190 | ------------------------------------------ | |
5191 | -- 11.2 Handled Sequence Of Statements -- | |
5192 | ------------------------------------------ | |
5193 | ||
5194 | -- HANDLED_SEQUENCE_OF_STATEMENTS ::= | |
5195 | -- SEQUENCE_OF_STATEMENTS | |
5196 | -- [exception | |
5197 | -- EXCEPTION_HANDLER | |
5198 | -- {EXCEPTION_HANDLER}] | |
5199 | -- [at end | |
5200 | -- cleanup_procedure_call (param, param, param, ...);] | |
5201 | ||
5202 | -- The AT END phrase is a GNAT extension to provide for cleanups. It is | |
5203 | -- used only internally currently, but is considered to be syntactic. | |
5204 | -- At the moment, the only cleanup action allowed is a single call to | |
5205 | -- a parameterless procedure, and the Identifier field of the node is | |
5206 | -- the procedure to be called. Also there is a current restriction | |
5207 | -- that exception handles and a cleanup cannot be present in the same | |
5208 | -- frame, so at least one of Exception_Handlers or the Identifier must | |
5209 | -- be missing. | |
5210 | ||
5211 | -- Actually, more accurately, this restriction applies to the original | |
5212 | -- source program. In the expanded tree, if the At_End_Proc field is | |
5213 | -- present, then there will also be an exception handler of the form: | |
5214 | ||
5215 | -- when all others => | |
5216 | -- cleanup; | |
5217 | -- raise; | |
5218 | ||
5219 | -- where cleanup is the procedure to be generated. The reason we do | |
5220 | -- this is so that the front end can handle the necessary entries in | |
5221 | -- the exception tables, and other exception handler actions required | |
5222 | -- as part of the normal handling for exception handlers. | |
5223 | ||
5224 | -- The AT END cleanup handler protects only the sequence of statements | |
5225 | -- (not the associated declarations of the parent), just like exception | |
5226 | -- handlers. The big difference is that the cleanup procedure is called | |
5227 | -- on either a normal or an abnormal exit from the statement sequence. | |
5228 | ||
5229 | -- Note: the list of Exception_Handlers can contain pragmas as well | |
5230 | -- as actual handlers. In practice these pragmas can only occur at | |
5231 | -- the start of the list, since any pragmas occurring later on will | |
5232 | -- be included in the statement list of the corresponding handler. | |
5233 | ||
5234 | -- Note: although in the Ada syntax, the sequence of statements in | |
5235 | -- a handled sequence of statements can only contain statements, we | |
5236 | -- allow free mixing of declarations and statements in the resulting | |
5237 | -- expanded tree. This is for example used to deal with the case of | |
5238 | -- a cleanup procedure that must handle declarations as well as the | |
5239 | -- statements of a block. | |
5240 | ||
5241 | -- N_Handled_Sequence_Of_Statements | |
5242 | -- Sloc points to first token of first statement | |
5243 | -- Statements (List3) | |
5244 | -- End_Label (Node4) (set to Empty if expander generated) | |
5245 | -- Exception_Handlers (List5) (set to No_List if none present) | |
5246 | -- At_End_Proc (Node1) (set to Empty if no clean up procedure) | |
5247 | -- First_Real_Statement (Node2-Sem) | |
5248 | -- Zero_Cost_Handling (Flag5-Sem) | |
5249 | ||
5250 | -- Note: the parent always contains a Declarations field which contains | |
5251 | -- declarations associated with the handled sequence of statements. This | |
5252 | -- is true even in the case of an accept statement (see description of | |
5253 | -- the N_Accept_Statement node). | |
5254 | ||
5255 | -- End_Label refers to the containing construct. | |
5256 | ||
5257 | ----------------------------- | |
5258 | -- 11.2 Exception Handler -- | |
5259 | ----------------------------- | |
5260 | ||
5261 | -- EXCEPTION_HANDLER ::= | |
5262 | -- when [CHOICE_PARAMETER_SPECIFICATION :] | |
5263 | -- EXCEPTION_CHOICE {| EXCEPTION_CHOICE} => | |
5264 | -- SEQUENCE_OF_STATEMENTS | |
5265 | ||
5266 | -- Note: choice parameter specification is not allowed in Ada 83 mode | |
5267 | ||
5268 | -- N_Exception_Handler | |
5269 | -- Sloc points to WHEN | |
5270 | -- Choice_Parameter (Node2) (set to Empty if not present) | |
5271 | -- Exception_Choices (List4) | |
5272 | -- Statements (List3) | |
5273 | -- Zero_Cost_Handling (Flag5-Sem) | |
5274 | ||
5275 | ------------------------------------------ | |
5276 | -- 11.2 Choice parameter specification -- | |
5277 | ------------------------------------------ | |
5278 | ||
5279 | -- CHOICE_PARAMETER_SPECIFICATION ::= DEFINING_IDENTIFIER | |
5280 | ||
5281 | ---------------------------- | |
5282 | -- 11.2 Exception Choice -- | |
5283 | ---------------------------- | |
5284 | ||
5285 | -- EXCEPTION_CHOICE ::= exception_NAME | others | |
5286 | ||
5287 | -- Except in the case of OTHERS, no explicit node appears in the tree | |
5288 | -- for exception choice. Instead the exception name appears directly. | |
5289 | -- An OTHERS choice is represented by a N_Others_Choice node (see | |
5290 | -- section 3.8.1. | |
5291 | ||
5292 | -- Note: for the exception choice created for an at end handler, the | |
5293 | -- exception choice is an N_Others_Choice node with All_Others set. | |
5294 | ||
5295 | --------------------------- | |
5296 | -- 11.3 Raise Statement -- | |
5297 | --------------------------- | |
5298 | ||
5299 | -- RAISE_STATEMENT ::= raise [exception_NAME]; | |
5300 | ||
5301 | -- N_Raise_Statement | |
5302 | -- Sloc points to RAISE | |
5303 | -- Name (Node2) (set to Empty if no exception name present) | |
5304 | ||
5305 | ------------------------------- | |
5306 | -- 12.1 Generic Declaration -- | |
5307 | ------------------------------- | |
5308 | ||
5309 | -- GENERIC_DECLARATION ::= | |
5310 | -- GENERIC_SUBPROGRAM_DECLARATION | GENERIC_PACKAGE_DECLARATION | |
5311 | ||
5312 | ------------------------------------------ | |
5313 | -- 12.1 Generic Subprogram Declaration -- | |
5314 | ------------------------------------------ | |
5315 | ||
5316 | -- GENERIC_SUBPROGRAM_DECLARATION ::= | |
5317 | -- GENERIC_FORMAL_PART SUBPROGRAM_SPECIFICATION; | |
5318 | ||
5319 | -- Note: Generic_Formal_Declarations can include pragmas | |
5320 | ||
5321 | -- N_Generic_Subprogram_Declaration | |
5322 | -- Sloc points to GENERIC | |
5323 | -- Specification (Node1) subprogram specification | |
5324 | -- Corresponding_Body (Node5-Sem) | |
5325 | -- Generic_Formal_Declarations (List2) from generic formal part | |
5326 | -- Parent_Spec (Node4-Sem) | |
5327 | ||
5328 | --------------------------------------- | |
5329 | -- 12.1 Generic Package Declaration -- | |
5330 | --------------------------------------- | |
5331 | ||
5332 | -- GENERIC_PACKAGE_DECLARATION ::= | |
5333 | -- GENERIC_FORMAL_PART PACKAGE_SPECIFICATION; | |
5334 | ||
5335 | -- Note: when we do generics right, the Activation_Chain_Entity entry | |
5336 | -- for this node can be removed (since the expander won't see generic | |
5337 | -- units any more)???. | |
5338 | ||
5339 | -- Note: Generic_Formal_Declarations can include pragmas | |
5340 | ||
5341 | -- N_Generic_Package_Declaration | |
5342 | -- Sloc points to GENERIC | |
5343 | -- Specification (Node1) package specification | |
5344 | -- Corresponding_Body (Node5-Sem) | |
5345 | -- Generic_Formal_Declarations (List2) from generic formal part | |
5346 | -- Parent_Spec (Node4-Sem) | |
5347 | -- Activation_Chain_Entity (Node3-Sem) | |
5348 | ||
5349 | ------------------------------- | |
5350 | -- 12.1 Generic Formal Part -- | |
5351 | ------------------------------- | |
5352 | ||
5353 | -- GENERIC_FORMAL_PART ::= | |
5354 | -- generic {GENERIC_FORMAL_PARAMETER_DECLARATION | USE_CLAUSE} | |
5355 | ||
5356 | ------------------------------------------------ | |
5357 | -- 12.1 Generic Formal Parameter Declaration -- | |
5358 | ------------------------------------------------ | |
5359 | ||
5360 | -- GENERIC_FORMAL_PARAMETER_DECLARATION ::= | |
5361 | -- FORMAL_OBJECT_DECLARATION | |
5362 | -- | FORMAL_TYPE_DECLARATION | |
5363 | -- | FORMAL_SUBPROGRAM_DECLARATION | |
5364 | -- | FORMAL_PACKAGE_DECLARATION | |
5365 | ||
5366 | --------------------------------- | |
5367 | -- 12.3 Generic Instantiation -- | |
5368 | --------------------------------- | |
5369 | ||
5370 | -- GENERIC_INSTANTIATION ::= | |
5371 | -- package DEFINING_PROGRAM_UNIT_NAME is | |
5372 | -- new generic_package_NAME [GENERIC_ACTUAL_PART]; | |
5373 | -- | procedure DEFINING_PROGRAM_UNIT_NAME is | |
5374 | -- new generic_procedure_NAME [GENERIC_ACTUAL_PART]; | |
5375 | -- | function DEFINING_DESIGNATOR is | |
5376 | -- new generic_function_NAME [GENERIC_ACTUAL_PART]; | |
5377 | ||
5378 | -- N_Package_Instantiation | |
5379 | -- Sloc points to PACKAGE | |
5380 | -- Defining_Unit_Name (Node1) | |
5381 | -- Name (Node2) | |
5382 | -- Generic_Associations (List3) (set to No_List if no | |
5383 | -- generic actual part) | |
5384 | -- Parent_Spec (Node4-Sem) | |
5385 | -- Instance_Spec (Node5-Sem) | |
5386 | -- ABE_Is_Certain (Flag18-Sem) | |
5387 | ||
5388 | -- N_Procedure_Instantiation | |
5389 | -- Sloc points to PROCEDURE | |
5390 | -- Defining_Unit_Name (Node1) | |
5391 | -- Name (Node2) | |
5392 | -- Parent_Spec (Node4-Sem) | |
5393 | -- Generic_Associations (List3) (set to No_List if no | |
5394 | -- generic actual part) | |
5395 | -- Instance_Spec (Node5-Sem) | |
5396 | -- ABE_Is_Certain (Flag18-Sem) | |
5397 | ||
5398 | -- N_Function_Instantiation | |
5399 | -- Sloc points to FUNCTION | |
5400 | -- Defining_Unit_Name (Node1) | |
5401 | -- Name (Node2) | |
5402 | -- Generic_Associations (List3) (set to No_List if no | |
5403 | -- generic actual part) | |
5404 | -- Parent_Spec (Node4-Sem) | |
5405 | -- Instance_Spec (Node5-Sem) | |
5406 | -- ABE_Is_Certain (Flag18-Sem) | |
5407 | ||
5408 | ------------------------------ | |
5409 | -- 12.3 Generic Actual Part -- | |
5410 | ------------------------------ | |
5411 | ||
5412 | -- GENERIC_ACTUAL_PART ::= | |
5413 | -- (GENERIC_ASSOCIATION {, GENERIC_ASSOCIATION}) | |
5414 | ||
5415 | ------------------------------- | |
5416 | -- 12.3 Generic Association -- | |
5417 | ------------------------------- | |
5418 | ||
5419 | -- GENERIC_ASSOCIATION ::= | |
5420 | -- [generic_formal_parameter_SELECTOR_NAME =>] | |
5421 | -- EXPLICIT_GENERIC_ACTUAL_PARAMETER | |
5422 | ||
5423 | -- Note: unlike the procedure call case, a generic association node | |
5424 | -- is generated for every association, even if no formal is present. | |
5425 | -- In this case the parser will leave the Selector_Name field set | |
5426 | -- to Empty, to be filled in later by the semantic pass. | |
5427 | ||
5428 | -- N_Generic_Association | |
5429 | -- Sloc points to first token of generic association | |
5430 | -- Selector_Name (Node2) (set to Empty if no formal | |
5431 | -- parameter selector name) | |
5432 | -- Explicit_Generic_Actual_Parameter (Node1) | |
5433 | ||
5434 | --------------------------------------------- | |
5435 | -- 12.3 Explicit Generic Actual Parameter -- | |
5436 | --------------------------------------------- | |
5437 | ||
5438 | -- EXPLICIT_GENERIC_ACTUAL_PARAMETER ::= | |
5439 | -- EXPRESSION | variable_NAME | subprogram_NAME | |
5440 | -- | entry_NAME | SUBTYPE_MARK | package_instance_NAME | |
5441 | ||
5442 | ------------------------------------- | |
5443 | -- 12.4 Formal Object Declaration -- | |
5444 | ------------------------------------- | |
5445 | ||
5446 | -- FORMAL_OBJECT_DECLARATION ::= | |
5447 | -- DEFINING_IDENTIFIER_LIST : | |
5448 | -- MODE SUBTYPE_MARK [:= DEFAULT_EXPRESSION]; | |
5449 | ||
5450 | -- Although the syntax allows multiple identifiers in the list, the | |
5451 | -- semantics is as though successive declarations were given with | |
5452 | -- identical type definition and expression components. To simplify | |
5453 | -- semantic processing, the parser represents a multiple declaration | |
5454 | -- case as a sequence of single declarations, using the More_Ids and | |
5455 | -- Prev_Ids flags to preserve the original source form as described | |
5456 | -- in the section on "Handling of Defining Identifier Lists". | |
5457 | ||
5458 | -- N_Formal_Object_Declaration | |
5459 | -- Sloc points to first identifier | |
5460 | -- Defining_Identifier (Node1) | |
5461 | -- In_Present (Flag15) | |
5462 | -- Out_Present (Flag17) | |
5463 | -- Subtype_Mark (Node4) | |
5464 | -- Expression (Node3) (set to Empty if no default expression) | |
5465 | -- More_Ids (Flag5) (set to False if no more identifiers in list) | |
5466 | -- Prev_Ids (Flag6) (set to False if no previous identifiers in list) | |
5467 | ||
5468 | ----------------------------------- | |
5469 | -- 12.5 Formal Type Declaration -- | |
5470 | ----------------------------------- | |
5471 | ||
5472 | -- FORMAL_TYPE_DECLARATION ::= | |
5473 | -- type DEFINING_IDENTIFIER [DISCRIMINANT_PART] | |
5474 | -- is FORMAL_TYPE_DEFINITION; | |
5475 | ||
5476 | -- N_Formal_Type_Declaration | |
5477 | -- Sloc points to TYPE | |
5478 | -- Defining_Identifier (Node1) | |
5479 | -- Formal_Type_Definition (Node3) | |
5480 | -- Discriminant_Specifications (List4) (set to No_List if no | |
5481 | -- discriminant part) | |
5482 | -- Unknown_Discriminants_Present (Flag13) set if (<>) discriminant | |
5483 | ||
5484 | ---------------------------------- | |
5485 | -- 12.5 Formal type definition -- | |
5486 | ---------------------------------- | |
5487 | ||
5488 | -- FORMAL_TYPE_DEFINITION ::= | |
5489 | -- FORMAL_PRIVATE_TYPE_DEFINITION | |
5490 | -- | FORMAL_DERIVED_TYPE_DEFINITION | |
5491 | -- | FORMAL_DISCRETE_TYPE_DEFINITION | |
5492 | -- | FORMAL_SIGNED_INTEGER_TYPE_DEFINITION | |
5493 | -- | FORMAL_MODULAR_TYPE_DEFINITION | |
5494 | -- | FORMAL_FLOATING_POINT_DEFINITION | |
5495 | -- | FORMAL_ORDINARY_FIXED_POINT_DEFINITION | |
5496 | -- | FORMAL_DECIMAL_FIXED_POINT_DEFINITION | |
5497 | -- | FORMAL_ARRAY_TYPE_DEFINITION | |
5498 | -- | FORMAL_ACCESS_TYPE_DEFINITION | |
5499 | ||
5500 | --------------------------------------------- | |
5501 | -- 12.5.1 Formal Private Type Definition -- | |
5502 | --------------------------------------------- | |
5503 | ||
5504 | -- FORMAL_PRIVATE_TYPE_DEFINITION ::= | |
5505 | -- [[abstract] tagged] [limited] private | |
5506 | ||
5507 | -- Note: TAGGED is not allowed in Ada 83 mode | |
5508 | ||
5509 | -- N_Formal_Private_Type_Definition | |
5510 | -- Sloc points to PRIVATE | |
5511 | -- Abstract_Present (Flag4) | |
5512 | -- Tagged_Present (Flag15) | |
5513 | -- Limited_Present (Flag17) | |
5514 | ||
5515 | -------------------------------------------- | |
5516 | -- 12.5.1 Formal Derived Type Definition -- | |
5517 | -------------------------------------------- | |
5518 | ||
5519 | -- FORMAL_DERIVED_TYPE_DEFINITION ::= | |
5520 | -- [abstract] new SUBTYPE_MARK [with private] | |
5521 | ||
5522 | -- Note: this construct is not allowed in Ada 83 mode | |
5523 | ||
5524 | -- N_Formal_Derived_Type_Definition | |
5525 | -- Sloc points to NEW | |
5526 | -- Subtype_Mark (Node4) | |
5527 | -- Private_Present (Flag15) | |
5528 | -- Abstract_Present (Flag4) | |
5529 | ||
5530 | --------------------------------------------- | |
5531 | -- 12.5.2 Formal Discrete Type Definition -- | |
5532 | --------------------------------------------- | |
5533 | ||
5534 | -- FORMAL_DISCRETE_TYPE_DEFINITION ::= (<>) | |
5535 | ||
5536 | -- N_Formal_Discrete_Type_Definition | |
5537 | -- Sloc points to ( | |
5538 | ||
5539 | --------------------------------------------------- | |
5540 | -- 12.5.2 Formal Signed Integer Type Definition -- | |
5541 | --------------------------------------------------- | |
5542 | ||
5543 | -- FORMAL_SIGNED_INTEGER_TYPE_DEFINITION ::= range <> | |
5544 | ||
5545 | -- N_Formal_Signed_Integer_Type_Definition | |
5546 | -- Sloc points to RANGE | |
5547 | ||
5548 | -------------------------------------------- | |
5549 | -- 12.5.2 Formal Modular Type Definition -- | |
5550 | -------------------------------------------- | |
5551 | ||
5552 | -- FORMAL_MODULAR_TYPE_DEFINITION ::= mod <> | |
5553 | ||
5554 | -- N_Formal_Modular_Type_Definition | |
5555 | -- Sloc points to MOD | |
5556 | ||
5557 | ---------------------------------------------- | |
5558 | -- 12.5.2 Formal Floating Point Definition -- | |
5559 | ---------------------------------------------- | |
5560 | ||
5561 | -- FORMAL_FLOATING_POINT_DEFINITION ::= digits <> | |
5562 | ||
5563 | -- N_Formal_Floating_Point_Definition | |
5564 | -- Sloc points to DIGITS | |
5565 | ||
5566 | ---------------------------------------------------- | |
5567 | -- 12.5.2 Formal Ordinary Fixed Point Definition -- | |
5568 | ---------------------------------------------------- | |
5569 | ||
5570 | -- FORMAL_ORDINARY_FIXED_POINT_DEFINITION ::= delta <> | |
5571 | ||
5572 | -- N_Formal_Ordinary_Fixed_Point_Definition | |
5573 | -- Sloc points to DELTA | |
5574 | ||
5575 | --------------------------------------------------- | |
5576 | -- 12.5.2 Formal Decimal Fixed Point Definition -- | |
5577 | --------------------------------------------------- | |
5578 | ||
5579 | -- FORMAL_DECIMAL_FIXED_POINT_DEFINITION ::= delta <> digits <> | |
5580 | ||
5581 | -- Note: formal decimal fixed point definition not allowed in Ada 83 | |
5582 | ||
5583 | -- N_Formal_Decimal_Fixed_Point_Definition | |
5584 | -- Sloc points to DELTA | |
5585 | ||
5586 | ------------------------------------------ | |
5587 | -- 12.5.3 Formal Array Type Definition -- | |
5588 | ------------------------------------------ | |
5589 | ||
5590 | -- FORMAL_ARRAY_TYPE_DEFINITION ::= ARRAY_TYPE_DEFINITION | |
5591 | ||
5592 | ------------------------------------------- | |
5593 | -- 12.5.4 Formal Access Type Definition -- | |
5594 | ------------------------------------------- | |
5595 | ||
5596 | -- FORMAL_ACCESS_TYPE_DEFINITION ::= ACCESS_TYPE_DEFINITION | |
5597 | ||
5598 | ----------------------------------------- | |
5599 | -- 12.6 Formal Subprogram Declaration -- | |
5600 | ----------------------------------------- | |
5601 | ||
5602 | -- FORMAL_SUBPROGRAM_DECLARATION ::= | |
5603 | -- with SUBPROGRAM_SPECIFICATION [is SUBPROGRAM_DEFAULT]; | |
5604 | ||
5605 | -- N_Formal_Subprogram_Declaration | |
5606 | -- Sloc points to WITH | |
5607 | -- Specification (Node1) | |
5608 | -- Default_Name (Node2) (set to Empty if no subprogram default) | |
5609 | -- Box_Present (Flag15) | |
5610 | ||
5611 | -- Note: if no subprogram default is present, then Name is set | |
5612 | -- to Empty, and Box_Present is False. | |
5613 | ||
5614 | ------------------------------ | |
5615 | -- 12.6 Subprogram Default -- | |
5616 | ------------------------------ | |
5617 | ||
5618 | -- SUBPROGRAM_DEFAULT ::= DEFAULT_NAME | <> | |
5619 | ||
5620 | -- There is no separate node in the tree for a subprogram default. | |
5621 | -- Instead the parent (N_Formal_Subprogram_Declaration) node contains | |
5622 | -- the default name or box indication, as needed. | |
5623 | ||
5624 | ------------------------ | |
5625 | -- 12.6 Default Name -- | |
5626 | ------------------------ | |
5627 | ||
5628 | -- DEFAULT_NAME ::= NAME | |
5629 | ||
5630 | -------------------------------------- | |
5631 | -- 12.7 Formal Package Declaration -- | |
5632 | -------------------------------------- | |
5633 | ||
5634 | -- FORMAL_PACKAGE_DECLARATION ::= | |
5635 | -- with package DEFINING_IDENTIFIER | |
5636 | -- is new generic_package_NAME FORMAL_PACKAGE_ACTUAL_PART; | |
5637 | ||
5638 | -- Note: formal package declarations not allowed in Ada 83 mode | |
5639 | ||
5640 | -- N_Formal_Package_Declaration | |
5641 | -- Sloc points to WITH | |
5642 | -- Defining_Identifier (Node1) | |
5643 | -- Name (Node2) | |
5644 | -- Generic_Associations (List3) (set to No_List if (<>) case or | |
5645 | -- empty generic actual part) | |
5646 | -- Box_Present (Flag15) | |
5647 | -- Instance_Spec (Node5-Sem) | |
5648 | -- ABE_Is_Certain (Flag18-Sem) | |
5649 | ||
5650 | -------------------------------------- | |
5651 | -- 12.7 Formal Package Actual Part -- | |
5652 | -------------------------------------- | |
5653 | ||
5654 | -- FORMAL_PACKAGE_ACTUAL_PART ::= | |
5655 | -- (<>) | [GENERIC_ACTUAL_PART] | |
5656 | ||
5657 | -- There is no explicit node in the tree for a formal package | |
5658 | -- actual part. Instead the information appears in the parent node | |
5659 | -- (i.e. the formal package declaration node itself). | |
5660 | ||
5661 | --------------------------------- | |
5662 | -- 13.1 Representation clause -- | |
5663 | --------------------------------- | |
5664 | ||
5665 | -- REPRESENTATION_CLAUSE ::= | |
5666 | -- ATTRIBUTE_DEFINITION_CLAUSE | |
5667 | -- | ENUMERATION_REPRESENTATION_CLAUSE | |
5668 | -- | RECORD_REPRESENTATION_CLAUSE | |
5669 | -- | AT_CLAUSE | |
5670 | ||
5671 | ---------------------- | |
5672 | -- 13.1 Local Name -- | |
5673 | ---------------------- | |
5674 | ||
5675 | -- LOCAL_NAME := | |
5676 | -- DIRECT_NAME | |
5677 | -- | DIRECT_NAME'ATTRIBUTE_DESIGNATOR | |
5678 | -- | library_unit_NAME | |
5679 | ||
5680 | -- The construct DIRECT_NAME'ATTRIBUTE_DESIGNATOR appears in the tree | |
5681 | -- as an attribute reference, which has essentially the same form. | |
5682 | ||
5683 | --------------------------------------- | |
5684 | -- 13.3 Attribute definition clause -- | |
5685 | --------------------------------------- | |
5686 | ||
5687 | -- ATTRIBUTE_DEFINITION_CLAUSE ::= | |
5688 | -- for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use EXPRESSION; | |
5689 | -- | for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use NAME; | |
5690 | ||
5691 | -- In Ada 83, the expression must be a simple expression and the | |
5692 | -- local name must be a direct name. | |
5693 | ||
fbf5a39b AC |
5694 | -- Note: the only attribute definition clause that is processed by |
5695 | -- gigi is an address clause. For all other cases, the information | |
5696 | -- is extracted by the front end and either results in setting entity | |
5697 | -- information, e.g. Esize for the Size clause, or in appropriate | |
5698 | -- expansion actions (e.g. in the case of Storage_Size). | |
5699 | ||
5700 | -- For an address clause, Gigi constructs the appropriate addressing | |
5701 | -- code. It also ensures that no aliasing optimizations are made | |
5702 | -- for the object for which the address clause appears. | |
5703 | ||
5704 | -- Note: for an address clause used to achieve an overlay: | |
5705 | ||
5706 | -- A : Integer; | |
5707 | -- B : Integer; | |
5708 | -- for B'Address use A'Address; | |
5709 | ||
5710 | -- the above rule means that Gigi will ensure that no optimizations | |
5711 | -- will be made for B that would violate the implementation advice | |
5712 | -- of RM 13.3(19). However, this advice applies only to B and not | |
5713 | -- to A, which seems unfortunate. The GNAT front end will mark the | |
5714 | -- object A as volatile to also prevent unwanted optimization | |
5715 | -- assumptions based on no aliasing being made for B. | |
996ae0b0 RK |
5716 | |
5717 | -- N_Attribute_Definition_Clause | |
5718 | -- Sloc points to FOR | |
5719 | -- Name (Node2) the local name | |
5720 | -- Chars (Name1) the identifier name from the attribute designator | |
5721 | -- Expression (Node3) the expression or name | |
5722 | -- Next_Rep_Item (Node4-Sem) | |
5723 | -- From_At_Mod (Flag4-Sem) | |
fbf5a39b | 5724 | -- Check_Address_Alignment (Flag11-Sem) |
996ae0b0 RK |
5725 | |
5726 | --------------------------------------------- | |
5727 | -- 13.4 Enumeration representation clause -- | |
5728 | --------------------------------------------- | |
5729 | ||
5730 | -- ENUMERATION_REPRESENTATION_CLAUSE ::= | |
5731 | -- for first_subtype_LOCAL_NAME use ENUMERATION_AGGREGATE; | |
5732 | ||
5733 | -- In Ada 83, the name must be a direct name | |
5734 | ||
5735 | -- N_Enumeration_Representation_Clause | |
5736 | -- Sloc points to FOR | |
5737 | -- Identifier (Node1) direct name | |
5738 | -- Array_Aggregate (Node3) | |
5739 | -- Next_Rep_Item (Node4-Sem) | |
5740 | ||
5741 | --------------------------------- | |
5742 | -- 13.4 Enumeration aggregate -- | |
5743 | --------------------------------- | |
5744 | ||
5745 | -- ENUMERATION_AGGREGATE ::= ARRAY_AGGREGATE | |
5746 | ||
5747 | ------------------------------------------ | |
5748 | -- 13.5.1 Record representation clause -- | |
5749 | ------------------------------------------ | |
5750 | ||
5751 | -- RECORD_REPRESENTATION_CLAUSE ::= | |
5752 | -- for first_subtype_LOCAL_NAME use | |
5753 | -- record [MOD_CLAUSE] | |
5754 | -- {COMPONENT_CLAUSE} | |
5755 | -- end record; | |
5756 | ||
5757 | -- Gigi restriction: Mod_Clause is always Empty (if present it is | |
5758 | -- replaced by a corresponding Alignment attribute definition clause). | |
5759 | ||
5760 | -- Note: Component_Clauses can include pragmas | |
5761 | ||
5762 | -- N_Record_Representation_Clause | |
5763 | -- Sloc points to FOR | |
5764 | -- Identifier (Node1) direct name | |
5765 | -- Mod_Clause (Node2) (set to Empty if no mod clause present) | |
5766 | -- Component_Clauses (List3) | |
5767 | -- Next_Rep_Item (Node4-Sem) | |
5768 | ||
5769 | ------------------------------ | |
5770 | -- 13.5.1 Component clause -- | |
5771 | ------------------------------ | |
5772 | ||
5773 | -- COMPONENT_CLAUSE ::= | |
5774 | -- component_LOCAL_NAME at POSITION | |
5775 | -- range FIRST_BIT .. LAST_BIT; | |
5776 | ||
5777 | -- N_Component_Clause | |
5778 | -- Sloc points to AT | |
5779 | -- Component_Name (Node1) points to Name or Attribute_Reference | |
5780 | -- Position (Node2) | |
5781 | -- First_Bit (Node3) | |
5782 | -- Last_Bit (Node4) | |
5783 | ||
5784 | ---------------------- | |
5785 | -- 13.5.1 Position -- | |
5786 | ---------------------- | |
5787 | ||
5788 | -- POSITION ::= static_EXPRESSION | |
5789 | ||
5790 | ----------------------- | |
5791 | -- 13.5.1 First_Bit -- | |
5792 | ----------------------- | |
5793 | ||
5794 | -- FIRST_BIT ::= static_SIMPLE_EXPRESSION | |
5795 | ||
5796 | ---------------------- | |
5797 | -- 13.5.1 Last_Bit -- | |
5798 | ---------------------- | |
5799 | ||
5800 | -- LAST_BIT ::= static_SIMPLE_EXPRESSION | |
5801 | ||
5802 | -------------------------- | |
5803 | -- 13.8 Code statement -- | |
5804 | -------------------------- | |
5805 | ||
5806 | -- CODE_STATEMENT ::= QUALIFIED_EXPRESSION; | |
5807 | ||
5808 | -- Note: in GNAT, the qualified expression has the form | |
5809 | ||
5810 | -- Asm_Insn'(Asm (...)); | |
5811 | ||
5812 | -- or | |
5813 | ||
5814 | -- Asm_Insn'(Asm_Volatile (...)) | |
5815 | ||
5816 | -- See package System.Machine_Code in file s-maccod.ads for details | |
5817 | -- on the allowed parameters to Asm[_Volatile]. There are two ways | |
5818 | -- this node can arise, as a code statement, in which case the | |
5819 | -- expression is the qualified expression, or as a result of the | |
5820 | -- expansion of an intrinsic call to the Asm or Asm_Input procedure. | |
5821 | ||
5822 | -- N_Code_Statement | |
5823 | -- Sloc points to first token of the expression | |
5824 | -- Expression (Node3) | |
5825 | ||
5826 | -- Note: package Exp_Code contains an abstract functional interface | |
5827 | -- for use by Gigi in accessing the data from N_Code_Statement nodes. | |
5828 | ||
5829 | ------------------------ | |
5830 | -- 13.12 Restriction -- | |
5831 | ------------------------ | |
5832 | ||
5833 | -- RESTRICTION ::= | |
5834 | -- restriction_IDENTIFIER | |
5835 | -- | restriction_parameter_IDENTIFIER => EXPRESSION | |
5836 | ||
5837 | -- There is no explicit node for restrictions. Instead the restriction | |
5838 | -- appears in normal pragma syntax as a pragma argument association, | |
5839 | -- which has the same syntactic form. | |
5840 | ||
5841 | -------------------------- | |
5842 | -- B.2 Shift Operators -- | |
5843 | -------------------------- | |
5844 | ||
5845 | -- Calls to the intrinsic shift functions are converted to one of | |
5846 | -- the following shift nodes, which have the form of normal binary | |
5847 | -- operator names. Note that for a given shift operation, one node | |
5848 | -- covers all possible types, as for normal operators. | |
5849 | ||
5850 | -- Note: it is perfectly permissible for the expander to generate | |
5851 | -- shift operation nodes directly, in which case they will be analyzed | |
5852 | -- and parsed in the usual manner. | |
5853 | ||
5854 | -- Sprint syntax: shift-function-name!(expr, count) | |
5855 | ||
5856 | -- Note: the Left_Opnd field holds the first argument (the value to | |
5857 | -- be shifted). The Right_Opnd field holds the second argument (the | |
5858 | -- shift count). The Chars field is the name of the intrinsic function. | |
5859 | ||
5860 | -- N_Op_Rotate_Left | |
5861 | -- Sloc points to the function name | |
5862 | -- plus fields for binary operator | |
5863 | -- plus fields for expression | |
5864 | -- Shift_Count_OK (Flag4-Sem) | |
5865 | ||
5866 | -- N_Op_Rotate_Right | |
5867 | -- Sloc points to the function name | |
5868 | -- plus fields for binary operator | |
5869 | -- plus fields for expression | |
5870 | -- Shift_Count_OK (Flag4-Sem) | |
5871 | ||
5872 | -- N_Op_Shift_Left | |
5873 | -- Sloc points to the function name | |
5874 | -- plus fields for binary operator | |
5875 | -- plus fields for expression | |
5876 | -- Shift_Count_OK (Flag4-Sem) | |
5877 | ||
5878 | -- N_Op_Shift_Right_Arithmetic | |
5879 | -- Sloc points to the function name | |
5880 | -- plus fields for binary operator | |
5881 | -- plus fields for expression | |
5882 | -- Shift_Count_OK (Flag4-Sem) | |
5883 | ||
5884 | -- N_Op_Shift_Right | |
5885 | -- Sloc points to the function name | |
5886 | -- plus fields for binary operator | |
5887 | -- plus fields for expression | |
5888 | -- Shift_Count_OK (Flag4-Sem) | |
5889 | ||
5890 | -------------------------- | |
5891 | -- Obsolescent Features -- | |
5892 | -------------------------- | |
5893 | ||
5894 | -- The syntax descriptions and tree nodes for obsolescent features are | |
5895 | -- grouped together, corresponding to their location in appendix I in | |
5896 | -- the RM. However, parsing and semantic analysis for these constructs | |
5897 | -- is located in an appropriate chapter (see individual notes). | |
5898 | ||
5899 | --------------------------- | |
5900 | -- J.3 Delta Constraint -- | |
5901 | --------------------------- | |
5902 | ||
5903 | -- Note: the parse routine for this construct is located in section | |
5904 | -- 3.5.9 of Par-Ch3, and semantic analysis is in Sem_Ch3, which is | |
5905 | -- where delta constraint logically belongs. | |
5906 | ||
5907 | -- DELTA_CONSTRAINT ::= DELTA static_EXPRESSION [RANGE_CONSTRAINT] | |
5908 | ||
5909 | -- N_Delta_Constraint | |
5910 | -- Sloc points to DELTA | |
5911 | -- Delta_Expression (Node3) | |
5912 | -- Range_Constraint (Node4) (set to Empty if not present) | |
5913 | ||
5914 | -------------------- | |
5915 | -- J.7 At Clause -- | |
5916 | -------------------- | |
5917 | ||
5918 | -- AT_CLAUSE ::= for DIRECT_NAME use at EXPRESSION; | |
5919 | ||
5920 | -- Note: the parse routine for this construct is located in Par-Ch13, | |
5921 | -- and the semantic analysis is in Sem_Ch13, where at clause logically | |
5922 | -- belongs if it were not obsolescent. | |
5923 | ||
5924 | -- Note: in Ada 83 the expression must be a simple expression | |
5925 | ||
5926 | -- Gigi restriction: This node never appears, it is rewritten as an | |
5927 | -- address attribute definition clause. | |
5928 | ||
5929 | -- N_At_Clause | |
5930 | -- Sloc points to FOR | |
5931 | -- Identifier (Node1) | |
5932 | -- Expression (Node3) | |
5933 | ||
5934 | --------------------- | |
5935 | -- J.8 Mod clause -- | |
5936 | --------------------- | |
5937 | ||
5938 | -- MOD_CLAUSE ::= at mod static_EXPRESSION; | |
5939 | ||
5940 | -- Note: the parse routine for this construct is located in Par-Ch13, | |
5941 | -- and the semantic analysis is in Sem_Ch13, where mod clause logically | |
5942 | -- belongs if it were not obsolescent. | |
5943 | ||
5944 | -- Note: in Ada 83, the expression must be a simple expression | |
5945 | ||
5946 | -- Gigi restriction: this node never appears. It is replaced | |
5947 | -- by a corresponding Alignment attribute definition clause. | |
5948 | ||
5949 | -- Note: pragmas can appear before and after the MOD_CLAUSE since | |
5950 | -- its name has "clause" in it. This is rather strange, but is quite | |
5951 | -- definitely specified. The pragmas before are collected in the | |
5952 | -- Pragmas_Before field of the mod clause node itself, and pragmas | |
5953 | -- after are simply swallowed up in the list of component clauses. | |
5954 | ||
5955 | -- N_Mod_Clause | |
5956 | -- Sloc points to AT | |
5957 | -- Expression (Node3) | |
5958 | -- Pragmas_Before (List4) Pragmas before mod clause (No_List if none) | |
5959 | ||
5960 | -------------------- | |
5961 | -- Semantic Nodes -- | |
5962 | -------------------- | |
5963 | ||
5964 | -- These semantic nodes are used to hold additional semantic information. | |
5965 | -- They are inserted into the tree as a result of semantic processing. | |
5966 | -- Although there are no legitimate source syntax constructions that | |
5967 | -- correspond directly to these nodes, we need a source syntax for the | |
5968 | -- reconstructed tree printed by Sprint, and the node descriptions here | |
5969 | -- show this syntax. | |
5970 | ||
5971 | ---------------------------- | |
5972 | -- Conditional Expression -- | |
5973 | ---------------------------- | |
5974 | ||
5975 | -- This node is used to represent an expression corresponding to the | |
5976 | -- C construct (condition ? then-expression : else_expression), where | |
5977 | -- Expressions is a three element list, whose first expression is the | |
5978 | -- condition, and whose second and third expressions are the then and | |
5979 | -- else expressions respectively. | |
5980 | ||
5981 | -- Note: the Then_Actions and Else_Actions fields are always set to | |
5982 | -- No_List in the tree passed to Gigi. These fields are used only | |
5983 | -- for temporary processing purposes in the expander. | |
5984 | ||
5985 | -- Sprint syntax: (if expr then expr else expr) | |
5986 | ||
5987 | -- N_Conditional_Expression | |
5988 | -- Sloc points to related node | |
5989 | -- Expressions (List1) | |
5990 | -- Then_Actions (List2-Sem) | |
5991 | -- Else_Actions (List3-Sem) | |
5992 | -- plus fields for expression | |
5993 | ||
5994 | -- Note: in the case where a debug source file is generated, the Sloc | |
5995 | -- for this node points to the IF keyword in the Sprint file output. | |
5996 | ||
5997 | ------------------- | |
5998 | -- Expanded_Name -- | |
5999 | ------------------- | |
6000 | ||
6001 | -- The N_Expanded_Name node is used to represent a selected component | |
6002 | -- name that has been resolved to an expanded name. The semantic phase | |
6003 | -- replaces N_Selected_Component nodes that represent names by the use | |
6004 | -- of this node, leaving the N_Selected_Component node used only when | |
6005 | -- the prefix is a record or protected type. | |
6006 | ||
6007 | -- The fields of the N_Expanded_Name node are layed out identically | |
6008 | -- to those of the N_Selected_Component node, allowing conversion of | |
6009 | -- an expanded name node to a selected component node to be done | |
6010 | -- easily, see Sinfo.CN.Change_Selected_Component_To_Expanded_Name. | |
6011 | ||
6012 | -- There is no special sprint syntax for an expanded name. | |
6013 | ||
6014 | -- N_Expanded_Name | |
6015 | -- Sloc points to the period | |
6016 | -- Chars (Name1) copy of Chars field of selector name | |
6017 | -- Prefix (Node3) | |
6018 | -- Selector_Name (Node2) | |
6019 | -- Entity (Node4-Sem) | |
3e542a58 | 6020 | -- Associated_Node (Node4-Sem) |
996ae0b0 RK |
6021 | -- Redundant_Use (Flag13-Sem) |
6022 | -- Has_Private_View (Flag11-Sem) set in generic units. | |
6023 | -- plus fields for expression | |
6024 | ||
6025 | -------------------- | |
6026 | -- Free Statement -- | |
6027 | -------------------- | |
6028 | ||
6029 | -- The N_Free_Statement node is generated as a result of a call to an | |
6030 | -- instantiation of Unchecked_Deallocation. The instantiation of this | |
6031 | -- generic is handled specially and generates this node directly. | |
6032 | ||
6033 | -- Sprint syntax: free expression | |
6034 | ||
6035 | -- N_Free_Statement | |
6036 | -- Sloc is copied from the unchecked deallocation call | |
6037 | -- Expression (Node3) argument to unchecked deallocation call | |
6038 | -- Storage_Pool (Node1-Sem) | |
6039 | -- Procedure_To_Call (Node4-Sem) | |
6040 | ||
6041 | -- Note: in the case where a debug source file is generated, the Sloc | |
6042 | -- for this node points to the FREE keyword in the Sprint file output. | |
6043 | ||
6044 | ------------------- | |
6045 | -- Freeze Entity -- | |
6046 | ------------------- | |
6047 | ||
6048 | -- This node marks the point in a declarative part at which an entity | |
6049 | -- declared therein becomes frozen. The expander places initialization | |
6050 | -- procedures for types at those points. Gigi uses the freezing point | |
6051 | -- to elaborate entities that may depend on previous private types. | |
6052 | ||
6053 | -- See the section in Einfo "Delayed Freezing and Elaboration" for | |
6054 | -- a full description of the use of this node. | |
6055 | ||
6056 | -- The Entity field points back to the entity for the type (whose | |
6057 | -- Freeze_Node field points back to this freeze node). | |
6058 | ||
6059 | -- The Actions field contains a list of declarations and statements | |
6060 | -- generated by the expander which are associated with the freeze | |
6061 | -- node, and are elaborated as though the freeze node were replaced | |
6062 | -- by this sequence of actions. | |
6063 | ||
6064 | -- Note: the Sloc field in the freeze node references a construct | |
6065 | -- associated with the freezing point. This is used for posting | |
6066 | -- messages in some error/warning situations, e.g. the case where | |
6067 | -- a primitive operation of a tagged type is declared too late. | |
6068 | ||
6069 | -- Sprint syntax: freeze entity-name [ | |
6070 | -- freeze actions | |
6071 | -- ] | |
6072 | ||
6073 | -- N_Freeze_Entity | |
6074 | -- Sloc points near freeze point (see above special note) | |
6075 | -- Entity (Node4-Sem) | |
6076 | -- Access_Types_To_Process (Elist2-Sem) (set to No_Elist if none) | |
6077 | -- TSS_Elist (Elist3-Sem) (set to No_Elist if no associated TSS's) | |
6078 | -- Actions (List1) (set to No_List if no freeze actions) | |
6079 | -- First_Subtype_Link (Node5-Sem) (set to Empty if no link) | |
6080 | ||
6081 | -- The Actions field holds actions associated with the freeze. These | |
6082 | -- actions are elaborated at the point where the type is frozen. | |
6083 | ||
6084 | -- Note: in the case where a debug source file is generated, the Sloc | |
6085 | -- for this node points to the FREEZE keyword in the Sprint file output. | |
6086 | ||
6087 | -------------------------------- | |
6088 | -- Implicit Label Declaration -- | |
6089 | -------------------------------- | |
6090 | ||
6091 | -- An implicit label declaration is created for every occurrence of a | |
6092 | -- label on a statement or a label on a block or loop. It is chained | |
6093 | -- in the declarations of the innermost enclosing block as specified | |
6094 | -- in RM section 5.1 (3). | |
6095 | ||
6096 | -- The Defining_Identifier is the actual identifier for the | |
6097 | -- statement identifier. Note that the occurrence of the label | |
6098 | -- is a reference, NOT the defining occurrence. The defining | |
6099 | -- occurrence occurs at the head of the innermost enclosing | |
6100 | -- block, and is represented by this node. | |
6101 | ||
6102 | -- Note: from the grammar, this might better be called an implicit | |
6103 | -- statement identifier declaration, but the term we choose seems | |
6104 | -- friendlier, since at least informally statement identifiers are | |
6105 | -- called labels in both cases (i.e. when used in labels, and when | |
6106 | -- used as the identifiers of blocks and loops). | |
6107 | ||
6108 | -- Note: although this is logically a semantic node, since it does | |
6109 | -- not correspond directly to a source syntax construction, these | |
6110 | -- nodes are actually created by the parser in a post pass done just | |
6111 | -- after parsing is complete, before semantic analysis is started (see | |
6112 | -- the Par.Labl subunit in file par-labl.adb). | |
6113 | ||
6114 | -- Sprint syntax: labelname : label; | |
6115 | ||
6116 | -- N_Implicit_Label_Declaration | |
6117 | -- Sloc points to the << of the label | |
6118 | -- Defining_Identifier (Node1) | |
6119 | -- Label_Construct (Node2-Sem) | |
6120 | ||
6121 | -- Note: in the case where a debug source file is generated, the Sloc | |
6122 | -- for this node points to the label name in the generated declaration. | |
6123 | ||
6124 | --------------------- | |
6125 | -- Itype_Reference -- | |
6126 | --------------------- | |
6127 | ||
6128 | -- This node is used to create a reference to an Itype. The only | |
6129 | -- purpose is to make sure that the Itype is defined if this is the | |
6130 | -- first reference. | |
6131 | ||
6132 | -- A typical use of this node is when an Itype is to be referenced in | |
6133 | -- two branches of an if statement. In this case it is important that | |
6134 | -- the first use of the Itype not be inside the conditional, since | |
6135 | -- then it might not be defined if the wrong branch of the if is | |
6136 | -- taken in the case where the definition generates elaboration code. | |
6137 | ||
6138 | -- The Itype field points to the referenced Itype | |
6139 | ||
6140 | -- sprint syntax: reference itype-name | |
6141 | ||
6142 | -- N_Itype_Reference | |
6143 | -- Sloc points to the node generating the reference | |
6144 | -- Itype (Node1-Sem) | |
6145 | ||
6146 | -- Note: in the case where a debug source file is generated, the Sloc | |
6147 | -- for this node points to the REFERENCE keyword in the file output. | |
6148 | ||
6149 | --------------------- | |
6150 | -- Raise_xxx_Error -- | |
6151 | --------------------- | |
6152 | ||
6153 | -- One of these nodes is created during semantic analysis to replace | |
6154 | -- a node for an expression that is determined to definitely raise | |
6155 | -- the corresponding exception. | |
6156 | ||
6157 | -- The N_Raise_xxx_Error node may also stand alone in place | |
6158 | -- of a declaration or statement, in which case it simply causes | |
6159 | -- the exception to be raised (i.e. it is equivalent to a raise | |
6160 | -- statement that raises the corresponding exception). This use | |
6161 | -- is distinguished by the fact that the Etype in this case is | |
6162 | -- Standard_Void_Type, In the subexprssion case, the Etype is the | |
6163 | -- same as the type of the subexpression which it replaces. | |
6164 | ||
6165 | -- If Condition is empty, then the raise is unconditional. If the | |
6166 | -- Condition field is non-empty, it is a boolean expression which | |
6167 | -- is first evaluated, and the exception is raised only if the | |
6168 | -- value of the expression is True. In the unconditional case, the | |
6169 | -- creation of this node is usually accompanied by a warning message | |
6170 | -- error. The creation of this node will usually be accompanied by a | |
6171 | -- message (unless it appears within the right operand of a short | |
6172 | -- circuit form whose left argument is static and decisively | |
6173 | -- eliminates elaboration of the raise operation. | |
6174 | ||
07fc65c4 GB |
6175 | -- The exception is generated with a message that contains the |
6176 | -- file name and line number, and then appended text. The Reason | |
6177 | -- code shows the text to be added. The Reason code is an element | |
6178 | -- of the type Types.RT_Exception_Code, and indicates both the | |
6179 | -- message to be added, and the exception to be raised (which must | |
6180 | -- match the node type). The value is stored by storing a Uint which | |
6181 | -- is the Pos value of the enumeration element in this type. | |
6182 | ||
996ae0b0 RK |
6183 | -- Gigi restriction: This expander ensures that the type of the |
6184 | -- Condition field is always Standard.Boolean, even if the type | |
6185 | -- in the source is some non-standard boolean type. | |
6186 | ||
07fc65c4 GB |
6187 | -- Sprint syntax: [xxx_error "msg"] |
6188 | -- or: [xxx_error when condition "msg"] | |
996ae0b0 RK |
6189 | |
6190 | -- N_Raise_Constraint_Error | |
6191 | -- Sloc references related construct | |
6192 | -- Condition (Node1) (set to Empty if no condition) | |
07fc65c4 | 6193 | -- Reason (Uint3) |
996ae0b0 RK |
6194 | -- plus fields for expression |
6195 | ||
6196 | -- N_Raise_Program_Error | |
6197 | -- Sloc references related construct | |
6198 | -- Condition (Node1) (set to Empty if no condition) | |
07fc65c4 | 6199 | -- Reason (Uint3) |
996ae0b0 RK |
6200 | -- plus fields for expression |
6201 | ||
6202 | -- N_Raise_Storage_Error | |
6203 | -- Sloc references related construct | |
6204 | -- Condition (Node1) (set to Empty if no condition) | |
07fc65c4 | 6205 | -- Reason (Uint3) |
996ae0b0 RK |
6206 | -- plus fields for expression |
6207 | ||
07fc65c4 GB |
6208 | -- Note: Sloc is copied from the expression generating the exception. |
6209 | -- In the case where a debug source file is generated, the Sloc for | |
6210 | -- this node points to the left bracket in the Sprint file output. | |
996ae0b0 RK |
6211 | |
6212 | --------------- | |
6213 | -- Reference -- | |
6214 | --------------- | |
6215 | ||
6216 | -- For a number of purposes, we need to construct references to objects. | |
6217 | -- These references are subsequently treated as normal access values. | |
6218 | -- An example is the construction of the parameter block passed to a | |
6219 | -- task entry. The N_Reference node is provided for this purpose. It is | |
6220 | -- similar in effect to the use of the Unrestricted_Access attribute, | |
6221 | -- and like Unrestricted_Access can be applied to objects which would | |
6222 | -- not be valid prefixes for the Unchecked_Access attribute (e.g. | |
6223 | -- objects which are not aliased, and slices). In addition it can be | |
6224 | -- applied to composite type values as well as objects, including string | |
6225 | -- values and aggregates. | |
6226 | ||
6227 | -- Note: we use the Prefix field for this expression so that the | |
6228 | -- resulting node can be treated using common code with the attribute | |
6229 | -- nodes for the 'Access and related attributes. Logically it would make | |
6230 | -- more sense to call it an Expression field, but then we would have to | |
6231 | -- special case the treatment of the N_Reference node. | |
6232 | ||
6233 | -- Sprint syntax: prefix'reference | |
6234 | ||
6235 | -- N_Reference | |
6236 | -- Sloc is copied from the expression | |
6237 | -- Prefix (Node3) | |
6238 | -- plus fields for expression | |
6239 | ||
6240 | -- Note: in the case where a debug source file is generated, the Sloc | |
6241 | -- for this node points to the quote in the Sprint file output. | |
6242 | ||
6243 | --------------------- | |
6244 | -- Subprogram_Info -- | |
6245 | --------------------- | |
6246 | ||
6247 | -- This node generates the appropriate Subprogram_Info value for a | |
6248 | -- given procedure. See Ada.Exceptions for further details | |
6249 | ||
6250 | -- Sprint syntax: subprog'subprogram_info | |
6251 | ||
6252 | -- N_Subprogram_Info | |
6253 | -- Sloc points to the entity for the procedure | |
6254 | -- Identifier (Node1) identifier referencing the procedure | |
6255 | -- Etype (Node5-Sem) type (always set to Ada.Exceptions.Code_Loc | |
6256 | ||
6257 | -- Note: in the case where a debug source file is generated, the Sloc | |
6258 | -- for this node points to the quote in the Sprint file output. | |
6259 | ||
6260 | -------------------------- | |
6261 | -- Unchecked Expression -- | |
6262 | -------------------------- | |
6263 | ||
6264 | -- An unchecked expression is one that must be analyzed and resolved | |
6265 | -- with all checks off, regardless of the current setting of scope | |
6266 | -- suppress flags. | |
6267 | ||
6268 | -- Sprint syntax: `(expression). | |
6269 | ||
6270 | -- Note: this node is always removed from the tree (and replaced by | |
6271 | -- its constituent expression) on completion of analysis, so it only | |
6272 | -- appears in intermediate trees, and will never be seen by Gigi. | |
6273 | ||
6274 | -- N_Unchecked_Expression | |
6275 | -- Sloc is a copy of the Sloc of the expression | |
6276 | -- Expression (Node3) | |
6277 | -- plus fields for expression | |
6278 | ||
6279 | -- Note: in the case where a debug source file is generated, the Sloc | |
6280 | -- for this node points to the back quote in the Sprint file output. | |
6281 | ||
6282 | ------------------------------- | |
6283 | -- Unchecked Type Conversion -- | |
6284 | ------------------------------- | |
6285 | ||
6286 | -- An unchecked type conversion node represents the semantic action | |
6287 | -- corresponding to a call to an instantiation of Unchecked_Conversion. | |
6288 | -- It is generated as a result of actual use of Unchecked_Conversion | |
6289 | -- and also the expander generates unchecked type conversion nodes | |
6290 | -- directly for expansion of complex semantic actions. | |
6291 | ||
6292 | -- Note: an unchecked type conversion is a variable as far as the | |
6293 | -- semantics are concerned, which is convenient for the expander. | |
6294 | -- This does not change what Ada source programs are legal, since | |
6295 | -- clearly a function call to an instantiation of Unchecked_Conversion | |
6296 | -- is not a variable in any case. | |
6297 | ||
6298 | -- Sprint syntax: subtype-mark!(expression). | |
6299 | ||
6300 | -- N_Unchecked_Type_Conversion | |
6301 | -- Sloc points to related node in source | |
6302 | -- Subtype_Mark (Node4) | |
6303 | -- Expression (Node3) | |
6304 | -- Kill_Range_Check (Flag11-Sem) | |
fbf5a39b | 6305 | -- No_Truncation (Flag17-Sem) |
996ae0b0 RK |
6306 | -- plus fields for expression |
6307 | ||
6308 | -- Note: in the case where a debug source file is generated, the Sloc | |
6309 | -- for this node points to the exclamation in the Sprint file output. | |
6310 | ||
6311 | ----------------------------------- | |
6312 | -- Validate_Unchecked_Conversion -- | |
6313 | ----------------------------------- | |
6314 | ||
6315 | -- The front end does most of the validation of unchecked conversion, | |
6316 | -- including checking sizes (this is done after the back end is called | |
6317 | -- to take advantage of back-annotation of calculated sizes). | |
6318 | ||
6319 | -- The front end also deals with specific cases that are not allowed | |
6320 | -- e.g. involving unconstrained array types. | |
6321 | ||
6322 | -- For the case of the standard gigi backend, this means that all | |
6323 | -- checks are done in the front-end. | |
6324 | ||
6325 | -- However, in the case of specialized back-ends, notably the JVM | |
6326 | -- backend for JGNAT, additional requirements and restrictions apply | |
6327 | -- to unchecked conversion, and these are most conveniently performed | |
6328 | -- in the specialized back-end. | |
6329 | ||
638e383e | 6330 | -- To accommodate this requirement, for such back ends, the following |
996ae0b0 RK |
6331 | -- special node is generated recording an unchecked conversion that |
6332 | -- needs to be validated. The back end should post an appropriate | |
6333 | -- error message if the unchecked conversion is invalid or warrants | |
6334 | -- a special warning message. | |
6335 | ||
6336 | -- Source_Type and Target_Type point to the entities for the two | |
6337 | -- types involved in the unchecked conversion instantiation that | |
6338 | -- is to be validated. | |
6339 | ||
6340 | -- Sprint syntax: validate Unchecked_Conversion (source, target); | |
6341 | ||
6342 | -- N_Validate_Unchecked_Conversion | |
6343 | -- Sloc points to instantiation (location for warning message) | |
6344 | -- Source_Type (Node1-Sem) | |
6345 | -- Target_Type (Node2-Sem) | |
6346 | ||
6347 | -- Note: in the case where a debug source file is generated, the Sloc | |
6348 | -- for this node points to the VALIDATE keyword in the file output. | |
6349 | ||
6350 | ----------- | |
6351 | -- Empty -- | |
6352 | ----------- | |
6353 | ||
996ae0b0 RK |
6354 | -- Used as the contents of the Nkind field of the dummy Empty node |
6355 | -- and in some other situations to indicate an uninitialized value. | |
6356 | ||
5c736541 RD |
6357 | -- N_Empty |
6358 | -- Chars (Name1) is set to No_Name | |
6359 | ||
996ae0b0 RK |
6360 | ----------- |
6361 | -- Error -- | |
6362 | ----------- | |
6363 | ||
5c736541 RD |
6364 | -- Used as the contents of the Nkind field of the dummy Error node. |
6365 | -- Has an Etype field, which gets set to Any_Type later on, to help | |
6366 | -- error recovery (Error_Posted is also set in the Error node). | |
6367 | ||
996ae0b0 RK |
6368 | -- N_Error |
6369 | -- Chars (Name1) is set to Error_Name | |
5c736541 | 6370 | -- Etype (Node5-Sem) |
996ae0b0 RK |
6371 | |
6372 | -------------------------- | |
6373 | -- Node Type Definition -- | |
6374 | -------------------------- | |
6375 | ||
6376 | -- The following is the definition of the Node_Kind type. As previously | |
6377 | -- discussed, this is separated off to allow rearrangement of the order | |
6378 | -- to facilitiate definition of subtype ranges. The comments show the | |
6379 | -- subtype classes which apply to each set of node kinds. The first | |
6380 | -- entry in the comment characterizes the following list of nodes. | |
6381 | ||
6382 | type Node_Kind is ( | |
6383 | N_Unused_At_Start, | |
6384 | ||
6385 | -- N_Representation_Clause | |
6386 | N_At_Clause, | |
6387 | N_Component_Clause, | |
6388 | N_Enumeration_Representation_Clause, | |
6389 | N_Mod_Clause, | |
6390 | N_Record_Representation_Clause, | |
6391 | ||
6392 | -- N_Representation_Clause, N_Has_Chars | |
6393 | N_Attribute_Definition_Clause, | |
6394 | ||
6395 | -- N_Has_Chars | |
6396 | N_Empty, | |
996ae0b0 RK |
6397 | N_Pragma, |
6398 | N_Pragma_Argument_Association, | |
6399 | ||
5c736541 RD |
6400 | -- N_Has_Etype |
6401 | N_Error, | |
6402 | ||
996ae0b0 RK |
6403 | -- N_Entity, N_Has_Etype, N_Has_Chars |
6404 | N_Defining_Character_Literal, | |
6405 | N_Defining_Identifier, | |
6406 | N_Defining_Operator_Symbol, | |
6407 | ||
6408 | -- N_Subexpr, N_Has_Etype, N_Has_Chars, N_Has_Entity | |
6409 | N_Expanded_Name, | |
6410 | ||
6411 | -- N_Direct_Name, N_Subexpr, N_Has_Etype, | |
6412 | -- N_Has_Chars, N_Has_Entity | |
6413 | N_Identifier, | |
6414 | N_Operator_Symbol, | |
6415 | ||
6416 | -- N_Direct_Name, N_Subexpr, N_Has_Etype, | |
6417 | -- N_Has_Chars, N_Has_Entity | |
6418 | N_Character_Literal, | |
6419 | ||
6420 | -- N_Binary_Op, N_Op, N_Subexpr, | |
6421 | -- N_Has_Etype, N_Has_Chars, N_Has_Entity | |
6422 | N_Op_Add, | |
6423 | N_Op_Concat, | |
996ae0b0 | 6424 | N_Op_Expon, |
fbf5a39b AC |
6425 | N_Op_Subtract, |
6426 | ||
6427 | -- N_Binary_Op, N_Op, N_Subexpr, N_Has_Treat_Fixed_As_Integer | |
6428 | -- N_Has_Etype, N_Has_Chars, N_Has_Entity | |
6429 | ||
6430 | N_Op_Divide, | |
996ae0b0 RK |
6431 | N_Op_Mod, |
6432 | N_Op_Multiply, | |
6433 | N_Op_Rem, | |
996ae0b0 RK |
6434 | |
6435 | -- N_Binary_Op, N_Op, N_Subexpr, N_Has_Etype | |
6436 | -- N_Has_Entity, N_Has_Chars, N_Op_Boolean | |
6437 | N_Op_And, | |
6438 | ||
6439 | -- N_Binary_Op, N_Op, N_Subexpr, N_Has_Etype | |
6440 | -- N_Has_Entity, N_Has_Chars, N_Op_Boolean, | |
6441 | -- N_Op_Compare | |
6442 | N_Op_Eq, | |
6443 | N_Op_Ge, | |
6444 | N_Op_Gt, | |
6445 | N_Op_Le, | |
6446 | N_Op_Lt, | |
6447 | N_Op_Ne, | |
6448 | ||
6449 | -- N_Binary_Op, N_Op, N_Subexpr, N_Has_Etype | |
6450 | -- N_Has_Entity, N_Has_Chars, N_Op_Boolean | |
6451 | N_Op_Or, | |
6452 | N_Op_Xor, | |
6453 | ||
6454 | -- N_Binary_Op, N_Op, N_Subexpr, N_Has_Etype, | |
6455 | -- N_Op_Shift, N_Has_Chars, N_Has_Entity | |
6456 | N_Op_Rotate_Left, | |
6457 | N_Op_Rotate_Right, | |
6458 | N_Op_Shift_Left, | |
6459 | N_Op_Shift_Right, | |
6460 | N_Op_Shift_Right_Arithmetic, | |
6461 | ||
6462 | -- N_Unary_Op, N_Op, N_Subexpr, N_Has_Etype, | |
6463 | -- N_Has_Chars, N_Has_Entity | |
6464 | N_Op_Abs, | |
6465 | N_Op_Minus, | |
6466 | N_Op_Not, | |
6467 | N_Op_Plus, | |
6468 | ||
6469 | -- N_Subexpr, N_Has_Etype, N_Has_Entity | |
6470 | N_Attribute_Reference, | |
6471 | ||
6472 | -- N_Subexpr, N_Has_Etype | |
6473 | N_And_Then, | |
6474 | N_Conditional_Expression, | |
6475 | N_Explicit_Dereference, | |
6476 | N_Function_Call, | |
6477 | N_In, | |
6478 | N_Indexed_Component, | |
6479 | N_Integer_Literal, | |
6480 | N_Not_In, | |
6481 | N_Null, | |
6482 | N_Or_Else, | |
6483 | N_Procedure_Call_Statement, | |
6484 | N_Qualified_Expression, | |
6485 | ||
6486 | -- N_Raise_xxx_Error, N_Subexpr, N_Has_Etype | |
6487 | ||
6488 | N_Raise_Constraint_Error, | |
6489 | N_Raise_Program_Error, | |
6490 | N_Raise_Storage_Error, | |
6491 | ||
6492 | -- N_Subexpr, N_Has_Etype | |
6493 | ||
6494 | N_Aggregate, | |
6495 | N_Allocator, | |
6496 | N_Extension_Aggregate, | |
6497 | N_Range, | |
6498 | N_Real_Literal, | |
6499 | N_Reference, | |
6500 | N_Selected_Component, | |
6501 | N_Slice, | |
6502 | N_String_Literal, | |
6503 | N_Subprogram_Info, | |
6504 | N_Type_Conversion, | |
6505 | N_Unchecked_Expression, | |
6506 | N_Unchecked_Type_Conversion, | |
6507 | ||
6508 | -- N_Has_Etype | |
6509 | N_Subtype_Indication, | |
6510 | ||
6511 | -- N_Declaration | |
6512 | N_Component_Declaration, | |
6513 | N_Entry_Declaration, | |
6514 | N_Formal_Object_Declaration, | |
6515 | N_Formal_Type_Declaration, | |
6516 | N_Full_Type_Declaration, | |
6517 | N_Incomplete_Type_Declaration, | |
6518 | N_Loop_Parameter_Specification, | |
6519 | N_Object_Declaration, | |
6520 | N_Protected_Type_Declaration, | |
6521 | N_Private_Extension_Declaration, | |
6522 | N_Private_Type_Declaration, | |
6523 | N_Subtype_Declaration, | |
6524 | ||
6525 | -- N_Subprogram_Specification, N_Declaration | |
6526 | N_Function_Specification, | |
6527 | N_Procedure_Specification, | |
6528 | ||
6529 | -- (nothing special) | |
6530 | N_Entry_Index_Specification, | |
6531 | N_Freeze_Entity, | |
6532 | ||
6533 | -- N_Access_To_Subprogram_Definition | |
6534 | N_Access_Function_Definition, | |
6535 | N_Access_Procedure_Definition, | |
6536 | ||
6537 | -- N_Later_Decl_Item, | |
6538 | N_Task_Type_Declaration, | |
6539 | ||
6540 | -- N_Body_Stub, N_Later_Decl_Item | |
6541 | N_Package_Body_Stub, | |
6542 | N_Protected_Body_Stub, | |
6543 | N_Subprogram_Body_Stub, | |
6544 | N_Task_Body_Stub, | |
6545 | ||
6546 | -- N_Generic_Instantiation, N_Later_Decl_Item | |
6547 | N_Function_Instantiation, | |
6548 | N_Package_Instantiation, | |
6549 | N_Procedure_Instantiation, | |
6550 | ||
6551 | -- N_Unit_Body, N_Later_Decl_Item, N_Proper_Body | |
6552 | N_Package_Body, | |
6553 | N_Subprogram_Body, | |
6554 | ||
6555 | -- N_Later_Decl_Item, N_Proper_Body | |
6556 | N_Protected_Body, | |
6557 | N_Task_Body, | |
6558 | ||
6559 | -- N_Later_Decl_Item | |
6560 | N_Implicit_Label_Declaration, | |
6561 | N_Package_Declaration, | |
6562 | N_Single_Task_Declaration, | |
6563 | N_Subprogram_Declaration, | |
6564 | N_Use_Package_Clause, | |
6565 | ||
6566 | -- N_Generic_Declaration, N_Later_Decl_Item | |
6567 | N_Generic_Package_Declaration, | |
6568 | N_Generic_Subprogram_Declaration, | |
6569 | ||
6570 | -- N_Array_Type_Definition | |
6571 | N_Constrained_Array_Definition, | |
6572 | N_Unconstrained_Array_Definition, | |
6573 | ||
6574 | -- N_Renaming_Declaration | |
6575 | N_Exception_Renaming_Declaration, | |
6576 | N_Object_Renaming_Declaration, | |
6577 | N_Package_Renaming_Declaration, | |
6578 | N_Subprogram_Renaming_Declaration, | |
6579 | ||
6580 | -- N_Generic_Renaming_Declarations, N_Renaming_Declaration | |
6581 | N_Generic_Function_Renaming_Declaration, | |
6582 | N_Generic_Package_Renaming_Declaration, | |
6583 | N_Generic_Procedure_Renaming_Declaration, | |
6584 | ||
6585 | -- N_Statement_Other_Than_Procedure_Call | |
6586 | N_Abort_Statement, | |
6587 | N_Accept_Statement, | |
6588 | N_Assignment_Statement, | |
6589 | N_Asynchronous_Select, | |
6590 | N_Block_Statement, | |
6591 | N_Case_Statement, | |
6592 | N_Code_Statement, | |
6593 | N_Conditional_Entry_Call, | |
6594 | N_Delay_Relative_Statement, | |
6595 | N_Delay_Until_Statement, | |
6596 | N_Entry_Call_Statement, | |
6597 | N_Free_Statement, | |
6598 | N_Goto_Statement, | |
6599 | N_Loop_Statement, | |
6600 | N_Null_Statement, | |
6601 | N_Raise_Statement, | |
6602 | N_Requeue_Statement, | |
6603 | N_Return_Statement, | |
6604 | N_Selective_Accept, | |
6605 | N_Timed_Entry_Call, | |
6606 | ||
6607 | -- N_Statement_Other_Than_Procedure_Call, N_Has_Condition | |
6608 | N_Exit_Statement, | |
6609 | N_If_Statement, | |
6610 | ||
6611 | -- N_Has_Condition | |
6612 | N_Accept_Alternative, | |
6613 | N_Delay_Alternative, | |
6614 | N_Elsif_Part, | |
6615 | N_Entry_Body_Formal_Part, | |
6616 | N_Iteration_Scheme, | |
6617 | N_Terminate_Alternative, | |
6618 | ||
6619 | -- Other nodes (not part of any subtype class) | |
6620 | N_Abortable_Part, | |
6621 | N_Abstract_Subprogram_Declaration, | |
6622 | N_Access_Definition, | |
6623 | N_Access_To_Object_Definition, | |
6624 | N_Case_Statement_Alternative, | |
6625 | N_Compilation_Unit, | |
6626 | N_Compilation_Unit_Aux, | |
6627 | N_Component_Association, | |
6628 | N_Component_List, | |
6629 | N_Derived_Type_Definition, | |
6630 | N_Decimal_Fixed_Point_Definition, | |
6631 | N_Defining_Program_Unit_Name, | |
6632 | N_Delta_Constraint, | |
6633 | N_Designator, | |
6634 | N_Digits_Constraint, | |
6635 | N_Discriminant_Association, | |
6636 | N_Discriminant_Specification, | |
6637 | N_Enumeration_Type_Definition, | |
6638 | N_Entry_Body, | |
6639 | N_Entry_Call_Alternative, | |
6640 | N_Exception_Declaration, | |
6641 | N_Exception_Handler, | |
6642 | N_Floating_Point_Definition, | |
6643 | N_Formal_Decimal_Fixed_Point_Definition, | |
6644 | N_Formal_Derived_Type_Definition, | |
6645 | N_Formal_Discrete_Type_Definition, | |
6646 | N_Formal_Floating_Point_Definition, | |
6647 | N_Formal_Modular_Type_Definition, | |
6648 | N_Formal_Ordinary_Fixed_Point_Definition, | |
6649 | N_Formal_Package_Declaration, | |
6650 | N_Formal_Private_Type_Definition, | |
6651 | N_Formal_Signed_Integer_Type_Definition, | |
6652 | N_Formal_Subprogram_Declaration, | |
6653 | N_Generic_Association, | |
6654 | N_Handled_Sequence_Of_Statements, | |
6655 | N_Index_Or_Discriminant_Constraint, | |
6656 | N_Itype_Reference, | |
6657 | N_Label, | |
6658 | N_Modular_Type_Definition, | |
6659 | N_Number_Declaration, | |
6660 | N_Ordinary_Fixed_Point_Definition, | |
6661 | N_Others_Choice, | |
6662 | N_Package_Specification, | |
6663 | N_Parameter_Association, | |
6664 | N_Parameter_Specification, | |
6665 | N_Protected_Definition, | |
6666 | N_Range_Constraint, | |
6667 | N_Real_Range_Specification, | |
6668 | N_Record_Definition, | |
6669 | N_Signed_Integer_Type_Definition, | |
6670 | N_Single_Protected_Declaration, | |
6671 | N_Subunit, | |
6672 | N_Task_Definition, | |
6673 | N_Triggering_Alternative, | |
6674 | N_Use_Type_Clause, | |
6675 | N_Validate_Unchecked_Conversion, | |
6676 | N_Variant, | |
6677 | N_Variant_Part, | |
6678 | N_With_Clause, | |
6679 | N_With_Type_Clause, | |
6680 | N_Unused_At_End); | |
6681 | ||
6682 | for Node_Kind'Size use 8; | |
6683 | -- The data structures in Atree assume this! | |
6684 | ||
6685 | ---------------------------- | |
6686 | -- Node Class Definitions -- | |
6687 | ---------------------------- | |
6688 | ||
6689 | subtype N_Access_To_Subprogram_Definition is Node_Kind range | |
6690 | N_Access_Function_Definition .. | |
6691 | N_Access_Procedure_Definition; | |
6692 | ||
6693 | subtype N_Array_Type_Definition is Node_Kind range | |
6694 | N_Constrained_Array_Definition .. | |
6695 | N_Unconstrained_Array_Definition; | |
6696 | ||
6697 | subtype N_Binary_Op is Node_Kind range | |
6698 | N_Op_Add .. | |
6699 | N_Op_Shift_Right_Arithmetic; | |
6700 | ||
6701 | subtype N_Body_Stub is Node_Kind range | |
6702 | N_Package_Body_Stub .. | |
6703 | N_Task_Body_Stub; | |
6704 | ||
6705 | subtype N_Declaration is Node_Kind range | |
6706 | N_Component_Declaration .. | |
6707 | N_Procedure_Specification; | |
6708 | -- Note: this includes all constructs normally thought of as declarations | |
6709 | -- except those which are separately grouped as later declarations. | |
6710 | ||
6711 | subtype N_Direct_Name is Node_Kind range | |
6712 | N_Identifier .. | |
6713 | N_Character_Literal; | |
6714 | ||
6715 | subtype N_Entity is Node_Kind range | |
6716 | N_Defining_Character_Literal .. | |
6717 | N_Defining_Operator_Symbol; | |
6718 | ||
6719 | subtype N_Generic_Declaration is Node_Kind range | |
6720 | N_Generic_Package_Declaration .. | |
6721 | N_Generic_Subprogram_Declaration; | |
6722 | ||
6723 | subtype N_Generic_Instantiation is Node_Kind range | |
6724 | N_Function_Instantiation .. | |
6725 | N_Procedure_Instantiation; | |
6726 | ||
6727 | subtype N_Generic_Renaming_Declaration is Node_Kind range | |
6728 | N_Generic_Function_Renaming_Declaration .. | |
6729 | N_Generic_Procedure_Renaming_Declaration; | |
6730 | ||
6731 | subtype N_Has_Chars is Node_Kind range | |
6732 | N_Attribute_Definition_Clause .. | |
6733 | N_Op_Plus; | |
6734 | ||
6735 | subtype N_Has_Entity is Node_Kind range | |
6736 | N_Expanded_Name .. | |
6737 | N_Attribute_Reference; | |
6738 | -- Nodes that have Entity fields | |
6739 | -- Warning: DOES NOT INCLUDE N_Freeze_Entity! | |
6740 | ||
6741 | subtype N_Has_Etype is Node_Kind range | |
5c736541 | 6742 | N_Error .. |
996ae0b0 RK |
6743 | N_Subtype_Indication; |
6744 | ||
fbf5a39b AC |
6745 | subtype N_Has_Treat_Fixed_As_Integer is Node_Kind range |
6746 | N_Op_Divide .. | |
6747 | N_Op_Rem; | |
6748 | ||
996ae0b0 RK |
6749 | subtype N_Later_Decl_Item is Node_Kind range |
6750 | N_Task_Type_Declaration .. | |
6751 | N_Generic_Subprogram_Declaration; | |
6752 | -- Note: this is Ada 83 relevant only (see Ada 83 RM 3.9 (2)) and | |
6753 | -- includes only those items which can appear as later declarative | |
6754 | -- items. This also includes N_Implicit_Label_Declaration which is | |
6755 | -- not specifically in the grammar but may appear as a valid later | |
6756 | -- declarative items. It does NOT include N_Pragma which can also | |
6757 | -- appear among later declarative items. It does however include | |
6758 | -- N_Protected_Body, which is a bit peculiar, but harmless since | |
6759 | -- this cannot appear in Ada 83 mode anyway. | |
6760 | ||
6761 | subtype N_Op is Node_Kind range | |
6762 | N_Op_Add .. | |
6763 | N_Op_Plus; | |
6764 | ||
6765 | subtype N_Op_Boolean is Node_Kind range | |
6766 | N_Op_And .. | |
6767 | N_Op_Xor; | |
6768 | -- Binary operators which take operands of a boolean type, and yield | |
6769 | -- a result of a boolean type. | |
6770 | ||
6771 | subtype N_Op_Compare is Node_Kind range | |
6772 | N_Op_Eq .. | |
6773 | N_Op_Ne; | |
6774 | ||
6775 | subtype N_Op_Shift is Node_Kind range | |
6776 | N_Op_Rotate_Left .. | |
6777 | N_Op_Shift_Right_Arithmetic; | |
6778 | ||
6779 | subtype N_Proper_Body is Node_Kind range | |
6780 | N_Package_Body .. | |
6781 | N_Task_Body; | |
6782 | ||
6783 | subtype N_Raise_xxx_Error is Node_Kind range | |
6784 | N_Raise_Constraint_Error .. | |
6785 | N_Raise_Storage_Error; | |
6786 | ||
6787 | subtype N_Renaming_Declaration is Node_Kind range | |
6788 | N_Exception_Renaming_Declaration .. | |
6789 | N_Generic_Procedure_Renaming_Declaration; | |
6790 | ||
6791 | subtype N_Representation_Clause is Node_Kind range | |
6792 | N_At_Clause .. | |
6793 | N_Attribute_Definition_Clause; | |
6794 | ||
6795 | subtype N_Statement_Other_Than_Procedure_Call is Node_Kind range | |
6796 | N_Abort_Statement .. | |
6797 | N_If_Statement; | |
6798 | -- Note that this includes all statement types except for the cases of the | |
6799 | -- N_Procedure_Call_Statement which is considered to be a subexpression | |
6800 | -- (since overloading is possible, so it needs to go through the normal | |
6801 | -- overloading resolution for expressions). | |
6802 | ||
6803 | subtype N_Has_Condition is Node_Kind range | |
6804 | N_Exit_Statement .. | |
6805 | N_Terminate_Alternative; | |
6806 | -- Nodes with condition fields (does not include N_Raise_xxx_Error) | |
6807 | ||
6808 | subtype N_Subexpr is Node_Kind range | |
6809 | N_Expanded_Name .. | |
6810 | N_Unchecked_Type_Conversion; | |
6811 | -- Nodes with expression fields | |
6812 | ||
6813 | subtype N_Subprogram_Specification is Node_Kind range | |
6814 | N_Function_Specification .. | |
6815 | N_Procedure_Specification; | |
6816 | ||
6817 | subtype N_Unary_Op is Node_Kind range | |
6818 | N_Op_Abs .. | |
6819 | N_Op_Plus; | |
6820 | ||
6821 | subtype N_Unit_Body is Node_Kind range | |
6822 | N_Package_Body .. | |
6823 | N_Subprogram_Body; | |
6824 | ||
6825 | --------------------------- | |
6826 | -- Node Access Functions -- | |
6827 | --------------------------- | |
6828 | ||
6829 | -- The following functions return the contents of the indicated field of | |
6830 | -- the node referenced by the argument, which is a Node_Id. They provide | |
6831 | -- logical access to fields in the node which could be accessed using the | |
6832 | -- Atree.Unchecked_Access package, but the idea is always to use these | |
6833 | -- higher level routines which preserve strong typing. In debug mode, | |
6834 | -- these routines check that they are being applied to an appropriate | |
6835 | -- node, as well as checking that the node is in range. | |
6836 | ||
6837 | function ABE_Is_Certain | |
6838 | (N : Node_Id) return Boolean; -- Flag18 | |
6839 | ||
6840 | function Abort_Present | |
6841 | (N : Node_Id) return Boolean; -- Flag15 | |
6842 | ||
6843 | function Abortable_Part | |
6844 | (N : Node_Id) return Node_Id; -- Node2 | |
6845 | ||
6846 | function Abstract_Present | |
6847 | (N : Node_Id) return Boolean; -- Flag4 | |
6848 | ||
6849 | function Accept_Handler_Records | |
6850 | (N : Node_Id) return List_Id; -- List5 | |
6851 | ||
6852 | function Accept_Statement | |
6853 | (N : Node_Id) return Node_Id; -- Node2 | |
6854 | ||
6855 | function Access_Types_To_Process | |
6856 | (N : Node_Id) return Elist_Id; -- Elist2 | |
6857 | ||
6858 | function Actions | |
6859 | (N : Node_Id) return List_Id; -- List1 | |
6860 | ||
6861 | function Activation_Chain_Entity | |
6862 | (N : Node_Id) return Node_Id; -- Node3 | |
6863 | ||
6864 | function Acts_As_Spec | |
6865 | (N : Node_Id) return Boolean; -- Flag4 | |
6866 | ||
6867 | function Aggregate_Bounds | |
6868 | (N : Node_Id) return Node_Id; -- Node3 | |
6869 | ||
6870 | function Aliased_Present | |
6871 | (N : Node_Id) return Boolean; -- Flag4 | |
6872 | ||
6873 | function All_Others | |
6874 | (N : Node_Id) return Boolean; -- Flag11 | |
6875 | ||
6876 | function All_Present | |
6877 | (N : Node_Id) return Boolean; -- Flag15 | |
6878 | ||
6879 | function Alternatives | |
6880 | (N : Node_Id) return List_Id; -- List4 | |
6881 | ||
6882 | function Ancestor_Part | |
6883 | (N : Node_Id) return Node_Id; -- Node3 | |
6884 | ||
6885 | function Array_Aggregate | |
6886 | (N : Node_Id) return Node_Id; -- Node3 | |
6887 | ||
6888 | function Assignment_OK | |
6889 | (N : Node_Id) return Boolean; -- Flag15 | |
6890 | ||
3e542a58 RD |
6891 | function Associated_Node |
6892 | (N : Node_Id) return Node_Id; -- Node4 | |
6893 | ||
996ae0b0 RK |
6894 | function At_End_Proc |
6895 | (N : Node_Id) return Node_Id; -- Node1 | |
6896 | ||
6897 | function Attribute_Name | |
6898 | (N : Node_Id) return Name_Id; -- Name2 | |
6899 | ||
6900 | function Aux_Decls_Node | |
6901 | (N : Node_Id) return Node_Id; -- Node5 | |
6902 | ||
6903 | function Backwards_OK | |
6904 | (N : Node_Id) return Boolean; -- Flag6 | |
6905 | ||
6906 | function Bad_Is_Detected | |
6907 | (N : Node_Id) return Boolean; -- Flag15 | |
6908 | ||
6909 | function By_Ref | |
6910 | (N : Node_Id) return Boolean; -- Flag5 | |
6911 | ||
6912 | function Body_Required | |
6913 | (N : Node_Id) return Boolean; -- Flag13 | |
6914 | ||
6915 | function Body_To_Inline | |
6916 | (N : Node_Id) return Node_Id; -- Node3 | |
6917 | ||
6918 | function Box_Present | |
6919 | (N : Node_Id) return Boolean; -- Flag15 | |
6920 | ||
6921 | function Char_Literal_Value | |
6922 | (N : Node_Id) return Char_Code; -- Char_Code2 | |
6923 | ||
6924 | function Chars | |
6925 | (N : Node_Id) return Name_Id; -- Name1 | |
6926 | ||
fbf5a39b AC |
6927 | function Check_Address_Alignment |
6928 | (N : Node_Id) return Boolean; -- Flag11 | |
6929 | ||
996ae0b0 RK |
6930 | function Choice_Parameter |
6931 | (N : Node_Id) return Node_Id; -- Node2 | |
6932 | ||
6933 | function Choices | |
6934 | (N : Node_Id) return List_Id; -- List1 | |
6935 | ||
6936 | function Compile_Time_Known_Aggregate | |
6937 | (N : Node_Id) return Boolean; -- Flag18 | |
6938 | ||
6939 | function Component_Associations | |
6940 | (N : Node_Id) return List_Id; -- List2 | |
6941 | ||
6942 | function Component_Clauses | |
6943 | (N : Node_Id) return List_Id; -- List3 | |
6944 | ||
6945 | function Component_Items | |
6946 | (N : Node_Id) return List_Id; -- List3 | |
6947 | ||
6948 | function Component_List | |
6949 | (N : Node_Id) return Node_Id; -- Node1 | |
6950 | ||
6951 | function Component_Name | |
6952 | (N : Node_Id) return Node_Id; -- Node1 | |
6953 | ||
6954 | function Condition | |
6955 | (N : Node_Id) return Node_Id; -- Node1 | |
6956 | ||
6957 | function Condition_Actions | |
6958 | (N : Node_Id) return List_Id; -- List3 | |
6959 | ||
fbf5a39b AC |
6960 | function Config_Pragmas |
6961 | (N : Node_Id) return List_Id; -- List4 | |
6962 | ||
996ae0b0 RK |
6963 | function Constant_Present |
6964 | (N : Node_Id) return Boolean; -- Flag17 | |
6965 | ||
6966 | function Constraint | |
6967 | (N : Node_Id) return Node_Id; -- Node3 | |
6968 | ||
6969 | function Constraints | |
6970 | (N : Node_Id) return List_Id; -- List1 | |
6971 | ||
6972 | function Context_Installed | |
6973 | (N : Node_Id) return Boolean; -- Flag13 | |
6974 | ||
6975 | function Context_Items | |
6976 | (N : Node_Id) return List_Id; -- List1 | |
6977 | ||
6978 | function Controlling_Argument | |
6979 | (N : Node_Id) return Node_Id; -- Node1 | |
6980 | ||
6981 | function Conversion_OK | |
6982 | (N : Node_Id) return Boolean; -- Flag14 | |
6983 | ||
6984 | function Corresponding_Body | |
6985 | (N : Node_Id) return Node_Id; -- Node5 | |
6986 | ||
6987 | function Corresponding_Generic_Association | |
6988 | (N : Node_Id) return Node_Id; -- Node5 | |
6989 | ||
6990 | function Corresponding_Integer_Value | |
6991 | (N : Node_Id) return Uint; -- Uint4 | |
6992 | ||
6993 | function Corresponding_Spec | |
6994 | (N : Node_Id) return Node_Id; -- Node5 | |
6995 | ||
6996 | function Corresponding_Stub | |
6997 | (N : Node_Id) return Node_Id; -- Node3 | |
6998 | ||
6999 | function Dcheck_Function | |
7000 | (N : Node_Id) return Entity_Id; -- Node5 | |
7001 | ||
7002 | function Debug_Statement | |
7003 | (N : Node_Id) return Node_Id; -- Node3 | |
7004 | ||
7005 | function Declarations | |
7006 | (N : Node_Id) return List_Id; -- List2 | |
7007 | ||
7008 | function Default_Expression | |
7009 | (N : Node_Id) return Node_Id; -- Node5 | |
7010 | ||
7011 | function Default_Name | |
7012 | (N : Node_Id) return Node_Id; -- Node2 | |
7013 | ||
7014 | function Defining_Identifier | |
7015 | (N : Node_Id) return Entity_Id; -- Node1 | |
7016 | ||
7017 | function Defining_Unit_Name | |
7018 | (N : Node_Id) return Node_Id; -- Node1 | |
7019 | ||
7020 | function Delay_Alternative | |
7021 | (N : Node_Id) return Node_Id; -- Node4 | |
7022 | ||
7023 | function Delay_Finalize_Attach | |
7024 | (N : Node_Id) return Boolean; -- Flag14 | |
7025 | ||
7026 | function Delay_Statement | |
7027 | (N : Node_Id) return Node_Id; -- Node2 | |
7028 | ||
7029 | function Delta_Expression | |
7030 | (N : Node_Id) return Node_Id; -- Node3 | |
7031 | ||
7032 | function Digits_Expression | |
7033 | (N : Node_Id) return Node_Id; -- Node2 | |
7034 | ||
7035 | function Discr_Check_Funcs_Built | |
7036 | (N : Node_Id) return Boolean; -- Flag11 | |
7037 | ||
7038 | function Discrete_Choices | |
7039 | (N : Node_Id) return List_Id; -- List4 | |
7040 | ||
7041 | function Discrete_Range | |
7042 | (N : Node_Id) return Node_Id; -- Node4 | |
7043 | ||
7044 | function Discrete_Subtype_Definition | |
7045 | (N : Node_Id) return Node_Id; -- Node4 | |
7046 | ||
7047 | function Discrete_Subtype_Definitions | |
7048 | (N : Node_Id) return List_Id; -- List2 | |
7049 | ||
7050 | function Discriminant_Specifications | |
7051 | (N : Node_Id) return List_Id; -- List4 | |
7052 | ||
7053 | function Discriminant_Type | |
7054 | (N : Node_Id) return Node_Id; -- Node5 | |
7055 | ||
996ae0b0 RK |
7056 | function Do_Accessibility_Check |
7057 | (N : Node_Id) return Boolean; -- Flag13 | |
7058 | ||
7059 | function Do_Discriminant_Check | |
7060 | (N : Node_Id) return Boolean; -- Flag13 | |
7061 | ||
7062 | function Do_Division_Check | |
7063 | (N : Node_Id) return Boolean; -- Flag13 | |
7064 | ||
7065 | function Do_Length_Check | |
7066 | (N : Node_Id) return Boolean; -- Flag4 | |
7067 | ||
7068 | function Do_Overflow_Check | |
7069 | (N : Node_Id) return Boolean; -- Flag17 | |
7070 | ||
7071 | function Do_Range_Check | |
7072 | (N : Node_Id) return Boolean; -- Flag9 | |
7073 | ||
7074 | function Do_Storage_Check | |
7075 | (N : Node_Id) return Boolean; -- Flag17 | |
7076 | ||
7077 | function Do_Tag_Check | |
7078 | (N : Node_Id) return Boolean; -- Flag13 | |
7079 | ||
7080 | function Elaborate_All_Present | |
7081 | (N : Node_Id) return Boolean; -- Flag15 | |
7082 | ||
7083 | function Elaborate_Present | |
7084 | (N : Node_Id) return Boolean; -- Flag4 | |
7085 | ||
7086 | function Elaboration_Boolean | |
7087 | (N : Node_Id) return Node_Id; -- Node2 | |
7088 | ||
7089 | function Else_Actions | |
7090 | (N : Node_Id) return List_Id; -- List3 | |
7091 | ||
7092 | function Else_Statements | |
7093 | (N : Node_Id) return List_Id; -- List4 | |
7094 | ||
7095 | function Elsif_Parts | |
7096 | (N : Node_Id) return List_Id; -- List3 | |
7097 | ||
7098 | function Enclosing_Variant | |
7099 | (N : Node_Id) return Node_Id; -- Node2 | |
7100 | ||
7101 | function End_Label | |
7102 | (N : Node_Id) return Node_Id; -- Node4 | |
7103 | ||
7104 | function End_Span | |
7105 | (N : Node_Id) return Uint; -- Uint5 | |
7106 | ||
7107 | function Entity | |
7108 | (N : Node_Id) return Node_Id; -- Node4 | |
7109 | ||
7110 | function Entry_Body_Formal_Part | |
7111 | (N : Node_Id) return Node_Id; -- Node5 | |
7112 | ||
7113 | function Entry_Call_Alternative | |
7114 | (N : Node_Id) return Node_Id; -- Node1 | |
7115 | ||
7116 | function Entry_Call_Statement | |
7117 | (N : Node_Id) return Node_Id; -- Node1 | |
7118 | ||
7119 | function Entry_Direct_Name | |
7120 | (N : Node_Id) return Node_Id; -- Node1 | |
7121 | ||
7122 | function Entry_Index | |
7123 | (N : Node_Id) return Node_Id; -- Node5 | |
7124 | ||
7125 | function Entry_Index_Specification | |
7126 | (N : Node_Id) return Node_Id; -- Node4 | |
7127 | ||
7128 | function Etype | |
7129 | (N : Node_Id) return Node_Id; -- Node5 | |
7130 | ||
7131 | function Exception_Choices | |
7132 | (N : Node_Id) return List_Id; -- List4 | |
7133 | ||
7134 | function Exception_Handlers | |
7135 | (N : Node_Id) return List_Id; -- List5 | |
7136 | ||
7137 | function Exception_Junk | |
7138 | (N : Node_Id) return Boolean; -- Flag11 | |
7139 | ||
7140 | function Explicit_Actual_Parameter | |
7141 | (N : Node_Id) return Node_Id; -- Node3 | |
7142 | ||
7143 | function Expansion_Delayed | |
7144 | (N : Node_Id) return Boolean; -- Flag11 | |
7145 | ||
7146 | function Explicit_Generic_Actual_Parameter | |
7147 | (N : Node_Id) return Node_Id; -- Node1 | |
7148 | ||
7149 | function Expression | |
7150 | (N : Node_Id) return Node_Id; -- Node3 | |
7151 | ||
7152 | function Expressions | |
7153 | (N : Node_Id) return List_Id; -- List1 | |
7154 | ||
7155 | function First_Bit | |
7156 | (N : Node_Id) return Node_Id; -- Node3 | |
7157 | ||
7158 | function First_Inlined_Subprogram | |
7159 | (N : Node_Id) return Entity_Id; -- Node3 | |
7160 | ||
7161 | function First_Name | |
7162 | (N : Node_Id) return Boolean; -- Flag5 | |
7163 | ||
7164 | function First_Named_Actual | |
7165 | (N : Node_Id) return Node_Id; -- Node4 | |
7166 | ||
7167 | function First_Real_Statement | |
7168 | (N : Node_Id) return Node_Id; -- Node2 | |
7169 | ||
7170 | function First_Subtype_Link | |
7171 | (N : Node_Id) return Entity_Id; -- Node5 | |
7172 | ||
7173 | function Float_Truncate | |
7174 | (N : Node_Id) return Boolean; -- Flag11 | |
7175 | ||
7176 | function Formal_Type_Definition | |
7177 | (N : Node_Id) return Node_Id; -- Node3 | |
7178 | ||
7179 | function Forwards_OK | |
7180 | (N : Node_Id) return Boolean; -- Flag5 | |
7181 | ||
7182 | function From_At_Mod | |
7183 | (N : Node_Id) return Boolean; -- Flag4 | |
7184 | ||
7185 | function Generic_Associations | |
7186 | (N : Node_Id) return List_Id; -- List3 | |
7187 | ||
7188 | function Generic_Formal_Declarations | |
7189 | (N : Node_Id) return List_Id; -- List2 | |
7190 | ||
7191 | function Generic_Parent | |
7192 | (N : Node_Id) return Node_Id; -- Node5 | |
7193 | ||
7194 | function Generic_Parent_Type | |
7195 | (N : Node_Id) return Node_Id; -- Node4 | |
7196 | ||
7197 | function Handled_Statement_Sequence | |
7198 | (N : Node_Id) return Node_Id; -- Node4 | |
7199 | ||
7200 | function Handler_List_Entry | |
7201 | (N : Node_Id) return Node_Id; -- Node2 | |
7202 | ||
7203 | function Has_Created_Identifier | |
7204 | (N : Node_Id) return Boolean; -- Flag15 | |
7205 | ||
7206 | function Has_Dynamic_Length_Check | |
7207 | (N : Node_Id) return Boolean; -- Flag10 | |
7208 | ||
7209 | function Has_Dynamic_Range_Check | |
7210 | (N : Node_Id) return Boolean; -- Flag12 | |
7211 | ||
7212 | function Has_No_Elaboration_Code | |
7213 | (N : Node_Id) return Boolean; -- Flag17 | |
7214 | ||
7215 | function Has_Priority_Pragma | |
7216 | (N : Node_Id) return Boolean; -- Flag6 | |
7217 | ||
7218 | function Has_Private_View | |
7219 | (N : Node_Id) return Boolean; -- Flag11 | |
7220 | ||
7221 | function Has_Storage_Size_Pragma | |
7222 | (N : Node_Id) return Boolean; -- Flag5 | |
7223 | ||
7224 | function Has_Task_Info_Pragma | |
7225 | (N : Node_Id) return Boolean; -- Flag7 | |
7226 | ||
7227 | function Has_Task_Name_Pragma | |
7228 | (N : Node_Id) return Boolean; -- Flag8 | |
7229 | ||
7230 | function Has_Wide_Character | |
7231 | (N : Node_Id) return Boolean; -- Flag11 | |
7232 | ||
7233 | function Hidden_By_Use_Clause | |
7234 | (N : Node_Id) return Elist_Id; -- Elist4 | |
7235 | ||
7236 | function High_Bound | |
7237 | (N : Node_Id) return Node_Id; -- Node2 | |
7238 | ||
7239 | function Identifier | |
7240 | (N : Node_Id) return Node_Id; -- Node1 | |
7241 | ||
7242 | function Implicit_With | |
fbf5a39b | 7243 | (N : Node_Id) return Boolean; -- Flag16 |
996ae0b0 RK |
7244 | |
7245 | function In_Present | |
7246 | (N : Node_Id) return Boolean; -- Flag15 | |
7247 | ||
7248 | function Includes_Infinities | |
7249 | (N : Node_Id) return Boolean; -- Flag11 | |
7250 | ||
7251 | function Instance_Spec | |
7252 | (N : Node_Id) return Node_Id; -- Node5 | |
7253 | ||
7254 | function Intval | |
7255 | (N : Node_Id) return Uint; -- Uint3 | |
7256 | ||
7257 | function Is_Asynchronous_Call_Block | |
7258 | (N : Node_Id) return Boolean; -- Flag7 | |
7259 | ||
7260 | function Is_Component_Left_Opnd | |
7261 | (N : Node_Id) return Boolean; -- Flag13 | |
7262 | ||
7263 | function Is_Component_Right_Opnd | |
7264 | (N : Node_Id) return Boolean; -- Flag14 | |
7265 | ||
7266 | function Is_Controlling_Actual | |
7267 | (N : Node_Id) return Boolean; -- Flag16 | |
7268 | ||
fbf5a39b AC |
7269 | function Is_In_Discriminant_Check |
7270 | (N : Node_Id) return Boolean; -- Flag11 | |
7271 | ||
996ae0b0 RK |
7272 | function Is_Machine_Number |
7273 | (N : Node_Id) return Boolean; -- Flag11 | |
7274 | ||
fbf5a39b AC |
7275 | function Is_Null_Loop |
7276 | (N : Node_Id) return Boolean; -- Flag16 | |
7277 | ||
996ae0b0 RK |
7278 | function Is_Overloaded |
7279 | (N : Node_Id) return Boolean; -- Flag5 | |
7280 | ||
7281 | function Is_Power_Of_2_For_Shift | |
7282 | (N : Node_Id) return Boolean; -- Flag13 | |
7283 | ||
7284 | function Is_Protected_Subprogram_Body | |
7285 | (N : Node_Id) return Boolean; -- Flag7 | |
7286 | ||
7287 | function Is_Static_Expression | |
7288 | (N : Node_Id) return Boolean; -- Flag6 | |
7289 | ||
7290 | function Is_Subprogram_Descriptor | |
7291 | (N : Node_Id) return Boolean; -- Flag16 | |
7292 | ||
7293 | function Is_Task_Allocation_Block | |
7294 | (N : Node_Id) return Boolean; -- Flag6 | |
7295 | ||
7296 | function Is_Task_Master | |
7297 | (N : Node_Id) return Boolean; -- Flag5 | |
7298 | ||
7299 | function Iteration_Scheme | |
7300 | (N : Node_Id) return Node_Id; -- Node2 | |
7301 | ||
7302 | function Itype | |
7303 | (N : Node_Id) return Entity_Id; -- Node1 | |
7304 | ||
7305 | function Kill_Range_Check | |
7306 | (N : Node_Id) return Boolean; -- Flag11 | |
7307 | ||
7308 | function Label_Construct | |
7309 | (N : Node_Id) return Node_Id; -- Node2 | |
7310 | ||
7311 | function Left_Opnd | |
7312 | (N : Node_Id) return Node_Id; -- Node2 | |
7313 | ||
7314 | function Last_Bit | |
7315 | (N : Node_Id) return Node_Id; -- Node4 | |
7316 | ||
7317 | function Last_Name | |
7318 | (N : Node_Id) return Boolean; -- Flag6 | |
7319 | ||
7320 | function Library_Unit | |
7321 | (N : Node_Id) return Node_Id; -- Node4 | |
7322 | ||
fbf5a39b AC |
7323 | function Limited_View_Installed |
7324 | (N : Node_Id) return Boolean; -- Flag18 | |
7325 | ||
996ae0b0 RK |
7326 | function Limited_Present |
7327 | (N : Node_Id) return Boolean; -- Flag17 | |
7328 | ||
7329 | function Literals | |
7330 | (N : Node_Id) return List_Id; -- List1 | |
7331 | ||
7332 | function Loop_Actions | |
7333 | (N : Node_Id) return List_Id; -- List2 | |
7334 | ||
7335 | function Loop_Parameter_Specification | |
7336 | (N : Node_Id) return Node_Id; -- Node4 | |
7337 | ||
7338 | function Low_Bound | |
7339 | (N : Node_Id) return Node_Id; -- Node1 | |
7340 | ||
7341 | function Mod_Clause | |
7342 | (N : Node_Id) return Node_Id; -- Node2 | |
7343 | ||
7344 | function More_Ids | |
7345 | (N : Node_Id) return Boolean; -- Flag5 | |
7346 | ||
07fc65c4 GB |
7347 | function Must_Be_Byte_Aligned |
7348 | (N : Node_Id) return Boolean; -- Flag14 | |
7349 | ||
996ae0b0 RK |
7350 | function Must_Not_Freeze |
7351 | (N : Node_Id) return Boolean; -- Flag8 | |
7352 | ||
7353 | function Name | |
7354 | (N : Node_Id) return Node_Id; -- Node2 | |
7355 | ||
7356 | function Names | |
7357 | (N : Node_Id) return List_Id; -- List2 | |
7358 | ||
7359 | function Next_Entity | |
7360 | (N : Node_Id) return Node_Id; -- Node2 | |
7361 | ||
7362 | function Next_Named_Actual | |
7363 | (N : Node_Id) return Node_Id; -- Node4 | |
7364 | ||
7365 | function Next_Rep_Item | |
7366 | (N : Node_Id) return Node_Id; -- Node4 | |
7367 | ||
7368 | function Next_Use_Clause | |
7369 | (N : Node_Id) return Node_Id; -- Node3 | |
7370 | ||
7371 | function No_Ctrl_Actions | |
7372 | (N : Node_Id) return Boolean; -- Flag7 | |
7373 | ||
7374 | function No_Entities_Ref_In_Spec | |
7375 | (N : Node_Id) return Boolean; -- Flag8 | |
7376 | ||
7377 | function No_Initialization | |
7378 | (N : Node_Id) return Boolean; -- Flag13 | |
7379 | ||
fbf5a39b AC |
7380 | function No_Truncation |
7381 | (N : Node_Id) return Boolean; -- Flag17 | |
7382 | ||
996ae0b0 RK |
7383 | function Null_Present |
7384 | (N : Node_Id) return Boolean; -- Flag13 | |
7385 | ||
7386 | function Null_Record_Present | |
7387 | (N : Node_Id) return Boolean; -- Flag17 | |
7388 | ||
7389 | function Object_Definition | |
7390 | (N : Node_Id) return Node_Id; -- Node4 | |
7391 | ||
7392 | function OK_For_Stream | |
7393 | (N : Node_Id) return Boolean; -- Flag4 | |
7394 | ||
7395 | function Original_Discriminant | |
7396 | (N : Node_Id) return Node_Id; -- Node2 | |
7397 | ||
fbf5a39b AC |
7398 | function Original_Entity |
7399 | (N : Node_Id) return Entity_Id; -- Node2 | |
7400 | ||
996ae0b0 RK |
7401 | function Others_Discrete_Choices |
7402 | (N : Node_Id) return List_Id; -- List1 | |
7403 | ||
7404 | function Out_Present | |
7405 | (N : Node_Id) return Boolean; -- Flag17 | |
7406 | ||
7407 | function Parameter_Associations | |
7408 | (N : Node_Id) return List_Id; -- List3 | |
7409 | ||
7410 | function Parameter_List_Truncated | |
7411 | (N : Node_Id) return Boolean; -- Flag17 | |
7412 | ||
7413 | function Parameter_Specifications | |
7414 | (N : Node_Id) return List_Id; -- List3 | |
7415 | ||
7416 | function Parameter_Type | |
7417 | (N : Node_Id) return Node_Id; -- Node2 | |
7418 | ||
7419 | function Parent_Spec | |
7420 | (N : Node_Id) return Node_Id; -- Node4 | |
7421 | ||
7422 | function Position | |
7423 | (N : Node_Id) return Node_Id; -- Node2 | |
7424 | ||
7425 | function Pragma_Argument_Associations | |
7426 | (N : Node_Id) return List_Id; -- List2 | |
7427 | ||
7428 | function Pragmas_After | |
7429 | (N : Node_Id) return List_Id; -- List5 | |
7430 | ||
7431 | function Pragmas_Before | |
7432 | (N : Node_Id) return List_Id; -- List4 | |
7433 | ||
7434 | function Prefix | |
7435 | (N : Node_Id) return Node_Id; -- Node3 | |
7436 | ||
7437 | function Present_Expr | |
7438 | (N : Node_Id) return Uint; -- Uint3 | |
7439 | ||
7440 | function Prev_Ids | |
7441 | (N : Node_Id) return Boolean; -- Flag6 | |
7442 | ||
7443 | function Print_In_Hex | |
7444 | (N : Node_Id) return Boolean; -- Flag13 | |
7445 | ||
7446 | function Private_Declarations | |
7447 | (N : Node_Id) return List_Id; -- List3 | |
7448 | ||
7449 | function Private_Present | |
7450 | (N : Node_Id) return Boolean; -- Flag15 | |
7451 | ||
7452 | function Procedure_To_Call | |
7453 | (N : Node_Id) return Node_Id; -- Node4 | |
7454 | ||
7455 | function Proper_Body | |
7456 | (N : Node_Id) return Node_Id; -- Node1 | |
7457 | ||
7458 | function Protected_Definition | |
7459 | (N : Node_Id) return Node_Id; -- Node3 | |
7460 | ||
7461 | function Protected_Present | |
7462 | (N : Node_Id) return Boolean; -- Flag15 | |
7463 | ||
7464 | function Raises_Constraint_Error | |
7465 | (N : Node_Id) return Boolean; -- Flag7 | |
7466 | ||
7467 | function Range_Constraint | |
7468 | (N : Node_Id) return Node_Id; -- Node4 | |
7469 | ||
7470 | function Range_Expression | |
7471 | (N : Node_Id) return Node_Id; -- Node4 | |
7472 | ||
7473 | function Real_Range_Specification | |
7474 | (N : Node_Id) return Node_Id; -- Node4 | |
7475 | ||
7476 | function Realval | |
7477 | (N : Node_Id) return Ureal; -- Ureal3 | |
7478 | ||
07fc65c4 GB |
7479 | function Reason |
7480 | (N : Node_Id) return Uint; -- Uint3 | |
7481 | ||
996ae0b0 RK |
7482 | function Record_Extension_Part |
7483 | (N : Node_Id) return Node_Id; -- Node3 | |
7484 | ||
7485 | function Redundant_Use | |
7486 | (N : Node_Id) return Boolean; -- Flag13 | |
7487 | ||
7488 | function Return_Type | |
7489 | (N : Node_Id) return Node_Id; -- Node2 | |
7490 | ||
7491 | function Reverse_Present | |
7492 | (N : Node_Id) return Boolean; -- Flag15 | |
7493 | ||
7494 | function Right_Opnd | |
7495 | (N : Node_Id) return Node_Id; -- Node3 | |
7496 | ||
7497 | function Rounded_Result | |
7498 | (N : Node_Id) return Boolean; -- Flag18 | |
7499 | ||
7500 | function Scope | |
7501 | (N : Node_Id) return Node_Id; -- Node3 | |
7502 | ||
7503 | function Select_Alternatives | |
7504 | (N : Node_Id) return List_Id; -- List1 | |
7505 | ||
7506 | function Selector_Name | |
7507 | (N : Node_Id) return Node_Id; -- Node2 | |
7508 | ||
7509 | function Selector_Names | |
7510 | (N : Node_Id) return List_Id; -- List1 | |
7511 | ||
7512 | function Shift_Count_OK | |
7513 | (N : Node_Id) return Boolean; -- Flag4 | |
7514 | ||
7515 | function Source_Type | |
7516 | (N : Node_Id) return Entity_Id; -- Node1 | |
7517 | ||
7518 | function Specification | |
7519 | (N : Node_Id) return Node_Id; -- Node1 | |
7520 | ||
7521 | function Statements | |
7522 | (N : Node_Id) return List_Id; -- List3 | |
7523 | ||
7524 | function Static_Processing_OK | |
7525 | (N : Node_Id) return Boolean; -- Flag4 | |
7526 | ||
7527 | function Storage_Pool | |
7528 | (N : Node_Id) return Node_Id; -- Node1 | |
7529 | ||
7530 | function Strval | |
7531 | (N : Node_Id) return String_Id; -- Str3 | |
7532 | ||
7533 | function Subtype_Indication | |
7534 | (N : Node_Id) return Node_Id; -- Node5 | |
7535 | ||
7536 | function Subtype_Mark | |
7537 | (N : Node_Id) return Node_Id; -- Node4 | |
7538 | ||
7539 | function Subtype_Marks | |
7540 | (N : Node_Id) return List_Id; -- List2 | |
7541 | ||
7542 | function Tagged_Present | |
7543 | (N : Node_Id) return Boolean; -- Flag15 | |
7544 | ||
7545 | function Target_Type | |
7546 | (N : Node_Id) return Entity_Id; -- Node2 | |
7547 | ||
7548 | function Task_Body_Procedure | |
7549 | (N : Node_Id) return Entity_Id; -- Node2 | |
7550 | ||
7551 | function Task_Definition | |
7552 | (N : Node_Id) return Node_Id; -- Node3 | |
7553 | ||
7554 | function Then_Actions | |
7555 | (N : Node_Id) return List_Id; -- List2 | |
7556 | ||
7557 | function Then_Statements | |
7558 | (N : Node_Id) return List_Id; -- List2 | |
7559 | ||
7560 | function Treat_Fixed_As_Integer | |
7561 | (N : Node_Id) return Boolean; -- Flag14 | |
7562 | ||
7563 | function Triggering_Alternative | |
7564 | (N : Node_Id) return Node_Id; -- Node1 | |
7565 | ||
7566 | function Triggering_Statement | |
7567 | (N : Node_Id) return Node_Id; -- Node1 | |
7568 | ||
7569 | function TSS_Elist | |
7570 | (N : Node_Id) return Elist_Id; -- Elist3 | |
7571 | ||
7572 | function Type_Definition | |
7573 | (N : Node_Id) return Node_Id; -- Node3 | |
7574 | ||
7575 | function Unit | |
7576 | (N : Node_Id) return Node_Id; -- Node2 | |
7577 | ||
7578 | function Unknown_Discriminants_Present | |
7579 | (N : Node_Id) return Boolean; -- Flag13 | |
7580 | ||
7581 | function Unreferenced_In_Spec | |
7582 | (N : Node_Id) return Boolean; -- Flag7 | |
7583 | ||
7584 | function Variant_Part | |
7585 | (N : Node_Id) return Node_Id; -- Node4 | |
7586 | ||
7587 | function Variants | |
7588 | (N : Node_Id) return List_Id; -- List1 | |
7589 | ||
7590 | function Visible_Declarations | |
7591 | (N : Node_Id) return List_Id; -- List2 | |
7592 | ||
7593 | function Was_Originally_Stub | |
7594 | (N : Node_Id) return Boolean; -- Flag13 | |
7595 | ||
7596 | function Zero_Cost_Handling | |
7597 | (N : Node_Id) return Boolean; -- Flag5 | |
7598 | ||
7599 | -- End functions (note used by xsinfo utility program to end processing) | |
7600 | ||
7601 | ---------------------------- | |
7602 | -- Node Update Procedures -- | |
7603 | ---------------------------- | |
7604 | ||
7605 | -- These are the corresponding node update routines, which again provide | |
7606 | -- a high level logical access with type checking. In addition to setting | |
7607 | -- the indicated field of the node N to the given Val, in the case of | |
7608 | -- tree pointers (List1-4), the parent pointer of the Val node is set to | |
7609 | -- point back to node N. This automates the setting of the parent pointer. | |
7610 | ||
7611 | procedure Set_ABE_Is_Certain | |
7612 | (N : Node_Id; Val : Boolean := True); -- Flag18 | |
7613 | ||
7614 | procedure Set_Abort_Present | |
7615 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7616 | ||
7617 | procedure Set_Abortable_Part | |
7618 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7619 | ||
7620 | procedure Set_Abstract_Present | |
7621 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7622 | ||
7623 | procedure Set_Accept_Handler_Records | |
7624 | (N : Node_Id; Val : List_Id); -- List5 | |
7625 | ||
7626 | procedure Set_Accept_Statement | |
7627 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7628 | ||
7629 | procedure Set_Access_Types_To_Process | |
7630 | (N : Node_Id; Val : Elist_Id); -- Elist2 | |
7631 | ||
7632 | procedure Set_Actions | |
7633 | (N : Node_Id; Val : List_Id); -- List1 | |
7634 | ||
7635 | procedure Set_Activation_Chain_Entity | |
7636 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7637 | ||
7638 | procedure Set_Acts_As_Spec | |
7639 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7640 | ||
7641 | procedure Set_Aggregate_Bounds | |
7642 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7643 | ||
7644 | procedure Set_Aliased_Present | |
7645 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7646 | ||
7647 | procedure Set_All_Others | |
7648 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7649 | ||
7650 | procedure Set_All_Present | |
7651 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7652 | ||
7653 | procedure Set_Alternatives | |
7654 | (N : Node_Id; Val : List_Id); -- List4 | |
7655 | ||
7656 | procedure Set_Ancestor_Part | |
7657 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7658 | ||
7659 | procedure Set_Array_Aggregate | |
7660 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7661 | ||
7662 | procedure Set_Assignment_OK | |
7663 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7664 | ||
3e542a58 RD |
7665 | procedure Set_Associated_Node |
7666 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7667 | ||
996ae0b0 RK |
7668 | procedure Set_Attribute_Name |
7669 | (N : Node_Id; Val : Name_Id); -- Name2 | |
7670 | ||
7671 | procedure Set_At_End_Proc | |
7672 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7673 | ||
7674 | procedure Set_Aux_Decls_Node | |
7675 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7676 | ||
7677 | procedure Set_Backwards_OK | |
7678 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
7679 | ||
7680 | procedure Set_Bad_Is_Detected | |
7681 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7682 | ||
7683 | procedure Set_Body_Required | |
7684 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7685 | ||
7686 | procedure Set_Body_To_Inline | |
7687 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7688 | ||
7689 | procedure Set_Box_Present | |
7690 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7691 | ||
7692 | procedure Set_By_Ref | |
7693 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
7694 | ||
7695 | procedure Set_Char_Literal_Value | |
7696 | (N : Node_Id; Val : Char_Code); -- Char_Code2 | |
7697 | ||
7698 | procedure Set_Chars | |
7699 | (N : Node_Id; Val : Name_Id); -- Name1 | |
7700 | ||
fbf5a39b AC |
7701 | procedure Set_Check_Address_Alignment |
7702 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7703 | ||
996ae0b0 RK |
7704 | procedure Set_Choice_Parameter |
7705 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7706 | ||
7707 | procedure Set_Choices | |
7708 | (N : Node_Id; Val : List_Id); -- List1 | |
7709 | ||
7710 | procedure Set_Compile_Time_Known_Aggregate | |
7711 | (N : Node_Id; Val : Boolean := True); -- Flag18 | |
7712 | ||
7713 | procedure Set_Component_Associations | |
7714 | (N : Node_Id; Val : List_Id); -- List2 | |
7715 | ||
7716 | procedure Set_Component_Clauses | |
7717 | (N : Node_Id; Val : List_Id); -- List3 | |
7718 | ||
7719 | procedure Set_Component_Items | |
7720 | (N : Node_Id; Val : List_Id); -- List3 | |
7721 | ||
7722 | procedure Set_Component_List | |
7723 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7724 | ||
7725 | procedure Set_Component_Name | |
7726 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7727 | ||
7728 | procedure Set_Condition | |
7729 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7730 | ||
7731 | procedure Set_Condition_Actions | |
7732 | (N : Node_Id; Val : List_Id); -- List3 | |
7733 | ||
fbf5a39b AC |
7734 | procedure Set_Config_Pragmas |
7735 | (N : Node_Id; Val : List_Id); -- List4 | |
7736 | ||
996ae0b0 RK |
7737 | procedure Set_Constant_Present |
7738 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
7739 | ||
7740 | procedure Set_Constraint | |
7741 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7742 | ||
7743 | procedure Set_Constraints | |
7744 | (N : Node_Id; Val : List_Id); -- List1 | |
7745 | ||
7746 | procedure Set_Context_Installed | |
7747 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7748 | ||
7749 | procedure Set_Context_Items | |
7750 | (N : Node_Id; Val : List_Id); -- List1 | |
7751 | ||
7752 | procedure Set_Controlling_Argument | |
7753 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7754 | ||
7755 | procedure Set_Conversion_OK | |
7756 | (N : Node_Id; Val : Boolean := True); -- Flag14 | |
7757 | ||
7758 | procedure Set_Corresponding_Body | |
7759 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7760 | ||
7761 | procedure Set_Corresponding_Generic_Association | |
7762 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7763 | ||
7764 | procedure Set_Corresponding_Integer_Value | |
7765 | (N : Node_Id; Val : Uint); -- Uint4 | |
7766 | ||
7767 | procedure Set_Corresponding_Spec | |
7768 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7769 | ||
7770 | procedure Set_Corresponding_Stub | |
7771 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7772 | ||
7773 | procedure Set_Dcheck_Function | |
7774 | (N : Node_Id; Val : Entity_Id); -- Node5 | |
7775 | ||
7776 | procedure Set_Debug_Statement | |
7777 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7778 | ||
7779 | procedure Set_Declarations | |
7780 | (N : Node_Id; Val : List_Id); -- List2 | |
7781 | ||
7782 | procedure Set_Default_Expression | |
7783 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7784 | ||
7785 | procedure Set_Default_Name | |
7786 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7787 | ||
7788 | procedure Set_Defining_Identifier | |
7789 | (N : Node_Id; Val : Entity_Id); -- Node1 | |
7790 | ||
7791 | procedure Set_Defining_Unit_Name | |
7792 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7793 | ||
7794 | procedure Set_Delay_Alternative | |
7795 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7796 | ||
7797 | procedure Set_Delay_Finalize_Attach | |
7798 | (N : Node_Id; Val : Boolean := True); -- Flag14 | |
7799 | ||
7800 | procedure Set_Delay_Statement | |
7801 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7802 | ||
7803 | procedure Set_Delta_Expression | |
7804 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7805 | ||
7806 | procedure Set_Digits_Expression | |
7807 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7808 | ||
7809 | procedure Set_Discr_Check_Funcs_Built | |
7810 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7811 | ||
7812 | procedure Set_Discrete_Choices | |
7813 | (N : Node_Id; Val : List_Id); -- List4 | |
7814 | ||
7815 | procedure Set_Discrete_Range | |
7816 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7817 | ||
7818 | procedure Set_Discrete_Subtype_Definition | |
7819 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7820 | ||
7821 | procedure Set_Discrete_Subtype_Definitions | |
7822 | (N : Node_Id; Val : List_Id); -- List2 | |
7823 | ||
7824 | procedure Set_Discriminant_Specifications | |
7825 | (N : Node_Id; Val : List_Id); -- List4 | |
7826 | ||
7827 | procedure Set_Discriminant_Type | |
7828 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7829 | ||
996ae0b0 RK |
7830 | procedure Set_Do_Accessibility_Check |
7831 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7832 | ||
7833 | procedure Set_Do_Discriminant_Check | |
7834 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7835 | ||
7836 | procedure Set_Do_Division_Check | |
7837 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7838 | ||
7839 | procedure Set_Do_Length_Check | |
7840 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7841 | ||
7842 | procedure Set_Do_Overflow_Check | |
7843 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
7844 | ||
7845 | procedure Set_Do_Range_Check | |
7846 | (N : Node_Id; Val : Boolean := True); -- Flag9 | |
7847 | ||
7848 | procedure Set_Do_Storage_Check | |
7849 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
7850 | ||
7851 | procedure Set_Do_Tag_Check | |
7852 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
7853 | ||
7854 | procedure Set_Elaborate_All_Present | |
7855 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7856 | ||
7857 | procedure Set_Elaborate_Present | |
7858 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7859 | ||
7860 | procedure Set_Elaboration_Boolean | |
7861 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7862 | ||
7863 | procedure Set_Else_Actions | |
7864 | (N : Node_Id; Val : List_Id); -- List3 | |
7865 | ||
7866 | procedure Set_Else_Statements | |
7867 | (N : Node_Id; Val : List_Id); -- List4 | |
7868 | ||
7869 | procedure Set_Elsif_Parts | |
7870 | (N : Node_Id; Val : List_Id); -- List3 | |
7871 | ||
7872 | procedure Set_Enclosing_Variant | |
7873 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7874 | ||
7875 | procedure Set_End_Label | |
7876 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7877 | ||
7878 | procedure Set_End_Span | |
7879 | (N : Node_Id; Val : Uint); -- Uint5 | |
7880 | ||
7881 | procedure Set_Entity | |
7882 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7883 | ||
7884 | procedure Set_Entry_Body_Formal_Part | |
7885 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7886 | ||
7887 | procedure Set_Entry_Call_Alternative | |
7888 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7889 | ||
7890 | procedure Set_Entry_Call_Statement | |
7891 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7892 | ||
7893 | procedure Set_Entry_Direct_Name | |
7894 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7895 | ||
7896 | procedure Set_Entry_Index | |
7897 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7898 | ||
7899 | procedure Set_Entry_Index_Specification | |
7900 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7901 | ||
7902 | procedure Set_Etype | |
7903 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7904 | ||
7905 | procedure Set_Exception_Choices | |
7906 | (N : Node_Id; Val : List_Id); -- List4 | |
7907 | ||
7908 | procedure Set_Exception_Handlers | |
7909 | (N : Node_Id; Val : List_Id); -- List5 | |
7910 | ||
7911 | procedure Set_Exception_Junk | |
7912 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7913 | ||
7914 | procedure Set_Expansion_Delayed | |
7915 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7916 | ||
7917 | procedure Set_Explicit_Actual_Parameter | |
7918 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7919 | ||
7920 | procedure Set_Explicit_Generic_Actual_Parameter | |
7921 | (N : Node_Id; Val : Node_Id); -- Node1 | |
7922 | ||
7923 | procedure Set_Expression | |
7924 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7925 | ||
7926 | procedure Set_Expressions | |
7927 | (N : Node_Id; Val : List_Id); -- List1 | |
7928 | ||
7929 | procedure Set_First_Bit | |
7930 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7931 | ||
7932 | procedure Set_First_Inlined_Subprogram | |
7933 | (N : Node_Id; Val : Entity_Id); -- Node3 | |
7934 | ||
7935 | procedure Set_First_Name | |
7936 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
7937 | ||
7938 | procedure Set_First_Named_Actual | |
7939 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7940 | ||
7941 | procedure Set_First_Real_Statement | |
7942 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7943 | ||
7944 | procedure Set_First_Subtype_Link | |
7945 | (N : Node_Id; Val : Entity_Id); -- Node5 | |
7946 | ||
7947 | procedure Set_Float_Truncate | |
7948 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7949 | ||
7950 | procedure Set_Formal_Type_Definition | |
7951 | (N : Node_Id; Val : Node_Id); -- Node3 | |
7952 | ||
7953 | procedure Set_Forwards_OK | |
7954 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
7955 | ||
7956 | procedure Set_From_At_Mod | |
7957 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
7958 | ||
7959 | procedure Set_Generic_Associations | |
7960 | (N : Node_Id; Val : List_Id); -- List3 | |
7961 | ||
7962 | procedure Set_Generic_Formal_Declarations | |
7963 | (N : Node_Id; Val : List_Id); -- List2 | |
7964 | ||
7965 | procedure Set_Generic_Parent | |
7966 | (N : Node_Id; Val : Node_Id); -- Node5 | |
7967 | ||
7968 | procedure Set_Generic_Parent_Type | |
7969 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7970 | ||
7971 | procedure Set_Handled_Statement_Sequence | |
7972 | (N : Node_Id; Val : Node_Id); -- Node4 | |
7973 | ||
7974 | procedure Set_Handler_List_Entry | |
7975 | (N : Node_Id; Val : Node_Id); -- Node2 | |
7976 | ||
7977 | procedure Set_Has_Created_Identifier | |
7978 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
7979 | ||
7980 | procedure Set_Has_Dynamic_Length_Check | |
7981 | (N : Node_Id; Val : Boolean := True); -- Flag10 | |
7982 | ||
7983 | procedure Set_Has_Dynamic_Range_Check | |
7984 | (N : Node_Id; Val : Boolean := True); -- Flag12 | |
7985 | ||
7986 | procedure Set_Has_No_Elaboration_Code | |
7987 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
7988 | ||
7989 | procedure Set_Has_Priority_Pragma | |
7990 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
7991 | ||
7992 | procedure Set_Has_Private_View | |
7993 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
7994 | ||
7995 | procedure Set_Has_Storage_Size_Pragma | |
7996 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
7997 | ||
7998 | procedure Set_Has_Task_Info_Pragma | |
7999 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8000 | ||
8001 | procedure Set_Has_Task_Name_Pragma | |
8002 | (N : Node_Id; Val : Boolean := True); -- Flag8 | |
8003 | ||
8004 | procedure Set_Has_Wide_Character | |
8005 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
8006 | ||
8007 | procedure Set_Hidden_By_Use_Clause | |
8008 | (N : Node_Id; Val : Elist_Id); -- Elist4 | |
8009 | ||
8010 | procedure Set_High_Bound | |
8011 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8012 | ||
8013 | procedure Set_Identifier | |
8014 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8015 | ||
8016 | procedure Set_Implicit_With | |
fbf5a39b | 8017 | (N : Node_Id; Val : Boolean := True); -- Flag16 |
996ae0b0 RK |
8018 | |
8019 | procedure Set_In_Present | |
8020 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
8021 | ||
8022 | procedure Set_Includes_Infinities | |
8023 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
8024 | ||
8025 | procedure Set_Instance_Spec | |
8026 | (N : Node_Id; Val : Node_Id); -- Node5 | |
8027 | ||
8028 | procedure Set_Intval | |
8029 | (N : Node_Id; Val : Uint); -- Uint3 | |
8030 | ||
8031 | procedure Set_Is_Asynchronous_Call_Block | |
8032 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8033 | ||
8034 | procedure Set_Is_Component_Left_Opnd | |
8035 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8036 | ||
8037 | procedure Set_Is_Component_Right_Opnd | |
8038 | (N : Node_Id; Val : Boolean := True); -- Flag14 | |
8039 | ||
8040 | procedure Set_Is_Controlling_Actual | |
8041 | (N : Node_Id; Val : Boolean := True); -- Flag16 | |
8042 | ||
fbf5a39b AC |
8043 | procedure Set_Is_In_Discriminant_Check |
8044 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
8045 | ||
996ae0b0 RK |
8046 | procedure Set_Is_Machine_Number |
8047 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
8048 | ||
fbf5a39b AC |
8049 | procedure Set_Is_Null_Loop |
8050 | (N : Node_Id; Val : Boolean := True); -- Flag16 | |
8051 | ||
996ae0b0 RK |
8052 | procedure Set_Is_Overloaded |
8053 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
8054 | ||
8055 | procedure Set_Is_Power_Of_2_For_Shift | |
8056 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8057 | ||
8058 | procedure Set_Is_Protected_Subprogram_Body | |
8059 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8060 | ||
8061 | procedure Set_Is_Static_Expression | |
8062 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
8063 | ||
8064 | procedure Set_Is_Subprogram_Descriptor | |
8065 | (N : Node_Id; Val : Boolean := True); -- Flag16 | |
8066 | ||
8067 | procedure Set_Is_Task_Allocation_Block | |
8068 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
8069 | ||
8070 | procedure Set_Is_Task_Master | |
8071 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
8072 | ||
8073 | procedure Set_Iteration_Scheme | |
8074 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8075 | ||
8076 | procedure Set_Itype | |
8077 | (N : Node_Id; Val : Entity_Id); -- Node1 | |
8078 | ||
8079 | procedure Set_Kill_Range_Check | |
8080 | (N : Node_Id; Val : Boolean := True); -- Flag11 | |
8081 | ||
8082 | procedure Set_Last_Bit | |
8083 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8084 | ||
8085 | procedure Set_Last_Name | |
8086 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
8087 | ||
8088 | procedure Set_Library_Unit | |
8089 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8090 | ||
8091 | procedure Set_Label_Construct | |
8092 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8093 | ||
8094 | procedure Set_Left_Opnd | |
8095 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8096 | ||
fbf5a39b AC |
8097 | procedure Set_Limited_View_Installed |
8098 | (N : Node_Id; Val : Boolean := True); -- Flag18 | |
8099 | ||
996ae0b0 RK |
8100 | procedure Set_Limited_Present |
8101 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
8102 | ||
8103 | procedure Set_Literals | |
8104 | (N : Node_Id; Val : List_Id); -- List1 | |
8105 | ||
8106 | procedure Set_Loop_Actions | |
8107 | (N : Node_Id; Val : List_Id); -- List2 | |
8108 | ||
8109 | procedure Set_Loop_Parameter_Specification | |
8110 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8111 | ||
8112 | procedure Set_Low_Bound | |
8113 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8114 | ||
8115 | procedure Set_Mod_Clause | |
8116 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8117 | ||
8118 | procedure Set_More_Ids | |
8119 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
8120 | ||
07fc65c4 GB |
8121 | procedure Set_Must_Be_Byte_Aligned |
8122 | (N : Node_Id; Val : Boolean := True); -- Flag14 | |
8123 | ||
996ae0b0 RK |
8124 | procedure Set_Must_Not_Freeze |
8125 | (N : Node_Id; Val : Boolean := True); -- Flag8 | |
8126 | ||
8127 | procedure Set_Name | |
8128 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8129 | ||
8130 | procedure Set_Names | |
8131 | (N : Node_Id; Val : List_Id); -- List2 | |
8132 | ||
8133 | procedure Set_Next_Entity | |
8134 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8135 | ||
8136 | procedure Set_Next_Named_Actual | |
8137 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8138 | ||
8139 | procedure Set_Next_Rep_Item | |
8140 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8141 | ||
8142 | procedure Set_Next_Use_Clause | |
8143 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8144 | ||
8145 | procedure Set_No_Ctrl_Actions | |
8146 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8147 | ||
8148 | procedure Set_No_Entities_Ref_In_Spec | |
8149 | (N : Node_Id; Val : Boolean := True); -- Flag8 | |
8150 | ||
8151 | procedure Set_No_Initialization | |
8152 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8153 | ||
fbf5a39b AC |
8154 | procedure Set_No_Truncation |
8155 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
8156 | ||
996ae0b0 RK |
8157 | procedure Set_Null_Present |
8158 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8159 | ||
8160 | procedure Set_Null_Record_Present | |
8161 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
8162 | ||
8163 | procedure Set_Object_Definition | |
8164 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8165 | ||
8166 | procedure Set_OK_For_Stream | |
8167 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
8168 | ||
8169 | procedure Set_Original_Discriminant | |
8170 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8171 | ||
fbf5a39b AC |
8172 | procedure Set_Original_Entity |
8173 | (N : Node_Id; Val : Entity_Id); -- Node2 | |
8174 | ||
996ae0b0 RK |
8175 | procedure Set_Others_Discrete_Choices |
8176 | (N : Node_Id; Val : List_Id); -- List1 | |
8177 | ||
8178 | procedure Set_Out_Present | |
8179 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
8180 | ||
8181 | procedure Set_Parameter_Associations | |
8182 | (N : Node_Id; Val : List_Id); -- List3 | |
8183 | ||
8184 | procedure Set_Parameter_List_Truncated | |
8185 | (N : Node_Id; Val : Boolean := True); -- Flag17 | |
8186 | ||
8187 | procedure Set_Parameter_Specifications | |
8188 | (N : Node_Id; Val : List_Id); -- List3 | |
8189 | ||
8190 | procedure Set_Parameter_Type | |
8191 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8192 | ||
8193 | procedure Set_Parent_Spec | |
8194 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8195 | ||
8196 | procedure Set_Position | |
8197 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8198 | ||
8199 | procedure Set_Pragma_Argument_Associations | |
8200 | (N : Node_Id; Val : List_Id); -- List2 | |
8201 | ||
8202 | procedure Set_Pragmas_After | |
8203 | (N : Node_Id; Val : List_Id); -- List5 | |
8204 | ||
8205 | procedure Set_Pragmas_Before | |
8206 | (N : Node_Id; Val : List_Id); -- List4 | |
8207 | ||
8208 | procedure Set_Prefix | |
8209 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8210 | ||
8211 | procedure Set_Present_Expr | |
8212 | (N : Node_Id; Val : Uint); -- Uint3 | |
8213 | ||
8214 | procedure Set_Prev_Ids | |
8215 | (N : Node_Id; Val : Boolean := True); -- Flag6 | |
8216 | ||
8217 | procedure Set_Print_In_Hex | |
8218 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8219 | ||
8220 | procedure Set_Private_Declarations | |
8221 | (N : Node_Id; Val : List_Id); -- List3 | |
8222 | ||
8223 | procedure Set_Private_Present | |
8224 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
8225 | ||
8226 | procedure Set_Procedure_To_Call | |
8227 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8228 | ||
8229 | procedure Set_Proper_Body | |
8230 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8231 | ||
8232 | procedure Set_Protected_Definition | |
8233 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8234 | ||
8235 | procedure Set_Protected_Present | |
8236 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
8237 | ||
8238 | procedure Set_Raises_Constraint_Error | |
8239 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8240 | ||
8241 | procedure Set_Range_Constraint | |
8242 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8243 | ||
8244 | procedure Set_Range_Expression | |
8245 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8246 | ||
8247 | procedure Set_Real_Range_Specification | |
8248 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8249 | ||
8250 | procedure Set_Realval | |
8251 | (N : Node_Id; Val : Ureal); -- Ureal3 | |
8252 | ||
07fc65c4 GB |
8253 | procedure Set_Reason |
8254 | (N : Node_Id; Val : Uint); -- Uint3 | |
8255 | ||
996ae0b0 RK |
8256 | procedure Set_Record_Extension_Part |
8257 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8258 | ||
8259 | procedure Set_Redundant_Use | |
8260 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8261 | ||
8262 | procedure Set_Return_Type | |
8263 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8264 | ||
8265 | procedure Set_Reverse_Present | |
8266 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
8267 | ||
8268 | procedure Set_Right_Opnd | |
8269 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8270 | ||
8271 | procedure Set_Rounded_Result | |
8272 | (N : Node_Id; Val : Boolean := True); -- Flag18 | |
8273 | ||
8274 | procedure Set_Scope | |
8275 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8276 | ||
8277 | procedure Set_Select_Alternatives | |
8278 | (N : Node_Id; Val : List_Id); -- List1 | |
8279 | ||
8280 | procedure Set_Selector_Name | |
8281 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8282 | ||
8283 | procedure Set_Selector_Names | |
8284 | (N : Node_Id; Val : List_Id); -- List1 | |
8285 | ||
8286 | procedure Set_Shift_Count_OK | |
8287 | (N : Node_Id; Val : Boolean := True); -- Flag4 | |
8288 | ||
8289 | procedure Set_Source_Type | |
8290 | (N : Node_Id; Val : Entity_Id); -- Node1 | |
8291 | ||
8292 | procedure Set_Specification | |
8293 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8294 | ||
8295 | procedure Set_Statements | |
8296 | (N : Node_Id; Val : List_Id); -- List3 | |
8297 | ||
8298 | procedure Set_Static_Processing_OK | |
8299 | (N : Node_Id; Val : Boolean); -- Flag4 | |
8300 | ||
8301 | procedure Set_Storage_Pool | |
8302 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8303 | ||
8304 | procedure Set_Strval | |
8305 | (N : Node_Id; Val : String_Id); -- Str3 | |
8306 | ||
8307 | procedure Set_Subtype_Indication | |
8308 | (N : Node_Id; Val : Node_Id); -- Node5 | |
8309 | ||
8310 | procedure Set_Subtype_Mark | |
8311 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8312 | ||
8313 | procedure Set_Subtype_Marks | |
8314 | (N : Node_Id; Val : List_Id); -- List2 | |
8315 | ||
8316 | procedure Set_Tagged_Present | |
8317 | (N : Node_Id; Val : Boolean := True); -- Flag15 | |
8318 | ||
8319 | procedure Set_Target_Type | |
8320 | (N : Node_Id; Val : Entity_Id); -- Node2 | |
8321 | ||
8322 | procedure Set_Task_Body_Procedure | |
8323 | (N : Node_Id; Val : Entity_Id); -- Node2 | |
8324 | ||
8325 | procedure Set_Task_Definition | |
8326 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8327 | ||
8328 | procedure Set_Then_Actions | |
8329 | (N : Node_Id; Val : List_Id); -- List2 | |
8330 | ||
8331 | procedure Set_Then_Statements | |
8332 | (N : Node_Id; Val : List_Id); -- List2 | |
8333 | ||
8334 | procedure Set_Treat_Fixed_As_Integer | |
8335 | (N : Node_Id; Val : Boolean := True); -- Flag14 | |
8336 | ||
8337 | procedure Set_Triggering_Alternative | |
8338 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8339 | ||
8340 | procedure Set_Triggering_Statement | |
8341 | (N : Node_Id; Val : Node_Id); -- Node1 | |
8342 | ||
8343 | procedure Set_TSS_Elist | |
8344 | (N : Node_Id; Val : Elist_Id); -- Elist3 | |
8345 | ||
8346 | procedure Set_Type_Definition | |
8347 | (N : Node_Id; Val : Node_Id); -- Node3 | |
8348 | ||
8349 | procedure Set_Unit | |
8350 | (N : Node_Id; Val : Node_Id); -- Node2 | |
8351 | ||
8352 | procedure Set_Unknown_Discriminants_Present | |
8353 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8354 | ||
8355 | procedure Set_Unreferenced_In_Spec | |
8356 | (N : Node_Id; Val : Boolean := True); -- Flag7 | |
8357 | ||
8358 | procedure Set_Variant_Part | |
8359 | (N : Node_Id; Val : Node_Id); -- Node4 | |
8360 | ||
8361 | procedure Set_Variants | |
8362 | (N : Node_Id; Val : List_Id); -- List1 | |
8363 | ||
8364 | procedure Set_Visible_Declarations | |
8365 | (N : Node_Id; Val : List_Id); -- List2 | |
8366 | ||
8367 | procedure Set_Was_Originally_Stub | |
8368 | (N : Node_Id; Val : Boolean := True); -- Flag13 | |
8369 | ||
8370 | procedure Set_Zero_Cost_Handling | |
8371 | (N : Node_Id; Val : Boolean := True); -- Flag5 | |
8372 | ||
8373 | ------------------------- | |
8374 | -- Iterator Procedures -- | |
8375 | ------------------------- | |
8376 | ||
8377 | -- The call to Next_xxx (N) is equivalent to N := Next_xxx (N) | |
8378 | ||
8379 | procedure Next_Entity (N : in out Node_Id); | |
8380 | procedure Next_Named_Actual (N : in out Node_Id); | |
8381 | procedure Next_Rep_Item (N : in out Node_Id); | |
8382 | procedure Next_Use_Clause (N : in out Node_Id); | |
8383 | ||
8384 | -------------------------------------- | |
8385 | -- Logical Access to End_Span Field -- | |
8386 | -------------------------------------- | |
8387 | ||
8388 | function End_Location (N : Node_Id) return Source_Ptr; | |
8389 | -- N is an N_If_Statement or N_Case_Statement node, and this | |
8390 | -- function returns the location of the IF token in the END IF | |
8391 | -- sequence by translating the value of the End_Span field. | |
8392 | ||
8393 | procedure Set_End_Location (N : Node_Id; S : Source_Ptr); | |
8394 | -- N is an N_If_Statement or N_Case_Statement node. This procedure | |
8395 | -- sets the End_Span field to correspond to the given value S. In | |
8396 | -- other words, End_Span is set to the difference between S and | |
8397 | -- Sloc (N), the starting location. | |
8398 | ||
8399 | -------------------- | |
8400 | -- Inline Pragmas -- | |
8401 | -------------------- | |
8402 | ||
8403 | pragma Inline (ABE_Is_Certain); | |
8404 | pragma Inline (Abort_Present); | |
8405 | pragma Inline (Abortable_Part); | |
8406 | pragma Inline (Abstract_Present); | |
8407 | pragma Inline (Accept_Handler_Records); | |
8408 | pragma Inline (Accept_Statement); | |
8409 | pragma Inline (Access_Types_To_Process); | |
8410 | pragma Inline (Actions); | |
8411 | pragma Inline (Activation_Chain_Entity); | |
8412 | pragma Inline (Acts_As_Spec); | |
8413 | pragma Inline (Aggregate_Bounds); | |
8414 | pragma Inline (Aliased_Present); | |
8415 | pragma Inline (All_Others); | |
8416 | pragma Inline (All_Present); | |
8417 | pragma Inline (Alternatives); | |
8418 | pragma Inline (Ancestor_Part); | |
8419 | pragma Inline (Array_Aggregate); | |
8420 | pragma Inline (Assignment_OK); | |
3e542a58 | 8421 | pragma Inline (Associated_Node); |
996ae0b0 RK |
8422 | pragma Inline (At_End_Proc); |
8423 | pragma Inline (Attribute_Name); | |
8424 | pragma Inline (Aux_Decls_Node); | |
8425 | pragma Inline (Backwards_OK); | |
8426 | pragma Inline (Bad_Is_Detected); | |
8427 | pragma Inline (Body_To_Inline); | |
8428 | pragma Inline (Body_Required); | |
8429 | pragma Inline (By_Ref); | |
8430 | pragma Inline (Box_Present); | |
8431 | pragma Inline (Char_Literal_Value); | |
8432 | pragma Inline (Chars); | |
fbf5a39b | 8433 | pragma Inline (Check_Address_Alignment); |
996ae0b0 RK |
8434 | pragma Inline (Choice_Parameter); |
8435 | pragma Inline (Choices); | |
8436 | pragma Inline (Compile_Time_Known_Aggregate); | |
8437 | pragma Inline (Component_Associations); | |
8438 | pragma Inline (Component_Clauses); | |
8439 | pragma Inline (Component_Items); | |
8440 | pragma Inline (Component_List); | |
8441 | pragma Inline (Component_Name); | |
8442 | pragma Inline (Condition); | |
8443 | pragma Inline (Condition_Actions); | |
fbf5a39b | 8444 | pragma Inline (Config_Pragmas); |
996ae0b0 RK |
8445 | pragma Inline (Constant_Present); |
8446 | pragma Inline (Constraint); | |
8447 | pragma Inline (Constraints); | |
8448 | pragma Inline (Context_Installed); | |
8449 | pragma Inline (Context_Items); | |
8450 | pragma Inline (Controlling_Argument); | |
8451 | pragma Inline (Conversion_OK); | |
8452 | pragma Inline (Corresponding_Body); | |
8453 | pragma Inline (Corresponding_Generic_Association); | |
8454 | pragma Inline (Corresponding_Integer_Value); | |
8455 | pragma Inline (Corresponding_Spec); | |
8456 | pragma Inline (Corresponding_Stub); | |
8457 | pragma Inline (Dcheck_Function); | |
8458 | pragma Inline (Debug_Statement); | |
8459 | pragma Inline (Declarations); | |
8460 | pragma Inline (Default_Expression); | |
8461 | pragma Inline (Default_Name); | |
8462 | pragma Inline (Defining_Identifier); | |
8463 | pragma Inline (Defining_Unit_Name); | |
8464 | pragma Inline (Delay_Alternative); | |
8465 | pragma Inline (Delay_Finalize_Attach); | |
8466 | pragma Inline (Delay_Statement); | |
8467 | pragma Inline (Delta_Expression); | |
8468 | pragma Inline (Digits_Expression); | |
8469 | pragma Inline (Discr_Check_Funcs_Built); | |
8470 | pragma Inline (Discrete_Choices); | |
8471 | pragma Inline (Discrete_Range); | |
8472 | pragma Inline (Discrete_Subtype_Definition); | |
8473 | pragma Inline (Discrete_Subtype_Definitions); | |
8474 | pragma Inline (Discriminant_Specifications); | |
8475 | pragma Inline (Discriminant_Type); | |
996ae0b0 RK |
8476 | pragma Inline (Do_Accessibility_Check); |
8477 | pragma Inline (Do_Discriminant_Check); | |
8478 | pragma Inline (Do_Length_Check); | |
8479 | pragma Inline (Do_Division_Check); | |
8480 | pragma Inline (Do_Overflow_Check); | |
8481 | pragma Inline (Do_Range_Check); | |
8482 | pragma Inline (Do_Storage_Check); | |
8483 | pragma Inline (Do_Tag_Check); | |
8484 | pragma Inline (Elaborate_Present); | |
8485 | pragma Inline (Elaborate_All_Present); | |
8486 | pragma Inline (Elaboration_Boolean); | |
8487 | pragma Inline (Else_Actions); | |
8488 | pragma Inline (Else_Statements); | |
8489 | pragma Inline (Elsif_Parts); | |
8490 | pragma Inline (Enclosing_Variant); | |
8491 | pragma Inline (End_Label); | |
8492 | pragma Inline (End_Span); | |
8493 | pragma Inline (Entity); | |
8494 | pragma Inline (Entry_Body_Formal_Part); | |
8495 | pragma Inline (Entry_Call_Alternative); | |
8496 | pragma Inline (Entry_Call_Statement); | |
8497 | pragma Inline (Entry_Direct_Name); | |
8498 | pragma Inline (Entry_Index); | |
8499 | pragma Inline (Entry_Index_Specification); | |
8500 | pragma Inline (Etype); | |
8501 | pragma Inline (Exception_Choices); | |
8502 | pragma Inline (Exception_Junk); | |
8503 | pragma Inline (Exception_Handlers); | |
8504 | pragma Inline (Expansion_Delayed); | |
8505 | pragma Inline (Explicit_Actual_Parameter); | |
8506 | pragma Inline (Explicit_Generic_Actual_Parameter); | |
8507 | pragma Inline (Expression); | |
8508 | pragma Inline (Expressions); | |
8509 | pragma Inline (First_Bit); | |
8510 | pragma Inline (First_Inlined_Subprogram); | |
8511 | pragma Inline (First_Name); | |
8512 | pragma Inline (First_Named_Actual); | |
8513 | pragma Inline (First_Real_Statement); | |
8514 | pragma Inline (First_Subtype_Link); | |
8515 | pragma Inline (Float_Truncate); | |
8516 | pragma Inline (Formal_Type_Definition); | |
8517 | pragma Inline (Forwards_OK); | |
8518 | pragma Inline (From_At_Mod); | |
8519 | pragma Inline (Generic_Associations); | |
8520 | pragma Inline (Generic_Formal_Declarations); | |
8521 | pragma Inline (Generic_Parent); | |
8522 | pragma Inline (Generic_Parent_Type); | |
8523 | pragma Inline (Handled_Statement_Sequence); | |
8524 | pragma Inline (Handler_List_Entry); | |
8525 | pragma Inline (Has_Created_Identifier); | |
8526 | pragma Inline (Has_Dynamic_Length_Check); | |
8527 | pragma Inline (Has_Dynamic_Range_Check); | |
8528 | pragma Inline (Has_No_Elaboration_Code); | |
8529 | pragma Inline (Has_Priority_Pragma); | |
8530 | pragma Inline (Has_Private_View); | |
8531 | pragma Inline (Has_Storage_Size_Pragma); | |
8532 | pragma Inline (Has_Task_Info_Pragma); | |
8533 | pragma Inline (Has_Task_Name_Pragma); | |
8534 | pragma Inline (Has_Wide_Character); | |
8535 | pragma Inline (Hidden_By_Use_Clause); | |
8536 | pragma Inline (High_Bound); | |
8537 | pragma Inline (Identifier); | |
8538 | pragma Inline (Implicit_With); | |
8539 | pragma Inline (Includes_Infinities); | |
8540 | pragma Inline (In_Present); | |
8541 | pragma Inline (Instance_Spec); | |
8542 | pragma Inline (Intval); | |
8543 | pragma Inline (Is_Asynchronous_Call_Block); | |
8544 | pragma Inline (Is_Component_Left_Opnd); | |
8545 | pragma Inline (Is_Component_Right_Opnd); | |
8546 | pragma Inline (Is_Controlling_Actual); | |
fbf5a39b | 8547 | pragma Inline (Is_In_Discriminant_Check); |
996ae0b0 | 8548 | pragma Inline (Is_Machine_Number); |
fbf5a39b | 8549 | pragma Inline (Is_Null_Loop); |
996ae0b0 RK |
8550 | pragma Inline (Is_Overloaded); |
8551 | pragma Inline (Is_Power_Of_2_For_Shift); | |
8552 | pragma Inline (Is_Protected_Subprogram_Body); | |
8553 | pragma Inline (Is_Static_Expression); | |
8554 | pragma Inline (Is_Subprogram_Descriptor); | |
8555 | pragma Inline (Is_Task_Allocation_Block); | |
8556 | pragma Inline (Is_Task_Master); | |
8557 | pragma Inline (Iteration_Scheme); | |
8558 | pragma Inline (Itype); | |
8559 | pragma Inline (Kill_Range_Check); | |
8560 | pragma Inline (Last_Bit); | |
8561 | pragma Inline (Last_Name); | |
8562 | pragma Inline (Library_Unit); | |
8563 | pragma Inline (Label_Construct); | |
8564 | pragma Inline (Left_Opnd); | |
fbf5a39b | 8565 | pragma Inline (Limited_View_Installed); |
996ae0b0 RK |
8566 | pragma Inline (Limited_Present); |
8567 | pragma Inline (Literals); | |
8568 | pragma Inline (Loop_Actions); | |
8569 | pragma Inline (Loop_Parameter_Specification); | |
8570 | pragma Inline (Low_Bound); | |
8571 | pragma Inline (Mod_Clause); | |
8572 | pragma Inline (More_Ids); | |
07fc65c4 | 8573 | pragma Inline (Must_Be_Byte_Aligned); |
996ae0b0 RK |
8574 | pragma Inline (Must_Not_Freeze); |
8575 | pragma Inline (Name); | |
8576 | pragma Inline (Names); | |
8577 | pragma Inline (Next_Entity); | |
8578 | pragma Inline (Next_Named_Actual); | |
8579 | pragma Inline (Next_Rep_Item); | |
8580 | pragma Inline (Next_Use_Clause); | |
8581 | pragma Inline (No_Ctrl_Actions); | |
8582 | pragma Inline (No_Entities_Ref_In_Spec); | |
8583 | pragma Inline (No_Initialization); | |
fbf5a39b | 8584 | pragma Inline (No_Truncation); |
996ae0b0 RK |
8585 | pragma Inline (Null_Present); |
8586 | pragma Inline (Null_Record_Present); | |
8587 | pragma Inline (Object_Definition); | |
8588 | pragma Inline (OK_For_Stream); | |
8589 | pragma Inline (Original_Discriminant); | |
fbf5a39b | 8590 | pragma Inline (Original_Entity); |
996ae0b0 RK |
8591 | pragma Inline (Others_Discrete_Choices); |
8592 | pragma Inline (Out_Present); | |
8593 | pragma Inline (Parameter_Associations); | |
8594 | pragma Inline (Parameter_Specifications); | |
8595 | pragma Inline (Parameter_List_Truncated); | |
8596 | pragma Inline (Parameter_Type); | |
8597 | pragma Inline (Parent_Spec); | |
8598 | pragma Inline (Position); | |
8599 | pragma Inline (Pragma_Argument_Associations); | |
8600 | pragma Inline (Pragmas_After); | |
8601 | pragma Inline (Pragmas_Before); | |
8602 | pragma Inline (Prefix); | |
8603 | pragma Inline (Present_Expr); | |
8604 | pragma Inline (Prev_Ids); | |
8605 | pragma Inline (Print_In_Hex); | |
8606 | pragma Inline (Private_Declarations); | |
8607 | pragma Inline (Private_Present); | |
8608 | pragma Inline (Procedure_To_Call); | |
8609 | pragma Inline (Proper_Body); | |
8610 | pragma Inline (Protected_Definition); | |
8611 | pragma Inline (Protected_Present); | |
8612 | pragma Inline (Raises_Constraint_Error); | |
8613 | pragma Inline (Range_Constraint); | |
8614 | pragma Inline (Range_Expression); | |
996ae0b0 | 8615 | pragma Inline (Real_Range_Specification); |
07fc65c4 GB |
8616 | pragma Inline (Realval); |
8617 | pragma Inline (Reason); | |
996ae0b0 RK |
8618 | pragma Inline (Record_Extension_Part); |
8619 | pragma Inline (Redundant_Use); | |
8620 | pragma Inline (Return_Type); | |
8621 | pragma Inline (Reverse_Present); | |
8622 | pragma Inline (Right_Opnd); | |
8623 | pragma Inline (Rounded_Result); | |
8624 | pragma Inline (Scope); | |
8625 | pragma Inline (Select_Alternatives); | |
8626 | pragma Inline (Selector_Name); | |
8627 | pragma Inline (Selector_Names); | |
8628 | pragma Inline (Shift_Count_OK); | |
8629 | pragma Inline (Source_Type); | |
8630 | pragma Inline (Specification); | |
8631 | pragma Inline (Statements); | |
8632 | pragma Inline (Static_Processing_OK); | |
8633 | pragma Inline (Storage_Pool); | |
8634 | pragma Inline (Strval); | |
8635 | pragma Inline (Subtype_Indication); | |
8636 | pragma Inline (Subtype_Mark); | |
8637 | pragma Inline (Subtype_Marks); | |
8638 | pragma Inline (Tagged_Present); | |
8639 | pragma Inline (Target_Type); | |
8640 | pragma Inline (Task_Body_Procedure); | |
8641 | pragma Inline (Task_Definition); | |
8642 | pragma Inline (Then_Actions); | |
8643 | pragma Inline (Then_Statements); | |
8644 | pragma Inline (Triggering_Alternative); | |
8645 | pragma Inline (Triggering_Statement); | |
8646 | pragma Inline (Treat_Fixed_As_Integer); | |
8647 | pragma Inline (TSS_Elist); | |
8648 | pragma Inline (Type_Definition); | |
8649 | pragma Inline (Unit); | |
8650 | pragma Inline (Unknown_Discriminants_Present); | |
8651 | pragma Inline (Unreferenced_In_Spec); | |
8652 | pragma Inline (Variant_Part); | |
8653 | pragma Inline (Variants); | |
8654 | pragma Inline (Visible_Declarations); | |
8655 | pragma Inline (Was_Originally_Stub); | |
8656 | pragma Inline (Zero_Cost_Handling); | |
8657 | ||
8658 | pragma Inline (Set_ABE_Is_Certain); | |
8659 | pragma Inline (Set_Abort_Present); | |
8660 | pragma Inline (Set_Abortable_Part); | |
8661 | pragma Inline (Set_Abstract_Present); | |
8662 | pragma Inline (Set_Accept_Handler_Records); | |
8663 | pragma Inline (Set_Accept_Statement); | |
8664 | pragma Inline (Set_Access_Types_To_Process); | |
8665 | pragma Inline (Set_Actions); | |
8666 | pragma Inline (Set_Activation_Chain_Entity); | |
8667 | pragma Inline (Set_Acts_As_Spec); | |
8668 | pragma Inline (Set_Aggregate_Bounds); | |
8669 | pragma Inline (Set_Aliased_Present); | |
8670 | pragma Inline (Set_All_Others); | |
8671 | pragma Inline (Set_All_Present); | |
8672 | pragma Inline (Set_Alternatives); | |
8673 | pragma Inline (Set_Ancestor_Part); | |
8674 | pragma Inline (Set_Array_Aggregate); | |
8675 | pragma Inline (Set_Assignment_OK); | |
3e542a58 | 8676 | pragma Inline (Set_Associated_Node); |
996ae0b0 RK |
8677 | pragma Inline (Set_At_End_Proc); |
8678 | pragma Inline (Set_Attribute_Name); | |
8679 | pragma Inline (Set_Aux_Decls_Node); | |
8680 | pragma Inline (Set_Backwards_OK); | |
8681 | pragma Inline (Set_Bad_Is_Detected); | |
8682 | pragma Inline (Set_Body_To_Inline); | |
8683 | pragma Inline (Set_Body_Required); | |
8684 | pragma Inline (Set_By_Ref); | |
8685 | pragma Inline (Set_Box_Present); | |
8686 | pragma Inline (Set_Char_Literal_Value); | |
8687 | pragma Inline (Set_Chars); | |
fbf5a39b | 8688 | pragma Inline (Set_Check_Address_Alignment); |
996ae0b0 RK |
8689 | pragma Inline (Set_Choice_Parameter); |
8690 | pragma Inline (Set_Choices); | |
8691 | pragma Inline (Set_Compile_Time_Known_Aggregate); | |
8692 | pragma Inline (Set_Component_Associations); | |
8693 | pragma Inline (Set_Component_Clauses); | |
8694 | pragma Inline (Set_Component_Items); | |
8695 | pragma Inline (Set_Component_List); | |
8696 | pragma Inline (Set_Component_Name); | |
8697 | pragma Inline (Set_Condition); | |
8698 | pragma Inline (Set_Condition_Actions); | |
fbf5a39b | 8699 | pragma Inline (Set_Config_Pragmas); |
996ae0b0 RK |
8700 | pragma Inline (Set_Constant_Present); |
8701 | pragma Inline (Set_Constraint); | |
8702 | pragma Inline (Set_Constraints); | |
8703 | pragma Inline (Set_Context_Installed); | |
8704 | pragma Inline (Set_Context_Items); | |
8705 | pragma Inline (Set_Controlling_Argument); | |
8706 | pragma Inline (Set_Conversion_OK); | |
8707 | pragma Inline (Set_Corresponding_Body); | |
8708 | pragma Inline (Set_Corresponding_Generic_Association); | |
8709 | pragma Inline (Set_Corresponding_Integer_Value); | |
8710 | pragma Inline (Set_Corresponding_Spec); | |
8711 | pragma Inline (Set_Corresponding_Stub); | |
8712 | pragma Inline (Set_Dcheck_Function); | |
8713 | pragma Inline (Set_Debug_Statement); | |
8714 | pragma Inline (Set_Declarations); | |
8715 | pragma Inline (Set_Default_Expression); | |
8716 | pragma Inline (Set_Default_Name); | |
8717 | pragma Inline (Set_Defining_Identifier); | |
8718 | pragma Inline (Set_Defining_Unit_Name); | |
8719 | pragma Inline (Set_Delay_Alternative); | |
8720 | pragma Inline (Set_Delay_Finalize_Attach); | |
8721 | pragma Inline (Set_Delay_Statement); | |
8722 | pragma Inline (Set_Delta_Expression); | |
8723 | pragma Inline (Set_Digits_Expression); | |
8724 | pragma Inline (Set_Discr_Check_Funcs_Built); | |
8725 | pragma Inline (Set_Discrete_Choices); | |
8726 | pragma Inline (Set_Discrete_Range); | |
8727 | pragma Inline (Set_Discrete_Subtype_Definition); | |
8728 | pragma Inline (Set_Discrete_Subtype_Definitions); | |
8729 | pragma Inline (Set_Discriminant_Specifications); | |
8730 | pragma Inline (Set_Discriminant_Type); | |
996ae0b0 RK |
8731 | pragma Inline (Set_Do_Accessibility_Check); |
8732 | pragma Inline (Set_Do_Discriminant_Check); | |
8733 | pragma Inline (Set_Do_Length_Check); | |
8734 | pragma Inline (Set_Do_Division_Check); | |
8735 | pragma Inline (Set_Do_Overflow_Check); | |
8736 | pragma Inline (Set_Do_Range_Check); | |
8737 | pragma Inline (Set_Do_Storage_Check); | |
8738 | pragma Inline (Set_Do_Tag_Check); | |
8739 | pragma Inline (Set_Elaborate_Present); | |
8740 | pragma Inline (Set_Elaborate_All_Present); | |
8741 | pragma Inline (Set_Elaboration_Boolean); | |
8742 | pragma Inline (Set_Else_Actions); | |
8743 | pragma Inline (Set_Else_Statements); | |
8744 | pragma Inline (Set_Elsif_Parts); | |
8745 | pragma Inline (Set_Enclosing_Variant); | |
8746 | pragma Inline (Set_End_Label); | |
8747 | pragma Inline (Set_End_Span); | |
8748 | pragma Inline (Set_Entity); | |
8749 | pragma Inline (Set_Entry_Body_Formal_Part); | |
8750 | pragma Inline (Set_Entry_Call_Alternative); | |
8751 | pragma Inline (Set_Entry_Call_Statement); | |
8752 | pragma Inline (Set_Entry_Direct_Name); | |
8753 | pragma Inline (Set_Entry_Index); | |
8754 | pragma Inline (Set_Entry_Index_Specification); | |
8755 | pragma Inline (Set_Etype); | |
8756 | pragma Inline (Set_Exception_Choices); | |
8757 | pragma Inline (Set_Exception_Junk); | |
8758 | pragma Inline (Set_Exception_Handlers); | |
8759 | pragma Inline (Set_Expansion_Delayed); | |
8760 | pragma Inline (Set_Explicit_Actual_Parameter); | |
8761 | pragma Inline (Set_Explicit_Generic_Actual_Parameter); | |
8762 | pragma Inline (Set_Expression); | |
8763 | pragma Inline (Set_Expressions); | |
8764 | pragma Inline (Set_First_Bit); | |
8765 | pragma Inline (Set_First_Inlined_Subprogram); | |
8766 | pragma Inline (Set_First_Name); | |
8767 | pragma Inline (Set_First_Named_Actual); | |
8768 | pragma Inline (Set_First_Real_Statement); | |
8769 | pragma Inline (Set_First_Subtype_Link); | |
8770 | pragma Inline (Set_Float_Truncate); | |
8771 | pragma Inline (Set_Formal_Type_Definition); | |
8772 | pragma Inline (Set_Forwards_OK); | |
8773 | pragma Inline (Set_From_At_Mod); | |
8774 | pragma Inline (Set_Generic_Associations); | |
8775 | pragma Inline (Set_Generic_Formal_Declarations); | |
8776 | pragma Inline (Set_Generic_Parent); | |
8777 | pragma Inline (Set_Generic_Parent_Type); | |
8778 | pragma Inline (Set_Handled_Statement_Sequence); | |
8779 | pragma Inline (Set_Handler_List_Entry); | |
8780 | pragma Inline (Set_Has_Created_Identifier); | |
8781 | pragma Inline (Set_Has_Dynamic_Length_Check); | |
8782 | pragma Inline (Set_Has_Dynamic_Range_Check); | |
8783 | pragma Inline (Set_Has_No_Elaboration_Code); | |
8784 | pragma Inline (Set_Has_Priority_Pragma); | |
8785 | pragma Inline (Set_Has_Private_View); | |
8786 | pragma Inline (Set_Has_Storage_Size_Pragma); | |
8787 | pragma Inline (Set_Has_Task_Info_Pragma); | |
8788 | pragma Inline (Set_Has_Task_Name_Pragma); | |
8789 | pragma Inline (Set_Has_Wide_Character); | |
8790 | pragma Inline (Set_Hidden_By_Use_Clause); | |
8791 | pragma Inline (Set_High_Bound); | |
8792 | pragma Inline (Set_Identifier); | |
8793 | pragma Inline (Set_Implicit_With); | |
8794 | pragma Inline (Set_Includes_Infinities); | |
8795 | pragma Inline (Set_In_Present); | |
8796 | pragma Inline (Set_Instance_Spec); | |
8797 | pragma Inline (Set_Intval); | |
8798 | pragma Inline (Set_Is_Asynchronous_Call_Block); | |
8799 | pragma Inline (Set_Is_Component_Left_Opnd); | |
8800 | pragma Inline (Set_Is_Component_Right_Opnd); | |
8801 | pragma Inline (Set_Is_Controlling_Actual); | |
fbf5a39b | 8802 | pragma Inline (Set_Is_In_Discriminant_Check); |
996ae0b0 | 8803 | pragma Inline (Set_Is_Machine_Number); |
fbf5a39b | 8804 | pragma Inline (Set_Is_Null_Loop); |
996ae0b0 RK |
8805 | pragma Inline (Set_Is_Overloaded); |
8806 | pragma Inline (Set_Is_Power_Of_2_For_Shift); | |
8807 | pragma Inline (Set_Is_Protected_Subprogram_Body); | |
8808 | pragma Inline (Set_Is_Static_Expression); | |
8809 | pragma Inline (Set_Is_Subprogram_Descriptor); | |
8810 | pragma Inline (Set_Is_Task_Allocation_Block); | |
8811 | pragma Inline (Set_Is_Task_Master); | |
8812 | pragma Inline (Set_Iteration_Scheme); | |
8813 | pragma Inline (Set_Itype); | |
8814 | pragma Inline (Set_Kill_Range_Check); | |
8815 | pragma Inline (Set_Last_Bit); | |
8816 | pragma Inline (Set_Last_Name); | |
8817 | pragma Inline (Set_Library_Unit); | |
8818 | pragma Inline (Set_Label_Construct); | |
8819 | pragma Inline (Set_Left_Opnd); | |
fbf5a39b | 8820 | pragma Inline (Set_Limited_View_Installed); |
996ae0b0 RK |
8821 | pragma Inline (Set_Limited_Present); |
8822 | pragma Inline (Set_Literals); | |
8823 | pragma Inline (Set_Loop_Actions); | |
8824 | pragma Inline (Set_Loop_Parameter_Specification); | |
8825 | pragma Inline (Set_Low_Bound); | |
8826 | pragma Inline (Set_Mod_Clause); | |
8827 | pragma Inline (Set_More_Ids); | |
07fc65c4 | 8828 | pragma Inline (Set_Must_Be_Byte_Aligned); |
996ae0b0 RK |
8829 | pragma Inline (Set_Must_Not_Freeze); |
8830 | pragma Inline (Set_Name); | |
8831 | pragma Inline (Set_Names); | |
8832 | pragma Inline (Set_Next_Entity); | |
8833 | pragma Inline (Set_Next_Named_Actual); | |
8834 | pragma Inline (Set_Next_Use_Clause); | |
8835 | pragma Inline (Set_No_Ctrl_Actions); | |
8836 | pragma Inline (Set_No_Entities_Ref_In_Spec); | |
8837 | pragma Inline (Set_No_Initialization); | |
fbf5a39b | 8838 | pragma Inline (Set_No_Truncation); |
996ae0b0 RK |
8839 | pragma Inline (Set_Null_Present); |
8840 | pragma Inline (Set_Null_Record_Present); | |
8841 | pragma Inline (Set_Object_Definition); | |
8842 | pragma Inline (Set_OK_For_Stream); | |
8843 | pragma Inline (Set_Original_Discriminant); | |
fbf5a39b | 8844 | pragma Inline (Set_Original_Entity); |
996ae0b0 RK |
8845 | pragma Inline (Set_Others_Discrete_Choices); |
8846 | pragma Inline (Set_Out_Present); | |
8847 | pragma Inline (Set_Parameter_Associations); | |
8848 | pragma Inline (Set_Parameter_Specifications); | |
8849 | pragma Inline (Set_Parameter_List_Truncated); | |
8850 | pragma Inline (Set_Parameter_Type); | |
8851 | pragma Inline (Set_Parent_Spec); | |
8852 | pragma Inline (Set_Position); | |
8853 | pragma Inline (Set_Pragma_Argument_Associations); | |
8854 | pragma Inline (Set_Pragmas_After); | |
8855 | pragma Inline (Set_Pragmas_Before); | |
8856 | pragma Inline (Set_Prefix); | |
8857 | pragma Inline (Set_Present_Expr); | |
8858 | pragma Inline (Set_Prev_Ids); | |
8859 | pragma Inline (Set_Print_In_Hex); | |
8860 | pragma Inline (Set_Private_Declarations); | |
8861 | pragma Inline (Set_Private_Present); | |
8862 | pragma Inline (Set_Procedure_To_Call); | |
8863 | pragma Inline (Set_Proper_Body); | |
8864 | pragma Inline (Set_Protected_Definition); | |
8865 | pragma Inline (Set_Protected_Present); | |
8866 | pragma Inline (Set_Raises_Constraint_Error); | |
8867 | pragma Inline (Set_Range_Constraint); | |
8868 | pragma Inline (Set_Range_Expression); | |
996ae0b0 | 8869 | pragma Inline (Set_Real_Range_Specification); |
07fc65c4 GB |
8870 | pragma Inline (Set_Realval); |
8871 | pragma Inline (Set_Reason); | |
996ae0b0 RK |
8872 | pragma Inline (Set_Record_Extension_Part); |
8873 | pragma Inline (Set_Redundant_Use); | |
8874 | pragma Inline (Set_Return_Type); | |
8875 | pragma Inline (Set_Reverse_Present); | |
8876 | pragma Inline (Set_Right_Opnd); | |
8877 | pragma Inline (Set_Rounded_Result); | |
8878 | pragma Inline (Set_Scope); | |
8879 | pragma Inline (Set_Select_Alternatives); | |
8880 | pragma Inline (Set_Selector_Name); | |
8881 | pragma Inline (Set_Selector_Names); | |
8882 | pragma Inline (Set_Shift_Count_OK); | |
8883 | pragma Inline (Set_Source_Type); | |
8884 | pragma Inline (Set_Specification); | |
8885 | pragma Inline (Set_Statements); | |
8886 | pragma Inline (Set_Static_Processing_OK); | |
8887 | pragma Inline (Set_Storage_Pool); | |
8888 | pragma Inline (Set_Strval); | |
8889 | pragma Inline (Set_Subtype_Indication); | |
8890 | pragma Inline (Set_Subtype_Mark); | |
8891 | pragma Inline (Set_Subtype_Marks); | |
8892 | pragma Inline (Set_Tagged_Present); | |
8893 | pragma Inline (Set_Target_Type); | |
8894 | pragma Inline (Set_Task_Body_Procedure); | |
8895 | pragma Inline (Set_Task_Definition); | |
8896 | pragma Inline (Set_Then_Actions); | |
8897 | pragma Inline (Set_Then_Statements); | |
8898 | pragma Inline (Set_Triggering_Alternative); | |
8899 | pragma Inline (Set_Triggering_Statement); | |
8900 | pragma Inline (Set_Treat_Fixed_As_Integer); | |
8901 | pragma Inline (Set_TSS_Elist); | |
8902 | pragma Inline (Set_Type_Definition); | |
8903 | pragma Inline (Set_Unit); | |
8904 | pragma Inline (Set_Unknown_Discriminants_Present); | |
8905 | pragma Inline (Set_Unreferenced_In_Spec); | |
8906 | pragma Inline (Set_Variant_Part); | |
8907 | pragma Inline (Set_Variants); | |
8908 | pragma Inline (Set_Visible_Declarations); | |
8909 | pragma Inline (Set_Was_Originally_Stub); | |
8910 | pragma Inline (Set_Zero_Cost_Handling); | |
8911 | ||
8912 | end Sinfo; |