1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- A T R E E -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- 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 3, 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. -- 17-- -- 18-- As a special exception under Section 7 of GPL version 3, you are granted -- 19-- additional permissions described in the GCC Runtime Library Exception, -- 20-- version 3.1, as published by the Free Software Foundation. -- 21-- -- 22-- You should have received a copy of the GNU General Public License and -- 23-- a copy of the GCC Runtime Library Exception along with this program; -- 24-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- 25-- <http://www.gnu.org/licenses/>. -- 26-- -- 27-- GNAT was originally developed by the GNAT team at New York University. -- 28-- Extensive contributions were provided by Ada Core Technologies Inc. -- 29-- -- 30------------------------------------------------------------------------------ 31 32with Alloc; 33with Sinfo; use Sinfo; 34with Einfo; use Einfo; 35with Namet; use Namet; 36with Types; use Types; 37with Snames; use Snames; 38with System; use System; 39with Table; 40with Uintp; use Uintp; 41with Urealp; use Urealp; 42with Unchecked_Conversion; 43 44package Atree is 45 46-- This package defines the format of the tree used to represent the Ada 47-- program internally. Syntactic and semantic information is combined in 48-- this tree. There is no separate symbol table structure. 49 50-- WARNING: There is a C version of this package. Any changes to this 51-- source file must be properly reflected in the C header file atree.h 52 53-- Package Atree defines the basic structure of the tree and its nodes and 54-- provides the basic abstract interface for manipulating the tree. Two 55-- other packages use this interface to define the representation of Ada 56-- programs using this tree format. The package Sinfo defines the basic 57-- representation of the syntactic structure of the program, as output 58-- by the parser. The package Entity_Info defines the semantic information 59-- which is added to the tree nodes that represent declared entities (i.e. 60-- the information which might typically be described in a separate symbol 61-- table structure). 62 63-- The front end of the compiler first parses the program and generates a 64-- tree that is simply a syntactic representation of the program in abstract 65-- syntax tree format. Subsequent processing in the front end traverses the 66-- tree, transforming it in various ways and adding semantic information. 67 68 ---------------------- 69 -- Size of Entities -- 70 ---------------------- 71 72 -- Currently entities are composed of 6 sequentially allocated 32-byte 73 -- nodes, considered as a single record. The following definition gives 74 -- the number of extension nodes. 75 76 Num_Extension_Nodes : Int := 5; 77 -- This value is increased by one if debug flag -gnatd.N is set. This is 78 -- for testing performance impact of adding a new extension node. 79 80 ---------------------------------------- 81 -- Definitions of Fields in Tree Node -- 82 ---------------------------------------- 83 84 -- The representation of the tree is completely hidden, using a functional 85 -- interface for accessing and modifying the contents of nodes. Logically 86 -- a node contains a number of fields, much as though the nodes were 87 -- defined as a record type. The fields in a node are as follows: 88 89 -- Nkind Indicates the kind of the node. This field is present 90 -- in all nodes. The type is Node_Kind, which is declared 91 -- in the package Sinfo. 92 93 -- Sloc Location (Source_Ptr) of the corresponding token 94 -- in the Source buffer. The individual node definitions 95 -- show which token is referenced by this pointer. 96 97 -- In_List A flag used to indicate if the node is a member 98 -- of a node list. 99 100 -- Rewrite_Ins A flag set if a node is marked as a rewrite inserted 101 -- node as a result of a call to Mark_Rewrite_Insertion. 102 103 -- Paren_Count A 2-bit count used in sub-expression nodes to indicate 104 -- the level of parentheses. The settings are 0,1,2 and 105 -- 3 for many. If the value is 3, then an auxiliary table 106 -- is used to indicate the real value. Set to zero for 107 -- non-subexpression nodes. 108 109 -- Note: the required parentheses surrounding conditional 110 -- and quantified expressions count as a level of parens 111 -- for this purpose, so e.g. in X := (if A then B else C); 112 -- Paren_Count for the right side will be 1. 113 114 -- Comes_From_Source 115 -- This flag is present in all nodes. It is set if the 116 -- node is built by the scanner or parser, and clear if 117 -- the node is built by the analyzer or expander. It 118 -- indicates that the node corresponds to a construct 119 -- that appears in the original source program. 120 121 -- Analyzed This flag is present in all nodes. It is set when 122 -- a node is analyzed, and is used to avoid analyzing 123 -- the same node twice. Analysis includes expansion if 124 -- expansion is active, so in this case if the flag is 125 -- set it means the node has been analyzed and expanded. 126 127 -- Error_Posted This flag is present in all nodes. It is set when 128 -- an error message is posted which is associated with 129 -- the flagged node. This is used to avoid posting more 130 -- than one message on the same node. 131 132 -- Field1 133 -- Field2 134 -- Field3 135 -- Field4 136 -- Field5 Five fields holding Union_Id values 137 138 -- ElistN Synonym for FieldN typed as Elist_Id (Empty = No_Elist) 139 -- ListN Synonym for FieldN typed as List_Id 140 -- NameN Synonym for FieldN typed as Name_Id 141 -- NodeN Synonym for FieldN typed as Node_Id 142 -- StrN Synonym for FieldN typed as String_Id 143 -- UintN Synonym for FieldN typed as Uint (Empty = Uint_0) 144 -- UrealN Synonym for FieldN typed as Ureal 145 146 -- Note: in the case of ElistN and UintN fields, it is common that we 147 -- end up with a value of Union_Id'(0) as the default value. This value 148 -- is meaningless as a Uint or Elist_Id value. We have two choices here. 149 -- We could require that all Uint and Elist fields be initialized to an 150 -- appropriate value, but that's error prone, since it would be easy to 151 -- miss an initialization. So instead we have the retrieval functions 152 -- generate an appropriate default value (Uint_0 or No_Elist). Probably 153 -- it would be cleaner to generate No_Uint in the Uint case but we got 154 -- stuck with representing an "unset" size value as zero early on, and 155 -- it will take a bit of fiddling to change that ??? 156 157 -- Note: the actual usage of FieldN (i.e. whether it contains a Elist_Id, 158 -- List_Id, Name_Id, Node_Id, String_Id, Uint or Ureal) depends on the 159 -- value in Nkind. Generally the access to this field is always via the 160 -- functional interface, so the field names ElistN, ListN, NameN, NodeN, 161 -- StrN, UintN and UrealN are used only in the bodies of the access 162 -- functions (i.e. in the bodies of Sinfo and Einfo). These access 163 -- functions contain debugging code that checks that the use is 164 -- consistent with Nkind and Ekind values. 165 166 -- However, in specialized circumstances (examples are the circuit in 167 -- generic instantiation to copy trees, and in the tree dump routine), 168 -- it is useful to be able to do untyped traversals, and an internal 169 -- package in Atree allows for direct untyped accesses in such cases. 170 171 -- Flag4 Fifteen Boolean flags (use depends on Nkind and 172 -- Flag5 Ekind, as described for FieldN). Again the access 173 -- Flag6 is usually via subprograms in Sinfo and Einfo which 174 -- Flag7 provide high-level synonyms for these flags, and 175 -- Flag8 contain debugging code that checks that the values 176 -- Flag9 in Nkind and Ekind are appropriate for the access. 177 -- Flag10 178 -- Flag11 Note that Flag1-3 are missing from this list. For 179 -- Flag12 historical reasons, these flag names are unused. 180 -- Flag13 181 -- Flag14 182 -- Flag15 183 -- Flag16 184 -- Flag17 185 -- Flag18 186 187 -- Link For a node, points to the Parent. For a list, points 188 -- to the list header. Note that in the latter case, a 189 -- client cannot modify the link field. This field is 190 -- private to the Atree package (but is also modified 191 -- by the Nlists package). 192 193 -- The following additional fields are present in extended nodes used 194 -- for entities (Nkind in N_Entity). 195 196 -- Ekind Entity type. This field indicates the type of the 197 -- entity, it is of type Entity_Kind which is defined 198 -- in package Einfo. 199 200 -- Flag19 299 additional flags 201 -- ... 202 -- Flag317 203 204 -- Convention Entity convention (Convention_Id value) 205 206 -- Field6 Additional Union_Id value stored in tree 207 208 -- Node6 Synonym for Field6 typed as Node_Id 209 -- Elist6 Synonym for Field6 typed as Elist_Id (Empty = No_Elist) 210 -- Uint6 Synonym for Field6 typed as Uint (Empty = Uint_0) 211 212 -- Similar definitions for Field7 to Field35 (and also Node7-Node35, 213 -- Elist7-Elist35, Uint7-Uint35, Ureal7-Ureal35). Note that not all 214 -- these functions are defined, only the ones that are actually used. 215 216 function Last_Node_Id return Node_Id; 217 pragma Inline (Last_Node_Id); 218 -- Returns Id of last allocated node Id 219 220 function Nodes_Address return System.Address; 221 -- Return address of Nodes table (used in Back_End for Gigi call) 222 223 function Num_Nodes return Nat; 224 -- Total number of nodes allocated, where an entity counts as a single 225 -- node. This count is incremented every time a node or entity is 226 -- allocated, and decremented every time a node or entity is deleted. 227 -- This value is used by Xref and by Treepr to allocate hash tables of 228 -- suitable size for hashing Node_Id values. 229 230 ----------------------- 231 -- Use of Empty Node -- 232 ----------------------- 233 234 -- The special Node_Id Empty is used to mark missing fields. Whenever the 235 -- syntax has an optional component, then the corresponding field will be 236 -- set to Empty if the component is missing. 237 238 -- Note: Empty is not used to describe an empty list. Instead in this 239 -- case the node field contains a list which is empty, and these cases 240 -- should be distinguished (essentially from a type point of view, Empty 241 -- is a Node, and is thus not a list). 242 243 -- Note: Empty does in fact correspond to an allocated node. Only the 244 -- Nkind field of this node may be referenced. It contains N_Empty, which 245 -- uniquely identifies the empty case. This allows the Nkind field to be 246 -- dereferenced before the check for Empty which is sometimes useful. 247 248 ----------------------- 249 -- Use of Error Node -- 250 ----------------------- 251 252 -- The Error node is used during syntactic and semantic analysis to 253 -- indicate that the corresponding piece of syntactic structure or 254 -- semantic meaning cannot properly be represented in the tree because 255 -- of an illegality in the program. 256 257 -- If an Error node is encountered, then you know that a previous 258 -- illegality has been detected. The proper reaction should be to 259 -- avoid posting related cascaded error messages, and to propagate 260 -- the error node if necessary. 261 262 ------------------------ 263 -- Current_Error_Node -- 264 ------------------------ 265 266 -- The current error node is a global location indicating the current 267 -- node that is being processed for the purposes of placing a compiler 268 -- abort message. This is not necessarily perfectly accurate, it is 269 -- just a reasonably accurate best guess. It is used to output the 270 -- source location in the abort message by Comperr, and also to 271 -- implement the d3 debugging flag. This is also used by Rtsfind 272 -- to generate error messages for high integrity mode. 273 274 -- There are two ways this gets set. During parsing, when new source 275 -- nodes are being constructed by calls to New_Node and New_Entity, 276 -- either one of these calls sets Current_Error_Node to the newly 277 -- created node. During semantic analysis, this mechanism is not 278 -- used, and instead Current_Error_Node is set by the subprograms in 279 -- Debug_A that mark the start and end of analysis/expansion of a 280 -- node in the tree. 281 282 Current_Error_Node : Node_Id; 283 -- Node to place error messages 284 285 ------------------ 286 -- Error Counts -- 287 ------------------ 288 289 -- The following variables denote the count of errors of various kinds 290 -- detected in the tree. Note that these might be more logically located 291 -- in Err_Vars, but we put it to deal with licensing issues (we need this 292 -- to have the GPL exception licensing, since Check_Error_Detected can 293 -- be called from units with this licensing). 294 295 Serious_Errors_Detected : Nat := 0; 296 -- This is a count of errors that are serious enough to stop expansion, 297 -- and hence to prevent generation of an object file even if the 298 -- switch -gnatQ is set. Initialized to zero at the start of compilation. 299 -- Initialized for -gnatVa use, see comment above. 300 301 Total_Errors_Detected : Nat := 0; 302 -- Number of errors detected so far. Includes count of serious errors and 303 -- non-serious errors, so this value is always greater than or equal to the 304 -- Serious_Errors_Detected value. Initialized to zero at the start of 305 -- compilation. Initialized for -gnatVa use, see comment above. 306 307 Warnings_Detected : Nat := 0; 308 -- Number of warnings detected. Initialized to zero at the start of 309 -- compilation. Initialized for -gnatVa use, see comment above. 310 311 Configurable_Run_Time_Violations : Nat := 0; 312 -- Count of configurable run time violations so far. This is used to 313 -- suppress certain cascaded error messages when we know that we may not 314 -- have fully expanded some items, due to high integrity violations (e.g. 315 -- the use of constructs not permitted by the library in use, or improper 316 -- constructs in No_Run_Time mode). 317 318 procedure Check_Error_Detected; 319 -- When an anomaly is found in the tree, many semantic routines silently 320 -- bail out, assuming that the anomaly was caused by a previously detected 321 -- serious error (or configurable run time violation). This routine should 322 -- be called in these cases, and will raise an exception if no such error 323 -- has been detected. This ensure that the anomaly is never allowed to go 324 -- unnoticed. 325 326 ------------------------------- 327 -- Default Setting of Fields -- 328 ------------------------------- 329 330 -- Nkind is set to N_Unused_At_Start 331 332 -- Ekind is set to E_Void 333 334 -- Sloc is always set, there is no default value 335 336 -- Field1-5 fields are set to Empty 337 338 -- Field6-35 fields in extended nodes are set to Empty 339 340 -- Parent is set to Empty 341 342 -- All Boolean flag fields are set to False 343 344 -- Note: the value Empty is used in Field1-Field35 to indicate a null node. 345 -- The usage varies. The common uses are to indicate absence of an optional 346 -- clause or a completely unused Field1-35 field. 347 348 ------------------------------------- 349 -- Use of Synonyms for Node Fields -- 350 ------------------------------------- 351 352 -- A subpackage Atree.Unchecked_Access provides routines for reading and 353 -- writing the fields defined above (Field1-35, Node1-35, Flag4-317 etc). 354 -- These unchecked access routines can be used for untyped traversals. 355 -- In addition they are used in the implementations of the Sinfo and 356 -- Einfo packages. These packages both provide logical synonyms for 357 -- the generic fields, together with an appropriate set of access routines. 358 -- Normally access to information within tree nodes uses these synonyms, 359 -- providing a high level typed interface to the tree information. 360 361 -------------------------------------------------- 362 -- Node Allocation and Modification Subprograms -- 363 -------------------------------------------------- 364 365 -- Generally the parser builds the tree and then it is further decorated 366 -- (e.g. by setting the entity fields), but not fundamentally modified. 367 -- However, there are cases in which the tree must be restructured by 368 -- adding and rearranging nodes, as a result of disambiguating cases 369 -- which the parser could not parse correctly, and adding additional 370 -- semantic information (e.g. making constraint checks explicit). The 371 -- following subprograms are used for constructing the tree in the first 372 -- place, and then for subsequent modifications as required. 373 374 procedure Initialize; 375 -- Called at the start of compilation to initialize the allocation of 376 -- the node and list tables and make the standard entries for Empty, 377 -- Error and Error_List. Note that Initialize must not be called if 378 -- Tree_Read is used. 379 380 procedure Lock; 381 -- Called before the back end is invoked to lock the nodes table 382 -- Also called after Unlock to relock??? 383 384 procedure Unlock; 385 -- Unlocks nodes table, in cases where the back end needs to modify it 386 387 procedure Tree_Read; 388 -- Initializes internal tables from current tree file using the relevant 389 -- Table.Tree_Read routines. Note that Initialize should not be called if 390 -- Tree_Read is used. Tree_Read includes all necessary initialization. 391 392 procedure Tree_Write; 393 -- Writes out internal tables to current tree file using the relevant 394 -- Table.Tree_Write routines. 395 396 function New_Node 397 (New_Node_Kind : Node_Kind; 398 New_Sloc : Source_Ptr) return Node_Id; 399 -- Allocates a completely new node with the given node type and source 400 -- location values. All other fields are set to their standard defaults: 401 -- 402 -- Empty for all FieldN fields 403 -- False for all FlagN fields 404 -- 405 -- The usual approach is to build a new node using this function and 406 -- then, using the value returned, use the Set_xxx functions to set 407 -- fields of the node as required. New_Node can only be used for 408 -- non-entity nodes, i.e. it never generates an extended node. 409 -- 410 -- If we are currently parsing, as indicated by a previous call to 411 -- Set_Comes_From_Source_Default (True), then this call also resets 412 -- the value of Current_Error_Node. 413 414 function New_Entity 415 (New_Node_Kind : Node_Kind; 416 New_Sloc : Source_Ptr) return Entity_Id; 417 -- Similar to New_Node, except that it is used only for entity nodes 418 -- and returns an extended node. 419 420 procedure Set_Comes_From_Source_Default (Default : Boolean); 421 -- Sets value of Comes_From_Source flag to be used in all subsequent 422 -- New_Node and New_Entity calls until another call to this procedure 423 -- changes the default. This value is set True during parsing and 424 -- False during semantic analysis. This is also used to determine 425 -- if New_Node and New_Entity should set Current_Error_Node. 426 427 function Get_Comes_From_Source_Default return Boolean; 428 pragma Inline (Get_Comes_From_Source_Default); 429 -- Gets the current value of the Comes_From_Source flag 430 431 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id); 432 pragma Inline (Preserve_Comes_From_Source); 433 -- When a node is rewritten, it is sometimes appropriate to preserve the 434 -- original comes from source indication. This is true when the rewrite 435 -- essentially corresponds to a transformation corresponding exactly to 436 -- semantics in the reference manual. This procedure copies the setting 437 -- of Comes_From_Source from OldN to NewN. 438 439 function Has_Extension (N : Node_Id) return Boolean; 440 pragma Inline (Has_Extension); 441 -- Returns True if the given node has an extension (i.e. was created by 442 -- a call to New_Entity rather than New_Node, and Nkind is in N_Entity) 443 444 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind); 445 -- This procedure replaces the given node by setting its Nkind field to 446 -- the indicated value and resetting all other fields to their default 447 -- values except for Sloc, which is unchanged, and the Parent pointer 448 -- and list links, which are also unchanged. All other information in 449 -- the original node is lost. The new node has an extension if the 450 -- original node had an extension. 451 452 procedure Copy_Node (Source : Node_Id; Destination : Node_Id); 453 -- Copy the entire contents of the source node to the destination node. 454 -- The contents of the source node is not affected. If the source node 455 -- has an extension, then the destination must have an extension also. 456 -- The parent pointer of the destination and its list link, if any, are 457 -- not affected by the copy. Note that parent pointers of descendents 458 -- are not adjusted, so the descendents of the destination node after 459 -- the Copy_Node is completed have dubious parent pointers. Note that 460 -- this routine does NOT copy aspect specifications, the Has_Aspects 461 -- flag in the returned node will always be False. The caller must deal 462 -- with copying aspect specifications where this is required. 463 464 function New_Copy (Source : Node_Id) return Node_Id; 465 -- This function allocates a completely new node, and then initializes it 466 -- by copying the contents of the source node into it. The contents of the 467 -- source node is not affected. The target node is always marked as not 468 -- being in a list (even if the source is a list member). The new node will 469 -- have an extension if the source has an extension. New_Copy (Empty) 470 -- returns Empty and New_Copy (Error) returns Error. Note that, unlike 471 -- Copy_Separate_Tree, New_Copy does not recursively copy any descendents, 472 -- so in general parent pointers are not set correctly for the descendents 473 -- of the copied node. Both normal and extended nodes (entities) may be 474 -- copied using New_Copy. 475 476 function Relocate_Node (Source : Node_Id) return Node_Id; 477 -- Source is a non-entity node that is to be relocated. A new node is 478 -- allocated and the contents of Source are copied to this node using 479 -- Copy_Node. The parent pointers of descendents of the node are then 480 -- adjusted to point to the relocated copy. The original node is not 481 -- modified, but the parent pointers of its descendents are no longer 482 -- valid. This routine is used in conjunction with the tree rewrite 483 -- routines (see descriptions of Replace/Rewrite). 484 -- 485 -- Note that the resulting node has the same parent as the source node, and 486 -- is thus still attached to the tree. It is valid for Source to be Empty, 487 -- in which case Relocate_Node simply returns Empty as the result. 488 489 function Copy_Separate_Tree (Source : Node_Id) return Node_Id; 490 -- Given a node that is the root of a subtree, Copy_Separate_Tree copies 491 -- the entire syntactic subtree, including recursively any descendants 492 -- whose parent field references a copied node (descendants not linked to 493 -- a copied node by the parent field are also copied.) The parent pointers 494 -- in the copy are properly set. Copy_Separate_Tree (Empty/Error) returns 495 -- Empty/Error. The new subtree does not share entities with the source, 496 -- but has new entities with the same name. Most of the time this routine 497 -- is called on an unanalyzed tree, and no semantic information is copied. 498 -- However, to ensure that no entities are shared between the two when the 499 -- source is already analyzed, entity fields in the copy are zeroed out. 500 501 function Copy_Separate_List (Source : List_Id) return List_Id; 502 -- Applies Copy_Separate_Tree to each element of the Source list, returning 503 -- a new list of the results of these copy operations. 504 505 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id); 506 -- Exchange the contents of two entities. The parent pointers are switched 507 -- as well as the Defining_Identifier fields in the parents, so that the 508 -- entities point correctly to their original parents. The effect is thus 509 -- to leave the tree completely unchanged in structure, except that the 510 -- entity ID values of the two entities are interchanged. Neither of the 511 -- two entities may be list members. Note that entities appear on two 512 -- semantic chains: Homonym and Next_Entity: the corresponding links must 513 -- be adjusted by the caller, according to context. 514 515 function Extend_Node (Node : Node_Id) return Entity_Id; 516 -- This function returns a copy of its input node with an extension added. 517 -- The fields of the extension are set to Empty. Due to the way extensions 518 -- are handled (as four consecutive array elements), it may be necessary 519 -- to reallocate the node, so that the returned value is not the same as 520 -- the input value, but where possible the returned value will be the same 521 -- as the input value (i.e. the extension will occur in place). It is the 522 -- caller's responsibility to ensure that any pointers to the original node 523 -- are appropriately updated. This function is used only by Sinfo.CN to 524 -- change nodes into their corresponding entities. 525 526 type Report_Proc is access procedure (Target : Node_Id; Source : Node_Id); 527 528 procedure Set_Reporting_Proc (P : Report_Proc); 529 -- Register a procedure that is invoked when a node is allocated, replaced 530 -- or rewritten. 531 532 type Traverse_Result is (Abandon, OK, OK_Orig, Skip); 533 -- This is the type of the result returned by the Process function passed 534 -- to Traverse_Func and Traverse_Proc. See below for details. 535 536 subtype Traverse_Final_Result is Traverse_Result range Abandon .. OK; 537 -- This is the type of the final result returned Traverse_Func, based on 538 -- the results of Process calls. See below for details. 539 540 generic 541 with function Process (N : Node_Id) return Traverse_Result is <>; 542 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result; 543 -- This is a generic function that, given the parent node for a subtree, 544 -- traverses all syntactic nodes of this tree, calling the given function 545 -- Process on each one, in pre order (i.e. top-down). The order of 546 -- traversing subtrees is arbitrary. The traversal is controlled as follows 547 -- by the result returned by Process: 548 549 -- OK The traversal continues normally with the syntactic 550 -- children of the node just processed. 551 552 -- OK_Orig The traversal continues normally with the syntactic 553 -- children of the original node of the node just processed. 554 555 -- Skip The children of the node just processed are skipped and 556 -- excluded from the traversal, but otherwise processing 557 -- continues elsewhere in the tree. 558 559 -- Abandon The entire traversal is immediately abandoned, and the 560 -- original call to Traverse returns Abandon. 561 562 -- The result returned by Traverse is Abandon if processing was terminated 563 -- by a call to Process returning Abandon, otherwise it is OK (meaning that 564 -- all calls to process returned either OK, OK_Orig, or Skip). 565 566 generic 567 with function Process (N : Node_Id) return Traverse_Result is <>; 568 procedure Traverse_Proc (Node : Node_Id); 569 pragma Inline (Traverse_Proc); 570 -- This is the same as Traverse_Func except that no result is returned, 571 -- i.e. Traverse_Func is called and the result is simply discarded. 572 573 --------------------------- 574 -- Node Access Functions -- 575 --------------------------- 576 577 -- The following functions return the contents of the indicated field of 578 -- the node referenced by the argument, which is a Node_Id. 579 580 function Nkind (N : Node_Id) return Node_Kind; 581 pragma Inline (Nkind); 582 583 function Analyzed (N : Node_Id) return Boolean; 584 pragma Inline (Analyzed); 585 586 function Has_Aspects (N : Node_Id) return Boolean; 587 pragma Inline (Has_Aspects); 588 589 function Comes_From_Source (N : Node_Id) return Boolean; 590 pragma Inline (Comes_From_Source); 591 592 function Error_Posted (N : Node_Id) return Boolean; 593 pragma Inline (Error_Posted); 594 595 function Sloc (N : Node_Id) return Source_Ptr; 596 pragma Inline (Sloc); 597 598 function Paren_Count (N : Node_Id) return Nat; 599 pragma Inline (Paren_Count); 600 601 function Parent (N : Node_Id) return Node_Id; 602 pragma Inline (Parent); 603 -- Returns the parent of a node if the node is not a list member, or else 604 -- the parent of the list containing the node if the node is a list member. 605 606 function No (N : Node_Id) return Boolean; 607 pragma Inline (No); 608 -- Tests given Id for equality with the Empty node. This allows notations 609 -- like "if No (Variant_Part)" as opposed to "if Variant_Part = Empty". 610 611 function Present (N : Node_Id) return Boolean; 612 pragma Inline (Present); 613 -- Tests given Id for inequality with the Empty node. This allows notations 614 -- like "if Present (Statement)" as opposed to "if Statement /= Empty". 615 616 --------------------- 617 -- Node_Kind Tests -- 618 --------------------- 619 620 -- These are like the functions in Sinfo, but the first argument is a 621 -- Node_Id, and the tested field is Nkind (N). 622 623 function Nkind_In 624 (N : Node_Id; 625 V1 : Node_Kind; 626 V2 : Node_Kind) return Boolean; 627 628 function Nkind_In 629 (N : Node_Id; 630 V1 : Node_Kind; 631 V2 : Node_Kind; 632 V3 : Node_Kind) return Boolean; 633 634 function Nkind_In 635 (N : Node_Id; 636 V1 : Node_Kind; 637 V2 : Node_Kind; 638 V3 : Node_Kind; 639 V4 : Node_Kind) return Boolean; 640 641 function Nkind_In 642 (N : Node_Id; 643 V1 : Node_Kind; 644 V2 : Node_Kind; 645 V3 : Node_Kind; 646 V4 : Node_Kind; 647 V5 : Node_Kind) return Boolean; 648 649 function Nkind_In 650 (N : Node_Id; 651 V1 : Node_Kind; 652 V2 : Node_Kind; 653 V3 : Node_Kind; 654 V4 : Node_Kind; 655 V5 : Node_Kind; 656 V6 : Node_Kind) return Boolean; 657 658 function Nkind_In 659 (N : Node_Id; 660 V1 : Node_Kind; 661 V2 : Node_Kind; 662 V3 : Node_Kind; 663 V4 : Node_Kind; 664 V5 : Node_Kind; 665 V6 : Node_Kind; 666 V7 : Node_Kind) return Boolean; 667 668 function Nkind_In 669 (N : Node_Id; 670 V1 : Node_Kind; 671 V2 : Node_Kind; 672 V3 : Node_Kind; 673 V4 : Node_Kind; 674 V5 : Node_Kind; 675 V6 : Node_Kind; 676 V7 : Node_Kind; 677 V8 : Node_Kind) return Boolean; 678 679 function Nkind_In 680 (N : Node_Id; 681 V1 : Node_Kind; 682 V2 : Node_Kind; 683 V3 : Node_Kind; 684 V4 : Node_Kind; 685 V5 : Node_Kind; 686 V6 : Node_Kind; 687 V7 : Node_Kind; 688 V8 : Node_Kind; 689 V9 : Node_Kind) return Boolean; 690 691 pragma Inline (Nkind_In); 692 -- Inline all above functions 693 694 ----------------------- 695 -- Entity_Kind_Tests -- 696 ----------------------- 697 698 -- Utility functions to test whether an Entity_Kind value, either given 699 -- directly as the first argument, or the Ekind field of an Entity give 700 -- as the first argument, matches any of the given list of Entity_Kind 701 -- values. Return True if any match, False if no match. 702 703 function Ekind_In 704 (E : Entity_Id; 705 V1 : Entity_Kind; 706 V2 : Entity_Kind) return Boolean; 707 708 function Ekind_In 709 (E : Entity_Id; 710 V1 : Entity_Kind; 711 V2 : Entity_Kind; 712 V3 : Entity_Kind) return Boolean; 713 714 function Ekind_In 715 (E : Entity_Id; 716 V1 : Entity_Kind; 717 V2 : Entity_Kind; 718 V3 : Entity_Kind; 719 V4 : Entity_Kind) return Boolean; 720 721 function Ekind_In 722 (E : Entity_Id; 723 V1 : Entity_Kind; 724 V2 : Entity_Kind; 725 V3 : Entity_Kind; 726 V4 : Entity_Kind; 727 V5 : Entity_Kind) return Boolean; 728 729 function Ekind_In 730 (E : Entity_Id; 731 V1 : Entity_Kind; 732 V2 : Entity_Kind; 733 V3 : Entity_Kind; 734 V4 : Entity_Kind; 735 V5 : Entity_Kind; 736 V6 : Entity_Kind) return Boolean; 737 738 function Ekind_In 739 (T : Entity_Kind; 740 V1 : Entity_Kind; 741 V2 : Entity_Kind) return Boolean; 742 743 function Ekind_In 744 (T : Entity_Kind; 745 V1 : Entity_Kind; 746 V2 : Entity_Kind; 747 V3 : Entity_Kind) return Boolean; 748 749 function Ekind_In 750 (T : Entity_Kind; 751 V1 : Entity_Kind; 752 V2 : Entity_Kind; 753 V3 : Entity_Kind; 754 V4 : Entity_Kind) return Boolean; 755 756 function Ekind_In 757 (T : Entity_Kind; 758 V1 : Entity_Kind; 759 V2 : Entity_Kind; 760 V3 : Entity_Kind; 761 V4 : Entity_Kind; 762 V5 : Entity_Kind) return Boolean; 763 764 function Ekind_In 765 (T : Entity_Kind; 766 V1 : Entity_Kind; 767 V2 : Entity_Kind; 768 V3 : Entity_Kind; 769 V4 : Entity_Kind; 770 V5 : Entity_Kind; 771 V6 : Entity_Kind) return Boolean; 772 773 pragma Inline (Ekind_In); 774 -- Inline all above functions 775 776 ----------------------------- 777 -- Entity Access Functions -- 778 ----------------------------- 779 780 -- The following functions apply only to Entity_Id values, i.e. 781 -- to extended nodes. 782 783 function Ekind (E : Entity_Id) return Entity_Kind; 784 pragma Inline (Ekind); 785 786 function Convention (E : Entity_Id) return Convention_Id; 787 pragma Inline (Convention); 788 789 ---------------------------- 790 -- Node Update Procedures -- 791 ---------------------------- 792 793 -- The following functions set a specified field in the node whose Id is 794 -- passed as the first argument. The second parameter is the new value 795 -- to be set in the specified field. Note that Set_Nkind is in the next 796 -- section, since its use is restricted. 797 798 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr); 799 pragma Inline (Set_Sloc); 800 801 procedure Set_Paren_Count (N : Node_Id; Val : Nat); 802 pragma Inline (Set_Paren_Count); 803 804 procedure Set_Parent (N : Node_Id; Val : Node_Id); 805 pragma Inline (Set_Parent); 806 807 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True); 808 pragma Inline (Set_Analyzed); 809 810 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True); 811 pragma Inline (Set_Error_Posted); 812 813 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean); 814 pragma Inline (Set_Comes_From_Source); 815 -- Note that this routine is very rarely used, since usually the 816 -- default mechanism provided sets the right value, but in some 817 -- unusual cases, the value needs to be reset (e.g. when a source 818 -- node is copied, and the copy must not have Comes_From_Source set). 819 820 procedure Set_Has_Aspects (N : Node_Id; Val : Boolean := True); 821 pragma Inline (Set_Has_Aspects); 822 823 procedure Set_Original_Node (N : Node_Id; Val : Node_Id); 824 pragma Inline (Set_Original_Node); 825 -- Note that this routine is used only in very peculiar cases. In normal 826 -- cases, the Original_Node link is set by calls to Rewrite. We currently 827 -- use it in ASIS mode to manually set the link from pragma expressions 828 -- to their aspect original source expressions, so that the original source 829 -- expressions accessed by ASIS are also semantically analyzed. 830 831 ------------------------------ 832 -- Entity Update Procedures -- 833 ------------------------------ 834 835 -- The following procedures apply only to Entity_Id values, i.e. 836 -- to extended nodes. 837 838 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id); 839 pragma Inline (Basic_Set_Convention); 840 -- Clients should use Sem_Util.Set_Convention rather than calling this 841 -- routine directly, as Set_Convention also deals with the special 842 -- processing required for access types. 843 844 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind); 845 pragma Inline (Set_Ekind); 846 847 --------------------------- 848 -- Tree Rewrite Routines -- 849 --------------------------- 850 851 -- During the compilation process it is necessary in a number of situations 852 -- to rewrite the tree. In some cases, such rewrites do not affect the 853 -- structure of the tree, for example, when an indexed component node is 854 -- replaced by the corresponding call node (the parser cannot distinguish 855 -- between these two cases). 856 857 -- In other situations, the rewrite does affect the structure of the 858 -- tree. Examples are the replacement of a generic instantiation by the 859 -- instantiated spec and body, and the static evaluation of expressions. 860 861 -- If such structural modifications are done by the expander, there are 862 -- no difficulties, since the form of the tree after the expander has no 863 -- special significance, except as input to the backend of the compiler. 864 -- However, if these modifications are done by the semantic phase, then 865 -- it is important that they be done in a manner which allows the original 866 -- tree to be preserved. This is because tools like pretty printers need 867 -- to have this original tree structure available. 868 869 -- The subprograms in this section allow rewriting of the tree by either 870 -- insertion of new nodes in an existing list, or complete replacement of 871 -- a subtree. The resulting tree for most purposes looks as though it has 872 -- been really changed, and there is no trace of the original. However, 873 -- special subprograms, also defined in this section, allow the original 874 -- tree to be reconstructed if necessary. 875 876 -- For tree modifications done in the expander, it is permissible to 877 -- destroy the original tree, although it is also allowable to use the 878 -- tree rewrite routines where it is convenient to do so. 879 880 procedure Mark_Rewrite_Insertion (New_Node : Node_Id); 881 pragma Inline (Mark_Rewrite_Insertion); 882 -- This procedure marks the given node as an insertion made during a tree 883 -- rewriting operation. Only the root needs to be marked. The call does 884 -- not do the actual insertion, which must be done using one of the normal 885 -- list insertion routines. The node is treated normally in all respects 886 -- except for its response to Is_Rewrite_Insertion. The function of these 887 -- calls is to be able to get an accurate original tree. This helps the 888 -- accuracy of Sprint.Sprint_Node, and in particular, when stubs are being 889 -- generated, it is essential that the original tree be accurate. 890 891 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean; 892 pragma Inline (Is_Rewrite_Insertion); 893 -- Tests whether the given node was marked using Mark_Rewrite_Insertion. 894 -- This is used in reconstructing the original tree (where such nodes are 895 -- to be eliminated). 896 897 procedure Rewrite (Old_Node, New_Node : Node_Id); 898 -- This is used when a complete subtree is to be replaced. Old_Node is the 899 -- root of the old subtree to be replaced, and New_Node is the root of the 900 -- newly constructed replacement subtree. The actual mechanism is to swap 901 -- the contents of these two nodes fixing up the parent pointers of the 902 -- replaced node (we do not attempt to preserve parent pointers for the 903 -- original node). Neither Old_Node nor New_Node can be extended nodes. 904 -- 905 -- Note: New_Node may not contain references to Old_Node, for example as 906 -- descendents, since the rewrite would make such references invalid. If 907 -- New_Node does need to reference Old_Node, then these references should 908 -- be to a relocated copy of Old_Node (see Relocate_Node procedure). 909 -- 910 -- Note: The Original_Node function applied to Old_Node (which has now 911 -- been replaced by the contents of New_Node), can be used to obtain the 912 -- original node, i.e. the old contents of Old_Node. 913 914 procedure Replace (Old_Node, New_Node : Node_Id); 915 -- This is similar to Rewrite, except that the old value of Old_Node is 916 -- not saved, and the New_Node is deleted after the replace, since it 917 -- is assumed that it can no longer be legitimately needed. The flag 918 -- Is_Rewrite_Substitution will be False for the resulting node, unless 919 -- it was already true on entry, and Original_Node will not return the 920 -- original contents of the Old_Node, but rather the New_Node value (unless 921 -- Old_Node had already been rewritten using Rewrite). Replace also 922 -- preserves the setting of Comes_From_Source. 923 -- 924 -- Note, New_Node may not contain references to Old_Node, for example as 925 -- descendents, since the rewrite would make such references invalid. If 926 -- New_Node does need to reference Old_Node, then these references should 927 -- be to a relocated copy of Old_Node (see Relocate_Node procedure). 928 -- 929 -- Replace is used in certain circumstances where it is desirable to 930 -- suppress any history of the rewriting operation. Notably, it is used 931 -- when the parser has mis-classified a node (e.g. a task entry call 932 -- that the parser has parsed as a procedure call). 933 934 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean; 935 pragma Inline (Is_Rewrite_Substitution); 936 -- Return True iff Node has been rewritten (i.e. if Node is the root 937 -- of a subtree which was installed using Rewrite). 938 939 function Original_Node (Node : Node_Id) return Node_Id; 940 pragma Inline (Original_Node); 941 -- If Node has not been rewritten, then returns its input argument 942 -- unchanged, else returns the Node for the original subtree. 943 -- 944 -- Note: Parents are not preserved in original tree nodes that are 945 -- retrieved in this way (i.e. their children may have children whose 946 -- pointers which reference some other node). 947 948 -- Note: there is no direct mechanism for deleting an original node (in 949 -- a manner that can be reversed later). One possible approach is to use 950 -- Rewrite to substitute a null statement for the node to be deleted. 951 952 ----------------------------------- 953 -- Generic Field Access Routines -- 954 ----------------------------------- 955 956 -- This subpackage provides the functions for accessing and procedures for 957 -- setting fields that are normally referenced by wrapper subprograms (e.g. 958 -- logical synonyms defined in packages Sinfo and Einfo, or specialized 959 -- routines such as Rewrite (for Original_Node), or the node creation 960 -- routines (for Set_Nkind). The implementations of these wrapper 961 -- subprograms use the package Atree.Unchecked_Access as do various 962 -- special case accesses where no wrapper applies. Documentation is always 963 -- required for such a special case access explaining why it is needed. 964 965 package Unchecked_Access is 966 967 -- Functions to allow interpretation of Union_Id values as Uint and 968 -- Ureal values. 969 970 function To_Union is new Unchecked_Conversion (Uint, Union_Id); 971 function To_Union is new Unchecked_Conversion (Ureal, Union_Id); 972 973 function From_Union is new Unchecked_Conversion (Union_Id, Uint); 974 function From_Union is new Unchecked_Conversion (Union_Id, Ureal); 975 976 -- Functions to fetch contents of indicated field. It is an error to 977 -- attempt to read the value of a field which is not present. 978 979 function Field1 (N : Node_Id) return Union_Id; 980 pragma Inline (Field1); 981 982 function Field2 (N : Node_Id) return Union_Id; 983 pragma Inline (Field2); 984 985 function Field3 (N : Node_Id) return Union_Id; 986 pragma Inline (Field3); 987 988 function Field4 (N : Node_Id) return Union_Id; 989 pragma Inline (Field4); 990 991 function Field5 (N : Node_Id) return Union_Id; 992 pragma Inline (Field5); 993 994 function Field6 (N : Node_Id) return Union_Id; 995 pragma Inline (Field6); 996 997 function Field7 (N : Node_Id) return Union_Id; 998 pragma Inline (Field7); 999 1000 function Field8 (N : Node_Id) return Union_Id; 1001 pragma Inline (Field8); 1002 1003 function Field9 (N : Node_Id) return Union_Id; 1004 pragma Inline (Field9); 1005 1006 function Field10 (N : Node_Id) return Union_Id; 1007 pragma Inline (Field10); 1008 1009 function Field11 (N : Node_Id) return Union_Id; 1010 pragma Inline (Field11); 1011 1012 function Field12 (N : Node_Id) return Union_Id; 1013 pragma Inline (Field12); 1014 1015 function Field13 (N : Node_Id) return Union_Id; 1016 pragma Inline (Field13); 1017 1018 function Field14 (N : Node_Id) return Union_Id; 1019 pragma Inline (Field14); 1020 1021 function Field15 (N : Node_Id) return Union_Id; 1022 pragma Inline (Field15); 1023 1024 function Field16 (N : Node_Id) return Union_Id; 1025 pragma Inline (Field16); 1026 1027 function Field17 (N : Node_Id) return Union_Id; 1028 pragma Inline (Field17); 1029 1030 function Field18 (N : Node_Id) return Union_Id; 1031 pragma Inline (Field18); 1032 1033 function Field19 (N : Node_Id) return Union_Id; 1034 pragma Inline (Field19); 1035 1036 function Field20 (N : Node_Id) return Union_Id; 1037 pragma Inline (Field20); 1038 1039 function Field21 (N : Node_Id) return Union_Id; 1040 pragma Inline (Field21); 1041 1042 function Field22 (N : Node_Id) return Union_Id; 1043 pragma Inline (Field22); 1044 1045 function Field23 (N : Node_Id) return Union_Id; 1046 pragma Inline (Field23); 1047 1048 function Field24 (N : Node_Id) return Union_Id; 1049 pragma Inline (Field24); 1050 1051 function Field25 (N : Node_Id) return Union_Id; 1052 pragma Inline (Field25); 1053 1054 function Field26 (N : Node_Id) return Union_Id; 1055 pragma Inline (Field26); 1056 1057 function Field27 (N : Node_Id) return Union_Id; 1058 pragma Inline (Field27); 1059 1060 function Field28 (N : Node_Id) return Union_Id; 1061 pragma Inline (Field28); 1062 1063 function Field29 (N : Node_Id) return Union_Id; 1064 pragma Inline (Field29); 1065 1066 function Field30 (N : Node_Id) return Union_Id; 1067 pragma Inline (Field30); 1068 1069 function Field31 (N : Node_Id) return Union_Id; 1070 pragma Inline (Field31); 1071 1072 function Field32 (N : Node_Id) return Union_Id; 1073 pragma Inline (Field32); 1074 1075 function Field33 (N : Node_Id) return Union_Id; 1076 pragma Inline (Field33); 1077 1078 function Field34 (N : Node_Id) return Union_Id; 1079 pragma Inline (Field34); 1080 1081 function Field35 (N : Node_Id) return Union_Id; 1082 pragma Inline (Field35); 1083 1084 function Node1 (N : Node_Id) return Node_Id; 1085 pragma Inline (Node1); 1086 1087 function Node2 (N : Node_Id) return Node_Id; 1088 pragma Inline (Node2); 1089 1090 function Node3 (N : Node_Id) return Node_Id; 1091 pragma Inline (Node3); 1092 1093 function Node4 (N : Node_Id) return Node_Id; 1094 pragma Inline (Node4); 1095 1096 function Node5 (N : Node_Id) return Node_Id; 1097 pragma Inline (Node5); 1098 1099 function Node6 (N : Node_Id) return Node_Id; 1100 pragma Inline (Node6); 1101 1102 function Node7 (N : Node_Id) return Node_Id; 1103 pragma Inline (Node7); 1104 1105 function Node8 (N : Node_Id) return Node_Id; 1106 pragma Inline (Node8); 1107 1108 function Node9 (N : Node_Id) return Node_Id; 1109 pragma Inline (Node9); 1110 1111 function Node10 (N : Node_Id) return Node_Id; 1112 pragma Inline (Node10); 1113 1114 function Node11 (N : Node_Id) return Node_Id; 1115 pragma Inline (Node11); 1116 1117 function Node12 (N : Node_Id) return Node_Id; 1118 pragma Inline (Node12); 1119 1120 function Node13 (N : Node_Id) return Node_Id; 1121 pragma Inline (Node13); 1122 1123 function Node14 (N : Node_Id) return Node_Id; 1124 pragma Inline (Node14); 1125 1126 function Node15 (N : Node_Id) return Node_Id; 1127 pragma Inline (Node15); 1128 1129 function Node16 (N : Node_Id) return Node_Id; 1130 pragma Inline (Node16); 1131 1132 function Node17 (N : Node_Id) return Node_Id; 1133 pragma Inline (Node17); 1134 1135 function Node18 (N : Node_Id) return Node_Id; 1136 pragma Inline (Node18); 1137 1138 function Node19 (N : Node_Id) return Node_Id; 1139 pragma Inline (Node19); 1140 1141 function Node20 (N : Node_Id) return Node_Id; 1142 pragma Inline (Node20); 1143 1144 function Node21 (N : Node_Id) return Node_Id; 1145 pragma Inline (Node21); 1146 1147 function Node22 (N : Node_Id) return Node_Id; 1148 pragma Inline (Node22); 1149 1150 function Node23 (N : Node_Id) return Node_Id; 1151 pragma Inline (Node23); 1152 1153 function Node24 (N : Node_Id) return Node_Id; 1154 pragma Inline (Node24); 1155 1156 function Node25 (N : Node_Id) return Node_Id; 1157 pragma Inline (Node25); 1158 1159 function Node26 (N : Node_Id) return Node_Id; 1160 pragma Inline (Node26); 1161 1162 function Node27 (N : Node_Id) return Node_Id; 1163 pragma Inline (Node27); 1164 1165 function Node28 (N : Node_Id) return Node_Id; 1166 pragma Inline (Node28); 1167 1168 function Node29 (N : Node_Id) return Node_Id; 1169 pragma Inline (Node29); 1170 1171 function Node30 (N : Node_Id) return Node_Id; 1172 pragma Inline (Node30); 1173 1174 function List1 (N : Node_Id) return List_Id; 1175 pragma Inline (List1); 1176 1177 function List2 (N : Node_Id) return List_Id; 1178 pragma Inline (List2); 1179 1180 function List3 (N : Node_Id) return List_Id; 1181 pragma Inline (List3); 1182 1183 function List4 (N : Node_Id) return List_Id; 1184 pragma Inline (List4); 1185 1186 function List5 (N : Node_Id) return List_Id; 1187 pragma Inline (List5); 1188 1189 function List10 (N : Node_Id) return List_Id; 1190 pragma Inline (List10); 1191 1192 function List14 (N : Node_Id) return List_Id; 1193 pragma Inline (List14); 1194 1195 function List25 (N : Node_Id) return List_Id; 1196 pragma Inline (List25); 1197 1198 function Elist1 (N : Node_Id) return Elist_Id; 1199 pragma Inline (Elist1); 1200 1201 function Elist2 (N : Node_Id) return Elist_Id; 1202 pragma Inline (Elist2); 1203 1204 function Elist3 (N : Node_Id) return Elist_Id; 1205 pragma Inline (Elist3); 1206 1207 function Elist4 (N : Node_Id) return Elist_Id; 1208 pragma Inline (Elist4); 1209 1210 function Elist5 (N : Node_Id) return Elist_Id; 1211 pragma Inline (Elist5); 1212 1213 function Elist8 (N : Node_Id) return Elist_Id; 1214 pragma Inline (Elist8); 1215 1216 function Elist10 (N : Node_Id) return Elist_Id; 1217 pragma Inline (Elist10); 1218 1219 function Elist13 (N : Node_Id) return Elist_Id; 1220 pragma Inline (Elist13); 1221 1222 function Elist15 (N : Node_Id) return Elist_Id; 1223 pragma Inline (Elist15); 1224 1225 function Elist16 (N : Node_Id) return Elist_Id; 1226 pragma Inline (Elist16); 1227 1228 function Elist18 (N : Node_Id) return Elist_Id; 1229 pragma Inline (Elist18); 1230 1231 function Elist21 (N : Node_Id) return Elist_Id; 1232 pragma Inline (Elist21); 1233 1234 function Elist23 (N : Node_Id) return Elist_Id; 1235 pragma Inline (Elist23); 1236 1237 function Elist24 (N : Node_Id) return Elist_Id; 1238 pragma Inline (Elist24); 1239 1240 function Elist25 (N : Node_Id) return Elist_Id; 1241 pragma Inline (Elist25); 1242 1243 function Elist26 (N : Node_Id) return Elist_Id; 1244 pragma Inline (Elist26); 1245 1246 function Name1 (N : Node_Id) return Name_Id; 1247 pragma Inline (Name1); 1248 1249 function Name2 (N : Node_Id) return Name_Id; 1250 pragma Inline (Name2); 1251 1252 function Str3 (N : Node_Id) return String_Id; 1253 pragma Inline (Str3); 1254 1255 -- Note: the following Uintnn functions have a special test for the 1256 -- Field value being Empty. If an Empty value is found then Uint_0 is 1257 -- returned. This avoids the rather tricky requirement of initializing 1258 -- all Uint fields in nodes and entities. 1259 1260 function Uint2 (N : Node_Id) return Uint; 1261 pragma Inline (Uint2); 1262 1263 function Uint3 (N : Node_Id) return Uint; 1264 pragma Inline (Uint3); 1265 1266 function Uint4 (N : Node_Id) return Uint; 1267 pragma Inline (Uint4); 1268 1269 function Uint5 (N : Node_Id) return Uint; 1270 pragma Inline (Uint5); 1271 1272 function Uint8 (N : Node_Id) return Uint; 1273 pragma Inline (Uint8); 1274 1275 function Uint9 (N : Node_Id) return Uint; 1276 pragma Inline (Uint9); 1277 1278 function Uint10 (N : Node_Id) return Uint; 1279 pragma Inline (Uint10); 1280 1281 function Uint11 (N : Node_Id) return Uint; 1282 pragma Inline (Uint11); 1283 1284 function Uint12 (N : Node_Id) return Uint; 1285 pragma Inline (Uint12); 1286 1287 function Uint13 (N : Node_Id) return Uint; 1288 pragma Inline (Uint13); 1289 1290 function Uint14 (N : Node_Id) return Uint; 1291 pragma Inline (Uint14); 1292 1293 function Uint15 (N : Node_Id) return Uint; 1294 pragma Inline (Uint15); 1295 1296 function Uint16 (N : Node_Id) return Uint; 1297 pragma Inline (Uint16); 1298 1299 function Uint17 (N : Node_Id) return Uint; 1300 pragma Inline (Uint17); 1301 1302 function Uint22 (N : Node_Id) return Uint; 1303 pragma Inline (Uint22); 1304 1305 function Ureal3 (N : Node_Id) return Ureal; 1306 pragma Inline (Ureal3); 1307 1308 function Ureal18 (N : Node_Id) return Ureal; 1309 pragma Inline (Ureal18); 1310 1311 function Ureal21 (N : Node_Id) return Ureal; 1312 pragma Inline (Ureal21); 1313 1314 function Flag4 (N : Node_Id) return Boolean; 1315 pragma Inline (Flag4); 1316 1317 function Flag5 (N : Node_Id) return Boolean; 1318 pragma Inline (Flag5); 1319 1320 function Flag6 (N : Node_Id) return Boolean; 1321 pragma Inline (Flag6); 1322 1323 function Flag7 (N : Node_Id) return Boolean; 1324 pragma Inline (Flag7); 1325 1326 function Flag8 (N : Node_Id) return Boolean; 1327 pragma Inline (Flag8); 1328 1329 function Flag9 (N : Node_Id) return Boolean; 1330 pragma Inline (Flag9); 1331 1332 function Flag10 (N : Node_Id) return Boolean; 1333 pragma Inline (Flag10); 1334 1335 function Flag11 (N : Node_Id) return Boolean; 1336 pragma Inline (Flag11); 1337 1338 function Flag12 (N : Node_Id) return Boolean; 1339 pragma Inline (Flag12); 1340 1341 function Flag13 (N : Node_Id) return Boolean; 1342 pragma Inline (Flag13); 1343 1344 function Flag14 (N : Node_Id) return Boolean; 1345 pragma Inline (Flag14); 1346 1347 function Flag15 (N : Node_Id) return Boolean; 1348 pragma Inline (Flag15); 1349 1350 function Flag16 (N : Node_Id) return Boolean; 1351 pragma Inline (Flag16); 1352 1353 function Flag17 (N : Node_Id) return Boolean; 1354 pragma Inline (Flag17); 1355 1356 function Flag18 (N : Node_Id) return Boolean; 1357 pragma Inline (Flag18); 1358 1359 function Flag19 (N : Node_Id) return Boolean; 1360 pragma Inline (Flag19); 1361 1362 function Flag20 (N : Node_Id) return Boolean; 1363 pragma Inline (Flag20); 1364 1365 function Flag21 (N : Node_Id) return Boolean; 1366 pragma Inline (Flag21); 1367 1368 function Flag22 (N : Node_Id) return Boolean; 1369 pragma Inline (Flag22); 1370 1371 function Flag23 (N : Node_Id) return Boolean; 1372 pragma Inline (Flag23); 1373 1374 function Flag24 (N : Node_Id) return Boolean; 1375 pragma Inline (Flag24); 1376 1377 function Flag25 (N : Node_Id) return Boolean; 1378 pragma Inline (Flag25); 1379 1380 function Flag26 (N : Node_Id) return Boolean; 1381 pragma Inline (Flag26); 1382 1383 function Flag27 (N : Node_Id) return Boolean; 1384 pragma Inline (Flag27); 1385 1386 function Flag28 (N : Node_Id) return Boolean; 1387 pragma Inline (Flag28); 1388 1389 function Flag29 (N : Node_Id) return Boolean; 1390 pragma Inline (Flag29); 1391 1392 function Flag30 (N : Node_Id) return Boolean; 1393 pragma Inline (Flag30); 1394 1395 function Flag31 (N : Node_Id) return Boolean; 1396 pragma Inline (Flag31); 1397 1398 function Flag32 (N : Node_Id) return Boolean; 1399 pragma Inline (Flag32); 1400 1401 function Flag33 (N : Node_Id) return Boolean; 1402 pragma Inline (Flag33); 1403 1404 function Flag34 (N : Node_Id) return Boolean; 1405 pragma Inline (Flag34); 1406 1407 function Flag35 (N : Node_Id) return Boolean; 1408 pragma Inline (Flag35); 1409 1410 function Flag36 (N : Node_Id) return Boolean; 1411 pragma Inline (Flag36); 1412 1413 function Flag37 (N : Node_Id) return Boolean; 1414 pragma Inline (Flag37); 1415 1416 function Flag38 (N : Node_Id) return Boolean; 1417 pragma Inline (Flag38); 1418 1419 function Flag39 (N : Node_Id) return Boolean; 1420 pragma Inline (Flag39); 1421 1422 function Flag40 (N : Node_Id) return Boolean; 1423 pragma Inline (Flag40); 1424 1425 function Flag41 (N : Node_Id) return Boolean; 1426 pragma Inline (Flag41); 1427 1428 function Flag42 (N : Node_Id) return Boolean; 1429 pragma Inline (Flag42); 1430 1431 function Flag43 (N : Node_Id) return Boolean; 1432 pragma Inline (Flag43); 1433 1434 function Flag44 (N : Node_Id) return Boolean; 1435 pragma Inline (Flag44); 1436 1437 function Flag45 (N : Node_Id) return Boolean; 1438 pragma Inline (Flag45); 1439 1440 function Flag46 (N : Node_Id) return Boolean; 1441 pragma Inline (Flag46); 1442 1443 function Flag47 (N : Node_Id) return Boolean; 1444 pragma Inline (Flag47); 1445 1446 function Flag48 (N : Node_Id) return Boolean; 1447 pragma Inline (Flag48); 1448 1449 function Flag49 (N : Node_Id) return Boolean; 1450 pragma Inline (Flag49); 1451 1452 function Flag50 (N : Node_Id) return Boolean; 1453 pragma Inline (Flag50); 1454 1455 function Flag51 (N : Node_Id) return Boolean; 1456 pragma Inline (Flag51); 1457 1458 function Flag52 (N : Node_Id) return Boolean; 1459 pragma Inline (Flag52); 1460 1461 function Flag53 (N : Node_Id) return Boolean; 1462 pragma Inline (Flag53); 1463 1464 function Flag54 (N : Node_Id) return Boolean; 1465 pragma Inline (Flag54); 1466 1467 function Flag55 (N : Node_Id) return Boolean; 1468 pragma Inline (Flag55); 1469 1470 function Flag56 (N : Node_Id) return Boolean; 1471 pragma Inline (Flag56); 1472 1473 function Flag57 (N : Node_Id) return Boolean; 1474 pragma Inline (Flag57); 1475 1476 function Flag58 (N : Node_Id) return Boolean; 1477 pragma Inline (Flag58); 1478 1479 function Flag59 (N : Node_Id) return Boolean; 1480 pragma Inline (Flag59); 1481 1482 function Flag60 (N : Node_Id) return Boolean; 1483 pragma Inline (Flag60); 1484 1485 function Flag61 (N : Node_Id) return Boolean; 1486 pragma Inline (Flag61); 1487 1488 function Flag62 (N : Node_Id) return Boolean; 1489 pragma Inline (Flag62); 1490 1491 function Flag63 (N : Node_Id) return Boolean; 1492 pragma Inline (Flag63); 1493 1494 function Flag64 (N : Node_Id) return Boolean; 1495 pragma Inline (Flag64); 1496 1497 function Flag65 (N : Node_Id) return Boolean; 1498 pragma Inline (Flag65); 1499 1500 function Flag66 (N : Node_Id) return Boolean; 1501 pragma Inline (Flag66); 1502 1503 function Flag67 (N : Node_Id) return Boolean; 1504 pragma Inline (Flag67); 1505 1506 function Flag68 (N : Node_Id) return Boolean; 1507 pragma Inline (Flag68); 1508 1509 function Flag69 (N : Node_Id) return Boolean; 1510 pragma Inline (Flag69); 1511 1512 function Flag70 (N : Node_Id) return Boolean; 1513 pragma Inline (Flag70); 1514 1515 function Flag71 (N : Node_Id) return Boolean; 1516 pragma Inline (Flag71); 1517 1518 function Flag72 (N : Node_Id) return Boolean; 1519 pragma Inline (Flag72); 1520 1521 function Flag73 (N : Node_Id) return Boolean; 1522 pragma Inline (Flag73); 1523 1524 function Flag74 (N : Node_Id) return Boolean; 1525 pragma Inline (Flag74); 1526 1527 function Flag75 (N : Node_Id) return Boolean; 1528 pragma Inline (Flag75); 1529 1530 function Flag76 (N : Node_Id) return Boolean; 1531 pragma Inline (Flag76); 1532 1533 function Flag77 (N : Node_Id) return Boolean; 1534 pragma Inline (Flag77); 1535 1536 function Flag78 (N : Node_Id) return Boolean; 1537 pragma Inline (Flag78); 1538 1539 function Flag79 (N : Node_Id) return Boolean; 1540 pragma Inline (Flag79); 1541 1542 function Flag80 (N : Node_Id) return Boolean; 1543 pragma Inline (Flag80); 1544 1545 function Flag81 (N : Node_Id) return Boolean; 1546 pragma Inline (Flag81); 1547 1548 function Flag82 (N : Node_Id) return Boolean; 1549 pragma Inline (Flag82); 1550 1551 function Flag83 (N : Node_Id) return Boolean; 1552 pragma Inline (Flag83); 1553 1554 function Flag84 (N : Node_Id) return Boolean; 1555 pragma Inline (Flag84); 1556 1557 function Flag85 (N : Node_Id) return Boolean; 1558 pragma Inline (Flag85); 1559 1560 function Flag86 (N : Node_Id) return Boolean; 1561 pragma Inline (Flag86); 1562 1563 function Flag87 (N : Node_Id) return Boolean; 1564 pragma Inline (Flag87); 1565 1566 function Flag88 (N : Node_Id) return Boolean; 1567 pragma Inline (Flag88); 1568 1569 function Flag89 (N : Node_Id) return Boolean; 1570 pragma Inline (Flag89); 1571 1572 function Flag90 (N : Node_Id) return Boolean; 1573 pragma Inline (Flag90); 1574 1575 function Flag91 (N : Node_Id) return Boolean; 1576 pragma Inline (Flag91); 1577 1578 function Flag92 (N : Node_Id) return Boolean; 1579 pragma Inline (Flag92); 1580 1581 function Flag93 (N : Node_Id) return Boolean; 1582 pragma Inline (Flag93); 1583 1584 function Flag94 (N : Node_Id) return Boolean; 1585 pragma Inline (Flag94); 1586 1587 function Flag95 (N : Node_Id) return Boolean; 1588 pragma Inline (Flag95); 1589 1590 function Flag96 (N : Node_Id) return Boolean; 1591 pragma Inline (Flag96); 1592 1593 function Flag97 (N : Node_Id) return Boolean; 1594 pragma Inline (Flag97); 1595 1596 function Flag98 (N : Node_Id) return Boolean; 1597 pragma Inline (Flag98); 1598 1599 function Flag99 (N : Node_Id) return Boolean; 1600 pragma Inline (Flag99); 1601 1602 function Flag100 (N : Node_Id) return Boolean; 1603 pragma Inline (Flag100); 1604 1605 function Flag101 (N : Node_Id) return Boolean; 1606 pragma Inline (Flag101); 1607 1608 function Flag102 (N : Node_Id) return Boolean; 1609 pragma Inline (Flag102); 1610 1611 function Flag103 (N : Node_Id) return Boolean; 1612 pragma Inline (Flag103); 1613 1614 function Flag104 (N : Node_Id) return Boolean; 1615 pragma Inline (Flag104); 1616 1617 function Flag105 (N : Node_Id) return Boolean; 1618 pragma Inline (Flag105); 1619 1620 function Flag106 (N : Node_Id) return Boolean; 1621 pragma Inline (Flag106); 1622 1623 function Flag107 (N : Node_Id) return Boolean; 1624 pragma Inline (Flag107); 1625 1626 function Flag108 (N : Node_Id) return Boolean; 1627 pragma Inline (Flag108); 1628 1629 function Flag109 (N : Node_Id) return Boolean; 1630 pragma Inline (Flag109); 1631 1632 function Flag110 (N : Node_Id) return Boolean; 1633 pragma Inline (Flag110); 1634 1635 function Flag111 (N : Node_Id) return Boolean; 1636 pragma Inline (Flag111); 1637 1638 function Flag112 (N : Node_Id) return Boolean; 1639 pragma Inline (Flag112); 1640 1641 function Flag113 (N : Node_Id) return Boolean; 1642 pragma Inline (Flag113); 1643 1644 function Flag114 (N : Node_Id) return Boolean; 1645 pragma Inline (Flag114); 1646 1647 function Flag115 (N : Node_Id) return Boolean; 1648 pragma Inline (Flag115); 1649 1650 function Flag116 (N : Node_Id) return Boolean; 1651 pragma Inline (Flag116); 1652 1653 function Flag117 (N : Node_Id) return Boolean; 1654 pragma Inline (Flag117); 1655 1656 function Flag118 (N : Node_Id) return Boolean; 1657 pragma Inline (Flag118); 1658 1659 function Flag119 (N : Node_Id) return Boolean; 1660 pragma Inline (Flag119); 1661 1662 function Flag120 (N : Node_Id) return Boolean; 1663 pragma Inline (Flag120); 1664 1665 function Flag121 (N : Node_Id) return Boolean; 1666 pragma Inline (Flag121); 1667 1668 function Flag122 (N : Node_Id) return Boolean; 1669 pragma Inline (Flag122); 1670 1671 function Flag123 (N : Node_Id) return Boolean; 1672 pragma Inline (Flag123); 1673 1674 function Flag124 (N : Node_Id) return Boolean; 1675 pragma Inline (Flag124); 1676 1677 function Flag125 (N : Node_Id) return Boolean; 1678 pragma Inline (Flag125); 1679 1680 function Flag126 (N : Node_Id) return Boolean; 1681 pragma Inline (Flag126); 1682 1683 function Flag127 (N : Node_Id) return Boolean; 1684 pragma Inline (Flag127); 1685 1686 function Flag128 (N : Node_Id) return Boolean; 1687 pragma Inline (Flag128); 1688 1689 function Flag129 (N : Node_Id) return Boolean; 1690 pragma Inline (Flag129); 1691 1692 function Flag130 (N : Node_Id) return Boolean; 1693 pragma Inline (Flag130); 1694 1695 function Flag131 (N : Node_Id) return Boolean; 1696 pragma Inline (Flag131); 1697 1698 function Flag132 (N : Node_Id) return Boolean; 1699 pragma Inline (Flag132); 1700 1701 function Flag133 (N : Node_Id) return Boolean; 1702 pragma Inline (Flag133); 1703 1704 function Flag134 (N : Node_Id) return Boolean; 1705 pragma Inline (Flag134); 1706 1707 function Flag135 (N : Node_Id) return Boolean; 1708 pragma Inline (Flag135); 1709 1710 function Flag136 (N : Node_Id) return Boolean; 1711 pragma Inline (Flag136); 1712 1713 function Flag137 (N : Node_Id) return Boolean; 1714 pragma Inline (Flag137); 1715 1716 function Flag138 (N : Node_Id) return Boolean; 1717 pragma Inline (Flag138); 1718 1719 function Flag139 (N : Node_Id) return Boolean; 1720 pragma Inline (Flag139); 1721 1722 function Flag140 (N : Node_Id) return Boolean; 1723 pragma Inline (Flag140); 1724 1725 function Flag141 (N : Node_Id) return Boolean; 1726 pragma Inline (Flag141); 1727 1728 function Flag142 (N : Node_Id) return Boolean; 1729 pragma Inline (Flag142); 1730 1731 function Flag143 (N : Node_Id) return Boolean; 1732 pragma Inline (Flag143); 1733 1734 function Flag144 (N : Node_Id) return Boolean; 1735 pragma Inline (Flag144); 1736 1737 function Flag145 (N : Node_Id) return Boolean; 1738 pragma Inline (Flag145); 1739 1740 function Flag146 (N : Node_Id) return Boolean; 1741 pragma Inline (Flag146); 1742 1743 function Flag147 (N : Node_Id) return Boolean; 1744 pragma Inline (Flag147); 1745 1746 function Flag148 (N : Node_Id) return Boolean; 1747 pragma Inline (Flag148); 1748 1749 function Flag149 (N : Node_Id) return Boolean; 1750 pragma Inline (Flag149); 1751 1752 function Flag150 (N : Node_Id) return Boolean; 1753 pragma Inline (Flag150); 1754 1755 function Flag151 (N : Node_Id) return Boolean; 1756 pragma Inline (Flag151); 1757 1758 function Flag152 (N : Node_Id) return Boolean; 1759 pragma Inline (Flag152); 1760 1761 function Flag153 (N : Node_Id) return Boolean; 1762 pragma Inline (Flag153); 1763 1764 function Flag154 (N : Node_Id) return Boolean; 1765 pragma Inline (Flag154); 1766 1767 function Flag155 (N : Node_Id) return Boolean; 1768 pragma Inline (Flag155); 1769 1770 function Flag156 (N : Node_Id) return Boolean; 1771 pragma Inline (Flag156); 1772 1773 function Flag157 (N : Node_Id) return Boolean; 1774 pragma Inline (Flag157); 1775 1776 function Flag158 (N : Node_Id) return Boolean; 1777 pragma Inline (Flag158); 1778 1779 function Flag159 (N : Node_Id) return Boolean; 1780 pragma Inline (Flag159); 1781 1782 function Flag160 (N : Node_Id) return Boolean; 1783 pragma Inline (Flag160); 1784 1785 function Flag161 (N : Node_Id) return Boolean; 1786 pragma Inline (Flag161); 1787 1788 function Flag162 (N : Node_Id) return Boolean; 1789 pragma Inline (Flag162); 1790 1791 function Flag163 (N : Node_Id) return Boolean; 1792 pragma Inline (Flag163); 1793 1794 function Flag164 (N : Node_Id) return Boolean; 1795 pragma Inline (Flag164); 1796 1797 function Flag165 (N : Node_Id) return Boolean; 1798 pragma Inline (Flag165); 1799 1800 function Flag166 (N : Node_Id) return Boolean; 1801 pragma Inline (Flag166); 1802 1803 function Flag167 (N : Node_Id) return Boolean; 1804 pragma Inline (Flag167); 1805 1806 function Flag168 (N : Node_Id) return Boolean; 1807 pragma Inline (Flag168); 1808 1809 function Flag169 (N : Node_Id) return Boolean; 1810 pragma Inline (Flag169); 1811 1812 function Flag170 (N : Node_Id) return Boolean; 1813 pragma Inline (Flag170); 1814 1815 function Flag171 (N : Node_Id) return Boolean; 1816 pragma Inline (Flag171); 1817 1818 function Flag172 (N : Node_Id) return Boolean; 1819 pragma Inline (Flag172); 1820 1821 function Flag173 (N : Node_Id) return Boolean; 1822 pragma Inline (Flag173); 1823 1824 function Flag174 (N : Node_Id) return Boolean; 1825 pragma Inline (Flag174); 1826 1827 function Flag175 (N : Node_Id) return Boolean; 1828 pragma Inline (Flag175); 1829 1830 function Flag176 (N : Node_Id) return Boolean; 1831 pragma Inline (Flag176); 1832 1833 function Flag177 (N : Node_Id) return Boolean; 1834 pragma Inline (Flag177); 1835 1836 function Flag178 (N : Node_Id) return Boolean; 1837 pragma Inline (Flag178); 1838 1839 function Flag179 (N : Node_Id) return Boolean; 1840 pragma Inline (Flag179); 1841 1842 function Flag180 (N : Node_Id) return Boolean; 1843 pragma Inline (Flag180); 1844 1845 function Flag181 (N : Node_Id) return Boolean; 1846 pragma Inline (Flag181); 1847 1848 function Flag182 (N : Node_Id) return Boolean; 1849 pragma Inline (Flag182); 1850 1851 function Flag183 (N : Node_Id) return Boolean; 1852 pragma Inline (Flag183); 1853 1854 function Flag184 (N : Node_Id) return Boolean; 1855 pragma Inline (Flag184); 1856 1857 function Flag185 (N : Node_Id) return Boolean; 1858 pragma Inline (Flag185); 1859 1860 function Flag186 (N : Node_Id) return Boolean; 1861 pragma Inline (Flag186); 1862 1863 function Flag187 (N : Node_Id) return Boolean; 1864 pragma Inline (Flag187); 1865 1866 function Flag188 (N : Node_Id) return Boolean; 1867 pragma Inline (Flag188); 1868 1869 function Flag189 (N : Node_Id) return Boolean; 1870 pragma Inline (Flag189); 1871 1872 function Flag190 (N : Node_Id) return Boolean; 1873 pragma Inline (Flag190); 1874 1875 function Flag191 (N : Node_Id) return Boolean; 1876 pragma Inline (Flag191); 1877 1878 function Flag192 (N : Node_Id) return Boolean; 1879 pragma Inline (Flag192); 1880 1881 function Flag193 (N : Node_Id) return Boolean; 1882 pragma Inline (Flag193); 1883 1884 function Flag194 (N : Node_Id) return Boolean; 1885 pragma Inline (Flag194); 1886 1887 function Flag195 (N : Node_Id) return Boolean; 1888 pragma Inline (Flag195); 1889 1890 function Flag196 (N : Node_Id) return Boolean; 1891 pragma Inline (Flag196); 1892 1893 function Flag197 (N : Node_Id) return Boolean; 1894 pragma Inline (Flag197); 1895 1896 function Flag198 (N : Node_Id) return Boolean; 1897 pragma Inline (Flag198); 1898 1899 function Flag199 (N : Node_Id) return Boolean; 1900 pragma Inline (Flag199); 1901 1902 function Flag200 (N : Node_Id) return Boolean; 1903 pragma Inline (Flag200); 1904 1905 function Flag201 (N : Node_Id) return Boolean; 1906 pragma Inline (Flag201); 1907 1908 function Flag202 (N : Node_Id) return Boolean; 1909 pragma Inline (Flag202); 1910 1911 function Flag203 (N : Node_Id) return Boolean; 1912 pragma Inline (Flag203); 1913 1914 function Flag204 (N : Node_Id) return Boolean; 1915 pragma Inline (Flag204); 1916 1917 function Flag205 (N : Node_Id) return Boolean; 1918 pragma Inline (Flag205); 1919 1920 function Flag206 (N : Node_Id) return Boolean; 1921 pragma Inline (Flag206); 1922 1923 function Flag207 (N : Node_Id) return Boolean; 1924 pragma Inline (Flag207); 1925 1926 function Flag208 (N : Node_Id) return Boolean; 1927 pragma Inline (Flag208); 1928 1929 function Flag209 (N : Node_Id) return Boolean; 1930 pragma Inline (Flag209); 1931 1932 function Flag210 (N : Node_Id) return Boolean; 1933 pragma Inline (Flag210); 1934 1935 function Flag211 (N : Node_Id) return Boolean; 1936 pragma Inline (Flag211); 1937 1938 function Flag212 (N : Node_Id) return Boolean; 1939 pragma Inline (Flag212); 1940 1941 function Flag213 (N : Node_Id) return Boolean; 1942 pragma Inline (Flag213); 1943 1944 function Flag214 (N : Node_Id) return Boolean; 1945 pragma Inline (Flag214); 1946 1947 function Flag215 (N : Node_Id) return Boolean; 1948 pragma Inline (Flag215); 1949 1950 function Flag216 (N : Node_Id) return Boolean; 1951 pragma Inline (Flag216); 1952 1953 function Flag217 (N : Node_Id) return Boolean; 1954 pragma Inline (Flag217); 1955 1956 function Flag218 (N : Node_Id) return Boolean; 1957 pragma Inline (Flag218); 1958 1959 function Flag219 (N : Node_Id) return Boolean; 1960 pragma Inline (Flag219); 1961 1962 function Flag220 (N : Node_Id) return Boolean; 1963 pragma Inline (Flag220); 1964 1965 function Flag221 (N : Node_Id) return Boolean; 1966 pragma Inline (Flag221); 1967 1968 function Flag222 (N : Node_Id) return Boolean; 1969 pragma Inline (Flag222); 1970 1971 function Flag223 (N : Node_Id) return Boolean; 1972 pragma Inline (Flag223); 1973 1974 function Flag224 (N : Node_Id) return Boolean; 1975 pragma Inline (Flag224); 1976 1977 function Flag225 (N : Node_Id) return Boolean; 1978 pragma Inline (Flag225); 1979 1980 function Flag226 (N : Node_Id) return Boolean; 1981 pragma Inline (Flag226); 1982 1983 function Flag227 (N : Node_Id) return Boolean; 1984 pragma Inline (Flag227); 1985 1986 function Flag228 (N : Node_Id) return Boolean; 1987 pragma Inline (Flag228); 1988 1989 function Flag229 (N : Node_Id) return Boolean; 1990 pragma Inline (Flag229); 1991 1992 function Flag230 (N : Node_Id) return Boolean; 1993 pragma Inline (Flag230); 1994 1995 function Flag231 (N : Node_Id) return Boolean; 1996 pragma Inline (Flag231); 1997 1998 function Flag232 (N : Node_Id) return Boolean; 1999 pragma Inline (Flag232); 2000 2001 function Flag233 (N : Node_Id) return Boolean; 2002 pragma Inline (Flag233); 2003 2004 function Flag234 (N : Node_Id) return Boolean; 2005 pragma Inline (Flag234); 2006 2007 function Flag235 (N : Node_Id) return Boolean; 2008 pragma Inline (Flag235); 2009 2010 function Flag236 (N : Node_Id) return Boolean; 2011 pragma Inline (Flag236); 2012 2013 function Flag237 (N : Node_Id) return Boolean; 2014 pragma Inline (Flag237); 2015 2016 function Flag238 (N : Node_Id) return Boolean; 2017 pragma Inline (Flag238); 2018 2019 function Flag239 (N : Node_Id) return Boolean; 2020 pragma Inline (Flag239); 2021 2022 function Flag240 (N : Node_Id) return Boolean; 2023 pragma Inline (Flag240); 2024 2025 function Flag241 (N : Node_Id) return Boolean; 2026 pragma Inline (Flag241); 2027 2028 function Flag242 (N : Node_Id) return Boolean; 2029 pragma Inline (Flag242); 2030 2031 function Flag243 (N : Node_Id) return Boolean; 2032 pragma Inline (Flag243); 2033 2034 function Flag244 (N : Node_Id) return Boolean; 2035 pragma Inline (Flag244); 2036 2037 function Flag245 (N : Node_Id) return Boolean; 2038 pragma Inline (Flag245); 2039 2040 function Flag246 (N : Node_Id) return Boolean; 2041 pragma Inline (Flag246); 2042 2043 function Flag247 (N : Node_Id) return Boolean; 2044 pragma Inline (Flag247); 2045 2046 function Flag248 (N : Node_Id) return Boolean; 2047 pragma Inline (Flag248); 2048 2049 function Flag249 (N : Node_Id) return Boolean; 2050 pragma Inline (Flag249); 2051 2052 function Flag250 (N : Node_Id) return Boolean; 2053 pragma Inline (Flag250); 2054 2055 function Flag251 (N : Node_Id) return Boolean; 2056 pragma Inline (Flag251); 2057 2058 function Flag252 (N : Node_Id) return Boolean; 2059 pragma Inline (Flag252); 2060 2061 function Flag253 (N : Node_Id) return Boolean; 2062 pragma Inline (Flag253); 2063 2064 function Flag254 (N : Node_Id) return Boolean; 2065 pragma Inline (Flag254); 2066 2067 function Flag255 (N : Node_Id) return Boolean; 2068 pragma Inline (Flag255); 2069 2070 function Flag256 (N : Node_Id) return Boolean; 2071 pragma Inline (Flag256); 2072 2073 function Flag257 (N : Node_Id) return Boolean; 2074 pragma Inline (Flag257); 2075 2076 function Flag258 (N : Node_Id) return Boolean; 2077 pragma Inline (Flag258); 2078 2079 function Flag259 (N : Node_Id) return Boolean; 2080 pragma Inline (Flag259); 2081 2082 function Flag260 (N : Node_Id) return Boolean; 2083 pragma Inline (Flag260); 2084 2085 function Flag261 (N : Node_Id) return Boolean; 2086 pragma Inline (Flag261); 2087 2088 function Flag262 (N : Node_Id) return Boolean; 2089 pragma Inline (Flag262); 2090 2091 function Flag263 (N : Node_Id) return Boolean; 2092 pragma Inline (Flag263); 2093 2094 function Flag264 (N : Node_Id) return Boolean; 2095 pragma Inline (Flag264); 2096 2097 function Flag265 (N : Node_Id) return Boolean; 2098 pragma Inline (Flag265); 2099 2100 function Flag266 (N : Node_Id) return Boolean; 2101 pragma Inline (Flag266); 2102 2103 function Flag267 (N : Node_Id) return Boolean; 2104 pragma Inline (Flag267); 2105 2106 function Flag268 (N : Node_Id) return Boolean; 2107 pragma Inline (Flag268); 2108 2109 function Flag269 (N : Node_Id) return Boolean; 2110 pragma Inline (Flag269); 2111 2112 function Flag270 (N : Node_Id) return Boolean; 2113 pragma Inline (Flag270); 2114 2115 function Flag271 (N : Node_Id) return Boolean; 2116 pragma Inline (Flag271); 2117 2118 function Flag272 (N : Node_Id) return Boolean; 2119 pragma Inline (Flag272); 2120 2121 function Flag273 (N : Node_Id) return Boolean; 2122 pragma Inline (Flag273); 2123 2124 function Flag274 (N : Node_Id) return Boolean; 2125 pragma Inline (Flag274); 2126 2127 function Flag275 (N : Node_Id) return Boolean; 2128 pragma Inline (Flag275); 2129 2130 function Flag276 (N : Node_Id) return Boolean; 2131 pragma Inline (Flag276); 2132 2133 function Flag277 (N : Node_Id) return Boolean; 2134 pragma Inline (Flag277); 2135 2136 function Flag278 (N : Node_Id) return Boolean; 2137 pragma Inline (Flag278); 2138 2139 function Flag279 (N : Node_Id) return Boolean; 2140 pragma Inline (Flag279); 2141 2142 function Flag280 (N : Node_Id) return Boolean; 2143 pragma Inline (Flag280); 2144 2145 function Flag281 (N : Node_Id) return Boolean; 2146 pragma Inline (Flag281); 2147 2148 function Flag282 (N : Node_Id) return Boolean; 2149 pragma Inline (Flag282); 2150 2151 function Flag283 (N : Node_Id) return Boolean; 2152 pragma Inline (Flag283); 2153 2154 function Flag284 (N : Node_Id) return Boolean; 2155 pragma Inline (Flag284); 2156 2157 function Flag285 (N : Node_Id) return Boolean; 2158 pragma Inline (Flag285); 2159 2160 function Flag286 (N : Node_Id) return Boolean; 2161 pragma Inline (Flag286); 2162 2163 function Flag287 (N : Node_Id) return Boolean; 2164 pragma Inline (Flag287); 2165 2166 function Flag288 (N : Node_Id) return Boolean; 2167 pragma Inline (Flag288); 2168 2169 function Flag289 (N : Node_Id) return Boolean; 2170 pragma Inline (Flag289); 2171 2172 function Flag290 (N : Node_Id) return Boolean; 2173 pragma Inline (Flag290); 2174 2175 function Flag291 (N : Node_Id) return Boolean; 2176 pragma Inline (Flag291); 2177 2178 function Flag292 (N : Node_Id) return Boolean; 2179 pragma Inline (Flag292); 2180 2181 function Flag293 (N : Node_Id) return Boolean; 2182 pragma Inline (Flag293); 2183 2184 function Flag294 (N : Node_Id) return Boolean; 2185 pragma Inline (Flag294); 2186 2187 function Flag295 (N : Node_Id) return Boolean; 2188 pragma Inline (Flag295); 2189 2190 function Flag296 (N : Node_Id) return Boolean; 2191 pragma Inline (Flag296); 2192 2193 function Flag297 (N : Node_Id) return Boolean; 2194 pragma Inline (Flag297); 2195 2196 function Flag298 (N : Node_Id) return Boolean; 2197 pragma Inline (Flag298); 2198 2199 function Flag299 (N : Node_Id) return Boolean; 2200 pragma Inline (Flag299); 2201 2202 function Flag300 (N : Node_Id) return Boolean; 2203 pragma Inline (Flag300); 2204 2205 function Flag301 (N : Node_Id) return Boolean; 2206 pragma Inline (Flag301); 2207 2208 function Flag302 (N : Node_Id) return Boolean; 2209 pragma Inline (Flag302); 2210 2211 function Flag303 (N : Node_Id) return Boolean; 2212 pragma Inline (Flag303); 2213 2214 function Flag304 (N : Node_Id) return Boolean; 2215 pragma Inline (Flag304); 2216 2217 function Flag305 (N : Node_Id) return Boolean; 2218 pragma Inline (Flag305); 2219 2220 function Flag306 (N : Node_Id) return Boolean; 2221 pragma Inline (Flag306); 2222 2223 function Flag307 (N : Node_Id) return Boolean; 2224 pragma Inline (Flag307); 2225 2226 function Flag308 (N : Node_Id) return Boolean; 2227 pragma Inline (Flag308); 2228 2229 function Flag309 (N : Node_Id) return Boolean; 2230 pragma Inline (Flag309); 2231 2232 function Flag310 (N : Node_Id) return Boolean; 2233 pragma Inline (Flag310); 2234 2235 function Flag311 (N : Node_Id) return Boolean; 2236 pragma Inline (Flag311); 2237 2238 function Flag312 (N : Node_Id) return Boolean; 2239 pragma Inline (Flag312); 2240 2241 function Flag313 (N : Node_Id) return Boolean; 2242 pragma Inline (Flag313); 2243 2244 function Flag314 (N : Node_Id) return Boolean; 2245 pragma Inline (Flag314); 2246 2247 function Flag315 (N : Node_Id) return Boolean; 2248 pragma Inline (Flag315); 2249 2250 function Flag316 (N : Node_Id) return Boolean; 2251 pragma Inline (Flag316); 2252 2253 function Flag317 (N : Node_Id) return Boolean; 2254 pragma Inline (Flag317); 2255 2256 -- Procedures to set value of indicated field 2257 2258 procedure Set_Nkind (N : Node_Id; Val : Node_Kind); 2259 pragma Inline (Set_Nkind); 2260 2261 procedure Set_Field1 (N : Node_Id; Val : Union_Id); 2262 pragma Inline (Set_Field1); 2263 2264 procedure Set_Field2 (N : Node_Id; Val : Union_Id); 2265 pragma Inline (Set_Field2); 2266 2267 procedure Set_Field3 (N : Node_Id; Val : Union_Id); 2268 pragma Inline (Set_Field3); 2269 2270 procedure Set_Field4 (N : Node_Id; Val : Union_Id); 2271 pragma Inline (Set_Field4); 2272 2273 procedure Set_Field5 (N : Node_Id; Val : Union_Id); 2274 pragma Inline (Set_Field5); 2275 2276 procedure Set_Field6 (N : Node_Id; Val : Union_Id); 2277 pragma Inline (Set_Field6); 2278 2279 procedure Set_Field7 (N : Node_Id; Val : Union_Id); 2280 pragma Inline (Set_Field7); 2281 2282 procedure Set_Field8 (N : Node_Id; Val : Union_Id); 2283 pragma Inline (Set_Field8); 2284 2285 procedure Set_Field9 (N : Node_Id; Val : Union_Id); 2286 pragma Inline (Set_Field9); 2287 2288 procedure Set_Field10 (N : Node_Id; Val : Union_Id); 2289 pragma Inline (Set_Field10); 2290 2291 procedure Set_Field11 (N : Node_Id; Val : Union_Id); 2292 pragma Inline (Set_Field11); 2293 2294 procedure Set_Field12 (N : Node_Id; Val : Union_Id); 2295 pragma Inline (Set_Field12); 2296 2297 procedure Set_Field13 (N : Node_Id; Val : Union_Id); 2298 pragma Inline (Set_Field13); 2299 2300 procedure Set_Field14 (N : Node_Id; Val : Union_Id); 2301 pragma Inline (Set_Field14); 2302 2303 procedure Set_Field15 (N : Node_Id; Val : Union_Id); 2304 pragma Inline (Set_Field15); 2305 2306 procedure Set_Field16 (N : Node_Id; Val : Union_Id); 2307 pragma Inline (Set_Field16); 2308 2309 procedure Set_Field17 (N : Node_Id; Val : Union_Id); 2310 pragma Inline (Set_Field17); 2311 2312 procedure Set_Field18 (N : Node_Id; Val : Union_Id); 2313 pragma Inline (Set_Field18); 2314 2315 procedure Set_Field19 (N : Node_Id; Val : Union_Id); 2316 pragma Inline (Set_Field19); 2317 2318 procedure Set_Field20 (N : Node_Id; Val : Union_Id); 2319 pragma Inline (Set_Field20); 2320 2321 procedure Set_Field21 (N : Node_Id; Val : Union_Id); 2322 pragma Inline (Set_Field21); 2323 2324 procedure Set_Field22 (N : Node_Id; Val : Union_Id); 2325 pragma Inline (Set_Field22); 2326 2327 procedure Set_Field23 (N : Node_Id; Val : Union_Id); 2328 pragma Inline (Set_Field23); 2329 2330 procedure Set_Field24 (N : Node_Id; Val : Union_Id); 2331 pragma Inline (Set_Field24); 2332 2333 procedure Set_Field25 (N : Node_Id; Val : Union_Id); 2334 pragma Inline (Set_Field25); 2335 2336 procedure Set_Field26 (N : Node_Id; Val : Union_Id); 2337 pragma Inline (Set_Field26); 2338 2339 procedure Set_Field27 (N : Node_Id; Val : Union_Id); 2340 pragma Inline (Set_Field27); 2341 2342 procedure Set_Field28 (N : Node_Id; Val : Union_Id); 2343 pragma Inline (Set_Field28); 2344 2345 procedure Set_Field29 (N : Node_Id; Val : Union_Id); 2346 pragma Inline (Set_Field29); 2347 2348 procedure Set_Field30 (N : Node_Id; Val : Union_Id); 2349 pragma Inline (Set_Field30); 2350 2351 procedure Set_Field31 (N : Node_Id; Val : Union_Id); 2352 pragma Inline (Set_Field31); 2353 2354 procedure Set_Field32 (N : Node_Id; Val : Union_Id); 2355 pragma Inline (Set_Field32); 2356 2357 procedure Set_Field33 (N : Node_Id; Val : Union_Id); 2358 pragma Inline (Set_Field33); 2359 2360 procedure Set_Field34 (N : Node_Id; Val : Union_Id); 2361 pragma Inline (Set_Field34); 2362 2363 procedure Set_Field35 (N : Node_Id; Val : Union_Id); 2364 pragma Inline (Set_Field35); 2365 2366 procedure Set_Node1 (N : Node_Id; Val : Node_Id); 2367 pragma Inline (Set_Node1); 2368 2369 procedure Set_Node2 (N : Node_Id; Val : Node_Id); 2370 pragma Inline (Set_Node2); 2371 2372 procedure Set_Node3 (N : Node_Id; Val : Node_Id); 2373 pragma Inline (Set_Node3); 2374 2375 procedure Set_Node4 (N : Node_Id; Val : Node_Id); 2376 pragma Inline (Set_Node4); 2377 2378 procedure Set_Node5 (N : Node_Id; Val : Node_Id); 2379 pragma Inline (Set_Node5); 2380 2381 procedure Set_Node6 (N : Node_Id; Val : Node_Id); 2382 pragma Inline (Set_Node6); 2383 2384 procedure Set_Node7 (N : Node_Id; Val : Node_Id); 2385 pragma Inline (Set_Node7); 2386 2387 procedure Set_Node8 (N : Node_Id; Val : Node_Id); 2388 pragma Inline (Set_Node8); 2389 2390 procedure Set_Node9 (N : Node_Id; Val : Node_Id); 2391 pragma Inline (Set_Node9); 2392 2393 procedure Set_Node10 (N : Node_Id; Val : Node_Id); 2394 pragma Inline (Set_Node10); 2395 2396 procedure Set_Node11 (N : Node_Id; Val : Node_Id); 2397 pragma Inline (Set_Node11); 2398 2399 procedure Set_Node12 (N : Node_Id; Val : Node_Id); 2400 pragma Inline (Set_Node12); 2401 2402 procedure Set_Node13 (N : Node_Id; Val : Node_Id); 2403 pragma Inline (Set_Node13); 2404 2405 procedure Set_Node14 (N : Node_Id; Val : Node_Id); 2406 pragma Inline (Set_Node14); 2407 2408 procedure Set_Node15 (N : Node_Id; Val : Node_Id); 2409 pragma Inline (Set_Node15); 2410 2411 procedure Set_Node16 (N : Node_Id; Val : Node_Id); 2412 pragma Inline (Set_Node16); 2413 2414 procedure Set_Node17 (N : Node_Id; Val : Node_Id); 2415 pragma Inline (Set_Node17); 2416 2417 procedure Set_Node18 (N : Node_Id; Val : Node_Id); 2418 pragma Inline (Set_Node18); 2419 2420 procedure Set_Node19 (N : Node_Id; Val : Node_Id); 2421 pragma Inline (Set_Node19); 2422 2423 procedure Set_Node20 (N : Node_Id; Val : Node_Id); 2424 pragma Inline (Set_Node20); 2425 2426 procedure Set_Node21 (N : Node_Id; Val : Node_Id); 2427 pragma Inline (Set_Node21); 2428 2429 procedure Set_Node22 (N : Node_Id; Val : Node_Id); 2430 pragma Inline (Set_Node22); 2431 2432 procedure Set_Node23 (N : Node_Id; Val : Node_Id); 2433 pragma Inline (Set_Node23); 2434 2435 procedure Set_Node24 (N : Node_Id; Val : Node_Id); 2436 pragma Inline (Set_Node24); 2437 2438 procedure Set_Node25 (N : Node_Id; Val : Node_Id); 2439 pragma Inline (Set_Node25); 2440 2441 procedure Set_Node26 (N : Node_Id; Val : Node_Id); 2442 pragma Inline (Set_Node26); 2443 2444 procedure Set_Node27 (N : Node_Id; Val : Node_Id); 2445 pragma Inline (Set_Node27); 2446 2447 procedure Set_Node28 (N : Node_Id; Val : Node_Id); 2448 pragma Inline (Set_Node28); 2449 2450 procedure Set_Node29 (N : Node_Id; Val : Node_Id); 2451 pragma Inline (Set_Node29); 2452 2453 procedure Set_Node30 (N : Node_Id; Val : Node_Id); 2454 pragma Inline (Set_Node30); 2455 2456 procedure Set_List1 (N : Node_Id; Val : List_Id); 2457 pragma Inline (Set_List1); 2458 2459 procedure Set_List2 (N : Node_Id; Val : List_Id); 2460 pragma Inline (Set_List2); 2461 2462 procedure Set_List3 (N : Node_Id; Val : List_Id); 2463 pragma Inline (Set_List3); 2464 2465 procedure Set_List4 (N : Node_Id; Val : List_Id); 2466 pragma Inline (Set_List4); 2467 2468 procedure Set_List5 (N : Node_Id; Val : List_Id); 2469 pragma Inline (Set_List5); 2470 2471 procedure Set_List10 (N : Node_Id; Val : List_Id); 2472 pragma Inline (Set_List10); 2473 2474 procedure Set_List14 (N : Node_Id; Val : List_Id); 2475 pragma Inline (Set_List14); 2476 2477 procedure Set_List25 (N : Node_Id; Val : List_Id); 2478 pragma Inline (Set_List25); 2479 2480 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id); 2481 pragma Inline (Set_Elist1); 2482 2483 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id); 2484 pragma Inline (Set_Elist2); 2485 2486 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id); 2487 pragma Inline (Set_Elist3); 2488 2489 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id); 2490 pragma Inline (Set_Elist4); 2491 2492 procedure Set_Elist5 (N : Node_Id; Val : Elist_Id); 2493 pragma Inline (Set_Elist5); 2494 2495 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id); 2496 pragma Inline (Set_Elist8); 2497 2498 procedure Set_Elist10 (N : Node_Id; Val : Elist_Id); 2499 pragma Inline (Set_Elist10); 2500 2501 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id); 2502 pragma Inline (Set_Elist13); 2503 2504 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id); 2505 pragma Inline (Set_Elist15); 2506 2507 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id); 2508 pragma Inline (Set_Elist16); 2509 2510 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id); 2511 pragma Inline (Set_Elist18); 2512 2513 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id); 2514 pragma Inline (Set_Elist21); 2515 2516 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id); 2517 pragma Inline (Set_Elist23); 2518 2519 procedure Set_Elist24 (N : Node_Id; Val : Elist_Id); 2520 pragma Inline (Set_Elist24); 2521 2522 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id); 2523 pragma Inline (Set_Elist25); 2524 2525 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id); 2526 pragma Inline (Set_Elist26); 2527 2528 procedure Set_Name1 (N : Node_Id; Val : Name_Id); 2529 pragma Inline (Set_Name1); 2530 2531 procedure Set_Name2 (N : Node_Id; Val : Name_Id); 2532 pragma Inline (Set_Name2); 2533 2534 procedure Set_Str3 (N : Node_Id; Val : String_Id); 2535 pragma Inline (Set_Str3); 2536 2537 procedure Set_Uint2 (N : Node_Id; Val : Uint); 2538 pragma Inline (Set_Uint2); 2539 2540 procedure Set_Uint3 (N : Node_Id; Val : Uint); 2541 pragma Inline (Set_Uint3); 2542 2543 procedure Set_Uint4 (N : Node_Id; Val : Uint); 2544 pragma Inline (Set_Uint4); 2545 2546 procedure Set_Uint5 (N : Node_Id; Val : Uint); 2547 pragma Inline (Set_Uint5); 2548 2549 procedure Set_Uint8 (N : Node_Id; Val : Uint); 2550 pragma Inline (Set_Uint8); 2551 2552 procedure Set_Uint9 (N : Node_Id; Val : Uint); 2553 pragma Inline (Set_Uint9); 2554 2555 procedure Set_Uint10 (N : Node_Id; Val : Uint); 2556 pragma Inline (Set_Uint10); 2557 2558 procedure Set_Uint11 (N : Node_Id; Val : Uint); 2559 pragma Inline (Set_Uint11); 2560 2561 procedure Set_Uint12 (N : Node_Id; Val : Uint); 2562 pragma Inline (Set_Uint12); 2563 2564 procedure Set_Uint13 (N : Node_Id; Val : Uint); 2565 pragma Inline (Set_Uint13); 2566 2567 procedure Set_Uint14 (N : Node_Id; Val : Uint); 2568 pragma Inline (Set_Uint14); 2569 2570 procedure Set_Uint15 (N : Node_Id; Val : Uint); 2571 pragma Inline (Set_Uint15); 2572 2573 procedure Set_Uint16 (N : Node_Id; Val : Uint); 2574 pragma Inline (Set_Uint16); 2575 2576 procedure Set_Uint17 (N : Node_Id; Val : Uint); 2577 pragma Inline (Set_Uint17); 2578 2579 procedure Set_Uint22 (N : Node_Id; Val : Uint); 2580 pragma Inline (Set_Uint22); 2581 2582 procedure Set_Ureal3 (N : Node_Id; Val : Ureal); 2583 pragma Inline (Set_Ureal3); 2584 2585 procedure Set_Ureal18 (N : Node_Id; Val : Ureal); 2586 pragma Inline (Set_Ureal18); 2587 2588 procedure Set_Ureal21 (N : Node_Id; Val : Ureal); 2589 pragma Inline (Set_Ureal21); 2590 2591 procedure Set_Flag4 (N : Node_Id; Val : Boolean); 2592 pragma Inline (Set_Flag4); 2593 2594 procedure Set_Flag5 (N : Node_Id; Val : Boolean); 2595 pragma Inline (Set_Flag5); 2596 2597 procedure Set_Flag6 (N : Node_Id; Val : Boolean); 2598 pragma Inline (Set_Flag6); 2599 2600 procedure Set_Flag7 (N : Node_Id; Val : Boolean); 2601 pragma Inline (Set_Flag7); 2602 2603 procedure Set_Flag8 (N : Node_Id; Val : Boolean); 2604 pragma Inline (Set_Flag8); 2605 2606 procedure Set_Flag9 (N : Node_Id; Val : Boolean); 2607 pragma Inline (Set_Flag9); 2608 2609 procedure Set_Flag10 (N : Node_Id; Val : Boolean); 2610 pragma Inline (Set_Flag10); 2611 2612 procedure Set_Flag11 (N : Node_Id; Val : Boolean); 2613 pragma Inline (Set_Flag11); 2614 2615 procedure Set_Flag12 (N : Node_Id; Val : Boolean); 2616 pragma Inline (Set_Flag12); 2617 2618 procedure Set_Flag13 (N : Node_Id; Val : Boolean); 2619 pragma Inline (Set_Flag13); 2620 2621 procedure Set_Flag14 (N : Node_Id; Val : Boolean); 2622 pragma Inline (Set_Flag14); 2623 2624 procedure Set_Flag15 (N : Node_Id; Val : Boolean); 2625 pragma Inline (Set_Flag15); 2626 2627 procedure Set_Flag16 (N : Node_Id; Val : Boolean); 2628 pragma Inline (Set_Flag16); 2629 2630 procedure Set_Flag17 (N : Node_Id; Val : Boolean); 2631 pragma Inline (Set_Flag17); 2632 2633 procedure Set_Flag18 (N : Node_Id; Val : Boolean); 2634 pragma Inline (Set_Flag18); 2635 2636 procedure Set_Flag19 (N : Node_Id; Val : Boolean); 2637 pragma Inline (Set_Flag19); 2638 2639 procedure Set_Flag20 (N : Node_Id; Val : Boolean); 2640 pragma Inline (Set_Flag20); 2641 2642 procedure Set_Flag21 (N : Node_Id; Val : Boolean); 2643 pragma Inline (Set_Flag21); 2644 2645 procedure Set_Flag22 (N : Node_Id; Val : Boolean); 2646 pragma Inline (Set_Flag22); 2647 2648 procedure Set_Flag23 (N : Node_Id; Val : Boolean); 2649 pragma Inline (Set_Flag23); 2650 2651 procedure Set_Flag24 (N : Node_Id; Val : Boolean); 2652 pragma Inline (Set_Flag24); 2653 2654 procedure Set_Flag25 (N : Node_Id; Val : Boolean); 2655 pragma Inline (Set_Flag25); 2656 2657 procedure Set_Flag26 (N : Node_Id; Val : Boolean); 2658 pragma Inline (Set_Flag26); 2659 2660 procedure Set_Flag27 (N : Node_Id; Val : Boolean); 2661 pragma Inline (Set_Flag27); 2662 2663 procedure Set_Flag28 (N : Node_Id; Val : Boolean); 2664 pragma Inline (Set_Flag28); 2665 2666 procedure Set_Flag29 (N : Node_Id; Val : Boolean); 2667 pragma Inline (Set_Flag29); 2668 2669 procedure Set_Flag30 (N : Node_Id; Val : Boolean); 2670 pragma Inline (Set_Flag30); 2671 2672 procedure Set_Flag31 (N : Node_Id; Val : Boolean); 2673 pragma Inline (Set_Flag31); 2674 2675 procedure Set_Flag32 (N : Node_Id; Val : Boolean); 2676 pragma Inline (Set_Flag32); 2677 2678 procedure Set_Flag33 (N : Node_Id; Val : Boolean); 2679 pragma Inline (Set_Flag33); 2680 2681 procedure Set_Flag34 (N : Node_Id; Val : Boolean); 2682 pragma Inline (Set_Flag34); 2683 2684 procedure Set_Flag35 (N : Node_Id; Val : Boolean); 2685 pragma Inline (Set_Flag35); 2686 2687 procedure Set_Flag36 (N : Node_Id; Val : Boolean); 2688 pragma Inline (Set_Flag36); 2689 2690 procedure Set_Flag37 (N : Node_Id; Val : Boolean); 2691 pragma Inline (Set_Flag37); 2692 2693 procedure Set_Flag38 (N : Node_Id; Val : Boolean); 2694 pragma Inline (Set_Flag38); 2695 2696 procedure Set_Flag39 (N : Node_Id; Val : Boolean); 2697 pragma Inline (Set_Flag39); 2698 2699 procedure Set_Flag40 (N : Node_Id; Val : Boolean); 2700 pragma Inline (Set_Flag40); 2701 2702 procedure Set_Flag41 (N : Node_Id; Val : Boolean); 2703 pragma Inline (Set_Flag41); 2704 2705 procedure Set_Flag42 (N : Node_Id; Val : Boolean); 2706 pragma Inline (Set_Flag42); 2707 2708 procedure Set_Flag43 (N : Node_Id; Val : Boolean); 2709 pragma Inline (Set_Flag43); 2710 2711 procedure Set_Flag44 (N : Node_Id; Val : Boolean); 2712 pragma Inline (Set_Flag44); 2713 2714 procedure Set_Flag45 (N : Node_Id; Val : Boolean); 2715 pragma Inline (Set_Flag45); 2716 2717 procedure Set_Flag46 (N : Node_Id; Val : Boolean); 2718 pragma Inline (Set_Flag46); 2719 2720 procedure Set_Flag47 (N : Node_Id; Val : Boolean); 2721 pragma Inline (Set_Flag47); 2722 2723 procedure Set_Flag48 (N : Node_Id; Val : Boolean); 2724 pragma Inline (Set_Flag48); 2725 2726 procedure Set_Flag49 (N : Node_Id; Val : Boolean); 2727 pragma Inline (Set_Flag49); 2728 2729 procedure Set_Flag50 (N : Node_Id; Val : Boolean); 2730 pragma Inline (Set_Flag50); 2731 2732 procedure Set_Flag51 (N : Node_Id; Val : Boolean); 2733 pragma Inline (Set_Flag51); 2734 2735 procedure Set_Flag52 (N : Node_Id; Val : Boolean); 2736 pragma Inline (Set_Flag52); 2737 2738 procedure Set_Flag53 (N : Node_Id; Val : Boolean); 2739 pragma Inline (Set_Flag53); 2740 2741 procedure Set_Flag54 (N : Node_Id; Val : Boolean); 2742 pragma Inline (Set_Flag54); 2743 2744 procedure Set_Flag55 (N : Node_Id; Val : Boolean); 2745 pragma Inline (Set_Flag55); 2746 2747 procedure Set_Flag56 (N : Node_Id; Val : Boolean); 2748 pragma Inline (Set_Flag56); 2749 2750 procedure Set_Flag57 (N : Node_Id; Val : Boolean); 2751 pragma Inline (Set_Flag57); 2752 2753 procedure Set_Flag58 (N : Node_Id; Val : Boolean); 2754 pragma Inline (Set_Flag58); 2755 2756 procedure Set_Flag59 (N : Node_Id; Val : Boolean); 2757 pragma Inline (Set_Flag59); 2758 2759 procedure Set_Flag60 (N : Node_Id; Val : Boolean); 2760 pragma Inline (Set_Flag60); 2761 2762 procedure Set_Flag61 (N : Node_Id; Val : Boolean); 2763 pragma Inline (Set_Flag61); 2764 2765 procedure Set_Flag62 (N : Node_Id; Val : Boolean); 2766 pragma Inline (Set_Flag62); 2767 2768 procedure Set_Flag63 (N : Node_Id; Val : Boolean); 2769 pragma Inline (Set_Flag63); 2770 2771 procedure Set_Flag64 (N : Node_Id; Val : Boolean); 2772 pragma Inline (Set_Flag64); 2773 2774 procedure Set_Flag65 (N : Node_Id; Val : Boolean); 2775 pragma Inline (Set_Flag65); 2776 2777 procedure Set_Flag66 (N : Node_Id; Val : Boolean); 2778 pragma Inline (Set_Flag66); 2779 2780 procedure Set_Flag67 (N : Node_Id; Val : Boolean); 2781 pragma Inline (Set_Flag67); 2782 2783 procedure Set_Flag68 (N : Node_Id; Val : Boolean); 2784 pragma Inline (Set_Flag68); 2785 2786 procedure Set_Flag69 (N : Node_Id; Val : Boolean); 2787 pragma Inline (Set_Flag69); 2788 2789 procedure Set_Flag70 (N : Node_Id; Val : Boolean); 2790 pragma Inline (Set_Flag70); 2791 2792 procedure Set_Flag71 (N : Node_Id; Val : Boolean); 2793 pragma Inline (Set_Flag71); 2794 2795 procedure Set_Flag72 (N : Node_Id; Val : Boolean); 2796 pragma Inline (Set_Flag72); 2797 2798 procedure Set_Flag73 (N : Node_Id; Val : Boolean); 2799 pragma Inline (Set_Flag73); 2800 2801 procedure Set_Flag74 (N : Node_Id; Val : Boolean); 2802 pragma Inline (Set_Flag74); 2803 2804 procedure Set_Flag75 (N : Node_Id; Val : Boolean); 2805 pragma Inline (Set_Flag75); 2806 2807 procedure Set_Flag76 (N : Node_Id; Val : Boolean); 2808 pragma Inline (Set_Flag76); 2809 2810 procedure Set_Flag77 (N : Node_Id; Val : Boolean); 2811 pragma Inline (Set_Flag77); 2812 2813 procedure Set_Flag78 (N : Node_Id; Val : Boolean); 2814 pragma Inline (Set_Flag78); 2815 2816 procedure Set_Flag79 (N : Node_Id; Val : Boolean); 2817 pragma Inline (Set_Flag79); 2818 2819 procedure Set_Flag80 (N : Node_Id; Val : Boolean); 2820 pragma Inline (Set_Flag80); 2821 2822 procedure Set_Flag81 (N : Node_Id; Val : Boolean); 2823 pragma Inline (Set_Flag81); 2824 2825 procedure Set_Flag82 (N : Node_Id; Val : Boolean); 2826 pragma Inline (Set_Flag82); 2827 2828 procedure Set_Flag83 (N : Node_Id; Val : Boolean); 2829 pragma Inline (Set_Flag83); 2830 2831 procedure Set_Flag84 (N : Node_Id; Val : Boolean); 2832 pragma Inline (Set_Flag84); 2833 2834 procedure Set_Flag85 (N : Node_Id; Val : Boolean); 2835 pragma Inline (Set_Flag85); 2836 2837 procedure Set_Flag86 (N : Node_Id; Val : Boolean); 2838 pragma Inline (Set_Flag86); 2839 2840 procedure Set_Flag87 (N : Node_Id; Val : Boolean); 2841 pragma Inline (Set_Flag87); 2842 2843 procedure Set_Flag88 (N : Node_Id; Val : Boolean); 2844 pragma Inline (Set_Flag88); 2845 2846 procedure Set_Flag89 (N : Node_Id; Val : Boolean); 2847 pragma Inline (Set_Flag89); 2848 2849 procedure Set_Flag90 (N : Node_Id; Val : Boolean); 2850 pragma Inline (Set_Flag90); 2851 2852 procedure Set_Flag91 (N : Node_Id; Val : Boolean); 2853 pragma Inline (Set_Flag91); 2854 2855 procedure Set_Flag92 (N : Node_Id; Val : Boolean); 2856 pragma Inline (Set_Flag92); 2857 2858 procedure Set_Flag93 (N : Node_Id; Val : Boolean); 2859 pragma Inline (Set_Flag93); 2860 2861 procedure Set_Flag94 (N : Node_Id; Val : Boolean); 2862 pragma Inline (Set_Flag94); 2863 2864 procedure Set_Flag95 (N : Node_Id; Val : Boolean); 2865 pragma Inline (Set_Flag95); 2866 2867 procedure Set_Flag96 (N : Node_Id; Val : Boolean); 2868 pragma Inline (Set_Flag96); 2869 2870 procedure Set_Flag97 (N : Node_Id; Val : Boolean); 2871 pragma Inline (Set_Flag97); 2872 2873 procedure Set_Flag98 (N : Node_Id; Val : Boolean); 2874 pragma Inline (Set_Flag98); 2875 2876 procedure Set_Flag99 (N : Node_Id; Val : Boolean); 2877 pragma Inline (Set_Flag99); 2878 2879 procedure Set_Flag100 (N : Node_Id; Val : Boolean); 2880 pragma Inline (Set_Flag100); 2881 2882 procedure Set_Flag101 (N : Node_Id; Val : Boolean); 2883 pragma Inline (Set_Flag101); 2884 2885 procedure Set_Flag102 (N : Node_Id; Val : Boolean); 2886 pragma Inline (Set_Flag102); 2887 2888 procedure Set_Flag103 (N : Node_Id; Val : Boolean); 2889 pragma Inline (Set_Flag103); 2890 2891 procedure Set_Flag104 (N : Node_Id; Val : Boolean); 2892 pragma Inline (Set_Flag104); 2893 2894 procedure Set_Flag105 (N : Node_Id; Val : Boolean); 2895 pragma Inline (Set_Flag105); 2896 2897 procedure Set_Flag106 (N : Node_Id; Val : Boolean); 2898 pragma Inline (Set_Flag106); 2899 2900 procedure Set_Flag107 (N : Node_Id; Val : Boolean); 2901 pragma Inline (Set_Flag107); 2902 2903 procedure Set_Flag108 (N : Node_Id; Val : Boolean); 2904 pragma Inline (Set_Flag108); 2905 2906 procedure Set_Flag109 (N : Node_Id; Val : Boolean); 2907 pragma Inline (Set_Flag109); 2908 2909 procedure Set_Flag110 (N : Node_Id; Val : Boolean); 2910 pragma Inline (Set_Flag110); 2911 2912 procedure Set_Flag111 (N : Node_Id; Val : Boolean); 2913 pragma Inline (Set_Flag111); 2914 2915 procedure Set_Flag112 (N : Node_Id; Val : Boolean); 2916 pragma Inline (Set_Flag112); 2917 2918 procedure Set_Flag113 (N : Node_Id; Val : Boolean); 2919 pragma Inline (Set_Flag113); 2920 2921 procedure Set_Flag114 (N : Node_Id; Val : Boolean); 2922 pragma Inline (Set_Flag114); 2923 2924 procedure Set_Flag115 (N : Node_Id; Val : Boolean); 2925 pragma Inline (Set_Flag115); 2926 2927 procedure Set_Flag116 (N : Node_Id; Val : Boolean); 2928 pragma Inline (Set_Flag116); 2929 2930 procedure Set_Flag117 (N : Node_Id; Val : Boolean); 2931 pragma Inline (Set_Flag117); 2932 2933 procedure Set_Flag118 (N : Node_Id; Val : Boolean); 2934 pragma Inline (Set_Flag118); 2935 2936 procedure Set_Flag119 (N : Node_Id; Val : Boolean); 2937 pragma Inline (Set_Flag119); 2938 2939 procedure Set_Flag120 (N : Node_Id; Val : Boolean); 2940 pragma Inline (Set_Flag120); 2941 2942 procedure Set_Flag121 (N : Node_Id; Val : Boolean); 2943 pragma Inline (Set_Flag121); 2944 2945 procedure Set_Flag122 (N : Node_Id; Val : Boolean); 2946 pragma Inline (Set_Flag122); 2947 2948 procedure Set_Flag123 (N : Node_Id; Val : Boolean); 2949 pragma Inline (Set_Flag123); 2950 2951 procedure Set_Flag124 (N : Node_Id; Val : Boolean); 2952 pragma Inline (Set_Flag124); 2953 2954 procedure Set_Flag125 (N : Node_Id; Val : Boolean); 2955 pragma Inline (Set_Flag125); 2956 2957 procedure Set_Flag126 (N : Node_Id; Val : Boolean); 2958 pragma Inline (Set_Flag126); 2959 2960 procedure Set_Flag127 (N : Node_Id; Val : Boolean); 2961 pragma Inline (Set_Flag127); 2962 2963 procedure Set_Flag128 (N : Node_Id; Val : Boolean); 2964 pragma Inline (Set_Flag128); 2965 2966 procedure Set_Flag129 (N : Node_Id; Val : Boolean); 2967 pragma Inline (Set_Flag129); 2968 2969 procedure Set_Flag130 (N : Node_Id; Val : Boolean); 2970 pragma Inline (Set_Flag130); 2971 2972 procedure Set_Flag131 (N : Node_Id; Val : Boolean); 2973 pragma Inline (Set_Flag131); 2974 2975 procedure Set_Flag132 (N : Node_Id; Val : Boolean); 2976 pragma Inline (Set_Flag132); 2977 2978 procedure Set_Flag133 (N : Node_Id; Val : Boolean); 2979 pragma Inline (Set_Flag133); 2980 2981 procedure Set_Flag134 (N : Node_Id; Val : Boolean); 2982 pragma Inline (Set_Flag134); 2983 2984 procedure Set_Flag135 (N : Node_Id; Val : Boolean); 2985 pragma Inline (Set_Flag135); 2986 2987 procedure Set_Flag136 (N : Node_Id; Val : Boolean); 2988 pragma Inline (Set_Flag136); 2989 2990 procedure Set_Flag137 (N : Node_Id; Val : Boolean); 2991 pragma Inline (Set_Flag137); 2992 2993 procedure Set_Flag138 (N : Node_Id; Val : Boolean); 2994 pragma Inline (Set_Flag138); 2995 2996 procedure Set_Flag139 (N : Node_Id; Val : Boolean); 2997 pragma Inline (Set_Flag139); 2998 2999 procedure Set_Flag140 (N : Node_Id; Val : Boolean); 3000 pragma Inline (Set_Flag140); 3001 3002 procedure Set_Flag141 (N : Node_Id; Val : Boolean); 3003 pragma Inline (Set_Flag141); 3004 3005 procedure Set_Flag142 (N : Node_Id; Val : Boolean); 3006 pragma Inline (Set_Flag142); 3007 3008 procedure Set_Flag143 (N : Node_Id; Val : Boolean); 3009 pragma Inline (Set_Flag143); 3010 3011 procedure Set_Flag144 (N : Node_Id; Val : Boolean); 3012 pragma Inline (Set_Flag144); 3013 3014 procedure Set_Flag145 (N : Node_Id; Val : Boolean); 3015 pragma Inline (Set_Flag145); 3016 3017 procedure Set_Flag146 (N : Node_Id; Val : Boolean); 3018 pragma Inline (Set_Flag146); 3019 3020 procedure Set_Flag147 (N : Node_Id; Val : Boolean); 3021 pragma Inline (Set_Flag147); 3022 3023 procedure Set_Flag148 (N : Node_Id; Val : Boolean); 3024 pragma Inline (Set_Flag148); 3025 3026 procedure Set_Flag149 (N : Node_Id; Val : Boolean); 3027 pragma Inline (Set_Flag149); 3028 3029 procedure Set_Flag150 (N : Node_Id; Val : Boolean); 3030 pragma Inline (Set_Flag150); 3031 3032 procedure Set_Flag151 (N : Node_Id; Val : Boolean); 3033 pragma Inline (Set_Flag151); 3034 3035 procedure Set_Flag152 (N : Node_Id; Val : Boolean); 3036 pragma Inline (Set_Flag152); 3037 3038 procedure Set_Flag153 (N : Node_Id; Val : Boolean); 3039 pragma Inline (Set_Flag153); 3040 3041 procedure Set_Flag154 (N : Node_Id; Val : Boolean); 3042 pragma Inline (Set_Flag154); 3043 3044 procedure Set_Flag155 (N : Node_Id; Val : Boolean); 3045 pragma Inline (Set_Flag155); 3046 3047 procedure Set_Flag156 (N : Node_Id; Val : Boolean); 3048 pragma Inline (Set_Flag156); 3049 3050 procedure Set_Flag157 (N : Node_Id; Val : Boolean); 3051 pragma Inline (Set_Flag157); 3052 3053 procedure Set_Flag158 (N : Node_Id; Val : Boolean); 3054 pragma Inline (Set_Flag158); 3055 3056 procedure Set_Flag159 (N : Node_Id; Val : Boolean); 3057 pragma Inline (Set_Flag159); 3058 3059 procedure Set_Flag160 (N : Node_Id; Val : Boolean); 3060 pragma Inline (Set_Flag160); 3061 3062 procedure Set_Flag161 (N : Node_Id; Val : Boolean); 3063 pragma Inline (Set_Flag161); 3064 3065 procedure Set_Flag162 (N : Node_Id; Val : Boolean); 3066 pragma Inline (Set_Flag162); 3067 3068 procedure Set_Flag163 (N : Node_Id; Val : Boolean); 3069 pragma Inline (Set_Flag163); 3070 3071 procedure Set_Flag164 (N : Node_Id; Val : Boolean); 3072 pragma Inline (Set_Flag164); 3073 3074 procedure Set_Flag165 (N : Node_Id; Val : Boolean); 3075 pragma Inline (Set_Flag165); 3076 3077 procedure Set_Flag166 (N : Node_Id; Val : Boolean); 3078 pragma Inline (Set_Flag166); 3079 3080 procedure Set_Flag167 (N : Node_Id; Val : Boolean); 3081 pragma Inline (Set_Flag167); 3082 3083 procedure Set_Flag168 (N : Node_Id; Val : Boolean); 3084 pragma Inline (Set_Flag168); 3085 3086 procedure Set_Flag169 (N : Node_Id; Val : Boolean); 3087 pragma Inline (Set_Flag169); 3088 3089 procedure Set_Flag170 (N : Node_Id; Val : Boolean); 3090 pragma Inline (Set_Flag170); 3091 3092 procedure Set_Flag171 (N : Node_Id; Val : Boolean); 3093 pragma Inline (Set_Flag171); 3094 3095 procedure Set_Flag172 (N : Node_Id; Val : Boolean); 3096 pragma Inline (Set_Flag172); 3097 3098 procedure Set_Flag173 (N : Node_Id; Val : Boolean); 3099 pragma Inline (Set_Flag173); 3100 3101 procedure Set_Flag174 (N : Node_Id; Val : Boolean); 3102 pragma Inline (Set_Flag174); 3103 3104 procedure Set_Flag175 (N : Node_Id; Val : Boolean); 3105 pragma Inline (Set_Flag175); 3106 3107 procedure Set_Flag176 (N : Node_Id; Val : Boolean); 3108 pragma Inline (Set_Flag176); 3109 3110 procedure Set_Flag177 (N : Node_Id; Val : Boolean); 3111 pragma Inline (Set_Flag177); 3112 3113 procedure Set_Flag178 (N : Node_Id; Val : Boolean); 3114 pragma Inline (Set_Flag178); 3115 3116 procedure Set_Flag179 (N : Node_Id; Val : Boolean); 3117 pragma Inline (Set_Flag179); 3118 3119 procedure Set_Flag180 (N : Node_Id; Val : Boolean); 3120 pragma Inline (Set_Flag180); 3121 3122 procedure Set_Flag181 (N : Node_Id; Val : Boolean); 3123 pragma Inline (Set_Flag181); 3124 3125 procedure Set_Flag182 (N : Node_Id; Val : Boolean); 3126 pragma Inline (Set_Flag182); 3127 3128 procedure Set_Flag183 (N : Node_Id; Val : Boolean); 3129 pragma Inline (Set_Flag183); 3130 3131 procedure Set_Flag184 (N : Node_Id; Val : Boolean); 3132 pragma Inline (Set_Flag184); 3133 3134 procedure Set_Flag185 (N : Node_Id; Val : Boolean); 3135 pragma Inline (Set_Flag185); 3136 3137 procedure Set_Flag186 (N : Node_Id; Val : Boolean); 3138 pragma Inline (Set_Flag186); 3139 3140 procedure Set_Flag187 (N : Node_Id; Val : Boolean); 3141 pragma Inline (Set_Flag187); 3142 3143 procedure Set_Flag188 (N : Node_Id; Val : Boolean); 3144 pragma Inline (Set_Flag188); 3145 3146 procedure Set_Flag189 (N : Node_Id; Val : Boolean); 3147 pragma Inline (Set_Flag189); 3148 3149 procedure Set_Flag190 (N : Node_Id; Val : Boolean); 3150 pragma Inline (Set_Flag190); 3151 3152 procedure Set_Flag191 (N : Node_Id; Val : Boolean); 3153 pragma Inline (Set_Flag191); 3154 3155 procedure Set_Flag192 (N : Node_Id; Val : Boolean); 3156 pragma Inline (Set_Flag192); 3157 3158 procedure Set_Flag193 (N : Node_Id; Val : Boolean); 3159 pragma Inline (Set_Flag193); 3160 3161 procedure Set_Flag194 (N : Node_Id; Val : Boolean); 3162 pragma Inline (Set_Flag194); 3163 3164 procedure Set_Flag195 (N : Node_Id; Val : Boolean); 3165 pragma Inline (Set_Flag195); 3166 3167 procedure Set_Flag196 (N : Node_Id; Val : Boolean); 3168 pragma Inline (Set_Flag196); 3169 3170 procedure Set_Flag197 (N : Node_Id; Val : Boolean); 3171 pragma Inline (Set_Flag197); 3172 3173 procedure Set_Flag198 (N : Node_Id; Val : Boolean); 3174 pragma Inline (Set_Flag198); 3175 3176 procedure Set_Flag199 (N : Node_Id; Val : Boolean); 3177 pragma Inline (Set_Flag199); 3178 3179 procedure Set_Flag200 (N : Node_Id; Val : Boolean); 3180 pragma Inline (Set_Flag200); 3181 3182 procedure Set_Flag201 (N : Node_Id; Val : Boolean); 3183 pragma Inline (Set_Flag201); 3184 3185 procedure Set_Flag202 (N : Node_Id; Val : Boolean); 3186 pragma Inline (Set_Flag202); 3187 3188 procedure Set_Flag203 (N : Node_Id; Val : Boolean); 3189 pragma Inline (Set_Flag203); 3190 3191 procedure Set_Flag204 (N : Node_Id; Val : Boolean); 3192 pragma Inline (Set_Flag204); 3193 3194 procedure Set_Flag205 (N : Node_Id; Val : Boolean); 3195 pragma Inline (Set_Flag205); 3196 3197 procedure Set_Flag206 (N : Node_Id; Val : Boolean); 3198 pragma Inline (Set_Flag206); 3199 3200 procedure Set_Flag207 (N : Node_Id; Val : Boolean); 3201 pragma Inline (Set_Flag207); 3202 3203 procedure Set_Flag208 (N : Node_Id; Val : Boolean); 3204 pragma Inline (Set_Flag208); 3205 3206 procedure Set_Flag209 (N : Node_Id; Val : Boolean); 3207 pragma Inline (Set_Flag209); 3208 3209 procedure Set_Flag210 (N : Node_Id; Val : Boolean); 3210 pragma Inline (Set_Flag210); 3211 3212 procedure Set_Flag211 (N : Node_Id; Val : Boolean); 3213 pragma Inline (Set_Flag211); 3214 3215 procedure Set_Flag212 (N : Node_Id; Val : Boolean); 3216 pragma Inline (Set_Flag212); 3217 3218 procedure Set_Flag213 (N : Node_Id; Val : Boolean); 3219 pragma Inline (Set_Flag213); 3220 3221 procedure Set_Flag214 (N : Node_Id; Val : Boolean); 3222 pragma Inline (Set_Flag214); 3223 3224 procedure Set_Flag215 (N : Node_Id; Val : Boolean); 3225 pragma Inline (Set_Flag215); 3226 3227 procedure Set_Flag216 (N : Node_Id; Val : Boolean); 3228 pragma Inline (Set_Flag216); 3229 3230 procedure Set_Flag217 (N : Node_Id; Val : Boolean); 3231 pragma Inline (Set_Flag217); 3232 3233 procedure Set_Flag218 (N : Node_Id; Val : Boolean); 3234 pragma Inline (Set_Flag218); 3235 3236 procedure Set_Flag219 (N : Node_Id; Val : Boolean); 3237 pragma Inline (Set_Flag219); 3238 3239 procedure Set_Flag220 (N : Node_Id; Val : Boolean); 3240 pragma Inline (Set_Flag220); 3241 3242 procedure Set_Flag221 (N : Node_Id; Val : Boolean); 3243 pragma Inline (Set_Flag221); 3244 3245 procedure Set_Flag222 (N : Node_Id; Val : Boolean); 3246 pragma Inline (Set_Flag222); 3247 3248 procedure Set_Flag223 (N : Node_Id; Val : Boolean); 3249 pragma Inline (Set_Flag223); 3250 3251 procedure Set_Flag224 (N : Node_Id; Val : Boolean); 3252 pragma Inline (Set_Flag224); 3253 3254 procedure Set_Flag225 (N : Node_Id; Val : Boolean); 3255 pragma Inline (Set_Flag225); 3256 3257 procedure Set_Flag226 (N : Node_Id; Val : Boolean); 3258 pragma Inline (Set_Flag226); 3259 3260 procedure Set_Flag227 (N : Node_Id; Val : Boolean); 3261 pragma Inline (Set_Flag227); 3262 3263 procedure Set_Flag228 (N : Node_Id; Val : Boolean); 3264 pragma Inline (Set_Flag228); 3265 3266 procedure Set_Flag229 (N : Node_Id; Val : Boolean); 3267 pragma Inline (Set_Flag229); 3268 3269 procedure Set_Flag230 (N : Node_Id; Val : Boolean); 3270 pragma Inline (Set_Flag230); 3271 3272 procedure Set_Flag231 (N : Node_Id; Val : Boolean); 3273 pragma Inline (Set_Flag231); 3274 3275 procedure Set_Flag232 (N : Node_Id; Val : Boolean); 3276 pragma Inline (Set_Flag232); 3277 3278 procedure Set_Flag233 (N : Node_Id; Val : Boolean); 3279 pragma Inline (Set_Flag233); 3280 3281 procedure Set_Flag234 (N : Node_Id; Val : Boolean); 3282 pragma Inline (Set_Flag234); 3283 3284 procedure Set_Flag235 (N : Node_Id; Val : Boolean); 3285 pragma Inline (Set_Flag235); 3286 3287 procedure Set_Flag236 (N : Node_Id; Val : Boolean); 3288 pragma Inline (Set_Flag236); 3289 3290 procedure Set_Flag237 (N : Node_Id; Val : Boolean); 3291 pragma Inline (Set_Flag237); 3292 3293 procedure Set_Flag238 (N : Node_Id; Val : Boolean); 3294 pragma Inline (Set_Flag238); 3295 3296 procedure Set_Flag239 (N : Node_Id; Val : Boolean); 3297 pragma Inline (Set_Flag239); 3298 3299 procedure Set_Flag240 (N : Node_Id; Val : Boolean); 3300 pragma Inline (Set_Flag240); 3301 3302 procedure Set_Flag241 (N : Node_Id; Val : Boolean); 3303 pragma Inline (Set_Flag241); 3304 3305 procedure Set_Flag242 (N : Node_Id; Val : Boolean); 3306 pragma Inline (Set_Flag242); 3307 3308 procedure Set_Flag243 (N : Node_Id; Val : Boolean); 3309 pragma Inline (Set_Flag243); 3310 3311 procedure Set_Flag244 (N : Node_Id; Val : Boolean); 3312 pragma Inline (Set_Flag244); 3313 3314 procedure Set_Flag245 (N : Node_Id; Val : Boolean); 3315 pragma Inline (Set_Flag245); 3316 3317 procedure Set_Flag246 (N : Node_Id; Val : Boolean); 3318 pragma Inline (Set_Flag246); 3319 3320 procedure Set_Flag247 (N : Node_Id; Val : Boolean); 3321 pragma Inline (Set_Flag247); 3322 3323 procedure Set_Flag248 (N : Node_Id; Val : Boolean); 3324 pragma Inline (Set_Flag248); 3325 3326 procedure Set_Flag249 (N : Node_Id; Val : Boolean); 3327 pragma Inline (Set_Flag249); 3328 3329 procedure Set_Flag250 (N : Node_Id; Val : Boolean); 3330 pragma Inline (Set_Flag250); 3331 3332 procedure Set_Flag251 (N : Node_Id; Val : Boolean); 3333 pragma Inline (Set_Flag251); 3334 3335 procedure Set_Flag252 (N : Node_Id; Val : Boolean); 3336 pragma Inline (Set_Flag252); 3337 3338 procedure Set_Flag253 (N : Node_Id; Val : Boolean); 3339 pragma Inline (Set_Flag253); 3340 3341 procedure Set_Flag254 (N : Node_Id; Val : Boolean); 3342 pragma Inline (Set_Flag254); 3343 3344 procedure Set_Flag255 (N : Node_Id; Val : Boolean); 3345 pragma Inline (Set_Flag255); 3346 3347 procedure Set_Flag256 (N : Node_Id; Val : Boolean); 3348 pragma Inline (Set_Flag256); 3349 3350 procedure Set_Flag257 (N : Node_Id; Val : Boolean); 3351 pragma Inline (Set_Flag257); 3352 3353 procedure Set_Flag258 (N : Node_Id; Val : Boolean); 3354 pragma Inline (Set_Flag258); 3355 3356 procedure Set_Flag259 (N : Node_Id; Val : Boolean); 3357 pragma Inline (Set_Flag259); 3358 3359 procedure Set_Flag260 (N : Node_Id; Val : Boolean); 3360 pragma Inline (Set_Flag260); 3361 3362 procedure Set_Flag261 (N : Node_Id; Val : Boolean); 3363 pragma Inline (Set_Flag261); 3364 3365 procedure Set_Flag262 (N : Node_Id; Val : Boolean); 3366 pragma Inline (Set_Flag262); 3367 3368 procedure Set_Flag263 (N : Node_Id; Val : Boolean); 3369 pragma Inline (Set_Flag263); 3370 3371 procedure Set_Flag264 (N : Node_Id; Val : Boolean); 3372 pragma Inline (Set_Flag264); 3373 3374 procedure Set_Flag265 (N : Node_Id; Val : Boolean); 3375 pragma Inline (Set_Flag265); 3376 3377 procedure Set_Flag266 (N : Node_Id; Val : Boolean); 3378 pragma Inline (Set_Flag266); 3379 3380 procedure Set_Flag267 (N : Node_Id; Val : Boolean); 3381 pragma Inline (Set_Flag267); 3382 3383 procedure Set_Flag268 (N : Node_Id; Val : Boolean); 3384 pragma Inline (Set_Flag268); 3385 3386 procedure Set_Flag269 (N : Node_Id; Val : Boolean); 3387 pragma Inline (Set_Flag269); 3388 3389 procedure Set_Flag270 (N : Node_Id; Val : Boolean); 3390 pragma Inline (Set_Flag270); 3391 3392 procedure Set_Flag271 (N : Node_Id; Val : Boolean); 3393 pragma Inline (Set_Flag271); 3394 3395 procedure Set_Flag272 (N : Node_Id; Val : Boolean); 3396 pragma Inline (Set_Flag272); 3397 3398 procedure Set_Flag273 (N : Node_Id; Val : Boolean); 3399 pragma Inline (Set_Flag273); 3400 3401 procedure Set_Flag274 (N : Node_Id; Val : Boolean); 3402 pragma Inline (Set_Flag274); 3403 3404 procedure Set_Flag275 (N : Node_Id; Val : Boolean); 3405 pragma Inline (Set_Flag275); 3406 3407 procedure Set_Flag276 (N : Node_Id; Val : Boolean); 3408 pragma Inline (Set_Flag276); 3409 3410 procedure Set_Flag277 (N : Node_Id; Val : Boolean); 3411 pragma Inline (Set_Flag277); 3412 3413 procedure Set_Flag278 (N : Node_Id; Val : Boolean); 3414 pragma Inline (Set_Flag278); 3415 3416 procedure Set_Flag279 (N : Node_Id; Val : Boolean); 3417 pragma Inline (Set_Flag279); 3418 3419 procedure Set_Flag280 (N : Node_Id; Val : Boolean); 3420 pragma Inline (Set_Flag280); 3421 3422 procedure Set_Flag281 (N : Node_Id; Val : Boolean); 3423 pragma Inline (Set_Flag281); 3424 3425 procedure Set_Flag282 (N : Node_Id; Val : Boolean); 3426 pragma Inline (Set_Flag282); 3427 3428 procedure Set_Flag283 (N : Node_Id; Val : Boolean); 3429 pragma Inline (Set_Flag283); 3430 3431 procedure Set_Flag284 (N : Node_Id; Val : Boolean); 3432 pragma Inline (Set_Flag284); 3433 3434 procedure Set_Flag285 (N : Node_Id; Val : Boolean); 3435 pragma Inline (Set_Flag285); 3436 3437 procedure Set_Flag286 (N : Node_Id; Val : Boolean); 3438 pragma Inline (Set_Flag286); 3439 3440 procedure Set_Flag287 (N : Node_Id; Val : Boolean); 3441 pragma Inline (Set_Flag287); 3442 3443 procedure Set_Flag288 (N : Node_Id; Val : Boolean); 3444 pragma Inline (Set_Flag288); 3445 3446 procedure Set_Flag289 (N : Node_Id; Val : Boolean); 3447 pragma Inline (Set_Flag289); 3448 3449 procedure Set_Flag290 (N : Node_Id; Val : Boolean); 3450 pragma Inline (Set_Flag290); 3451 3452 procedure Set_Flag291 (N : Node_Id; Val : Boolean); 3453 pragma Inline (Set_Flag291); 3454 3455 procedure Set_Flag292 (N : Node_Id; Val : Boolean); 3456 pragma Inline (Set_Flag292); 3457 3458 procedure Set_Flag293 (N : Node_Id; Val : Boolean); 3459 pragma Inline (Set_Flag293); 3460 3461 procedure Set_Flag294 (N : Node_Id; Val : Boolean); 3462 pragma Inline (Set_Flag294); 3463 3464 procedure Set_Flag295 (N : Node_Id; Val : Boolean); 3465 pragma Inline (Set_Flag295); 3466 3467 procedure Set_Flag296 (N : Node_Id; Val : Boolean); 3468 pragma Inline (Set_Flag296); 3469 3470 procedure Set_Flag297 (N : Node_Id; Val : Boolean); 3471 pragma Inline (Set_Flag297); 3472 3473 procedure Set_Flag298 (N : Node_Id; Val : Boolean); 3474 pragma Inline (Set_Flag298); 3475 3476 procedure Set_Flag299 (N : Node_Id; Val : Boolean); 3477 pragma Inline (Set_Flag299); 3478 3479 procedure Set_Flag300 (N : Node_Id; Val : Boolean); 3480 pragma Inline (Set_Flag300); 3481 3482 procedure Set_Flag301 (N : Node_Id; Val : Boolean); 3483 pragma Inline (Set_Flag301); 3484 3485 procedure Set_Flag302 (N : Node_Id; Val : Boolean); 3486 pragma Inline (Set_Flag302); 3487 3488 procedure Set_Flag303 (N : Node_Id; Val : Boolean); 3489 pragma Inline (Set_Flag303); 3490 3491 procedure Set_Flag304 (N : Node_Id; Val : Boolean); 3492 pragma Inline (Set_Flag304); 3493 3494 procedure Set_Flag305 (N : Node_Id; Val : Boolean); 3495 pragma Inline (Set_Flag305); 3496 3497 procedure Set_Flag306 (N : Node_Id; Val : Boolean); 3498 pragma Inline (Set_Flag306); 3499 3500 procedure Set_Flag307 (N : Node_Id; Val : Boolean); 3501 pragma Inline (Set_Flag307); 3502 3503 procedure Set_Flag308 (N : Node_Id; Val : Boolean); 3504 pragma Inline (Set_Flag308); 3505 3506 procedure Set_Flag309 (N : Node_Id; Val : Boolean); 3507 pragma Inline (Set_Flag309); 3508 3509 procedure Set_Flag310 (N : Node_Id; Val : Boolean); 3510 pragma Inline (Set_Flag310); 3511 3512 procedure Set_Flag311 (N : Node_Id; Val : Boolean); 3513 pragma Inline (Set_Flag311); 3514 3515 procedure Set_Flag312 (N : Node_Id; Val : Boolean); 3516 pragma Inline (Set_Flag312); 3517 3518 procedure Set_Flag313 (N : Node_Id; Val : Boolean); 3519 pragma Inline (Set_Flag313); 3520 3521 procedure Set_Flag314 (N : Node_Id; Val : Boolean); 3522 pragma Inline (Set_Flag314); 3523 3524 procedure Set_Flag315 (N : Node_Id; Val : Boolean); 3525 pragma Inline (Set_Flag315); 3526 3527 procedure Set_Flag316 (N : Node_Id; Val : Boolean); 3528 pragma Inline (Set_Flag316); 3529 3530 procedure Set_Flag317 (N : Node_Id; Val : Boolean); 3531 pragma Inline (Set_Flag317); 3532 3533 -- The following versions of Set_Noden also set the parent pointer of 3534 -- the referenced node if it is not Empty. 3535 3536 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id); 3537 pragma Inline (Set_Node1_With_Parent); 3538 3539 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id); 3540 pragma Inline (Set_Node2_With_Parent); 3541 3542 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id); 3543 pragma Inline (Set_Node3_With_Parent); 3544 3545 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id); 3546 pragma Inline (Set_Node4_With_Parent); 3547 3548 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id); 3549 pragma Inline (Set_Node5_With_Parent); 3550 3551 -- The following versions of Set_Listn also set the parent pointer of 3552 -- the referenced node if it is not Empty. 3553 3554 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id); 3555 pragma Inline (Set_List1_With_Parent); 3556 3557 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id); 3558 pragma Inline (Set_List2_With_Parent); 3559 3560 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id); 3561 pragma Inline (Set_List3_With_Parent); 3562 3563 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id); 3564 pragma Inline (Set_List4_With_Parent); 3565 3566 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id); 3567 pragma Inline (Set_List5_With_Parent); 3568 3569 end Unchecked_Access; 3570 3571 ----------------------------- 3572 -- Private Part Subpackage -- 3573 ----------------------------- 3574 3575 -- The following package contains the definition of the data structure 3576 -- used by the implementation of the Atree package. Logically it really 3577 -- corresponds to the private part, hence the name. The reason that it 3578 -- is defined as a sub-package is to allow special access from clients 3579 -- that need to see the internals of the data structures. 3580 3581 package Atree_Private_Part is 3582 3583 ------------------------- 3584 -- Tree Representation -- 3585 ------------------------- 3586 3587 -- The nodes of the tree are stored in a table (i.e. an array). In the 3588 -- case of extended nodes five consecutive components in the array are 3589 -- used. There are thus two formats for array components. One is used 3590 -- for non-extended nodes, and for the first component of extended 3591 -- nodes. The other is used for the extension parts (second, third, 3592 -- fourth and fifth components) of an extended node. A variant record 3593 -- structure is used to distinguish the two formats. 3594 3595 type Node_Record (Is_Extension : Boolean := False) is record 3596 3597 -- Logically, the only field in the common part is the above 3598 -- Is_Extension discriminant (a single bit). However, Gigi cannot 3599 -- yet handle such a structure, so we fill out the common part of 3600 -- the record with fields that are used in different ways for 3601 -- normal nodes and node extensions. 3602 3603 Pflag1, Pflag2 : Boolean; 3604 -- The Paren_Count field is represented using two boolean flags, 3605 -- where Pflag1 is worth 1, and Pflag2 is worth 2. This is done 3606 -- because we need to be easily able to reuse this field for 3607 -- extra flags in the extended node case. 3608 3609 In_List : Boolean; 3610 -- Flag used to indicate if node is a member of a list. 3611 -- This field is considered private to the Atree package. 3612 3613 Has_Aspects : Boolean; 3614 -- Flag used to indicate that a node has aspect specifications that 3615 -- are associated with the node. See Aspects package for details. 3616 3617 Rewrite_Ins : Boolean; 3618 -- Flag set by Mark_Rewrite_Insertion procedure. 3619 -- This field is considered private to the Atree package. 3620 3621 Analyzed : Boolean; 3622 -- Flag to indicate the node has been analyzed (and expanded) 3623 3624 Comes_From_Source : Boolean; 3625 -- Flag to indicate that node comes from the source program (i.e. 3626 -- was built by the parser or scanner, not the analyzer or expander). 3627 3628 Error_Posted : Boolean; 3629 -- Flag to indicate that an error message has been posted on the 3630 -- node (to avoid duplicate flags on the same node) 3631 3632 Flag4 : Boolean; 3633 Flag5 : Boolean; 3634 Flag6 : Boolean; 3635 Flag7 : Boolean; 3636 Flag8 : Boolean; 3637 Flag9 : Boolean; 3638 Flag10 : Boolean; 3639 Flag11 : Boolean; 3640 Flag12 : Boolean; 3641 Flag13 : Boolean; 3642 Flag14 : Boolean; 3643 Flag15 : Boolean; 3644 Flag16 : Boolean; 3645 Flag17 : Boolean; 3646 Flag18 : Boolean; 3647 -- The eighteen flags for a normal node 3648 3649 -- The above fields are used as follows in components 2-6 of 3650 -- an extended node entry. 3651 3652 -- In_List used as Flag19,Flag40,Flag129,Flag216,Flag287 3653 -- Has_Aspects used as Flag20,Flag41,Flag130,Flag217,Flag288 3654 -- Rewrite_Ins used as Flag21,Flag42,Flag131,Flag218,Flag289 3655 -- Analyzed used as Flag22,Flag43,Flag132,Flag219,Flag290 3656 -- Comes_From_Source used as Flag23,Flag44,Flag133,Flag220,Flag291 3657 -- Error_Posted used as Flag24,Flag45,Flag134,Flag221,Flag292 3658 -- Flag4 used as Flag25,Flag46,Flag135,Flag222,Flag293 3659 -- Flag5 used as Flag26,Flag47,Flag136,Flag223,Flag294 3660 -- Flag6 used as Flag27,Flag48,Flag137,Flag224,Flag295 3661 -- Flag7 used as Flag28,Flag49,Flag138,Flag225,Flag296 3662 -- Flag8 used as Flag29,Flag50,Flag139,Flag226,Flag297 3663 -- Flag9 used as Flag30,Flag51,Flag140,Flag227,Flag298 3664 -- Flag10 used as Flag31,Flag52,Flag141,Flag228,Flag299 3665 -- Flag11 used as Flag32,Flag53,Flag142,Flag229,Flag300 3666 -- Flag12 used as Flag33,Flag54,Flag143,Flag230,Flag301 3667 -- Flag13 used as Flag34,Flag55,Flag144,Flag231,Flag302 3668 -- Flag14 used as Flag35,Flag56,Flag145,Flag232,Flag303 3669 -- Flag15 used as Flag36,Flag57,Flag146,Flag233,Flag304 3670 -- Flag16 used as Flag37,Flag58,Flag147,Flag234,Flag305 3671 -- Flag17 used as Flag38,Flag59,Flag148,Flag235,Flag306 3672 -- Flag18 used as Flag39,Flag60,Flag149,Flag236,Flag307 3673 -- Pflag1 used as Flag61,Flag62,Flag150,Flag237,Flag308 3674 -- Pflag2 used as Flag63,Flag64,Flag151,Flag238,Flag309 3675 3676 Nkind : Node_Kind; 3677 -- For a non-extended node, or the initial section of an extended 3678 -- node, this field holds the Node_Kind value. For an extended node, 3679 -- The Nkind field is used as follows: 3680 -- 3681 -- Second entry: holds the Ekind field of the entity 3682 -- Third entry: holds 8 additional flags (Flag65-Flag72) 3683 -- Fourth entry: holds 8 additional flags (Flag239-246) 3684 -- Fifth entry: holds 8 additional flags (Flag247-254) 3685 -- Sixth entry: holds 8 additional flags (Flag310-317) 3686 3687 -- Now finally (on an 32-bit boundary!) comes the variant part 3688 3689 case Is_Extension is 3690 3691 -- Non-extended node, or first component of extended node 3692 3693 when False => 3694 3695 Sloc : Source_Ptr; 3696 -- Source location for this node 3697 3698 Link : Union_Id; 3699 -- This field is used either as the Parent pointer (if In_List 3700 -- is False), or to point to the list header (if In_List is 3701 -- True). This field is considered private and can be modified 3702 -- only by Atree or by Nlists. 3703 3704 Field1 : Union_Id; 3705 Field2 : Union_Id; 3706 Field3 : Union_Id; 3707 Field4 : Union_Id; 3708 Field5 : Union_Id; 3709 -- Five general use fields, which can contain Node_Id, List_Id, 3710 -- Elist_Id, String_Id, or Name_Id values depending on the 3711 -- values in Nkind and (for extended nodes), in Ekind. See 3712 -- packages Sinfo and Einfo for details of their use. 3713 3714 -- Extension (second component) of extended node 3715 3716 when True => 3717 3718 Field6 : Union_Id; 3719 Field7 : Union_Id; 3720 Field8 : Union_Id; 3721 Field9 : Union_Id; 3722 Field10 : Union_Id; 3723 Field11 : Union_Id; 3724 Field12 : Union_Id; 3725 -- Seven additional general fields available only for entities 3726 -- See package Einfo for details of their use (which depends 3727 -- on the value in the Ekind field). 3728 3729 -- In the third component, the extension format as described 3730 -- above is used to hold additional general fields and flags 3731 -- as follows: 3732 3733 -- Field6-11 Holds Field13-Field18 3734 -- Field12 Holds Flag73-Flag96 and Convention 3735 3736 -- In the fourth component, the extension format as described 3737 -- above is used to hold additional general fields and flags 3738 -- as follows: 3739 3740 -- Field6-10 Holds Field19-Field23 3741 -- Field11 Holds Flag152-Flag183 3742 -- Field12 Holds Flag97-Flag128 3743 3744 -- In the fifth component, the extension format as described 3745 -- above is used to hold additional general fields and flags 3746 -- as follows: 3747 3748 -- Field6-11 Holds Field24-Field29 3749 -- Field12 Holds Flag184-Flag215 3750 3751 -- In the sixth component, the extension format as described 3752 -- above is used to hold additional general fields and flags 3753 -- as follows: 3754 3755 -- Field6-11 Holds Field30-Field35 3756 -- Field12 Holds Flag255-Flag286 3757 3758 end case; 3759 end record; 3760 3761 pragma Pack (Node_Record); 3762 for Node_Record'Size use 8*32; 3763 for Node_Record'Alignment use 4; 3764 3765 function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind); 3766 function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind); 3767 3768 -- Default value used to initialize default nodes. Note that some of the 3769 -- fields get overwritten, and in particular, Nkind always gets reset. 3770 3771 Default_Node : Node_Record := ( 3772 Is_Extension => False, 3773 Pflag1 => False, 3774 Pflag2 => False, 3775 In_List => False, 3776 Has_Aspects => False, 3777 Rewrite_Ins => False, 3778 Analyzed => False, 3779 Comes_From_Source => False, 3780 -- modified by Set_Comes_From_Source_Default 3781 Error_Posted => False, 3782 Flag4 => False, 3783 3784 Flag5 => False, 3785 Flag6 => False, 3786 Flag7 => False, 3787 Flag8 => False, 3788 Flag9 => False, 3789 Flag10 => False, 3790 Flag11 => False, 3791 Flag12 => False, 3792 3793 Flag13 => False, 3794 Flag14 => False, 3795 Flag15 => False, 3796 Flag16 => False, 3797 Flag17 => False, 3798 Flag18 => False, 3799 3800 Nkind => N_Unused_At_Start, 3801 3802 Sloc => No_Location, 3803 Link => Empty_List_Or_Node, 3804 Field1 => Empty_List_Or_Node, 3805 Field2 => Empty_List_Or_Node, 3806 Field3 => Empty_List_Or_Node, 3807 Field4 => Empty_List_Or_Node, 3808 Field5 => Empty_List_Or_Node); 3809 3810 -- Default value used to initialize node extensions (i.e. the second 3811 -- through sixth components of an extended node). Note we are cheating 3812 -- a bit here when it comes to Node12, which really holds flags and (for 3813 -- the third component), the convention. But it works because Empty, 3814 -- False, Convention_Ada, all happen to be all zero bits. 3815 3816 Default_Node_Extension : constant Node_Record := ( 3817 Is_Extension => True, 3818 Pflag1 => False, 3819 Pflag2 => False, 3820 In_List => False, 3821 Has_Aspects => False, 3822 Rewrite_Ins => False, 3823 Analyzed => False, 3824 Comes_From_Source => False, 3825 Error_Posted => False, 3826 Flag4 => False, 3827 3828 Flag5 => False, 3829 Flag6 => False, 3830 Flag7 => False, 3831 Flag8 => False, 3832 Flag9 => False, 3833 Flag10 => False, 3834 Flag11 => False, 3835 Flag12 => False, 3836 3837 Flag13 => False, 3838 Flag14 => False, 3839 Flag15 => False, 3840 Flag16 => False, 3841 Flag17 => False, 3842 Flag18 => False, 3843 3844 Nkind => E_To_N (E_Void), 3845 3846 Field6 => Empty_List_Or_Node, 3847 Field7 => Empty_List_Or_Node, 3848 Field8 => Empty_List_Or_Node, 3849 Field9 => Empty_List_Or_Node, 3850 Field10 => Empty_List_Or_Node, 3851 Field11 => Empty_List_Or_Node, 3852 Field12 => Empty_List_Or_Node); 3853 3854 -- The following defines the extendable array used for the nodes table 3855 -- Nodes with extensions use five consecutive entries in the array 3856 3857 package Nodes is new Table.Table ( 3858 Table_Component_Type => Node_Record, 3859 Table_Index_Type => Node_Id'Base, 3860 Table_Low_Bound => First_Node_Id, 3861 Table_Initial => Alloc.Nodes_Initial, 3862 Table_Increment => Alloc.Nodes_Increment, 3863 Table_Name => "Nodes"); 3864 3865 end Atree_Private_Part; 3866 3867end Atree; 3868