1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- A T R E E -- 6-- -- 7-- B o d y -- 8-- -- 9-- Copyright (C) 1992-2020, 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. See the GNU General Public License -- 17-- for more details. You should have received a copy of the GNU General -- 18-- Public License distributed with GNAT; see file COPYING3. If not, go to -- 19-- http://www.gnu.org/licenses for a complete copy of the license. -- 20-- -- 21-- GNAT was originally developed by the GNAT team at New York University. -- 22-- Extensive contributions were provided by Ada Core Technologies Inc. -- 23-- -- 24------------------------------------------------------------------------------ 25 26pragma Style_Checks (All_Checks); 27-- Turn off subprogram ordering check for this package 28 29-- WARNING: There is a C version of this package. Any changes to this source 30-- file must be properly reflected in the file atree.h which is a C header 31-- file containing equivalent definitions for use by gigi. 32 33with Aspects; use Aspects; 34with Debug; use Debug; 35with Nlists; use Nlists; 36with Opt; use Opt; 37with Output; use Output; 38with Sinput; use Sinput; 39 40with GNAT.Heap_Sort_G; 41 42package body Atree is 43 44 Ignored_Ghost_Recording_Proc : Ignored_Ghost_Record_Proc := null; 45 -- This soft link captures the procedure invoked during the creation of an 46 -- ignored Ghost node or entity. 47 48 Locked : Boolean := False; 49 -- Compiling with assertions enabled, node contents modifications are 50 -- permitted only when this switch is set to False; compiling without 51 -- assertions this lock has no effect. 52 53 Reporting_Proc : Report_Proc := null; 54 -- Set_Reporting_Proc sets this. Set_Reporting_Proc must be called only 55 -- once. 56 57 Rewriting_Proc : Rewrite_Proc := null; 58 -- This soft link captures the procedure invoked during a node rewrite 59 60 --------------- 61 -- Debugging -- 62 --------------- 63 64 -- Suppose you find that node 12345 is messed up. You might want to find 65 -- the code that created that node. There are two ways to do this: 66 67 -- One way is to set a conditional breakpoint on New_Node_Debugging_Output 68 -- (nickname "nnd"): 69 -- break nnd if n = 12345 70 -- and run gnat1 again from the beginning. 71 72 -- The other way is to set a breakpoint near the beginning (e.g. on 73 -- gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb: 74 -- ww := 12345 75 -- and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue. 76 77 -- Either way, gnat1 will stop when node 12345 is created, or certain other 78 -- interesting operations are performed, such as Rewrite. To see exactly 79 -- which operations, search for "pragma Debug" below. 80 81 -- The second method is much faster if the amount of Ada code being 82 -- compiled is large. 83 84 ww : Node_Id'Base := Node_Id'First - 1; 85 pragma Export (Ada, ww); -- trick the optimizer 86 Watch_Node : Node_Id'Base renames ww; 87 -- Node to "watch"; that is, whenever a node is created, we check if it 88 -- is equal to Watch_Node, and if so, call New_Node_Breakpoint. You have 89 -- presumably set a breakpoint on New_Node_Breakpoint. Note that the 90 -- initial value of Node_Id'First - 1 ensures that by default, no node 91 -- will be equal to Watch_Node. 92 93 procedure nn; 94 pragma Export (Ada, nn); 95 procedure New_Node_Breakpoint renames nn; 96 -- This doesn't do anything interesting; it's just for setting breakpoint 97 -- on as explained above. 98 99 procedure nnd (N : Node_Id); 100 pragma Export (Ada, nnd); 101 procedure New_Node_Debugging_Output (N : Node_Id) renames nnd; 102 -- For debugging. If debugging is turned on, New_Node and New_Entity call 103 -- this. If debug flag N is turned on, this prints out the new node. 104 -- 105 -- If Node = Watch_Node, this prints out the new node and calls 106 -- New_Node_Breakpoint. Otherwise, does nothing. 107 108 procedure Node_Debug_Output (Op : String; N : Node_Id); 109 -- Called by nnd; writes Op followed by information about N 110 111 ----------------------------- 112 -- Local Objects and Types -- 113 ----------------------------- 114 115 Comes_From_Source_Default : Boolean := False; 116 117 use Unchecked_Access; 118 -- We are allowed to see these from within our own body 119 120 use Atree_Private_Part; 121 -- We are also allowed to see our private data structures 122 123 -- Functions used to store Entity_Kind value in Nkind field 124 125 -- The following declarations are used to store flags 65-72 in the 126 -- Nkind field of the third component of an extended (entity) node. 127 128 type Flag_Byte is record 129 Flag65 : Boolean; 130 Flag66 : Boolean; 131 Flag67 : Boolean; 132 Flag68 : Boolean; 133 Flag69 : Boolean; 134 Flag70 : Boolean; 135 Flag71 : Boolean; 136 Flag72 : Boolean; 137 end record; 138 139 pragma Pack (Flag_Byte); 140 for Flag_Byte'Size use 8; 141 142 type Flag_Byte_Ptr is access all Flag_Byte; 143 type Node_Kind_Ptr is access all Node_Kind; 144 145 function To_Flag_Byte is new 146 Unchecked_Conversion (Node_Kind, Flag_Byte); 147 148 function To_Flag_Byte_Ptr is new 149 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr); 150 151 -- The following declarations are used to store flags 239-246 in the 152 -- Nkind field of the fourth component of an extended (entity) node. 153 154 type Flag_Byte2 is record 155 Flag239 : Boolean; 156 Flag240 : Boolean; 157 Flag241 : Boolean; 158 Flag242 : Boolean; 159 Flag243 : Boolean; 160 Flag244 : Boolean; 161 Flag245 : Boolean; 162 Flag246 : Boolean; 163 end record; 164 165 pragma Pack (Flag_Byte2); 166 for Flag_Byte2'Size use 8; 167 168 type Flag_Byte2_Ptr is access all Flag_Byte2; 169 170 function To_Flag_Byte2 is new 171 Unchecked_Conversion (Node_Kind, Flag_Byte2); 172 173 function To_Flag_Byte2_Ptr is new 174 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte2_Ptr); 175 176 -- The following declarations are used to store flags 247-254 in the 177 -- Nkind field of the fifth component of an extended (entity) node. 178 179 type Flag_Byte3 is record 180 Flag247 : Boolean; 181 Flag248 : Boolean; 182 Flag249 : Boolean; 183 Flag250 : Boolean; 184 Flag251 : Boolean; 185 Flag252 : Boolean; 186 Flag253 : Boolean; 187 Flag254 : Boolean; 188 end record; 189 190 pragma Pack (Flag_Byte3); 191 for Flag_Byte3'Size use 8; 192 193 type Flag_Byte3_Ptr is access all Flag_Byte3; 194 195 function To_Flag_Byte3 is new 196 Unchecked_Conversion (Node_Kind, Flag_Byte3); 197 198 function To_Flag_Byte3_Ptr is new 199 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte3_Ptr); 200 201 -- The following declarations are used to store flags 310-317 in the 202 -- Nkind field of the sixth component of an extended (entity) node. 203 204 type Flag_Byte4 is record 205 Flag310 : Boolean; 206 Flag311 : Boolean; 207 Flag312 : Boolean; 208 Flag313 : Boolean; 209 Flag314 : Boolean; 210 Flag315 : Boolean; 211 Flag316 : Boolean; 212 Flag317 : Boolean; 213 end record; 214 215 pragma Pack (Flag_Byte4); 216 for Flag_Byte4'Size use 8; 217 218 type Flag_Byte4_Ptr is access all Flag_Byte4; 219 220 function To_Flag_Byte4 is new 221 Unchecked_Conversion (Node_Kind, Flag_Byte4); 222 223 function To_Flag_Byte4_Ptr is new 224 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte4_Ptr); 225 226 -- The following declarations are used to store flags 73-96 and the 227 -- Convention field in the Field12 field of the third component of an 228 -- extended (Entity) node. 229 230 type Flag_Word is record 231 Flag73 : Boolean; 232 Flag74 : Boolean; 233 Flag75 : Boolean; 234 Flag76 : Boolean; 235 Flag77 : Boolean; 236 Flag78 : Boolean; 237 Flag79 : Boolean; 238 Flag80 : Boolean; 239 240 Flag81 : Boolean; 241 Flag82 : Boolean; 242 Flag83 : Boolean; 243 Flag84 : Boolean; 244 Flag85 : Boolean; 245 Flag86 : Boolean; 246 Flag87 : Boolean; 247 Flag88 : Boolean; 248 249 Flag89 : Boolean; 250 Flag90 : Boolean; 251 Flag91 : Boolean; 252 Flag92 : Boolean; 253 Flag93 : Boolean; 254 Flag94 : Boolean; 255 Flag95 : Boolean; 256 Flag96 : Boolean; 257 258 Convention : Convention_Id; 259 end record; 260 261 pragma Pack (Flag_Word); 262 for Flag_Word'Size use 32; 263 for Flag_Word'Alignment use 4; 264 265 type Flag_Word_Ptr is access all Flag_Word; 266 type Union_Id_Ptr is access all Union_Id; 267 268 function To_Flag_Word is new 269 Unchecked_Conversion (Union_Id, Flag_Word); 270 271 function To_Flag_Word_Ptr is new 272 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr); 273 274 -- The following declarations are used to store flags 97-128 in the 275 -- Field12 field of the fourth component of an extended (entity) node. 276 277 type Flag_Word2 is record 278 Flag97 : Boolean; 279 Flag98 : Boolean; 280 Flag99 : Boolean; 281 Flag100 : Boolean; 282 Flag101 : Boolean; 283 Flag102 : Boolean; 284 Flag103 : Boolean; 285 Flag104 : Boolean; 286 287 Flag105 : Boolean; 288 Flag106 : Boolean; 289 Flag107 : Boolean; 290 Flag108 : Boolean; 291 Flag109 : Boolean; 292 Flag110 : Boolean; 293 Flag111 : Boolean; 294 Flag112 : Boolean; 295 296 Flag113 : Boolean; 297 Flag114 : Boolean; 298 Flag115 : Boolean; 299 Flag116 : Boolean; 300 Flag117 : Boolean; 301 Flag118 : Boolean; 302 Flag119 : Boolean; 303 Flag120 : Boolean; 304 305 Flag121 : Boolean; 306 Flag122 : Boolean; 307 Flag123 : Boolean; 308 Flag124 : Boolean; 309 Flag125 : Boolean; 310 Flag126 : Boolean; 311 Flag127 : Boolean; 312 Flag128 : Boolean; 313 end record; 314 315 pragma Pack (Flag_Word2); 316 for Flag_Word2'Size use 32; 317 for Flag_Word2'Alignment use 4; 318 319 type Flag_Word2_Ptr is access all Flag_Word2; 320 321 function To_Flag_Word2 is new 322 Unchecked_Conversion (Union_Id, Flag_Word2); 323 324 function To_Flag_Word2_Ptr is new 325 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr); 326 327 -- The following declarations are used to store flags 152-183 in the 328 -- Field11 field of the fourth component of an extended (entity) node. 329 330 type Flag_Word3 is record 331 Flag152 : Boolean; 332 Flag153 : Boolean; 333 Flag154 : Boolean; 334 Flag155 : Boolean; 335 Flag156 : Boolean; 336 Flag157 : Boolean; 337 Flag158 : Boolean; 338 Flag159 : Boolean; 339 340 Flag160 : Boolean; 341 Flag161 : Boolean; 342 Flag162 : Boolean; 343 Flag163 : Boolean; 344 Flag164 : Boolean; 345 Flag165 : Boolean; 346 Flag166 : Boolean; 347 Flag167 : Boolean; 348 349 Flag168 : Boolean; 350 Flag169 : Boolean; 351 Flag170 : Boolean; 352 Flag171 : Boolean; 353 Flag172 : Boolean; 354 Flag173 : Boolean; 355 Flag174 : Boolean; 356 Flag175 : Boolean; 357 358 Flag176 : Boolean; 359 Flag177 : Boolean; 360 Flag178 : Boolean; 361 Flag179 : Boolean; 362 Flag180 : Boolean; 363 Flag181 : Boolean; 364 Flag182 : Boolean; 365 Flag183 : Boolean; 366 end record; 367 368 pragma Pack (Flag_Word3); 369 for Flag_Word3'Size use 32; 370 for Flag_Word3'Alignment use 4; 371 372 type Flag_Word3_Ptr is access all Flag_Word3; 373 374 function To_Flag_Word3 is new 375 Unchecked_Conversion (Union_Id, Flag_Word3); 376 377 function To_Flag_Word3_Ptr is new 378 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr); 379 380 -- The following declarations are used to store flags 184-215 in the 381 -- Field12 field of the fifth component of an extended (entity) node. 382 383 type Flag_Word4 is record 384 Flag184 : Boolean; 385 Flag185 : Boolean; 386 Flag186 : Boolean; 387 Flag187 : Boolean; 388 Flag188 : Boolean; 389 Flag189 : Boolean; 390 Flag190 : Boolean; 391 Flag191 : Boolean; 392 393 Flag192 : Boolean; 394 Flag193 : Boolean; 395 Flag194 : Boolean; 396 Flag195 : Boolean; 397 Flag196 : Boolean; 398 Flag197 : Boolean; 399 Flag198 : Boolean; 400 Flag199 : Boolean; 401 402 Flag200 : Boolean; 403 Flag201 : Boolean; 404 Flag202 : Boolean; 405 Flag203 : Boolean; 406 Flag204 : Boolean; 407 Flag205 : Boolean; 408 Flag206 : Boolean; 409 Flag207 : Boolean; 410 411 Flag208 : Boolean; 412 Flag209 : Boolean; 413 Flag210 : Boolean; 414 Flag211 : Boolean; 415 Flag212 : Boolean; 416 Flag213 : Boolean; 417 Flag214 : Boolean; 418 Flag215 : Boolean; 419 end record; 420 421 pragma Pack (Flag_Word4); 422 for Flag_Word4'Size use 32; 423 for Flag_Word4'Alignment use 4; 424 425 type Flag_Word4_Ptr is access all Flag_Word4; 426 427 function To_Flag_Word4 is new 428 Unchecked_Conversion (Union_Id, Flag_Word4); 429 430 function To_Flag_Word4_Ptr is new 431 Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr); 432 433 -- The following declarations are used to store flags 255-286 in the 434 -- Field12 field of the sixth component of an extended (entity) node. 435 436 type Flag_Word5 is record 437 Flag255 : Boolean; 438 Flag256 : Boolean; 439 Flag257 : Boolean; 440 Flag258 : Boolean; 441 Flag259 : Boolean; 442 Flag260 : Boolean; 443 Flag261 : Boolean; 444 Flag262 : Boolean; 445 446 Flag263 : Boolean; 447 Flag264 : Boolean; 448 Flag265 : Boolean; 449 Flag266 : Boolean; 450 Flag267 : Boolean; 451 Flag268 : Boolean; 452 Flag269 : Boolean; 453 Flag270 : Boolean; 454 455 Flag271 : Boolean; 456 Flag272 : Boolean; 457 Flag273 : Boolean; 458 Flag274 : Boolean; 459 Flag275 : Boolean; 460 Flag276 : Boolean; 461 Flag277 : Boolean; 462 Flag278 : Boolean; 463 464 Flag279 : Boolean; 465 Flag280 : Boolean; 466 Flag281 : Boolean; 467 Flag282 : Boolean; 468 Flag283 : Boolean; 469 Flag284 : Boolean; 470 Flag285 : Boolean; 471 Flag286 : Boolean; 472 end record; 473 474 pragma Pack (Flag_Word5); 475 for Flag_Word5'Size use 32; 476 for Flag_Word5'Alignment use 4; 477 478 type Flag_Word5_Ptr is access all Flag_Word5; 479 480 function To_Flag_Word5 is new 481 Unchecked_Conversion (Union_Id, Flag_Word5); 482 483 function To_Flag_Word5_Ptr is new 484 Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr); 485 486 -------------------------------------------------- 487 -- Implementation of Tree Substitution Routines -- 488 -------------------------------------------------- 489 490 -- A separate table keeps track of the mapping between rewritten nodes 491 -- and their corresponding original tree nodes. Rewrite makes an entry 492 -- in this table for use by Original_Node. By default, if no call is 493 -- Rewrite, the entry in this table points to the original unwritten node. 494 495 -- Note: eventually, this should be a field in the Node directly, but 496 -- for now we do not want to disturb the efficiency of a power of 2 497 -- for the node size. ????We are planning to get rid of power-of-2. 498 499 package Orig_Nodes is new Table.Table ( 500 Table_Component_Type => Node_Id, 501 Table_Index_Type => Node_Id'Base, 502 Table_Low_Bound => First_Node_Id, 503 Table_Initial => Alloc.Nodes_Initial, 504 Table_Increment => Alloc.Nodes_Increment, 505 Release_Threshold => Alloc.Nodes_Release_Threshold, 506 Table_Name => "Orig_Nodes"); 507 508 -------------------------- 509 -- Paren_Count Handling -- 510 -------------------------- 511 512 -- As noted in the spec, the paren count in a sub-expression node has 513 -- four possible values 0,1,2, and 3. The value 3 really means 3 or more, 514 -- and we use an auxiliary serially scanned table to record the actual 515 -- count. A serial search is fine, only pathological programs will use 516 -- entries in this table. Normal programs won't use it at all. 517 518 type Paren_Count_Entry is record 519 Nod : Node_Id; 520 -- The node to which this count applies 521 522 Count : Nat range 3 .. Nat'Last; 523 -- The count of parentheses, which will be in the indicated range 524 end record; 525 526 package Paren_Counts is new Table.Table ( 527 Table_Component_Type => Paren_Count_Entry, 528 Table_Index_Type => Int, 529 Table_Low_Bound => 0, 530 Table_Initial => 10, 531 Table_Increment => 200, 532 Table_Name => "Paren_Counts"); 533 534 procedure Set_Paren_Count_Of_Copy (Target, Source : Node_Id); 535 pragma Inline (Set_Paren_Count_Of_Copy); 536 -- Called when copying a node. Makes sure the Paren_Count of the copy is 537 -- correct. 538 539 ----------------------- 540 -- Local Subprograms -- 541 ----------------------- 542 543 function Allocate_New_Node return Node_Id; 544 pragma Inline (Allocate_New_Node); 545 -- Allocate a new node or first part of a node extension. Initialize the 546 -- Nodes.Table entry, Flags, Orig_Nodes, and List tables. 547 548 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id); 549 -- Fix up parent pointers for the syntactic children of Fix_Node after a 550 -- copy, setting them to Fix_Node when they pointed to Ref_Node. 551 552 procedure Mark_New_Ghost_Node (N : Node_Or_Entity_Id); 553 -- Mark arbitrary node or entity N as Ghost when it is created within a 554 -- Ghost region. 555 556 procedure Report (Target, Source : Node_Id); 557 pragma Inline (Report); 558 -- Invoke the reporting procedure if available 559 560 ----------------------- 561 -- Allocate_New_Node -- 562 ----------------------- 563 564 function Allocate_New_Node return Node_Id is 565 New_Id : Node_Id; 566 begin 567 Nodes.Append (Default_Node); 568 New_Id := Nodes.Last; 569 Flags.Append (Default_Flags); 570 Orig_Nodes.Append (New_Id); 571 Nodes.Table (Nodes.Last).Comes_From_Source := 572 Comes_From_Source_Default; 573 Allocate_List_Tables (Nodes.Last); 574 Report (Target => New_Id, Source => Empty); 575 576 return New_Id; 577 end Allocate_New_Node; 578 579 -------------- 580 -- Analyzed -- 581 -------------- 582 583 function Analyzed (N : Node_Id) return Boolean is 584 begin 585 pragma Assert (N <= Nodes.Last); 586 return Nodes.Table (N).Analyzed; 587 end Analyzed; 588 589 -------------------------- 590 -- Basic_Set_Convention -- 591 -------------------------- 592 593 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id) is 594 begin 595 pragma Assert (Nkind (E) in N_Entity); 596 To_Flag_Word_Ptr 597 (Union_Id_Ptr' 598 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val; 599 end Basic_Set_Convention; 600 601 ------------------- 602 -- Check_Actuals -- 603 ------------------- 604 605 function Check_Actuals (N : Node_Id) return Boolean is 606 begin 607 return Flags.Table (N).Check_Actuals; 608 end Check_Actuals; 609 610 -------------------------- 611 -- Check_Error_Detected -- 612 -------------------------- 613 614 procedure Check_Error_Detected is 615 begin 616 -- An anomaly has been detected which is assumed to be a consequence of 617 -- a previous serious error or configurable run time violation. Raise 618 -- an exception if no such error has been detected. 619 620 if Serious_Errors_Detected = 0 621 and then Configurable_Run_Time_Violations = 0 622 then 623 raise Program_Error; 624 end if; 625 end Check_Error_Detected; 626 627 ----------------- 628 -- Change_Node -- 629 ----------------- 630 631 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is 632 633 -- Flags table attributes 634 635 Save_CA : constant Boolean := Flags.Table (N).Check_Actuals; 636 Save_Is_IGN : constant Boolean := Flags.Table (N).Is_Ignored_Ghost_Node; 637 638 -- Nodes table attributes 639 640 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source; 641 Save_In_List : constant Boolean := Nodes.Table (N).In_List; 642 Save_Link : constant Union_Id := Nodes.Table (N).Link; 643 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted; 644 Save_Sloc : constant Source_Ptr := Sloc (N); 645 646 Par_Count : Nat := 0; 647 648 begin 649 if Nkind (N) in N_Subexpr then 650 Par_Count := Paren_Count (N); 651 end if; 652 653 Nodes.Table (N) := Default_Node; 654 Nodes.Table (N).Sloc := Save_Sloc; 655 Nodes.Table (N).In_List := Save_In_List; 656 Nodes.Table (N).Link := Save_Link; 657 Nodes.Table (N).Comes_From_Source := Save_CFS; 658 Nodes.Table (N).Nkind := New_Node_Kind; 659 Nodes.Table (N).Error_Posted := Save_Posted; 660 661 Flags.Table (N) := Default_Flags; 662 Flags.Table (N).Check_Actuals := Save_CA; 663 Flags.Table (N).Is_Ignored_Ghost_Node := Save_Is_IGN; 664 665 if New_Node_Kind in N_Subexpr then 666 Set_Paren_Count (N, Par_Count); 667 end if; 668 end Change_Node; 669 670 ----------------------- 671 -- Comes_From_Source -- 672 ----------------------- 673 674 function Comes_From_Source (N : Node_Id) return Boolean is 675 begin 676 pragma Assert (N <= Nodes.Last); 677 return Nodes.Table (N).Comes_From_Source; 678 end Comes_From_Source; 679 680 ---------------- 681 -- Convention -- 682 ---------------- 683 684 function Convention (E : Entity_Id) return Convention_Id is 685 begin 686 pragma Assert (Nkind (E) in N_Entity); 687 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention; 688 end Convention; 689 690 --------------- 691 -- Copy_Node -- 692 --------------- 693 694 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is 695 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List; 696 Save_Link : constant Union_Id := Nodes.Table (Destination).Link; 697 698 begin 699 pragma Debug (New_Node_Debugging_Output (Source)); 700 pragma Debug (New_Node_Debugging_Output (Destination)); 701 702 Nodes.Table (Destination) := Nodes.Table (Source); 703 Nodes.Table (Destination).In_List := Save_In_List; 704 Nodes.Table (Destination).Link := Save_Link; 705 706 Flags.Table (Destination) := Flags.Table (Source); 707 708 Set_Paren_Count_Of_Copy (Target => Destination, Source => Source); 709 710 -- Deal with copying extension nodes if present. No need to copy flags 711 -- table entries, since they are always zero for extending components. 712 713 pragma Assert (Has_Extension (Source) = Has_Extension (Destination)); 714 715 if Has_Extension (Source) then 716 for J in 1 .. Num_Extension_Nodes loop 717 Nodes.Table (Destination + J) := Nodes.Table (Source + J); 718 end loop; 719 end if; 720 end Copy_Node; 721 722 ------------------------ 723 -- Copy_Separate_List -- 724 ------------------------ 725 726 function Copy_Separate_List (Source : List_Id) return List_Id is 727 Result : constant List_Id := New_List; 728 Nod : Node_Id; 729 730 begin 731 Nod := First (Source); 732 while Present (Nod) loop 733 Append (Copy_Separate_Tree (Nod), Result); 734 Next (Nod); 735 end loop; 736 737 return Result; 738 end Copy_Separate_List; 739 740 ------------------------ 741 -- Copy_Separate_Tree -- 742 ------------------------ 743 744 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is 745 New_Id : Node_Id; 746 747 function Copy_Entity (E : Entity_Id) return Entity_Id; 748 -- Copy Entity, copying only the Ekind and Chars fields 749 750 function Copy_List (List : List_Id) return List_Id; 751 -- Copy list 752 753 function Possible_Copy (Field : Union_Id) return Union_Id; 754 -- Given a field, returns a copy of the node or list if its parent is 755 -- the current source node, and otherwise returns the input. 756 757 ----------------- 758 -- Copy_Entity -- 759 ----------------- 760 761 function Copy_Entity (E : Entity_Id) return Entity_Id is 762 New_Ent : Entity_Id; 763 764 begin 765 -- Build appropriate node 766 767 case N_Entity (Nkind (E)) is 768 when N_Defining_Identifier => 769 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E)); 770 771 when N_Defining_Character_Literal => 772 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E)); 773 774 when N_Defining_Operator_Symbol => 775 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E)); 776 end case; 777 778 Set_Chars (New_Ent, Chars (E)); 779 -- Set_Comes_From_Source (New_Ent, Comes_From_Source (E)); 780 return New_Ent; 781 end Copy_Entity; 782 783 --------------- 784 -- Copy_List -- 785 --------------- 786 787 function Copy_List (List : List_Id) return List_Id is 788 NL : List_Id; 789 E : Node_Id; 790 791 begin 792 if List = No_List then 793 return No_List; 794 795 else 796 NL := New_List; 797 798 E := First (List); 799 while Present (E) loop 800 if Has_Extension (E) then 801 Append (Copy_Entity (E), NL); 802 else 803 Append (Copy_Separate_Tree (E), NL); 804 end if; 805 806 Next (E); 807 end loop; 808 809 return NL; 810 end if; 811 end Copy_List; 812 813 ------------------- 814 -- Possible_Copy -- 815 ------------------- 816 817 function Possible_Copy (Field : Union_Id) return Union_Id is 818 New_N : Union_Id; 819 820 begin 821 if Field in Node_Range then 822 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field))); 823 824 if Parent (Node_Id (Field)) = Source then 825 Set_Parent (Node_Id (New_N), New_Id); 826 end if; 827 828 return New_N; 829 830 elsif Field in List_Range then 831 New_N := Union_Id (Copy_List (List_Id (Field))); 832 833 if Parent (List_Id (Field)) = Source then 834 Set_Parent (List_Id (New_N), New_Id); 835 end if; 836 837 return New_N; 838 839 else 840 return Field; 841 end if; 842 end Possible_Copy; 843 844 -- Start of processing for Copy_Separate_Tree 845 846 begin 847 if Source <= Empty_Or_Error then 848 return Source; 849 850 elsif Has_Extension (Source) then 851 return Copy_Entity (Source); 852 853 else 854 New_Id := New_Copy (Source); 855 856 -- Recursively copy descendants 857 858 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id))); 859 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id))); 860 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id))); 861 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id))); 862 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id))); 863 864 -- Explicitly copy the aspect specifications as those do not reside 865 -- in a node field. 866 867 if Permits_Aspect_Specifications (Source) 868 and then Has_Aspects (Source) 869 then 870 Set_Aspect_Specifications 871 (New_Id, Copy_List (Aspect_Specifications (Source))); 872 end if; 873 874 -- Set Entity field to Empty to ensure that no entity references 875 -- are shared between the two, if the source is already analyzed. 876 877 if Nkind (New_Id) in N_Has_Entity 878 or else Nkind (New_Id) = N_Freeze_Entity 879 then 880 Set_Entity (New_Id, Empty); 881 end if; 882 883 -- Reset all Etype fields and Analyzed flags, because input tree may 884 -- have been fully or partially analyzed. 885 886 if Nkind (New_Id) in N_Has_Etype then 887 Set_Etype (New_Id, Empty); 888 end if; 889 890 Set_Analyzed (New_Id, False); 891 892 -- Rather special case, if we have an expanded name, then change 893 -- it back into a selected component, so that the tree looks the 894 -- way it did coming out of the parser. This will change back 895 -- when we analyze the selected component node. 896 897 if Nkind (New_Id) = N_Expanded_Name then 898 899 -- The following code is a bit kludgy. It would be cleaner to 900 -- Add an entry Change_Expanded_Name_To_Selected_Component to 901 -- Sinfo.CN, but that's delicate because Atree is used in the 902 -- binder, so we don't want to add that dependency. 903 -- ??? Revisit now that ASIS is no longer using this unit. 904 905 -- Consequently we have no choice but to hold our noses and do 906 -- the change manually. At least we are Atree, so this odd use 907 -- of Atree.Unchecked_Access is at least all in the family. 908 909 -- Change the node type 910 911 Atree.Unchecked_Access.Set_Nkind (New_Id, N_Selected_Component); 912 913 -- Clear the Chars field which is not present in a selected 914 -- component node, so we don't want a junk value around. 915 916 Set_Node1 (New_Id, Empty); 917 end if; 918 919 -- All done, return copied node 920 921 return New_Id; 922 end if; 923 end Copy_Separate_Tree; 924 925 ----------- 926 -- Ekind -- 927 ----------- 928 929 function Ekind (E : Entity_Id) return Entity_Kind is 930 begin 931 pragma Assert (Nkind (E) in N_Entity); 932 return N_To_E (Nodes.Table (E + 1).Nkind); 933 end Ekind; 934 935 ------------------ 936 -- Error_Posted -- 937 ------------------ 938 939 function Error_Posted (N : Node_Id) return Boolean is 940 begin 941 pragma Assert (N <= Nodes.Last); 942 return Nodes.Table (N).Error_Posted; 943 end Error_Posted; 944 945 ----------------------- 946 -- Exchange_Entities -- 947 ----------------------- 948 949 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is 950 Temp_Ent : Node_Record; 951 Temp_Flg : Flags_Byte; 952 953 begin 954 pragma Debug (New_Node_Debugging_Output (E1)); 955 pragma Debug (New_Node_Debugging_Output (E2)); 956 957 pragma Assert (True 958 and then Has_Extension (E1) 959 and then Has_Extension (E2) 960 and then not Nodes.Table (E1).In_List 961 and then not Nodes.Table (E2).In_List); 962 963 -- Exchange the contents of the two entities 964 965 for J in 0 .. Num_Extension_Nodes loop 966 Temp_Ent := Nodes.Table (E1 + J); 967 Nodes.Table (E1 + J) := Nodes.Table (E2 + J); 968 Nodes.Table (E2 + J) := Temp_Ent; 969 end loop; 970 971 -- Exchange flag bytes for first component. No need to do the exchange 972 -- for the other components, since the flag bytes are always zero. 973 974 Temp_Flg := Flags.Table (E1); 975 Flags.Table (E1) := Flags.Table (E2); 976 Flags.Table (E2) := Temp_Flg; 977 978 -- That exchange exchanged the parent pointers as well, which is what 979 -- we want, but we need to patch up the defining identifier pointers 980 -- in the parent nodes (the child pointers) to match this switch 981 -- unless for Implicit types entities which have no parent, in which 982 -- case we don't do anything otherwise we won't be able to revert back 983 -- to the original situation. 984 985 -- Shouldn't this use Is_Itype instead of the Parent test 986 987 if Present (Parent (E1)) and then Present (Parent (E2)) then 988 Set_Defining_Identifier (Parent (E1), E1); 989 Set_Defining_Identifier (Parent (E2), E2); 990 end if; 991 end Exchange_Entities; 992 993 ----------------- 994 -- Extend_Node -- 995 ----------------- 996 997 function Extend_Node (Source : Node_Id) return Entity_Id is 998 pragma Assert (Present (Source)); 999 pragma Assert (not Has_Extension (Source)); 1000 New_Id : Entity_Id; 1001 1002 procedure Debug_Extend_Node; 1003 pragma Inline (Debug_Extend_Node); 1004 -- Debug routine for -gnatdn 1005 1006 ----------------------- 1007 -- Debug_Extend_Node -- 1008 ----------------------- 1009 1010 procedure Debug_Extend_Node is 1011 begin 1012 if Debug_Flag_N then 1013 Write_Str ("Extend node "); 1014 Write_Int (Int (Source)); 1015 1016 if New_Id = Source then 1017 Write_Str (" in place"); 1018 else 1019 Write_Str (" copied to "); 1020 Write_Int (Int (New_Id)); 1021 end if; 1022 1023 -- Write_Eol; 1024 end if; 1025 end Debug_Extend_Node; 1026 1027 -- Start of processing for Extend_Node 1028 1029 begin 1030 -- Optimize the case where Source happens to be the last node; in that 1031 -- case, we don't need to move it. 1032 1033 if Source = Nodes.Last then 1034 New_Id := Source; 1035 else 1036 Nodes.Append (Nodes.Table (Source)); 1037 Flags.Append (Flags.Table (Source)); 1038 New_Id := Nodes.Last; 1039 Orig_Nodes.Append (New_Id); 1040 end if; 1041 1042 Set_Check_Actuals (New_Id, False); 1043 1044 -- Set extension nodes 1045 1046 for J in 1 .. Num_Extension_Nodes loop 1047 Nodes.Append (Default_Node_Extension); 1048 Flags.Append (Default_Flags); 1049 end loop; 1050 1051 Orig_Nodes.Set_Last (Nodes.Last); 1052 Allocate_List_Tables (Nodes.Last); 1053 Report (Target => New_Id, Source => Source); 1054 1055 pragma Debug (Debug_Extend_Node); 1056 1057 return New_Id; 1058 end Extend_Node; 1059 1060 ----------------- 1061 -- Fix_Parents -- 1062 ----------------- 1063 1064 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is 1065 pragma Assert (Nkind (Ref_Node) = Nkind (Fix_Node)); 1066 1067 procedure Fix_Parent (Field : Union_Id); 1068 -- Fix up one parent pointer. Field is checked to see if it points to 1069 -- a node, list, or element list that has a parent that points to 1070 -- Ref_Node. If so, the parent is reset to point to Fix_Node. 1071 1072 ---------------- 1073 -- Fix_Parent -- 1074 ---------------- 1075 1076 procedure Fix_Parent (Field : Union_Id) is 1077 begin 1078 -- Fix parent of node that is referenced by Field. Note that we must 1079 -- exclude the case where the node is a member of a list, because in 1080 -- this case the parent is the parent of the list. 1081 1082 if Field in Node_Range 1083 and then Present (Node_Id (Field)) 1084 and then not Nodes.Table (Node_Id (Field)).In_List 1085 and then Parent (Node_Id (Field)) = Ref_Node 1086 then 1087 Set_Parent (Node_Id (Field), Fix_Node); 1088 1089 -- Fix parent of list that is referenced by Field 1090 1091 elsif Field in List_Range 1092 and then Present (List_Id (Field)) 1093 and then Parent (List_Id (Field)) = Ref_Node 1094 then 1095 Set_Parent (List_Id (Field), Fix_Node); 1096 end if; 1097 end Fix_Parent; 1098 1099 -- Start of processing for Fix_Parents 1100 1101 begin 1102 Fix_Parent (Field1 (Fix_Node)); 1103 Fix_Parent (Field2 (Fix_Node)); 1104 Fix_Parent (Field3 (Fix_Node)); 1105 Fix_Parent (Field4 (Fix_Node)); 1106 Fix_Parent (Field5 (Fix_Node)); 1107 end Fix_Parents; 1108 1109 ------------------- 1110 -- Flags_Address -- 1111 ------------------- 1112 1113 function Flags_Address return System.Address is 1114 begin 1115 return Flags.Table (First_Node_Id)'Address; 1116 end Flags_Address; 1117 1118 ----------------------------------- 1119 -- Get_Comes_From_Source_Default -- 1120 ----------------------------------- 1121 1122 function Get_Comes_From_Source_Default return Boolean is 1123 begin 1124 return Comes_From_Source_Default; 1125 end Get_Comes_From_Source_Default; 1126 1127 ----------------- 1128 -- Has_Aspects -- 1129 ----------------- 1130 1131 function Has_Aspects (N : Node_Id) return Boolean is 1132 begin 1133 pragma Assert (N <= Nodes.Last); 1134 return Nodes.Table (N).Has_Aspects; 1135 end Has_Aspects; 1136 1137 ------------------- 1138 -- Has_Extension -- 1139 ------------------- 1140 1141 function Has_Extension (N : Node_Id) return Boolean is 1142 begin 1143 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension; 1144 end Has_Extension; 1145 1146 ---------------- 1147 -- Initialize -- 1148 ---------------- 1149 1150 procedure Initialize is 1151 Dummy : Node_Id; 1152 pragma Warnings (Off, Dummy); 1153 1154 begin 1155 Atree_Private_Part.Nodes.Init; 1156 Atree_Private_Part.Flags.Init; 1157 Orig_Nodes.Init; 1158 Paren_Counts.Init; 1159 1160 -- Allocate Empty node 1161 1162 Dummy := New_Node (N_Empty, No_Location); 1163 Set_Name1 (Empty, No_Name); 1164 1165 -- Allocate Error node, and set Error_Posted, since we certainly 1166 -- only generate an Error node if we do post some kind of error. 1167 1168 Dummy := New_Node (N_Error, No_Location); 1169 Set_Name1 (Error, Error_Name); 1170 Set_Error_Posted (Error, True); 1171 end Initialize; 1172 1173 --------------------------- 1174 -- Is_Ignored_Ghost_Node -- 1175 --------------------------- 1176 1177 function Is_Ignored_Ghost_Node (N : Node_Id) return Boolean is 1178 begin 1179 return Flags.Table (N).Is_Ignored_Ghost_Node; 1180 end Is_Ignored_Ghost_Node; 1181 1182 -------------------------- 1183 -- Is_Rewrite_Insertion -- 1184 -------------------------- 1185 1186 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is 1187 begin 1188 return Nodes.Table (Node).Rewrite_Ins; 1189 end Is_Rewrite_Insertion; 1190 1191 ----------------------------- 1192 -- Is_Rewrite_Substitution -- 1193 ----------------------------- 1194 1195 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is 1196 begin 1197 return Orig_Nodes.Table (Node) /= Node; 1198 end Is_Rewrite_Substitution; 1199 1200 ------------------ 1201 -- Last_Node_Id -- 1202 ------------------ 1203 1204 function Last_Node_Id return Node_Id is 1205 begin 1206 return Nodes.Last; 1207 end Last_Node_Id; 1208 1209 ---------- 1210 -- Lock -- 1211 ---------- 1212 1213 procedure Lock is 1214 begin 1215 -- We used to Release the tables, as in the comments below, but that is 1216 -- a waste of time. We're only wasting virtual memory here, and the 1217 -- release calls copy large amounts of data. 1218 -- ???Get rid of Release? 1219 1220 -- Flags.Release; 1221 Flags.Locked := True; 1222 -- Orig_Nodes.Release; 1223 Orig_Nodes.Locked := True; 1224 end Lock; 1225 1226 ---------------- 1227 -- Lock_Nodes -- 1228 ---------------- 1229 1230 procedure Lock_Nodes is 1231 begin 1232 pragma Assert (not Locked); 1233 Locked := True; 1234 end Lock_Nodes; 1235 1236 ------------------------- 1237 -- Mark_New_Ghost_Node -- 1238 ------------------------- 1239 1240 procedure Mark_New_Ghost_Node (N : Node_Or_Entity_Id) is 1241 begin 1242 -- The Ghost node is created within a Ghost region 1243 1244 if Ghost_Mode = Check then 1245 if Nkind (N) in N_Entity then 1246 Set_Is_Checked_Ghost_Entity (N); 1247 end if; 1248 1249 elsif Ghost_Mode = Ignore then 1250 if Nkind (N) in N_Entity then 1251 Set_Is_Ignored_Ghost_Entity (N); 1252 end if; 1253 1254 Set_Is_Ignored_Ghost_Node (N); 1255 1256 -- Record the ignored Ghost node or entity in order to eliminate it 1257 -- from the tree later. 1258 1259 if Ignored_Ghost_Recording_Proc /= null then 1260 Ignored_Ghost_Recording_Proc.all (N); 1261 end if; 1262 end if; 1263 end Mark_New_Ghost_Node; 1264 1265 ---------------------------- 1266 -- Mark_Rewrite_Insertion -- 1267 ---------------------------- 1268 1269 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is 1270 begin 1271 Nodes.Table (New_Node).Rewrite_Ins := True; 1272 end Mark_Rewrite_Insertion; 1273 1274 -------------- 1275 -- New_Copy -- 1276 -------------- 1277 1278 function New_Copy (Source : Node_Id) return Node_Id is 1279 New_Id : Node_Id; 1280 begin 1281 if Source <= Empty_Or_Error then 1282 return Source; 1283 end if; 1284 1285 Nodes.Append (Nodes.Table (Source)); 1286 Flags.Append (Flags.Table (Source)); 1287 New_Id := Nodes.Last; 1288 Orig_Nodes.Append (New_Id); 1289 Set_Check_Actuals (New_Id, False); 1290 Set_Paren_Count_Of_Copy (Target => New_Id, Source => Source); 1291 1292 -- Set extension nodes if required 1293 1294 if Has_Extension (Source) then 1295 for J in 1 .. Num_Extension_Nodes loop 1296 Nodes.Append (Nodes.Table (Source + J)); 1297 Flags.Append (Flags.Table (Source + J)); 1298 end loop; 1299 Orig_Nodes.Set_Last (Nodes.Last); 1300 else 1301 pragma Assert (Orig_Nodes.Table (Orig_Nodes.Last) = Nodes.Last); 1302 end if; 1303 1304 Allocate_List_Tables (Nodes.Last); 1305 Report (Target => New_Id, Source => Source); 1306 1307 Nodes.Table (New_Id).In_List := False; 1308 Nodes.Table (New_Id).Link := Empty_List_Or_Node; 1309 1310 -- If the original is marked as a rewrite insertion, then unmark the 1311 -- copy, since we inserted the original, not the copy. 1312 1313 Nodes.Table (New_Id).Rewrite_Ins := False; 1314 pragma Debug (New_Node_Debugging_Output (New_Id)); 1315 1316 -- Clear Is_Overloaded since we cannot have semantic interpretations 1317 -- of this new node. 1318 1319 if Nkind (Source) in N_Subexpr then 1320 Set_Is_Overloaded (New_Id, False); 1321 end if; 1322 1323 -- Always clear Has_Aspects, the caller must take care of copying 1324 -- aspects if this is required for the particular situation. 1325 1326 Set_Has_Aspects (New_Id, False); 1327 1328 -- Mark the copy as Ghost depending on the current Ghost region 1329 1330 Mark_New_Ghost_Node (New_Id); 1331 1332 pragma Assert (New_Id /= Source); 1333 return New_Id; 1334 end New_Copy; 1335 1336 ---------------- 1337 -- New_Entity -- 1338 ---------------- 1339 1340 function New_Entity 1341 (New_Node_Kind : Node_Kind; 1342 New_Sloc : Source_Ptr) return Entity_Id 1343 is 1344 pragma Assert (New_Node_Kind in N_Entity); 1345 New_Id : constant Entity_Id := Allocate_New_Node; 1346 begin 1347 -- Set extension nodes 1348 1349 for J in 1 .. Num_Extension_Nodes loop 1350 Nodes.Append (Default_Node_Extension); 1351 Flags.Append (Default_Flags); 1352 end loop; 1353 1354 Orig_Nodes.Set_Last (Nodes.Last); 1355 1356 -- If this is a node with a real location and we are generating 1357 -- source nodes, then reset Current_Error_Node. This is useful 1358 -- if we bomb during parsing to get a error location for the bomb. 1359 1360 if New_Sloc > No_Location and then Comes_From_Source_Default then 1361 Current_Error_Node := New_Id; 1362 end if; 1363 1364 Nodes.Table (New_Id).Nkind := New_Node_Kind; 1365 Nodes.Table (New_Id).Sloc := New_Sloc; 1366 pragma Debug (New_Node_Debugging_Output (New_Id)); 1367 1368 -- Mark the new entity as Ghost depending on the current Ghost region 1369 1370 Mark_New_Ghost_Node (New_Id); 1371 1372 return New_Id; 1373 end New_Entity; 1374 1375 -------------- 1376 -- New_Node -- 1377 -------------- 1378 1379 function New_Node 1380 (New_Node_Kind : Node_Kind; 1381 New_Sloc : Source_Ptr) return Node_Id 1382 is 1383 pragma Assert (New_Node_Kind not in N_Entity); 1384 New_Id : constant Node_Id := Allocate_New_Node; 1385 pragma Assert (Orig_Nodes.Table (Orig_Nodes.Last) = Nodes.Last); 1386 begin 1387 Nodes.Table (New_Id).Nkind := New_Node_Kind; 1388 Nodes.Table (New_Id).Sloc := New_Sloc; 1389 pragma Debug (New_Node_Debugging_Output (New_Id)); 1390 1391 -- If this is a node with a real location and we are generating source 1392 -- nodes, then reset Current_Error_Node. This is useful if we bomb 1393 -- during parsing to get an error location for the bomb. 1394 1395 if Comes_From_Source_Default and then New_Sloc > No_Location then 1396 Current_Error_Node := New_Id; 1397 end if; 1398 1399 -- Mark the new node as Ghost depending on the current Ghost region 1400 1401 Mark_New_Ghost_Node (New_Id); 1402 1403 return New_Id; 1404 end New_Node; 1405 1406 ------------------------- 1407 -- New_Node_Breakpoint -- 1408 ------------------------- 1409 1410 procedure nn is 1411 begin 1412 Write_Str ("Watched node "); 1413 Write_Int (Int (Watch_Node)); 1414 Write_Eol; 1415 end nn; 1416 1417 ------------------------------- 1418 -- New_Node_Debugging_Output -- 1419 ------------------------------- 1420 1421 procedure nnd (N : Node_Id) is 1422 Node_Is_Watched : constant Boolean := N = Watch_Node; 1423 1424 begin 1425 if Debug_Flag_N or else Node_Is_Watched then 1426 Node_Debug_Output ("Node", N); 1427 1428 if Node_Is_Watched then 1429 New_Node_Breakpoint; 1430 end if; 1431 end if; 1432 end nnd; 1433 1434 ----------- 1435 -- Nkind -- 1436 ----------- 1437 1438 function Nkind (N : Node_Id) return Node_Kind is 1439 begin 1440 return Nodes.Table (N).Nkind; 1441 end Nkind; 1442 1443 -------- 1444 -- No -- 1445 -------- 1446 1447 function No (N : Node_Id) return Boolean is 1448 begin 1449 return N = Empty; 1450 end No; 1451 1452 ----------------------- 1453 -- Node_Debug_Output -- 1454 ----------------------- 1455 1456 procedure Node_Debug_Output (Op : String; N : Node_Id) is 1457 begin 1458 Write_Str (Op); 1459 1460 if Nkind (N) in N_Entity then 1461 Write_Str (" entity"); 1462 else 1463 Write_Str (" node"); 1464 end if; 1465 1466 Write_Str (" Id = "); 1467 Write_Int (Int (N)); 1468 Write_Str (" "); 1469 Write_Location (Sloc (N)); 1470 Write_Str (" "); 1471 Write_Str (Node_Kind'Image (Nkind (N))); 1472 Write_Eol; 1473 end Node_Debug_Output; 1474 1475 ------------------- 1476 -- Nodes_Address -- 1477 ------------------- 1478 1479 function Nodes_Address return System.Address is 1480 begin 1481 return Nodes.Table (First_Node_Id)'Address; 1482 end Nodes_Address; 1483 1484 ----------------------------------- 1485 -- Approx_Num_Nodes_And_Entities -- 1486 ----------------------------------- 1487 1488 function Approx_Num_Nodes_And_Entities return Nat is 1489 begin 1490 -- This is an overestimate, because entities take up more space, but 1491 -- that really doesn't matter; it's not worth subtracting out the 1492 -- "extra". 1493 1494 return Nat (Nodes.Last - First_Node_Id); 1495 end Approx_Num_Nodes_And_Entities; 1496 1497 ------------------- 1498 -- Original_Node -- 1499 ------------------- 1500 1501 function Original_Node (Node : Node_Id) return Node_Id is 1502 begin 1503 return Orig_Nodes.Table (Node); 1504 end Original_Node; 1505 1506 ----------------- 1507 -- Paren_Count -- 1508 ----------------- 1509 1510 function Paren_Count (N : Node_Id) return Nat is 1511 C : Nat := 0; 1512 1513 begin 1514 pragma Assert (N <= Nodes.Last); 1515 1516 if Nodes.Table (N).Pflag1 then 1517 C := C + 1; 1518 end if; 1519 1520 if Nodes.Table (N).Pflag2 then 1521 C := C + 2; 1522 end if; 1523 1524 -- Value of 0,1,2 returned as is 1525 1526 if C <= 2 then 1527 return C; 1528 1529 -- Value of 3 means we search the table, and we must find an entry 1530 1531 else 1532 for J in Paren_Counts.First .. Paren_Counts.Last loop 1533 if N = Paren_Counts.Table (J).Nod then 1534 return Paren_Counts.Table (J).Count; 1535 end if; 1536 end loop; 1537 1538 raise Program_Error; 1539 end if; 1540 end Paren_Count; 1541 1542 ------------ 1543 -- Parent -- 1544 ------------ 1545 1546 function Parent (N : Node_Id) return Node_Id is 1547 begin 1548 if Is_List_Member (N) then 1549 return Parent (List_Containing (N)); 1550 else 1551 return Node_Id (Nodes.Table (N).Link); 1552 end if; 1553 end Parent; 1554 1555 ------------- 1556 -- Present -- 1557 ------------- 1558 1559 function Present (N : Node_Id) return Boolean is 1560 begin 1561 return N /= Empty; 1562 end Present; 1563 1564 -------------------------------- 1565 -- Preserve_Comes_From_Source -- 1566 -------------------------------- 1567 1568 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is 1569 begin 1570 Set_Comes_From_Source (NewN, Comes_From_Source (OldN)); 1571 end Preserve_Comes_From_Source; 1572 1573 ---------------------- 1574 -- Print_Statistics -- 1575 ---------------------- 1576 1577 procedure Print_Statistics is 1578 N_Count : constant Natural := Natural (Nodes.Last - First_Node_Id + 1); 1579 E_Count : Natural := 0; 1580 1581 begin 1582 Write_Str ("Number of entities: "); 1583 Write_Eol; 1584 1585 declare 1586 function CP_Lt (Op1, Op2 : Natural) return Boolean; 1587 -- Compare routine for Sort 1588 1589 procedure CP_Move (From : Natural; To : Natural); 1590 -- Move routine for Sort 1591 1592 Kind_Count : array (Node_Kind) of Natural := (others => 0); 1593 -- Array of occurrence count per node kind 1594 1595 Kind_Max : constant Natural := Node_Kind'Pos (N_Unused_At_End) - 1; 1596 -- The index of the largest (interesting) node kind 1597 1598 Ranking : array (0 .. Kind_Max) of Node_Kind; 1599 -- Ranking array for node kinds (index 0 is used for the temporary) 1600 1601 package Sorting is new GNAT.Heap_Sort_G (CP_Move, CP_Lt); 1602 1603 function CP_Lt (Op1, Op2 : Natural) return Boolean is 1604 begin 1605 return Kind_Count (Ranking (Op2)) < Kind_Count (Ranking (Op1)); 1606 end CP_Lt; 1607 1608 procedure CP_Move (From : Natural; To : Natural) is 1609 begin 1610 Ranking (To) := Ranking (From); 1611 end CP_Move; 1612 1613 begin 1614 -- Count the number of occurrences of each node kind 1615 1616 for I in First_Node_Id .. Nodes.Last loop 1617 declare 1618 Nkind : constant Node_Kind := Nodes.Table (I).Nkind; 1619 begin 1620 if not Nodes.Table (I).Is_Extension then 1621 Kind_Count (Nkind) := Kind_Count (Nkind) + 1; 1622 end if; 1623 end; 1624 end loop; 1625 1626 -- Sort the node kinds by number of occurrences 1627 1628 for N in 1 .. Kind_Max loop 1629 Ranking (N) := Node_Kind'Val (N); 1630 end loop; 1631 1632 Sorting.Sort (Kind_Max); 1633 1634 -- Print the list in descending order 1635 1636 for N in 1 .. Kind_Max loop 1637 declare 1638 Count : constant Natural := Kind_Count (Ranking (N)); 1639 begin 1640 if Count > 0 then 1641 Write_Str (" "); 1642 Write_Str (Node_Kind'Image (Ranking (N))); 1643 Write_Str (": "); 1644 Write_Int (Int (Count)); 1645 Write_Eol; 1646 1647 E_Count := E_Count + Count; 1648 end if; 1649 end; 1650 end loop; 1651 end; 1652 1653 Write_Str ("Total number of entities: "); 1654 Write_Int (Int (E_Count)); 1655 Write_Eol; 1656 1657 Write_Str ("Maximum number of nodes per entity: "); 1658 Write_Int (Int (Num_Extension_Nodes + 1)); 1659 Write_Eol; 1660 1661 Write_Str ("Number of allocated nodes: "); 1662 Write_Int (Int (N_Count)); 1663 Write_Eol; 1664 1665 Write_Str ("Ratio allocated nodes/entities: "); 1666 Write_Int (Int (Long_Long_Integer (N_Count) * 100 / 1667 Long_Long_Integer (E_Count))); 1668 Write_Str ("/100"); 1669 Write_Eol; 1670 1671 Write_Str ("Size of a node in bytes: "); 1672 Write_Int (Int (Node_Record'Size) / Storage_Unit); 1673 Write_Eol; 1674 1675 Write_Str ("Memory consumption in bytes: "); 1676 Write_Int (Int (Long_Long_Integer (N_Count) * 1677 (Node_Record'Size / Storage_Unit))); 1678 Write_Eol; 1679 end Print_Statistics; 1680 1681 ------------------- 1682 -- Relocate_Node -- 1683 ------------------- 1684 1685 function Relocate_Node (Source : Node_Id) return Node_Id is 1686 New_Node : Node_Id; 1687 1688 begin 1689 if No (Source) then 1690 return Empty; 1691 end if; 1692 1693 New_Node := New_Copy (Source); 1694 Fix_Parents (Ref_Node => Source, Fix_Node => New_Node); 1695 1696 -- We now set the parent of the new node to be the same as the parent of 1697 -- the source. Almost always this parent will be replaced by a new value 1698 -- when the relocated node is reattached to the tree, but by doing it 1699 -- now, we ensure that this node is not even temporarily disconnected 1700 -- from the tree. Note that this does not happen free, because in the 1701 -- list case, the parent does not get set. 1702 1703 Set_Parent (New_Node, Parent (Source)); 1704 1705 -- If the node being relocated was a rewriting of some original node, 1706 -- then the relocated node has the same original node. 1707 1708 if Is_Rewrite_Substitution (Source) then 1709 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source); 1710 end if; 1711 1712 return New_Node; 1713 end Relocate_Node; 1714 1715 ------------- 1716 -- Replace -- 1717 ------------- 1718 1719 procedure Replace (Old_Node, New_Node : Node_Id) is 1720 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted; 1721 Old_HasA : constant Boolean := Nodes.Table (Old_Node).Has_Aspects; 1722 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source; 1723 1724 begin 1725 pragma Assert 1726 (not Has_Extension (Old_Node) 1727 and not Has_Extension (New_Node) 1728 and not Nodes.Table (New_Node).In_List); 1729 1730 pragma Debug (New_Node_Debugging_Output (Old_Node)); 1731 pragma Debug (New_Node_Debugging_Output (New_Node)); 1732 1733 -- Do copy, preserving link and in list status and required flags 1734 1735 Copy_Node (Source => New_Node, Destination => Old_Node); 1736 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS; 1737 Nodes.Table (Old_Node).Error_Posted := Old_Post; 1738 Nodes.Table (Old_Node).Has_Aspects := Old_HasA; 1739 1740 -- Fix parents of substituted node, since it has changed identity 1741 1742 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node); 1743 1744 -- Since we are doing a replace, we assume that the original node 1745 -- is intended to become the new replaced node. The call would be 1746 -- to Rewrite if there were an intention to save the original node. 1747 1748 Orig_Nodes.Table (Old_Node) := Old_Node; 1749 1750 -- Invoke the reporting procedure (if available) 1751 1752 if Reporting_Proc /= null then 1753 Reporting_Proc.all (Target => Old_Node, Source => New_Node); 1754 end if; 1755 end Replace; 1756 1757 ------------ 1758 -- Report -- 1759 ------------ 1760 1761 procedure Report (Target, Source : Node_Id) is 1762 begin 1763 if Reporting_Proc /= null then 1764 Reporting_Proc.all (Target, Source); 1765 end if; 1766 end Report; 1767 1768 ------------- 1769 -- Rewrite -- 1770 ------------- 1771 1772 procedure Rewrite (Old_Node, New_Node : Node_Id) is 1773 1774 -- Flags table attributes 1775 1776 Old_CA : constant Boolean := Flags.Table (Old_Node).Check_Actuals; 1777 Old_Is_IGN : constant Boolean := 1778 Flags.Table (Old_Node).Is_Ignored_Ghost_Node; 1779 1780 -- Nodes table attributes 1781 1782 Old_Error_Posted : constant Boolean := 1783 Nodes.Table (Old_Node).Error_Posted; 1784 Old_Has_Aspects : constant Boolean := 1785 Nodes.Table (Old_Node).Has_Aspects; 1786 1787 Old_Must_Not_Freeze : Boolean; 1788 Old_Paren_Count : Nat; 1789 -- These fields are preserved in the new node only if the new node and 1790 -- the old node are both subexpression nodes. 1791 1792 -- Note: it is a violation of abstraction levels for Must_Not_Freeze 1793 -- to be referenced like this. ??? 1794 1795 Sav_Node : Node_Id; 1796 1797 begin 1798 pragma Assert 1799 (not Has_Extension (Old_Node) 1800 and not Has_Extension (New_Node) 1801 and not Nodes.Table (New_Node).In_List); 1802 1803 pragma Debug (New_Node_Debugging_Output (Old_Node)); 1804 pragma Debug (New_Node_Debugging_Output (New_Node)); 1805 1806 if Nkind (Old_Node) in N_Subexpr then 1807 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node); 1808 Old_Paren_Count := Paren_Count (Old_Node); 1809 else 1810 Old_Must_Not_Freeze := False; 1811 Old_Paren_Count := 0; 1812 end if; 1813 1814 -- Allocate a new node, to be used to preserve the original contents 1815 -- of the Old_Node, for possible later retrival by Original_Node and 1816 -- make an entry in the Orig_Nodes table. This is only done if we have 1817 -- not already rewritten the node, as indicated by an Orig_Nodes entry 1818 -- that does not reference the Old_Node. 1819 1820 if Orig_Nodes.Table (Old_Node) = Old_Node then 1821 Sav_Node := New_Copy (Old_Node); 1822 Orig_Nodes.Table (Sav_Node) := Sav_Node; 1823 Orig_Nodes.Table (Old_Node) := Sav_Node; 1824 1825 -- Both the old and new copies of the node will share the same list 1826 -- of aspect specifications if aspect specifications are present. 1827 1828 if Old_Has_Aspects then 1829 Set_Aspect_Specifications 1830 (Sav_Node, Aspect_Specifications (Old_Node)); 1831 end if; 1832 end if; 1833 1834 -- Copy substitute node into place, preserving old fields as required 1835 1836 Copy_Node (Source => New_Node, Destination => Old_Node); 1837 Nodes.Table (Old_Node).Error_Posted := Old_Error_Posted; 1838 Nodes.Table (Old_Node).Has_Aspects := Old_Has_Aspects; 1839 1840 Flags.Table (Old_Node).Check_Actuals := Old_CA; 1841 Flags.Table (Old_Node).Is_Ignored_Ghost_Node := Old_Is_IGN; 1842 1843 if Nkind (New_Node) in N_Subexpr then 1844 Set_Paren_Count (Old_Node, Old_Paren_Count); 1845 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze); 1846 end if; 1847 1848 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node); 1849 1850 -- Invoke the reporting procedure (if available) 1851 1852 if Reporting_Proc /= null then 1853 Reporting_Proc.all (Target => Old_Node, Source => New_Node); 1854 end if; 1855 1856 -- Invoke the rewriting procedure (if available) 1857 1858 if Rewriting_Proc /= null then 1859 Rewriting_Proc.all (Target => Old_Node, Source => New_Node); 1860 end if; 1861 end Rewrite; 1862 1863 ------------------ 1864 -- Set_Analyzed -- 1865 ------------------ 1866 1867 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is 1868 begin 1869 pragma Assert (not Locked); 1870 Nodes.Table (N).Analyzed := Val; 1871 end Set_Analyzed; 1872 1873 ----------------------- 1874 -- Set_Check_Actuals -- 1875 ----------------------- 1876 1877 procedure Set_Check_Actuals (N : Node_Id; Val : Boolean := True) is 1878 begin 1879 pragma Assert (not Locked); 1880 Flags.Table (N).Check_Actuals := Val; 1881 end Set_Check_Actuals; 1882 1883 --------------------------- 1884 -- Set_Comes_From_Source -- 1885 --------------------------- 1886 1887 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is 1888 begin 1889 pragma Assert (not Locked); 1890 pragma Assert (N <= Nodes.Last); 1891 Nodes.Table (N).Comes_From_Source := Val; 1892 end Set_Comes_From_Source; 1893 1894 ----------------------------------- 1895 -- Set_Comes_From_Source_Default -- 1896 ----------------------------------- 1897 1898 procedure Set_Comes_From_Source_Default (Default : Boolean) is 1899 begin 1900 Comes_From_Source_Default := Default; 1901 end Set_Comes_From_Source_Default; 1902 1903 --------------- 1904 -- Set_Ekind -- 1905 --------------- 1906 1907 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is 1908 begin 1909 pragma Assert (not Locked); 1910 pragma Assert (Nkind (E) in N_Entity); 1911 Nodes.Table (E + 1).Nkind := E_To_N (Val); 1912 end Set_Ekind; 1913 1914 ---------------------- 1915 -- Set_Error_Posted -- 1916 ---------------------- 1917 1918 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is 1919 begin 1920 pragma Assert (not Locked); 1921 Nodes.Table (N).Error_Posted := Val; 1922 end Set_Error_Posted; 1923 1924 --------------------- 1925 -- Set_Has_Aspects -- 1926 --------------------- 1927 1928 procedure Set_Has_Aspects (N : Node_Id; Val : Boolean := True) is 1929 begin 1930 pragma Assert (not Locked); 1931 pragma Assert (N <= Nodes.Last); 1932 Nodes.Table (N).Has_Aspects := Val; 1933 end Set_Has_Aspects; 1934 1935 -------------------------------------- 1936 -- Set_Ignored_Ghost_Recording_Proc -- 1937 -------------------------------------- 1938 1939 procedure Set_Ignored_Ghost_Recording_Proc 1940 (Proc : Ignored_Ghost_Record_Proc) 1941 is 1942 begin 1943 pragma Assert (Ignored_Ghost_Recording_Proc = null); 1944 Ignored_Ghost_Recording_Proc := Proc; 1945 end Set_Ignored_Ghost_Recording_Proc; 1946 1947 ------------------------------- 1948 -- Set_Is_Ignored_Ghost_Node -- 1949 ------------------------------- 1950 1951 procedure Set_Is_Ignored_Ghost_Node (N : Node_Id; Val : Boolean := True) is 1952 begin 1953 pragma Assert (not Locked); 1954 Flags.Table (N).Is_Ignored_Ghost_Node := Val; 1955 end Set_Is_Ignored_Ghost_Node; 1956 1957 ----------------------- 1958 -- Set_Original_Node -- 1959 ----------------------- 1960 1961 procedure Set_Original_Node (N : Node_Id; Val : Node_Id) is 1962 begin 1963 pragma Assert (not Locked); 1964 Orig_Nodes.Table (N) := Val; 1965 end Set_Original_Node; 1966 1967 --------------------- 1968 -- Set_Paren_Count -- 1969 --------------------- 1970 1971 procedure Set_Paren_Count (N : Node_Id; Val : Nat) is 1972 begin 1973 pragma Assert (not Locked); 1974 pragma Assert (Nkind (N) in N_Subexpr); 1975 1976 -- Value of 0,1,2 stored as is 1977 1978 if Val <= 2 then 1979 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0); 1980 Nodes.Table (N).Pflag2 := (Val = 2); 1981 1982 -- Value of 3 or greater stores 3 in node and makes table entry 1983 1984 else 1985 Nodes.Table (N).Pflag1 := True; 1986 Nodes.Table (N).Pflag2 := True; 1987 1988 -- Search for existing table entry 1989 1990 for J in Paren_Counts.First .. Paren_Counts.Last loop 1991 if N = Paren_Counts.Table (J).Nod then 1992 Paren_Counts.Table (J).Count := Val; 1993 return; 1994 end if; 1995 end loop; 1996 1997 -- No existing table entry; make a new one 1998 1999 Paren_Counts.Append ((Nod => N, Count => Val)); 2000 end if; 2001 end Set_Paren_Count; 2002 2003 ----------------------------- 2004 -- Set_Paren_Count_Of_Copy -- 2005 ----------------------------- 2006 2007 procedure Set_Paren_Count_Of_Copy (Target, Source : Node_Id) is 2008 begin 2009 -- We already copied the two Pflags. We need to update the Paren_Counts 2010 -- table only if greater than 2. 2011 2012 if Nkind (Source) in N_Subexpr 2013 and then Paren_Count (Source) > 2 2014 then 2015 Set_Paren_Count (Target, Paren_Count (Source)); 2016 end if; 2017 2018 pragma Assert (Paren_Count (Target) = Paren_Count (Source)); 2019 end Set_Paren_Count_Of_Copy; 2020 2021 ---------------- 2022 -- Set_Parent -- 2023 ---------------- 2024 2025 procedure Set_Parent (N : Node_Id; Val : Node_Id) is 2026 begin 2027 pragma Assert (not Locked); 2028 pragma Assert (not Nodes.Table (N).In_List); 2029 Nodes.Table (N).Link := Union_Id (Val); 2030 end Set_Parent; 2031 2032 ------------------------ 2033 -- Set_Reporting_Proc -- 2034 ------------------------ 2035 2036 procedure Set_Reporting_Proc (Proc : Report_Proc) is 2037 begin 2038 pragma Assert (Reporting_Proc = null); 2039 Reporting_Proc := Proc; 2040 end Set_Reporting_Proc; 2041 2042 -------------- 2043 -- Set_Sloc -- 2044 -------------- 2045 2046 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is 2047 begin 2048 pragma Assert (not Locked); 2049 Nodes.Table (N).Sloc := Val; 2050 end Set_Sloc; 2051 2052 ------------------------ 2053 -- Set_Rewriting_Proc -- 2054 ------------------------ 2055 2056 procedure Set_Rewriting_Proc (Proc : Rewrite_Proc) is 2057 begin 2058 pragma Assert (Rewriting_Proc = null); 2059 Rewriting_Proc := Proc; 2060 end Set_Rewriting_Proc; 2061 2062 ---------- 2063 -- Sloc -- 2064 ---------- 2065 2066 function Sloc (N : Node_Id) return Source_Ptr is 2067 begin 2068 return Nodes.Table (N).Sloc; 2069 end Sloc; 2070 2071 ------------------- 2072 -- Traverse_Func -- 2073 ------------------- 2074 2075 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is 2076 2077 function Traverse_Field 2078 (Nod : Node_Id; 2079 Fld : Union_Id; 2080 FN : Field_Num) return Traverse_Final_Result; 2081 -- Fld is one of the fields of Nod. If the field points to syntactic 2082 -- node or list, then this node or list is traversed, and the result is 2083 -- the result of this traversal. Otherwise a value of True is returned 2084 -- with no processing. FN is the number of the field (1 .. 5). 2085 2086 -------------------- 2087 -- Traverse_Field -- 2088 -------------------- 2089 2090 function Traverse_Field 2091 (Nod : Node_Id; 2092 Fld : Union_Id; 2093 FN : Field_Num) return Traverse_Final_Result 2094 is 2095 begin 2096 if Fld = Union_Id (Empty) then 2097 return OK; 2098 2099 -- Descendant is a node 2100 2101 elsif Fld in Node_Range then 2102 2103 -- Traverse descendant that is syntactic subtree node 2104 2105 if Is_Syntactic_Field (Nkind (Nod), FN) then 2106 return Traverse_Func (Node_Id (Fld)); 2107 2108 -- Node that is not a syntactic subtree 2109 2110 else 2111 return OK; 2112 end if; 2113 2114 -- Descendant is a list 2115 2116 elsif Fld in List_Range then 2117 2118 -- Traverse descendant that is a syntactic subtree list 2119 2120 if Is_Syntactic_Field (Nkind (Nod), FN) then 2121 declare 2122 Elmt : Node_Id := First (List_Id (Fld)); 2123 2124 begin 2125 while Present (Elmt) loop 2126 if Traverse_Func (Elmt) = Abandon then 2127 return Abandon; 2128 else 2129 Next (Elmt); 2130 end if; 2131 end loop; 2132 2133 return OK; 2134 end; 2135 2136 -- List that is not a syntactic subtree 2137 2138 else 2139 return OK; 2140 end if; 2141 2142 -- Field was not a node or a list 2143 2144 else 2145 return OK; 2146 end if; 2147 end Traverse_Field; 2148 2149 Cur_Node : Node_Id := Node; 2150 2151 -- Start of processing for Traverse_Func 2152 2153 begin 2154 -- We walk Field2 last, and if it is a node, we eliminate the tail 2155 -- recursion by jumping back to this label. This is because Field2 is 2156 -- where the Left_Opnd field of N_Op_Concat is stored, and in practice 2157 -- concatenations are sometimes deeply nested, as in X1&X2&...&XN. This 2158 -- trick prevents us from running out of memory in that case. We don't 2159 -- bother eliminating the tail recursion if Field2 is a list. 2160 2161 <<Tail_Recurse>> 2162 2163 case Process (Cur_Node) is 2164 when Abandon => 2165 return Abandon; 2166 2167 when Skip => 2168 return OK; 2169 2170 when OK => 2171 null; 2172 2173 when OK_Orig => 2174 Cur_Node := Original_Node (Cur_Node); 2175 end case; 2176 2177 if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon 2178 or else -- skip Field2 here 2179 Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon 2180 or else 2181 Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon 2182 or else 2183 Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon 2184 then 2185 return Abandon; 2186 end if; 2187 2188 if Field2 (Cur_Node) not in Node_Range then 2189 return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2); 2190 2191 elsif Is_Syntactic_Field (Nkind (Cur_Node), 2) 2192 and then Field2 (Cur_Node) /= Empty_List_Or_Node 2193 then 2194 -- Here is the tail recursion step, we reset Cur_Node and jump back 2195 -- to the start of the procedure, which has the same semantic effect 2196 -- as a call. 2197 2198 Cur_Node := Node_Id (Field2 (Cur_Node)); 2199 goto Tail_Recurse; 2200 end if; 2201 2202 return OK; 2203 end Traverse_Func; 2204 2205 ------------------- 2206 -- Traverse_Proc -- 2207 ------------------- 2208 2209 procedure Traverse_Proc (Node : Node_Id) is 2210 function Traverse is new Traverse_Func (Process); 2211 Discard : Traverse_Final_Result; 2212 pragma Warnings (Off, Discard); 2213 begin 2214 Discard := Traverse (Node); 2215 end Traverse_Proc; 2216 2217 ------------------------------ 2218 -- Unchecked Access Package -- 2219 ------------------------------ 2220 2221 package body Unchecked_Access is 2222 2223 function Field1 (N : Node_Id) return Union_Id is 2224 begin 2225 pragma Assert (N <= Nodes.Last); 2226 return Nodes.Table (N).Field1; 2227 end Field1; 2228 2229 function Field2 (N : Node_Id) return Union_Id is 2230 begin 2231 pragma Assert (N <= Nodes.Last); 2232 return Nodes.Table (N).Field2; 2233 end Field2; 2234 2235 function Field3 (N : Node_Id) return Union_Id is 2236 begin 2237 pragma Assert (N <= Nodes.Last); 2238 return Nodes.Table (N).Field3; 2239 end Field3; 2240 2241 function Field4 (N : Node_Id) return Union_Id is 2242 begin 2243 pragma Assert (N <= Nodes.Last); 2244 return Nodes.Table (N).Field4; 2245 end Field4; 2246 2247 function Field5 (N : Node_Id) return Union_Id is 2248 begin 2249 pragma Assert (N <= Nodes.Last); 2250 return Nodes.Table (N).Field5; 2251 end Field5; 2252 2253 function Field6 (N : Node_Id) return Union_Id is 2254 begin 2255 pragma Assert (Nkind (N) in N_Entity); 2256 return Nodes.Table (N + 1).Field6; 2257 end Field6; 2258 2259 function Field7 (N : Node_Id) return Union_Id is 2260 begin 2261 pragma Assert (Nkind (N) in N_Entity); 2262 return Nodes.Table (N + 1).Field7; 2263 end Field7; 2264 2265 function Field8 (N : Node_Id) return Union_Id is 2266 begin 2267 pragma Assert (Nkind (N) in N_Entity); 2268 return Nodes.Table (N + 1).Field8; 2269 end Field8; 2270 2271 function Field9 (N : Node_Id) return Union_Id is 2272 begin 2273 pragma Assert (Nkind (N) in N_Entity); 2274 return Nodes.Table (N + 1).Field9; 2275 end Field9; 2276 2277 function Field10 (N : Node_Id) return Union_Id is 2278 begin 2279 pragma Assert (Nkind (N) in N_Entity); 2280 return Nodes.Table (N + 1).Field10; 2281 end Field10; 2282 2283 function Field11 (N : Node_Id) return Union_Id is 2284 begin 2285 pragma Assert (Nkind (N) in N_Entity); 2286 return Nodes.Table (N + 1).Field11; 2287 end Field11; 2288 2289 function Field12 (N : Node_Id) return Union_Id is 2290 begin 2291 pragma Assert (Nkind (N) in N_Entity); 2292 return Nodes.Table (N + 1).Field12; 2293 end Field12; 2294 2295 function Field13 (N : Node_Id) return Union_Id is 2296 begin 2297 pragma Assert (Nkind (N) in N_Entity); 2298 return Nodes.Table (N + 2).Field6; 2299 end Field13; 2300 2301 function Field14 (N : Node_Id) return Union_Id is 2302 begin 2303 pragma Assert (Nkind (N) in N_Entity); 2304 return Nodes.Table (N + 2).Field7; 2305 end Field14; 2306 2307 function Field15 (N : Node_Id) return Union_Id is 2308 begin 2309 pragma Assert (Nkind (N) in N_Entity); 2310 return Nodes.Table (N + 2).Field8; 2311 end Field15; 2312 2313 function Field16 (N : Node_Id) return Union_Id is 2314 begin 2315 pragma Assert (Nkind (N) in N_Entity); 2316 return Nodes.Table (N + 2).Field9; 2317 end Field16; 2318 2319 function Field17 (N : Node_Id) return Union_Id is 2320 begin 2321 pragma Assert (Nkind (N) in N_Entity); 2322 return Nodes.Table (N + 2).Field10; 2323 end Field17; 2324 2325 function Field18 (N : Node_Id) return Union_Id is 2326 begin 2327 pragma Assert (Nkind (N) in N_Entity); 2328 return Nodes.Table (N + 2).Field11; 2329 end Field18; 2330 2331 function Field19 (N : Node_Id) return Union_Id is 2332 begin 2333 pragma Assert (Nkind (N) in N_Entity); 2334 return Nodes.Table (N + 3).Field6; 2335 end Field19; 2336 2337 function Field20 (N : Node_Id) return Union_Id is 2338 begin 2339 pragma Assert (Nkind (N) in N_Entity); 2340 return Nodes.Table (N + 3).Field7; 2341 end Field20; 2342 2343 function Field21 (N : Node_Id) return Union_Id is 2344 begin 2345 pragma Assert (Nkind (N) in N_Entity); 2346 return Nodes.Table (N + 3).Field8; 2347 end Field21; 2348 2349 function Field22 (N : Node_Id) return Union_Id is 2350 begin 2351 pragma Assert (Nkind (N) in N_Entity); 2352 return Nodes.Table (N + 3).Field9; 2353 end Field22; 2354 2355 function Field23 (N : Node_Id) return Union_Id is 2356 begin 2357 pragma Assert (Nkind (N) in N_Entity); 2358 return Nodes.Table (N + 3).Field10; 2359 end Field23; 2360 2361 function Field24 (N : Node_Id) return Union_Id is 2362 begin 2363 pragma Assert (Nkind (N) in N_Entity); 2364 return Nodes.Table (N + 4).Field6; 2365 end Field24; 2366 2367 function Field25 (N : Node_Id) return Union_Id is 2368 begin 2369 pragma Assert (Nkind (N) in N_Entity); 2370 return Nodes.Table (N + 4).Field7; 2371 end Field25; 2372 2373 function Field26 (N : Node_Id) return Union_Id is 2374 begin 2375 pragma Assert (Nkind (N) in N_Entity); 2376 return Nodes.Table (N + 4).Field8; 2377 end Field26; 2378 2379 function Field27 (N : Node_Id) return Union_Id is 2380 begin 2381 pragma Assert (Nkind (N) in N_Entity); 2382 return Nodes.Table (N + 4).Field9; 2383 end Field27; 2384 2385 function Field28 (N : Node_Id) return Union_Id is 2386 begin 2387 pragma Assert (Nkind (N) in N_Entity); 2388 return Nodes.Table (N + 4).Field10; 2389 end Field28; 2390 2391 function Field29 (N : Node_Id) return Union_Id is 2392 begin 2393 pragma Assert (Nkind (N) in N_Entity); 2394 return Nodes.Table (N + 4).Field11; 2395 end Field29; 2396 2397 function Field30 (N : Node_Id) return Union_Id is 2398 begin 2399 pragma Assert (Nkind (N) in N_Entity); 2400 return Nodes.Table (N + 5).Field6; 2401 end Field30; 2402 2403 function Field31 (N : Node_Id) return Union_Id is 2404 begin 2405 pragma Assert (Nkind (N) in N_Entity); 2406 return Nodes.Table (N + 5).Field7; 2407 end Field31; 2408 2409 function Field32 (N : Node_Id) return Union_Id is 2410 begin 2411 pragma Assert (Nkind (N) in N_Entity); 2412 return Nodes.Table (N + 5).Field8; 2413 end Field32; 2414 2415 function Field33 (N : Node_Id) return Union_Id is 2416 begin 2417 pragma Assert (Nkind (N) in N_Entity); 2418 return Nodes.Table (N + 5).Field9; 2419 end Field33; 2420 2421 function Field34 (N : Node_Id) return Union_Id is 2422 begin 2423 pragma Assert (Nkind (N) in N_Entity); 2424 return Nodes.Table (N + 5).Field10; 2425 end Field34; 2426 2427 function Field35 (N : Node_Id) return Union_Id is 2428 begin 2429 pragma Assert (Nkind (N) in N_Entity); 2430 return Nodes.Table (N + 5).Field11; 2431 end Field35; 2432 2433 function Field36 (N : Node_Id) return Union_Id is 2434 begin 2435 pragma Assert (Nkind (N) in N_Entity); 2436 return Nodes.Table (N + 6).Field6; 2437 end Field36; 2438 2439 function Field37 (N : Node_Id) return Union_Id is 2440 begin 2441 pragma Assert (Nkind (N) in N_Entity); 2442 return Nodes.Table (N + 6).Field7; 2443 end Field37; 2444 2445 function Field38 (N : Node_Id) return Union_Id is 2446 begin 2447 pragma Assert (Nkind (N) in N_Entity); 2448 return Nodes.Table (N + 6).Field8; 2449 end Field38; 2450 2451 function Field39 (N : Node_Id) return Union_Id is 2452 begin 2453 pragma Assert (Nkind (N) in N_Entity); 2454 return Nodes.Table (N + 6).Field9; 2455 end Field39; 2456 2457 function Field40 (N : Node_Id) return Union_Id is 2458 begin 2459 pragma Assert (Nkind (N) in N_Entity); 2460 return Nodes.Table (N + 6).Field10; 2461 end Field40; 2462 2463 function Field41 (N : Node_Id) return Union_Id is 2464 begin 2465 pragma Assert (Nkind (N) in N_Entity); 2466 return Nodes.Table (N + 6).Field11; 2467 end Field41; 2468 2469 function Node1 (N : Node_Id) return Node_Id is 2470 begin 2471 pragma Assert (N <= Nodes.Last); 2472 return Node_Id (Nodes.Table (N).Field1); 2473 end Node1; 2474 2475 function Node2 (N : Node_Id) return Node_Id is 2476 begin 2477 pragma Assert (N <= Nodes.Last); 2478 return Node_Id (Nodes.Table (N).Field2); 2479 end Node2; 2480 2481 function Node3 (N : Node_Id) return Node_Id is 2482 begin 2483 pragma Assert (N <= Nodes.Last); 2484 return Node_Id (Nodes.Table (N).Field3); 2485 end Node3; 2486 2487 function Node4 (N : Node_Id) return Node_Id is 2488 begin 2489 pragma Assert (N <= Nodes.Last); 2490 return Node_Id (Nodes.Table (N).Field4); 2491 end Node4; 2492 2493 function Node5 (N : Node_Id) return Node_Id is 2494 begin 2495 pragma Assert (N <= Nodes.Last); 2496 return Node_Id (Nodes.Table (N).Field5); 2497 end Node5; 2498 2499 function Node6 (N : Node_Id) return Node_Id is 2500 begin 2501 pragma Assert (Nkind (N) in N_Entity); 2502 return Node_Id (Nodes.Table (N + 1).Field6); 2503 end Node6; 2504 2505 function Node7 (N : Node_Id) return Node_Id is 2506 begin 2507 pragma Assert (Nkind (N) in N_Entity); 2508 return Node_Id (Nodes.Table (N + 1).Field7); 2509 end Node7; 2510 2511 function Node8 (N : Node_Id) return Node_Id is 2512 begin 2513 pragma Assert (Nkind (N) in N_Entity); 2514 return Node_Id (Nodes.Table (N + 1).Field8); 2515 end Node8; 2516 2517 function Node9 (N : Node_Id) return Node_Id is 2518 begin 2519 pragma Assert (Nkind (N) in N_Entity); 2520 return Node_Id (Nodes.Table (N + 1).Field9); 2521 end Node9; 2522 2523 function Node10 (N : Node_Id) return Node_Id is 2524 begin 2525 pragma Assert (Nkind (N) in N_Entity); 2526 return Node_Id (Nodes.Table (N + 1).Field10); 2527 end Node10; 2528 2529 function Node11 (N : Node_Id) return Node_Id is 2530 begin 2531 pragma Assert (Nkind (N) in N_Entity); 2532 return Node_Id (Nodes.Table (N + 1).Field11); 2533 end Node11; 2534 2535 function Node12 (N : Node_Id) return Node_Id is 2536 begin 2537 pragma Assert (Nkind (N) in N_Entity); 2538 return Node_Id (Nodes.Table (N + 1).Field12); 2539 end Node12; 2540 2541 function Node13 (N : Node_Id) return Node_Id is 2542 begin 2543 pragma Assert (Nkind (N) in N_Entity); 2544 return Node_Id (Nodes.Table (N + 2).Field6); 2545 end Node13; 2546 2547 function Node14 (N : Node_Id) return Node_Id is 2548 begin 2549 pragma Assert (Nkind (N) in N_Entity); 2550 return Node_Id (Nodes.Table (N + 2).Field7); 2551 end Node14; 2552 2553 function Node15 (N : Node_Id) return Node_Id is 2554 begin 2555 pragma Assert (Nkind (N) in N_Entity); 2556 return Node_Id (Nodes.Table (N + 2).Field8); 2557 end Node15; 2558 2559 function Node16 (N : Node_Id) return Node_Id is 2560 begin 2561 pragma Assert (Nkind (N) in N_Entity); 2562 return Node_Id (Nodes.Table (N + 2).Field9); 2563 end Node16; 2564 2565 function Node17 (N : Node_Id) return Node_Id is 2566 begin 2567 pragma Assert (Nkind (N) in N_Entity); 2568 return Node_Id (Nodes.Table (N + 2).Field10); 2569 end Node17; 2570 2571 function Node18 (N : Node_Id) return Node_Id is 2572 begin 2573 pragma Assert (Nkind (N) in N_Entity); 2574 return Node_Id (Nodes.Table (N + 2).Field11); 2575 end Node18; 2576 2577 function Node19 (N : Node_Id) return Node_Id is 2578 begin 2579 pragma Assert (Nkind (N) in N_Entity); 2580 return Node_Id (Nodes.Table (N + 3).Field6); 2581 end Node19; 2582 2583 function Node20 (N : Node_Id) return Node_Id is 2584 begin 2585 pragma Assert (Nkind (N) in N_Entity); 2586 return Node_Id (Nodes.Table (N + 3).Field7); 2587 end Node20; 2588 2589 function Node21 (N : Node_Id) return Node_Id is 2590 begin 2591 pragma Assert (Nkind (N) in N_Entity); 2592 return Node_Id (Nodes.Table (N + 3).Field8); 2593 end Node21; 2594 2595 function Node22 (N : Node_Id) return Node_Id is 2596 begin 2597 pragma Assert (Nkind (N) in N_Entity); 2598 return Node_Id (Nodes.Table (N + 3).Field9); 2599 end Node22; 2600 2601 function Node23 (N : Node_Id) return Node_Id is 2602 begin 2603 pragma Assert (Nkind (N) in N_Entity); 2604 return Node_Id (Nodes.Table (N + 3).Field10); 2605 end Node23; 2606 2607 function Node24 (N : Node_Id) return Node_Id is 2608 begin 2609 pragma Assert (Nkind (N) in N_Entity); 2610 return Node_Id (Nodes.Table (N + 4).Field6); 2611 end Node24; 2612 2613 function Node25 (N : Node_Id) return Node_Id is 2614 begin 2615 pragma Assert (Nkind (N) in N_Entity); 2616 return Node_Id (Nodes.Table (N + 4).Field7); 2617 end Node25; 2618 2619 function Node26 (N : Node_Id) return Node_Id is 2620 begin 2621 pragma Assert (Nkind (N) in N_Entity); 2622 return Node_Id (Nodes.Table (N + 4).Field8); 2623 end Node26; 2624 2625 function Node27 (N : Node_Id) return Node_Id is 2626 begin 2627 pragma Assert (Nkind (N) in N_Entity); 2628 return Node_Id (Nodes.Table (N + 4).Field9); 2629 end Node27; 2630 2631 function Node28 (N : Node_Id) return Node_Id is 2632 begin 2633 pragma Assert (Nkind (N) in N_Entity); 2634 return Node_Id (Nodes.Table (N + 4).Field10); 2635 end Node28; 2636 2637 function Node29 (N : Node_Id) return Node_Id is 2638 begin 2639 pragma Assert (Nkind (N) in N_Entity); 2640 return Node_Id (Nodes.Table (N + 4).Field11); 2641 end Node29; 2642 2643 function Node30 (N : Node_Id) return Node_Id is 2644 begin 2645 pragma Assert (Nkind (N) in N_Entity); 2646 return Node_Id (Nodes.Table (N + 5).Field6); 2647 end Node30; 2648 2649 function Node31 (N : Node_Id) return Node_Id is 2650 begin 2651 pragma Assert (Nkind (N) in N_Entity); 2652 return Node_Id (Nodes.Table (N + 5).Field7); 2653 end Node31; 2654 2655 function Node32 (N : Node_Id) return Node_Id is 2656 begin 2657 pragma Assert (Nkind (N) in N_Entity); 2658 return Node_Id (Nodes.Table (N + 5).Field8); 2659 end Node32; 2660 2661 function Node33 (N : Node_Id) return Node_Id is 2662 begin 2663 pragma Assert (Nkind (N) in N_Entity); 2664 return Node_Id (Nodes.Table (N + 5).Field9); 2665 end Node33; 2666 2667 function Node34 (N : Node_Id) return Node_Id is 2668 begin 2669 pragma Assert (Nkind (N) in N_Entity); 2670 return Node_Id (Nodes.Table (N + 5).Field10); 2671 end Node34; 2672 2673 function Node35 (N : Node_Id) return Node_Id is 2674 begin 2675 pragma Assert (Nkind (N) in N_Entity); 2676 return Node_Id (Nodes.Table (N + 5).Field11); 2677 end Node35; 2678 2679 function Node36 (N : Node_Id) return Node_Id is 2680 begin 2681 pragma Assert (Nkind (N) in N_Entity); 2682 return Node_Id (Nodes.Table (N + 6).Field6); 2683 end Node36; 2684 2685 function Node37 (N : Node_Id) return Node_Id is 2686 begin 2687 pragma Assert (Nkind (N) in N_Entity); 2688 return Node_Id (Nodes.Table (N + 6).Field7); 2689 end Node37; 2690 2691 function Node38 (N : Node_Id) return Node_Id is 2692 begin 2693 pragma Assert (Nkind (N) in N_Entity); 2694 return Node_Id (Nodes.Table (N + 6).Field8); 2695 end Node38; 2696 2697 function Node39 (N : Node_Id) return Node_Id is 2698 begin 2699 pragma Assert (Nkind (N) in N_Entity); 2700 return Node_Id (Nodes.Table (N + 6).Field9); 2701 end Node39; 2702 2703 function Node40 (N : Node_Id) return Node_Id is 2704 begin 2705 pragma Assert (Nkind (N) in N_Entity); 2706 return Node_Id (Nodes.Table (N + 6).Field10); 2707 end Node40; 2708 2709 function Node41 (N : Node_Id) return Node_Id is 2710 begin 2711 pragma Assert (Nkind (N) in N_Entity); 2712 return Node_Id (Nodes.Table (N + 6).Field11); 2713 end Node41; 2714 2715 function List1 (N : Node_Id) return List_Id is 2716 begin 2717 pragma Assert (N <= Nodes.Last); 2718 return List_Id (Nodes.Table (N).Field1); 2719 end List1; 2720 2721 function List2 (N : Node_Id) return List_Id is 2722 begin 2723 pragma Assert (N <= Nodes.Last); 2724 return List_Id (Nodes.Table (N).Field2); 2725 end List2; 2726 2727 function List3 (N : Node_Id) return List_Id is 2728 begin 2729 pragma Assert (N <= Nodes.Last); 2730 return List_Id (Nodes.Table (N).Field3); 2731 end List3; 2732 2733 function List4 (N : Node_Id) return List_Id is 2734 begin 2735 pragma Assert (N <= Nodes.Last); 2736 return List_Id (Nodes.Table (N).Field4); 2737 end List4; 2738 2739 function List5 (N : Node_Id) return List_Id is 2740 begin 2741 pragma Assert (N <= Nodes.Last); 2742 return List_Id (Nodes.Table (N).Field5); 2743 end List5; 2744 2745 function List10 (N : Node_Id) return List_Id is 2746 begin 2747 pragma Assert (Nkind (N) in N_Entity); 2748 return List_Id (Nodes.Table (N + 1).Field10); 2749 end List10; 2750 2751 function List14 (N : Node_Id) return List_Id is 2752 begin 2753 pragma Assert (Nkind (N) in N_Entity); 2754 return List_Id (Nodes.Table (N + 2).Field7); 2755 end List14; 2756 2757 function List25 (N : Node_Id) return List_Id is 2758 begin 2759 pragma Assert (Nkind (N) in N_Entity); 2760 return List_Id (Nodes.Table (N + 4).Field7); 2761 end List25; 2762 2763 function List38 (N : Node_Id) return List_Id is 2764 begin 2765 return List_Id (Nodes.Table (N + 6).Field8); 2766 end List38; 2767 2768 function List39 (N : Node_Id) return List_Id is 2769 begin 2770 return List_Id (Nodes.Table (N + 6).Field9); 2771 end List39; 2772 2773 function Elist1 (N : Node_Id) return Elist_Id is 2774 pragma Assert (N <= Nodes.Last); 2775 Value : constant Union_Id := Nodes.Table (N).Field1; 2776 begin 2777 if Value = 0 then 2778 return No_Elist; 2779 else 2780 return Elist_Id (Value); 2781 end if; 2782 end Elist1; 2783 2784 function Elist2 (N : Node_Id) return Elist_Id is 2785 pragma Assert (N <= Nodes.Last); 2786 Value : constant Union_Id := Nodes.Table (N).Field2; 2787 begin 2788 if Value = 0 then 2789 return No_Elist; 2790 else 2791 return Elist_Id (Value); 2792 end if; 2793 end Elist2; 2794 2795 function Elist3 (N : Node_Id) return Elist_Id is 2796 pragma Assert (N <= Nodes.Last); 2797 Value : constant Union_Id := Nodes.Table (N).Field3; 2798 begin 2799 if Value = 0 then 2800 return No_Elist; 2801 else 2802 return Elist_Id (Value); 2803 end if; 2804 end Elist3; 2805 2806 function Elist4 (N : Node_Id) return Elist_Id is 2807 pragma Assert (N <= Nodes.Last); 2808 Value : constant Union_Id := Nodes.Table (N).Field4; 2809 begin 2810 if Value = 0 then 2811 return No_Elist; 2812 else 2813 return Elist_Id (Value); 2814 end if; 2815 end Elist4; 2816 2817 function Elist5 (N : Node_Id) return Elist_Id is 2818 pragma Assert (N <= Nodes.Last); 2819 Value : constant Union_Id := Nodes.Table (N).Field5; 2820 begin 2821 if Value = 0 then 2822 return No_Elist; 2823 else 2824 return Elist_Id (Value); 2825 end if; 2826 end Elist5; 2827 2828 function Elist8 (N : Node_Id) return Elist_Id is 2829 pragma Assert (Nkind (N) in N_Entity); 2830 Value : constant Union_Id := Nodes.Table (N + 1).Field8; 2831 begin 2832 if Value = 0 then 2833 return No_Elist; 2834 else 2835 return Elist_Id (Value); 2836 end if; 2837 end Elist8; 2838 2839 function Elist9 (N : Node_Id) return Elist_Id is 2840 pragma Assert (Nkind (N) in N_Entity); 2841 Value : constant Union_Id := Nodes.Table (N + 1).Field9; 2842 begin 2843 if Value = 0 then 2844 return No_Elist; 2845 else 2846 return Elist_Id (Value); 2847 end if; 2848 end Elist9; 2849 2850 function Elist10 (N : Node_Id) return Elist_Id is 2851 pragma Assert (Nkind (N) in N_Entity); 2852 Value : constant Union_Id := Nodes.Table (N + 1).Field10; 2853 begin 2854 if Value = 0 then 2855 return No_Elist; 2856 else 2857 return Elist_Id (Value); 2858 end if; 2859 end Elist10; 2860 2861 function Elist11 (N : Node_Id) return Elist_Id is 2862 pragma Assert (Nkind (N) in N_Entity); 2863 Value : constant Union_Id := Nodes.Table (N + 1).Field11; 2864 begin 2865 if Value = 0 then 2866 return No_Elist; 2867 else 2868 return Elist_Id (Value); 2869 end if; 2870 end Elist11; 2871 2872 function Elist13 (N : Node_Id) return Elist_Id is 2873 pragma Assert (Nkind (N) in N_Entity); 2874 Value : constant Union_Id := Nodes.Table (N + 2).Field6; 2875 begin 2876 if Value = 0 then 2877 return No_Elist; 2878 else 2879 return Elist_Id (Value); 2880 end if; 2881 end Elist13; 2882 2883 function Elist15 (N : Node_Id) return Elist_Id is 2884 pragma Assert (Nkind (N) in N_Entity); 2885 Value : constant Union_Id := Nodes.Table (N + 2).Field8; 2886 begin 2887 if Value = 0 then 2888 return No_Elist; 2889 else 2890 return Elist_Id (Value); 2891 end if; 2892 end Elist15; 2893 2894 function Elist16 (N : Node_Id) return Elist_Id is 2895 pragma Assert (Nkind (N) in N_Entity); 2896 Value : constant Union_Id := Nodes.Table (N + 2).Field9; 2897 begin 2898 if Value = 0 then 2899 return No_Elist; 2900 else 2901 return Elist_Id (Value); 2902 end if; 2903 end Elist16; 2904 2905 function Elist18 (N : Node_Id) return Elist_Id is 2906 pragma Assert (Nkind (N) in N_Entity); 2907 Value : constant Union_Id := Nodes.Table (N + 2).Field11; 2908 begin 2909 if Value = 0 then 2910 return No_Elist; 2911 else 2912 return Elist_Id (Value); 2913 end if; 2914 end Elist18; 2915 2916 function Elist21 (N : Node_Id) return Elist_Id is 2917 pragma Assert (Nkind (N) in N_Entity); 2918 Value : constant Union_Id := Nodes.Table (N + 3).Field8; 2919 begin 2920 if Value = 0 then 2921 return No_Elist; 2922 else 2923 return Elist_Id (Value); 2924 end if; 2925 end Elist21; 2926 2927 function Elist23 (N : Node_Id) return Elist_Id is 2928 pragma Assert (Nkind (N) in N_Entity); 2929 Value : constant Union_Id := Nodes.Table (N + 3).Field10; 2930 begin 2931 if Value = 0 then 2932 return No_Elist; 2933 else 2934 return Elist_Id (Value); 2935 end if; 2936 end Elist23; 2937 2938 function Elist24 (N : Node_Id) return Elist_Id is 2939 pragma Assert (Nkind (N) in N_Entity); 2940 Value : constant Union_Id := Nodes.Table (N + 4).Field6; 2941 begin 2942 if Value = 0 then 2943 return No_Elist; 2944 else 2945 return Elist_Id (Value); 2946 end if; 2947 end Elist24; 2948 2949 function Elist25 (N : Node_Id) return Elist_Id is 2950 pragma Assert (Nkind (N) in N_Entity); 2951 Value : constant Union_Id := Nodes.Table (N + 4).Field7; 2952 begin 2953 if Value = 0 then 2954 return No_Elist; 2955 else 2956 return Elist_Id (Value); 2957 end if; 2958 end Elist25; 2959 2960 function Elist26 (N : Node_Id) return Elist_Id is 2961 pragma Assert (Nkind (N) in N_Entity); 2962 Value : constant Union_Id := Nodes.Table (N + 4).Field8; 2963 begin 2964 if Value = 0 then 2965 return No_Elist; 2966 else 2967 return Elist_Id (Value); 2968 end if; 2969 end Elist26; 2970 2971 function Elist29 (N : Node_Id) return Elist_Id is 2972 pragma Assert (Nkind (N) in N_Entity); 2973 Value : constant Union_Id := Nodes.Table (N + 4).Field11; 2974 begin 2975 if Value = 0 then 2976 return No_Elist; 2977 else 2978 return Elist_Id (Value); 2979 end if; 2980 end Elist29; 2981 2982 function Elist30 (N : Node_Id) return Elist_Id is 2983 pragma Assert (Nkind (N) in N_Entity); 2984 Value : constant Union_Id := Nodes.Table (N + 5).Field6; 2985 begin 2986 if Value = 0 then 2987 return No_Elist; 2988 else 2989 return Elist_Id (Value); 2990 end if; 2991 end Elist30; 2992 2993 function Elist36 (N : Node_Id) return Elist_Id is 2994 pragma Assert (Nkind (N) in N_Entity); 2995 Value : constant Union_Id := Nodes.Table (N + 6).Field6; 2996 begin 2997 if Value = 0 then 2998 return No_Elist; 2999 else 3000 return Elist_Id (Value); 3001 end if; 3002 end Elist36; 3003 3004 function Name1 (N : Node_Id) return Name_Id is 3005 begin 3006 pragma Assert (N <= Nodes.Last); 3007 return Name_Id (Nodes.Table (N).Field1); 3008 end Name1; 3009 3010 function Name2 (N : Node_Id) return Name_Id is 3011 begin 3012 pragma Assert (N <= Nodes.Last); 3013 return Name_Id (Nodes.Table (N).Field2); 3014 end Name2; 3015 3016 function Str3 (N : Node_Id) return String_Id is 3017 begin 3018 pragma Assert (N <= Nodes.Last); 3019 return String_Id (Nodes.Table (N).Field3); 3020 end Str3; 3021 3022 function Uint2 (N : Node_Id) return Uint is 3023 pragma Assert (N <= Nodes.Last); 3024 U : constant Union_Id := Nodes.Table (N).Field2; 3025 begin 3026 if U = 0 then 3027 return Uint_0; 3028 else 3029 return From_Union (U); 3030 end if; 3031 end Uint2; 3032 3033 function Uint3 (N : Node_Id) return Uint is 3034 pragma Assert (N <= Nodes.Last); 3035 U : constant Union_Id := Nodes.Table (N).Field3; 3036 begin 3037 if U = 0 then 3038 return Uint_0; 3039 else 3040 return From_Union (U); 3041 end if; 3042 end Uint3; 3043 3044 function Uint4 (N : Node_Id) return Uint is 3045 pragma Assert (N <= Nodes.Last); 3046 U : constant Union_Id := Nodes.Table (N).Field4; 3047 begin 3048 if U = 0 then 3049 return Uint_0; 3050 else 3051 return From_Union (U); 3052 end if; 3053 end Uint4; 3054 3055 function Uint5 (N : Node_Id) return Uint is 3056 pragma Assert (N <= Nodes.Last); 3057 U : constant Union_Id := Nodes.Table (N).Field5; 3058 begin 3059 if U = 0 then 3060 return Uint_0; 3061 else 3062 return From_Union (U); 3063 end if; 3064 end Uint5; 3065 3066 function Uint8 (N : Node_Id) return Uint is 3067 pragma Assert (Nkind (N) in N_Entity); 3068 U : constant Union_Id := Nodes.Table (N + 1).Field8; 3069 begin 3070 if U = 0 then 3071 return Uint_0; 3072 else 3073 return From_Union (U); 3074 end if; 3075 end Uint8; 3076 3077 function Uint9 (N : Node_Id) return Uint is 3078 pragma Assert (Nkind (N) in N_Entity); 3079 U : constant Union_Id := Nodes.Table (N + 1).Field9; 3080 begin 3081 if U = 0 then 3082 return Uint_0; 3083 else 3084 return From_Union (U); 3085 end if; 3086 end Uint9; 3087 3088 function Uint10 (N : Node_Id) return Uint is 3089 pragma Assert (Nkind (N) in N_Entity); 3090 U : constant Union_Id := Nodes.Table (N + 1).Field10; 3091 begin 3092 if U = 0 then 3093 return Uint_0; 3094 else 3095 return From_Union (U); 3096 end if; 3097 end Uint10; 3098 3099 function Uint11 (N : Node_Id) return Uint is 3100 pragma Assert (Nkind (N) in N_Entity); 3101 U : constant Union_Id := Nodes.Table (N + 1).Field11; 3102 begin 3103 if U = 0 then 3104 return Uint_0; 3105 else 3106 return From_Union (U); 3107 end if; 3108 end Uint11; 3109 3110 function Uint12 (N : Node_Id) return Uint is 3111 pragma Assert (Nkind (N) in N_Entity); 3112 U : constant Union_Id := Nodes.Table (N + 1).Field12; 3113 begin 3114 if U = 0 then 3115 return Uint_0; 3116 else 3117 return From_Union (U); 3118 end if; 3119 end Uint12; 3120 3121 function Uint13 (N : Node_Id) return Uint is 3122 pragma Assert (Nkind (N) in N_Entity); 3123 U : constant Union_Id := Nodes.Table (N + 2).Field6; 3124 begin 3125 if U = 0 then 3126 return Uint_0; 3127 else 3128 return From_Union (U); 3129 end if; 3130 end Uint13; 3131 3132 function Uint14 (N : Node_Id) return Uint is 3133 pragma Assert (Nkind (N) in N_Entity); 3134 U : constant Union_Id := Nodes.Table (N + 2).Field7; 3135 begin 3136 if U = 0 then 3137 return Uint_0; 3138 else 3139 return From_Union (U); 3140 end if; 3141 end Uint14; 3142 3143 function Uint15 (N : Node_Id) return Uint is 3144 pragma Assert (Nkind (N) in N_Entity); 3145 U : constant Union_Id := Nodes.Table (N + 2).Field8; 3146 begin 3147 if U = 0 then 3148 return Uint_0; 3149 else 3150 return From_Union (U); 3151 end if; 3152 end Uint15; 3153 3154 function Uint16 (N : Node_Id) return Uint is 3155 pragma Assert (Nkind (N) in N_Entity); 3156 U : constant Union_Id := Nodes.Table (N + 2).Field9; 3157 begin 3158 if U = 0 then 3159 return Uint_0; 3160 else 3161 return From_Union (U); 3162 end if; 3163 end Uint16; 3164 3165 function Uint17 (N : Node_Id) return Uint is 3166 pragma Assert (Nkind (N) in N_Entity); 3167 U : constant Union_Id := Nodes.Table (N + 2).Field10; 3168 begin 3169 if U = 0 then 3170 return Uint_0; 3171 else 3172 return From_Union (U); 3173 end if; 3174 end Uint17; 3175 3176 function Uint22 (N : Node_Id) return Uint is 3177 pragma Assert (Nkind (N) in N_Entity); 3178 U : constant Union_Id := Nodes.Table (N + 3).Field9; 3179 begin 3180 if U = 0 then 3181 return Uint_0; 3182 else 3183 return From_Union (U); 3184 end if; 3185 end Uint22; 3186 3187 function Uint24 (N : Node_Id) return Uint is 3188 pragma Assert (Nkind (N) in N_Entity); 3189 U : constant Union_Id := Nodes.Table (N + 4).Field6; 3190 begin 3191 if U = 0 then 3192 return Uint_0; 3193 else 3194 return From_Union (U); 3195 end if; 3196 end Uint24; 3197 3198 function Ureal3 (N : Node_Id) return Ureal is 3199 begin 3200 pragma Assert (N <= Nodes.Last); 3201 return From_Union (Nodes.Table (N).Field3); 3202 end Ureal3; 3203 3204 function Ureal18 (N : Node_Id) return Ureal is 3205 begin 3206 pragma Assert (Nkind (N) in N_Entity); 3207 return From_Union (Nodes.Table (N + 2).Field11); 3208 end Ureal18; 3209 3210 function Ureal21 (N : Node_Id) return Ureal is 3211 begin 3212 pragma Assert (Nkind (N) in N_Entity); 3213 return From_Union (Nodes.Table (N + 3).Field8); 3214 end Ureal21; 3215 3216 function Flag0 (N : Node_Id) return Boolean is 3217 begin 3218 pragma Assert (N <= Nodes.Last); 3219 return Flags.Table (N).Flag0; 3220 end Flag0; 3221 3222 function Flag1 (N : Node_Id) return Boolean is 3223 begin 3224 pragma Assert (N <= Nodes.Last); 3225 return Flags.Table (N).Flag1; 3226 end Flag1; 3227 3228 function Flag2 (N : Node_Id) return Boolean is 3229 begin 3230 pragma Assert (N <= Nodes.Last); 3231 return Flags.Table (N).Flag2; 3232 end Flag2; 3233 3234 function Flag3 (N : Node_Id) return Boolean is 3235 begin 3236 pragma Assert (N <= Nodes.Last); 3237 return Flags.Table (N).Flag3; 3238 end Flag3; 3239 3240 function Flag4 (N : Node_Id) return Boolean is 3241 begin 3242 pragma Assert (N <= Nodes.Last); 3243 return Nodes.Table (N).Flag4; 3244 end Flag4; 3245 3246 function Flag5 (N : Node_Id) return Boolean is 3247 begin 3248 pragma Assert (N <= Nodes.Last); 3249 return Nodes.Table (N).Flag5; 3250 end Flag5; 3251 3252 function Flag6 (N : Node_Id) return Boolean is 3253 begin 3254 pragma Assert (N <= Nodes.Last); 3255 return Nodes.Table (N).Flag6; 3256 end Flag6; 3257 3258 function Flag7 (N : Node_Id) return Boolean is 3259 begin 3260 pragma Assert (N <= Nodes.Last); 3261 return Nodes.Table (N).Flag7; 3262 end Flag7; 3263 3264 function Flag8 (N : Node_Id) return Boolean is 3265 begin 3266 pragma Assert (N <= Nodes.Last); 3267 return Nodes.Table (N).Flag8; 3268 end Flag8; 3269 3270 function Flag9 (N : Node_Id) return Boolean is 3271 begin 3272 pragma Assert (N <= Nodes.Last); 3273 return Nodes.Table (N).Flag9; 3274 end Flag9; 3275 3276 function Flag10 (N : Node_Id) return Boolean is 3277 begin 3278 pragma Assert (N <= Nodes.Last); 3279 return Nodes.Table (N).Flag10; 3280 end Flag10; 3281 3282 function Flag11 (N : Node_Id) return Boolean is 3283 begin 3284 pragma Assert (N <= Nodes.Last); 3285 return Nodes.Table (N).Flag11; 3286 end Flag11; 3287 3288 function Flag12 (N : Node_Id) return Boolean is 3289 begin 3290 pragma Assert (N <= Nodes.Last); 3291 return Nodes.Table (N).Flag12; 3292 end Flag12; 3293 3294 function Flag13 (N : Node_Id) return Boolean is 3295 begin 3296 pragma Assert (N <= Nodes.Last); 3297 return Nodes.Table (N).Flag13; 3298 end Flag13; 3299 3300 function Flag14 (N : Node_Id) return Boolean is 3301 begin 3302 pragma Assert (N <= Nodes.Last); 3303 return Nodes.Table (N).Flag14; 3304 end Flag14; 3305 3306 function Flag15 (N : Node_Id) return Boolean is 3307 begin 3308 pragma Assert (N <= Nodes.Last); 3309 return Nodes.Table (N).Flag15; 3310 end Flag15; 3311 3312 function Flag16 (N : Node_Id) return Boolean is 3313 begin 3314 pragma Assert (N <= Nodes.Last); 3315 return Nodes.Table (N).Flag16; 3316 end Flag16; 3317 3318 function Flag17 (N : Node_Id) return Boolean is 3319 begin 3320 pragma Assert (N <= Nodes.Last); 3321 return Nodes.Table (N).Flag17; 3322 end Flag17; 3323 3324 function Flag18 (N : Node_Id) return Boolean is 3325 begin 3326 pragma Assert (N <= Nodes.Last); 3327 return Nodes.Table (N).Flag18; 3328 end Flag18; 3329 3330 function Flag19 (N : Node_Id) return Boolean is 3331 begin 3332 pragma Assert (Nkind (N) in N_Entity); 3333 return Nodes.Table (N + 1).In_List; 3334 end Flag19; 3335 3336 function Flag20 (N : Node_Id) return Boolean is 3337 begin 3338 pragma Assert (Nkind (N) in N_Entity); 3339 return Nodes.Table (N + 1).Has_Aspects; 3340 end Flag20; 3341 3342 function Flag21 (N : Node_Id) return Boolean is 3343 begin 3344 pragma Assert (Nkind (N) in N_Entity); 3345 return Nodes.Table (N + 1).Rewrite_Ins; 3346 end Flag21; 3347 3348 function Flag22 (N : Node_Id) return Boolean is 3349 begin 3350 pragma Assert (Nkind (N) in N_Entity); 3351 return Nodes.Table (N + 1).Analyzed; 3352 end Flag22; 3353 3354 function Flag23 (N : Node_Id) return Boolean is 3355 begin 3356 pragma Assert (Nkind (N) in N_Entity); 3357 return Nodes.Table (N + 1).Comes_From_Source; 3358 end Flag23; 3359 3360 function Flag24 (N : Node_Id) return Boolean is 3361 begin 3362 pragma Assert (Nkind (N) in N_Entity); 3363 return Nodes.Table (N + 1).Error_Posted; 3364 end Flag24; 3365 3366 function Flag25 (N : Node_Id) return Boolean is 3367 begin 3368 pragma Assert (Nkind (N) in N_Entity); 3369 return Nodes.Table (N + 1).Flag4; 3370 end Flag25; 3371 3372 function Flag26 (N : Node_Id) return Boolean is 3373 begin 3374 pragma Assert (Nkind (N) in N_Entity); 3375 return Nodes.Table (N + 1).Flag5; 3376 end Flag26; 3377 3378 function Flag27 (N : Node_Id) return Boolean is 3379 begin 3380 pragma Assert (Nkind (N) in N_Entity); 3381 return Nodes.Table (N + 1).Flag6; 3382 end Flag27; 3383 3384 function Flag28 (N : Node_Id) return Boolean is 3385 begin 3386 pragma Assert (Nkind (N) in N_Entity); 3387 return Nodes.Table (N + 1).Flag7; 3388 end Flag28; 3389 3390 function Flag29 (N : Node_Id) return Boolean is 3391 begin 3392 pragma Assert (Nkind (N) in N_Entity); 3393 return Nodes.Table (N + 1).Flag8; 3394 end Flag29; 3395 3396 function Flag30 (N : Node_Id) return Boolean is 3397 begin 3398 pragma Assert (Nkind (N) in N_Entity); 3399 return Nodes.Table (N + 1).Flag9; 3400 end Flag30; 3401 3402 function Flag31 (N : Node_Id) return Boolean is 3403 begin 3404 pragma Assert (Nkind (N) in N_Entity); 3405 return Nodes.Table (N + 1).Flag10; 3406 end Flag31; 3407 3408 function Flag32 (N : Node_Id) return Boolean is 3409 begin 3410 pragma Assert (Nkind (N) in N_Entity); 3411 return Nodes.Table (N + 1).Flag11; 3412 end Flag32; 3413 3414 function Flag33 (N : Node_Id) return Boolean is 3415 begin 3416 pragma Assert (Nkind (N) in N_Entity); 3417 return Nodes.Table (N + 1).Flag12; 3418 end Flag33; 3419 3420 function Flag34 (N : Node_Id) return Boolean is 3421 begin 3422 pragma Assert (Nkind (N) in N_Entity); 3423 return Nodes.Table (N + 1).Flag13; 3424 end Flag34; 3425 3426 function Flag35 (N : Node_Id) return Boolean is 3427 begin 3428 pragma Assert (Nkind (N) in N_Entity); 3429 return Nodes.Table (N + 1).Flag14; 3430 end Flag35; 3431 3432 function Flag36 (N : Node_Id) return Boolean is 3433 begin 3434 pragma Assert (Nkind (N) in N_Entity); 3435 return Nodes.Table (N + 1).Flag15; 3436 end Flag36; 3437 3438 function Flag37 (N : Node_Id) return Boolean is 3439 begin 3440 pragma Assert (Nkind (N) in N_Entity); 3441 return Nodes.Table (N + 1).Flag16; 3442 end Flag37; 3443 3444 function Flag38 (N : Node_Id) return Boolean is 3445 begin 3446 pragma Assert (Nkind (N) in N_Entity); 3447 return Nodes.Table (N + 1).Flag17; 3448 end Flag38; 3449 3450 function Flag39 (N : Node_Id) return Boolean is 3451 begin 3452 pragma Assert (Nkind (N) in N_Entity); 3453 return Nodes.Table (N + 1).Flag18; 3454 end Flag39; 3455 3456 function Flag40 (N : Node_Id) return Boolean is 3457 begin 3458 pragma Assert (Nkind (N) in N_Entity); 3459 return Nodes.Table (N + 2).In_List; 3460 end Flag40; 3461 3462 function Flag41 (N : Node_Id) return Boolean is 3463 begin 3464 pragma Assert (Nkind (N) in N_Entity); 3465 return Nodes.Table (N + 2).Has_Aspects; 3466 end Flag41; 3467 3468 function Flag42 (N : Node_Id) return Boolean is 3469 begin 3470 pragma Assert (Nkind (N) in N_Entity); 3471 return Nodes.Table (N + 2).Rewrite_Ins; 3472 end Flag42; 3473 3474 function Flag43 (N : Node_Id) return Boolean is 3475 begin 3476 pragma Assert (Nkind (N) in N_Entity); 3477 return Nodes.Table (N + 2).Analyzed; 3478 end Flag43; 3479 3480 function Flag44 (N : Node_Id) return Boolean is 3481 begin 3482 pragma Assert (Nkind (N) in N_Entity); 3483 return Nodes.Table (N + 2).Comes_From_Source; 3484 end Flag44; 3485 3486 function Flag45 (N : Node_Id) return Boolean is 3487 begin 3488 pragma Assert (Nkind (N) in N_Entity); 3489 return Nodes.Table (N + 2).Error_Posted; 3490 end Flag45; 3491 3492 function Flag46 (N : Node_Id) return Boolean is 3493 begin 3494 pragma Assert (Nkind (N) in N_Entity); 3495 return Nodes.Table (N + 2).Flag4; 3496 end Flag46; 3497 3498 function Flag47 (N : Node_Id) return Boolean is 3499 begin 3500 pragma Assert (Nkind (N) in N_Entity); 3501 return Nodes.Table (N + 2).Flag5; 3502 end Flag47; 3503 3504 function Flag48 (N : Node_Id) return Boolean is 3505 begin 3506 pragma Assert (Nkind (N) in N_Entity); 3507 return Nodes.Table (N + 2).Flag6; 3508 end Flag48; 3509 3510 function Flag49 (N : Node_Id) return Boolean is 3511 begin 3512 pragma Assert (Nkind (N) in N_Entity); 3513 return Nodes.Table (N + 2).Flag7; 3514 end Flag49; 3515 3516 function Flag50 (N : Node_Id) return Boolean is 3517 begin 3518 pragma Assert (Nkind (N) in N_Entity); 3519 return Nodes.Table (N + 2).Flag8; 3520 end Flag50; 3521 3522 function Flag51 (N : Node_Id) return Boolean is 3523 begin 3524 pragma Assert (Nkind (N) in N_Entity); 3525 return Nodes.Table (N + 2).Flag9; 3526 end Flag51; 3527 3528 function Flag52 (N : Node_Id) return Boolean is 3529 begin 3530 pragma Assert (Nkind (N) in N_Entity); 3531 return Nodes.Table (N + 2).Flag10; 3532 end Flag52; 3533 3534 function Flag53 (N : Node_Id) return Boolean is 3535 begin 3536 pragma Assert (Nkind (N) in N_Entity); 3537 return Nodes.Table (N + 2).Flag11; 3538 end Flag53; 3539 3540 function Flag54 (N : Node_Id) return Boolean is 3541 begin 3542 pragma Assert (Nkind (N) in N_Entity); 3543 return Nodes.Table (N + 2).Flag12; 3544 end Flag54; 3545 3546 function Flag55 (N : Node_Id) return Boolean is 3547 begin 3548 pragma Assert (Nkind (N) in N_Entity); 3549 return Nodes.Table (N + 2).Flag13; 3550 end Flag55; 3551 3552 function Flag56 (N : Node_Id) return Boolean is 3553 begin 3554 pragma Assert (Nkind (N) in N_Entity); 3555 return Nodes.Table (N + 2).Flag14; 3556 end Flag56; 3557 3558 function Flag57 (N : Node_Id) return Boolean is 3559 begin 3560 pragma Assert (Nkind (N) in N_Entity); 3561 return Nodes.Table (N + 2).Flag15; 3562 end Flag57; 3563 3564 function Flag58 (N : Node_Id) return Boolean is 3565 begin 3566 pragma Assert (Nkind (N) in N_Entity); 3567 return Nodes.Table (N + 2).Flag16; 3568 end Flag58; 3569 3570 function Flag59 (N : Node_Id) return Boolean is 3571 begin 3572 pragma Assert (Nkind (N) in N_Entity); 3573 return Nodes.Table (N + 2).Flag17; 3574 end Flag59; 3575 3576 function Flag60 (N : Node_Id) return Boolean is 3577 begin 3578 pragma Assert (Nkind (N) in N_Entity); 3579 return Nodes.Table (N + 2).Flag18; 3580 end Flag60; 3581 3582 function Flag61 (N : Node_Id) return Boolean is 3583 begin 3584 pragma Assert (Nkind (N) in N_Entity); 3585 return Nodes.Table (N + 1).Pflag1; 3586 end Flag61; 3587 3588 function Flag62 (N : Node_Id) return Boolean is 3589 begin 3590 pragma Assert (Nkind (N) in N_Entity); 3591 return Nodes.Table (N + 1).Pflag2; 3592 end Flag62; 3593 3594 function Flag63 (N : Node_Id) return Boolean is 3595 begin 3596 pragma Assert (Nkind (N) in N_Entity); 3597 return Nodes.Table (N + 2).Pflag1; 3598 end Flag63; 3599 3600 function Flag64 (N : Node_Id) return Boolean is 3601 begin 3602 pragma Assert (Nkind (N) in N_Entity); 3603 return Nodes.Table (N + 2).Pflag2; 3604 end Flag64; 3605 3606 function Flag65 (N : Node_Id) return Boolean is 3607 begin 3608 pragma Assert (Nkind (N) in N_Entity); 3609 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65; 3610 end Flag65; 3611 3612 function Flag66 (N : Node_Id) return Boolean is 3613 begin 3614 pragma Assert (Nkind (N) in N_Entity); 3615 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66; 3616 end Flag66; 3617 3618 function Flag67 (N : Node_Id) return Boolean is 3619 begin 3620 pragma Assert (Nkind (N) in N_Entity); 3621 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67; 3622 end Flag67; 3623 3624 function Flag68 (N : Node_Id) return Boolean is 3625 begin 3626 pragma Assert (Nkind (N) in N_Entity); 3627 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68; 3628 end Flag68; 3629 3630 function Flag69 (N : Node_Id) return Boolean is 3631 begin 3632 pragma Assert (Nkind (N) in N_Entity); 3633 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69; 3634 end Flag69; 3635 3636 function Flag70 (N : Node_Id) return Boolean is 3637 begin 3638 pragma Assert (Nkind (N) in N_Entity); 3639 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70; 3640 end Flag70; 3641 3642 function Flag71 (N : Node_Id) return Boolean is 3643 begin 3644 pragma Assert (Nkind (N) in N_Entity); 3645 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71; 3646 end Flag71; 3647 3648 function Flag72 (N : Node_Id) return Boolean is 3649 begin 3650 pragma Assert (Nkind (N) in N_Entity); 3651 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72; 3652 end Flag72; 3653 3654 function Flag73 (N : Node_Id) return Boolean is 3655 begin 3656 pragma Assert (Nkind (N) in N_Entity); 3657 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73; 3658 end Flag73; 3659 3660 function Flag74 (N : Node_Id) return Boolean is 3661 begin 3662 pragma Assert (Nkind (N) in N_Entity); 3663 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74; 3664 end Flag74; 3665 3666 function Flag75 (N : Node_Id) return Boolean is 3667 begin 3668 pragma Assert (Nkind (N) in N_Entity); 3669 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75; 3670 end Flag75; 3671 3672 function Flag76 (N : Node_Id) return Boolean is 3673 begin 3674 pragma Assert (Nkind (N) in N_Entity); 3675 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76; 3676 end Flag76; 3677 3678 function Flag77 (N : Node_Id) return Boolean is 3679 begin 3680 pragma Assert (Nkind (N) in N_Entity); 3681 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77; 3682 end Flag77; 3683 3684 function Flag78 (N : Node_Id) return Boolean is 3685 begin 3686 pragma Assert (Nkind (N) in N_Entity); 3687 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78; 3688 end Flag78; 3689 3690 function Flag79 (N : Node_Id) return Boolean is 3691 begin 3692 pragma Assert (Nkind (N) in N_Entity); 3693 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79; 3694 end Flag79; 3695 3696 function Flag80 (N : Node_Id) return Boolean is 3697 begin 3698 pragma Assert (Nkind (N) in N_Entity); 3699 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80; 3700 end Flag80; 3701 3702 function Flag81 (N : Node_Id) return Boolean is 3703 begin 3704 pragma Assert (Nkind (N) in N_Entity); 3705 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81; 3706 end Flag81; 3707 3708 function Flag82 (N : Node_Id) return Boolean is 3709 begin 3710 pragma Assert (Nkind (N) in N_Entity); 3711 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82; 3712 end Flag82; 3713 3714 function Flag83 (N : Node_Id) return Boolean is 3715 begin 3716 pragma Assert (Nkind (N) in N_Entity); 3717 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83; 3718 end Flag83; 3719 3720 function Flag84 (N : Node_Id) return Boolean is 3721 begin 3722 pragma Assert (Nkind (N) in N_Entity); 3723 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84; 3724 end Flag84; 3725 3726 function Flag85 (N : Node_Id) return Boolean is 3727 begin 3728 pragma Assert (Nkind (N) in N_Entity); 3729 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85; 3730 end Flag85; 3731 3732 function Flag86 (N : Node_Id) return Boolean is 3733 begin 3734 pragma Assert (Nkind (N) in N_Entity); 3735 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86; 3736 end Flag86; 3737 3738 function Flag87 (N : Node_Id) return Boolean is 3739 begin 3740 pragma Assert (Nkind (N) in N_Entity); 3741 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87; 3742 end Flag87; 3743 3744 function Flag88 (N : Node_Id) return Boolean is 3745 begin 3746 pragma Assert (Nkind (N) in N_Entity); 3747 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88; 3748 end Flag88; 3749 3750 function Flag89 (N : Node_Id) return Boolean is 3751 begin 3752 pragma Assert (Nkind (N) in N_Entity); 3753 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89; 3754 end Flag89; 3755 3756 function Flag90 (N : Node_Id) return Boolean is 3757 begin 3758 pragma Assert (Nkind (N) in N_Entity); 3759 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90; 3760 end Flag90; 3761 3762 function Flag91 (N : Node_Id) return Boolean is 3763 begin 3764 pragma Assert (Nkind (N) in N_Entity); 3765 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91; 3766 end Flag91; 3767 3768 function Flag92 (N : Node_Id) return Boolean is 3769 begin 3770 pragma Assert (Nkind (N) in N_Entity); 3771 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92; 3772 end Flag92; 3773 3774 function Flag93 (N : Node_Id) return Boolean is 3775 begin 3776 pragma Assert (Nkind (N) in N_Entity); 3777 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93; 3778 end Flag93; 3779 3780 function Flag94 (N : Node_Id) return Boolean is 3781 begin 3782 pragma Assert (Nkind (N) in N_Entity); 3783 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94; 3784 end Flag94; 3785 3786 function Flag95 (N : Node_Id) return Boolean is 3787 begin 3788 pragma Assert (Nkind (N) in N_Entity); 3789 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95; 3790 end Flag95; 3791 3792 function Flag96 (N : Node_Id) return Boolean is 3793 begin 3794 pragma Assert (Nkind (N) in N_Entity); 3795 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96; 3796 end Flag96; 3797 3798 function Flag97 (N : Node_Id) return Boolean is 3799 begin 3800 pragma Assert (Nkind (N) in N_Entity); 3801 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97; 3802 end Flag97; 3803 3804 function Flag98 (N : Node_Id) return Boolean is 3805 begin 3806 pragma Assert (Nkind (N) in N_Entity); 3807 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98; 3808 end Flag98; 3809 3810 function Flag99 (N : Node_Id) return Boolean is 3811 begin 3812 pragma Assert (Nkind (N) in N_Entity); 3813 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99; 3814 end Flag99; 3815 3816 function Flag100 (N : Node_Id) return Boolean is 3817 begin 3818 pragma Assert (Nkind (N) in N_Entity); 3819 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100; 3820 end Flag100; 3821 3822 function Flag101 (N : Node_Id) return Boolean is 3823 begin 3824 pragma Assert (Nkind (N) in N_Entity); 3825 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101; 3826 end Flag101; 3827 3828 function Flag102 (N : Node_Id) return Boolean is 3829 begin 3830 pragma Assert (Nkind (N) in N_Entity); 3831 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102; 3832 end Flag102; 3833 3834 function Flag103 (N : Node_Id) return Boolean is 3835 begin 3836 pragma Assert (Nkind (N) in N_Entity); 3837 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103; 3838 end Flag103; 3839 3840 function Flag104 (N : Node_Id) return Boolean is 3841 begin 3842 pragma Assert (Nkind (N) in N_Entity); 3843 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104; 3844 end Flag104; 3845 3846 function Flag105 (N : Node_Id) return Boolean is 3847 begin 3848 pragma Assert (Nkind (N) in N_Entity); 3849 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105; 3850 end Flag105; 3851 3852 function Flag106 (N : Node_Id) return Boolean is 3853 begin 3854 pragma Assert (Nkind (N) in N_Entity); 3855 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106; 3856 end Flag106; 3857 3858 function Flag107 (N : Node_Id) return Boolean is 3859 begin 3860 pragma Assert (Nkind (N) in N_Entity); 3861 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107; 3862 end Flag107; 3863 3864 function Flag108 (N : Node_Id) return Boolean is 3865 begin 3866 pragma Assert (Nkind (N) in N_Entity); 3867 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108; 3868 end Flag108; 3869 3870 function Flag109 (N : Node_Id) return Boolean is 3871 begin 3872 pragma Assert (Nkind (N) in N_Entity); 3873 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109; 3874 end Flag109; 3875 3876 function Flag110 (N : Node_Id) return Boolean is 3877 begin 3878 pragma Assert (Nkind (N) in N_Entity); 3879 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110; 3880 end Flag110; 3881 3882 function Flag111 (N : Node_Id) return Boolean is 3883 begin 3884 pragma Assert (Nkind (N) in N_Entity); 3885 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111; 3886 end Flag111; 3887 3888 function Flag112 (N : Node_Id) return Boolean is 3889 begin 3890 pragma Assert (Nkind (N) in N_Entity); 3891 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112; 3892 end Flag112; 3893 3894 function Flag113 (N : Node_Id) return Boolean is 3895 begin 3896 pragma Assert (Nkind (N) in N_Entity); 3897 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113; 3898 end Flag113; 3899 3900 function Flag114 (N : Node_Id) return Boolean is 3901 begin 3902 pragma Assert (Nkind (N) in N_Entity); 3903 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114; 3904 end Flag114; 3905 3906 function Flag115 (N : Node_Id) return Boolean is 3907 begin 3908 pragma Assert (Nkind (N) in N_Entity); 3909 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115; 3910 end Flag115; 3911 3912 function Flag116 (N : Node_Id) return Boolean is 3913 begin 3914 pragma Assert (Nkind (N) in N_Entity); 3915 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116; 3916 end Flag116; 3917 3918 function Flag117 (N : Node_Id) return Boolean is 3919 begin 3920 pragma Assert (Nkind (N) in N_Entity); 3921 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117; 3922 end Flag117; 3923 3924 function Flag118 (N : Node_Id) return Boolean is 3925 begin 3926 pragma Assert (Nkind (N) in N_Entity); 3927 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118; 3928 end Flag118; 3929 3930 function Flag119 (N : Node_Id) return Boolean is 3931 begin 3932 pragma Assert (Nkind (N) in N_Entity); 3933 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119; 3934 end Flag119; 3935 3936 function Flag120 (N : Node_Id) return Boolean is 3937 begin 3938 pragma Assert (Nkind (N) in N_Entity); 3939 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120; 3940 end Flag120; 3941 3942 function Flag121 (N : Node_Id) return Boolean is 3943 begin 3944 pragma Assert (Nkind (N) in N_Entity); 3945 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121; 3946 end Flag121; 3947 3948 function Flag122 (N : Node_Id) return Boolean is 3949 begin 3950 pragma Assert (Nkind (N) in N_Entity); 3951 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122; 3952 end Flag122; 3953 3954 function Flag123 (N : Node_Id) return Boolean is 3955 begin 3956 pragma Assert (Nkind (N) in N_Entity); 3957 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123; 3958 end Flag123; 3959 3960 function Flag124 (N : Node_Id) return Boolean is 3961 begin 3962 pragma Assert (Nkind (N) in N_Entity); 3963 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124; 3964 end Flag124; 3965 3966 function Flag125 (N : Node_Id) return Boolean is 3967 begin 3968 pragma Assert (Nkind (N) in N_Entity); 3969 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125; 3970 end Flag125; 3971 3972 function Flag126 (N : Node_Id) return Boolean is 3973 begin 3974 pragma Assert (Nkind (N) in N_Entity); 3975 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126; 3976 end Flag126; 3977 3978 function Flag127 (N : Node_Id) return Boolean is 3979 begin 3980 pragma Assert (Nkind (N) in N_Entity); 3981 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127; 3982 end Flag127; 3983 3984 function Flag128 (N : Node_Id) return Boolean is 3985 begin 3986 pragma Assert (Nkind (N) in N_Entity); 3987 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128; 3988 end Flag128; 3989 3990 function Flag129 (N : Node_Id) return Boolean is 3991 begin 3992 pragma Assert (Nkind (N) in N_Entity); 3993 return Nodes.Table (N + 3).In_List; 3994 end Flag129; 3995 3996 function Flag130 (N : Node_Id) return Boolean is 3997 begin 3998 pragma Assert (Nkind (N) in N_Entity); 3999 return Nodes.Table (N + 3).Has_Aspects; 4000 end Flag130; 4001 4002 function Flag131 (N : Node_Id) return Boolean is 4003 begin 4004 pragma Assert (Nkind (N) in N_Entity); 4005 return Nodes.Table (N + 3).Rewrite_Ins; 4006 end Flag131; 4007 4008 function Flag132 (N : Node_Id) return Boolean is 4009 begin 4010 pragma Assert (Nkind (N) in N_Entity); 4011 return Nodes.Table (N + 3).Analyzed; 4012 end Flag132; 4013 4014 function Flag133 (N : Node_Id) return Boolean is 4015 begin 4016 pragma Assert (Nkind (N) in N_Entity); 4017 return Nodes.Table (N + 3).Comes_From_Source; 4018 end Flag133; 4019 4020 function Flag134 (N : Node_Id) return Boolean is 4021 begin 4022 pragma Assert (Nkind (N) in N_Entity); 4023 return Nodes.Table (N + 3).Error_Posted; 4024 end Flag134; 4025 4026 function Flag135 (N : Node_Id) return Boolean is 4027 begin 4028 pragma Assert (Nkind (N) in N_Entity); 4029 return Nodes.Table (N + 3).Flag4; 4030 end Flag135; 4031 4032 function Flag136 (N : Node_Id) return Boolean is 4033 begin 4034 pragma Assert (Nkind (N) in N_Entity); 4035 return Nodes.Table (N + 3).Flag5; 4036 end Flag136; 4037 4038 function Flag137 (N : Node_Id) return Boolean is 4039 begin 4040 pragma Assert (Nkind (N) in N_Entity); 4041 return Nodes.Table (N + 3).Flag6; 4042 end Flag137; 4043 4044 function Flag138 (N : Node_Id) return Boolean is 4045 begin 4046 pragma Assert (Nkind (N) in N_Entity); 4047 return Nodes.Table (N + 3).Flag7; 4048 end Flag138; 4049 4050 function Flag139 (N : Node_Id) return Boolean is 4051 begin 4052 pragma Assert (Nkind (N) in N_Entity); 4053 return Nodes.Table (N + 3).Flag8; 4054 end Flag139; 4055 4056 function Flag140 (N : Node_Id) return Boolean is 4057 begin 4058 pragma Assert (Nkind (N) in N_Entity); 4059 return Nodes.Table (N + 3).Flag9; 4060 end Flag140; 4061 4062 function Flag141 (N : Node_Id) return Boolean is 4063 begin 4064 pragma Assert (Nkind (N) in N_Entity); 4065 return Nodes.Table (N + 3).Flag10; 4066 end Flag141; 4067 4068 function Flag142 (N : Node_Id) return Boolean is 4069 begin 4070 pragma Assert (Nkind (N) in N_Entity); 4071 return Nodes.Table (N + 3).Flag11; 4072 end Flag142; 4073 4074 function Flag143 (N : Node_Id) return Boolean is 4075 begin 4076 pragma Assert (Nkind (N) in N_Entity); 4077 return Nodes.Table (N + 3).Flag12; 4078 end Flag143; 4079 4080 function Flag144 (N : Node_Id) return Boolean is 4081 begin 4082 pragma Assert (Nkind (N) in N_Entity); 4083 return Nodes.Table (N + 3).Flag13; 4084 end Flag144; 4085 4086 function Flag145 (N : Node_Id) return Boolean is 4087 begin 4088 pragma Assert (Nkind (N) in N_Entity); 4089 return Nodes.Table (N + 3).Flag14; 4090 end Flag145; 4091 4092 function Flag146 (N : Node_Id) return Boolean is 4093 begin 4094 pragma Assert (Nkind (N) in N_Entity); 4095 return Nodes.Table (N + 3).Flag15; 4096 end Flag146; 4097 4098 function Flag147 (N : Node_Id) return Boolean is 4099 begin 4100 pragma Assert (Nkind (N) in N_Entity); 4101 return Nodes.Table (N + 3).Flag16; 4102 end Flag147; 4103 4104 function Flag148 (N : Node_Id) return Boolean is 4105 begin 4106 pragma Assert (Nkind (N) in N_Entity); 4107 return Nodes.Table (N + 3).Flag17; 4108 end Flag148; 4109 4110 function Flag149 (N : Node_Id) return Boolean is 4111 begin 4112 pragma Assert (Nkind (N) in N_Entity); 4113 return Nodes.Table (N + 3).Flag18; 4114 end Flag149; 4115 4116 function Flag150 (N : Node_Id) return Boolean is 4117 begin 4118 pragma Assert (Nkind (N) in N_Entity); 4119 return Nodes.Table (N + 3).Pflag1; 4120 end Flag150; 4121 4122 function Flag151 (N : Node_Id) return Boolean is 4123 begin 4124 pragma Assert (Nkind (N) in N_Entity); 4125 return Nodes.Table (N + 3).Pflag2; 4126 end Flag151; 4127 4128 function Flag152 (N : Node_Id) return Boolean is 4129 begin 4130 pragma Assert (Nkind (N) in N_Entity); 4131 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152; 4132 end Flag152; 4133 4134 function Flag153 (N : Node_Id) return Boolean is 4135 begin 4136 pragma Assert (Nkind (N) in N_Entity); 4137 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153; 4138 end Flag153; 4139 4140 function Flag154 (N : Node_Id) return Boolean is 4141 begin 4142 pragma Assert (Nkind (N) in N_Entity); 4143 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154; 4144 end Flag154; 4145 4146 function Flag155 (N : Node_Id) return Boolean is 4147 begin 4148 pragma Assert (Nkind (N) in N_Entity); 4149 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155; 4150 end Flag155; 4151 4152 function Flag156 (N : Node_Id) return Boolean is 4153 begin 4154 pragma Assert (Nkind (N) in N_Entity); 4155 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156; 4156 end Flag156; 4157 4158 function Flag157 (N : Node_Id) return Boolean is 4159 begin 4160 pragma Assert (Nkind (N) in N_Entity); 4161 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157; 4162 end Flag157; 4163 4164 function Flag158 (N : Node_Id) return Boolean is 4165 begin 4166 pragma Assert (Nkind (N) in N_Entity); 4167 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158; 4168 end Flag158; 4169 4170 function Flag159 (N : Node_Id) return Boolean is 4171 begin 4172 pragma Assert (Nkind (N) in N_Entity); 4173 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159; 4174 end Flag159; 4175 4176 function Flag160 (N : Node_Id) return Boolean is 4177 begin 4178 pragma Assert (Nkind (N) in N_Entity); 4179 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160; 4180 end Flag160; 4181 4182 function Flag161 (N : Node_Id) return Boolean is 4183 begin 4184 pragma Assert (Nkind (N) in N_Entity); 4185 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161; 4186 end Flag161; 4187 4188 function Flag162 (N : Node_Id) return Boolean is 4189 begin 4190 pragma Assert (Nkind (N) in N_Entity); 4191 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162; 4192 end Flag162; 4193 4194 function Flag163 (N : Node_Id) return Boolean is 4195 begin 4196 pragma Assert (Nkind (N) in N_Entity); 4197 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163; 4198 end Flag163; 4199 4200 function Flag164 (N : Node_Id) return Boolean is 4201 begin 4202 pragma Assert (Nkind (N) in N_Entity); 4203 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164; 4204 end Flag164; 4205 4206 function Flag165 (N : Node_Id) return Boolean is 4207 begin 4208 pragma Assert (Nkind (N) in N_Entity); 4209 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165; 4210 end Flag165; 4211 4212 function Flag166 (N : Node_Id) return Boolean is 4213 begin 4214 pragma Assert (Nkind (N) in N_Entity); 4215 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166; 4216 end Flag166; 4217 4218 function Flag167 (N : Node_Id) return Boolean is 4219 begin 4220 pragma Assert (Nkind (N) in N_Entity); 4221 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167; 4222 end Flag167; 4223 4224 function Flag168 (N : Node_Id) return Boolean is 4225 begin 4226 pragma Assert (Nkind (N) in N_Entity); 4227 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168; 4228 end Flag168; 4229 4230 function Flag169 (N : Node_Id) return Boolean is 4231 begin 4232 pragma Assert (Nkind (N) in N_Entity); 4233 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169; 4234 end Flag169; 4235 4236 function Flag170 (N : Node_Id) return Boolean is 4237 begin 4238 pragma Assert (Nkind (N) in N_Entity); 4239 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170; 4240 end Flag170; 4241 4242 function Flag171 (N : Node_Id) return Boolean is 4243 begin 4244 pragma Assert (Nkind (N) in N_Entity); 4245 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171; 4246 end Flag171; 4247 4248 function Flag172 (N : Node_Id) return Boolean is 4249 begin 4250 pragma Assert (Nkind (N) in N_Entity); 4251 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172; 4252 end Flag172; 4253 4254 function Flag173 (N : Node_Id) return Boolean is 4255 begin 4256 pragma Assert (Nkind (N) in N_Entity); 4257 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173; 4258 end Flag173; 4259 4260 function Flag174 (N : Node_Id) return Boolean is 4261 begin 4262 pragma Assert (Nkind (N) in N_Entity); 4263 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174; 4264 end Flag174; 4265 4266 function Flag175 (N : Node_Id) return Boolean is 4267 begin 4268 pragma Assert (Nkind (N) in N_Entity); 4269 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175; 4270 end Flag175; 4271 4272 function Flag176 (N : Node_Id) return Boolean is 4273 begin 4274 pragma Assert (Nkind (N) in N_Entity); 4275 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176; 4276 end Flag176; 4277 4278 function Flag177 (N : Node_Id) return Boolean is 4279 begin 4280 pragma Assert (Nkind (N) in N_Entity); 4281 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177; 4282 end Flag177; 4283 4284 function Flag178 (N : Node_Id) return Boolean is 4285 begin 4286 pragma Assert (Nkind (N) in N_Entity); 4287 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178; 4288 end Flag178; 4289 4290 function Flag179 (N : Node_Id) return Boolean is 4291 begin 4292 pragma Assert (Nkind (N) in N_Entity); 4293 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179; 4294 end Flag179; 4295 4296 function Flag180 (N : Node_Id) return Boolean is 4297 begin 4298 pragma Assert (Nkind (N) in N_Entity); 4299 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180; 4300 end Flag180; 4301 4302 function Flag181 (N : Node_Id) return Boolean is 4303 begin 4304 pragma Assert (Nkind (N) in N_Entity); 4305 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181; 4306 end Flag181; 4307 4308 function Flag182 (N : Node_Id) return Boolean is 4309 begin 4310 pragma Assert (Nkind (N) in N_Entity); 4311 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182; 4312 end Flag182; 4313 4314 function Flag183 (N : Node_Id) return Boolean is 4315 begin 4316 pragma Assert (Nkind (N) in N_Entity); 4317 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183; 4318 end Flag183; 4319 4320 function Flag184 (N : Node_Id) return Boolean is 4321 begin 4322 pragma Assert (Nkind (N) in N_Entity); 4323 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag184; 4324 end Flag184; 4325 4326 function Flag185 (N : Node_Id) return Boolean is 4327 begin 4328 pragma Assert (Nkind (N) in N_Entity); 4329 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag185; 4330 end Flag185; 4331 4332 function Flag186 (N : Node_Id) return Boolean is 4333 begin 4334 pragma Assert (Nkind (N) in N_Entity); 4335 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag186; 4336 end Flag186; 4337 4338 function Flag187 (N : Node_Id) return Boolean is 4339 begin 4340 pragma Assert (Nkind (N) in N_Entity); 4341 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag187; 4342 end Flag187; 4343 4344 function Flag188 (N : Node_Id) return Boolean is 4345 begin 4346 pragma Assert (Nkind (N) in N_Entity); 4347 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag188; 4348 end Flag188; 4349 4350 function Flag189 (N : Node_Id) return Boolean is 4351 begin 4352 pragma Assert (Nkind (N) in N_Entity); 4353 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag189; 4354 end Flag189; 4355 4356 function Flag190 (N : Node_Id) return Boolean is 4357 begin 4358 pragma Assert (Nkind (N) in N_Entity); 4359 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag190; 4360 end Flag190; 4361 4362 function Flag191 (N : Node_Id) return Boolean is 4363 begin 4364 pragma Assert (Nkind (N) in N_Entity); 4365 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag191; 4366 end Flag191; 4367 4368 function Flag192 (N : Node_Id) return Boolean is 4369 begin 4370 pragma Assert (Nkind (N) in N_Entity); 4371 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag192; 4372 end Flag192; 4373 4374 function Flag193 (N : Node_Id) return Boolean is 4375 begin 4376 pragma Assert (Nkind (N) in N_Entity); 4377 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag193; 4378 end Flag193; 4379 4380 function Flag194 (N : Node_Id) return Boolean is 4381 begin 4382 pragma Assert (Nkind (N) in N_Entity); 4383 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag194; 4384 end Flag194; 4385 4386 function Flag195 (N : Node_Id) return Boolean is 4387 begin 4388 pragma Assert (Nkind (N) in N_Entity); 4389 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag195; 4390 end Flag195; 4391 4392 function Flag196 (N : Node_Id) return Boolean is 4393 begin 4394 pragma Assert (Nkind (N) in N_Entity); 4395 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag196; 4396 end Flag196; 4397 4398 function Flag197 (N : Node_Id) return Boolean is 4399 begin 4400 pragma Assert (Nkind (N) in N_Entity); 4401 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag197; 4402 end Flag197; 4403 4404 function Flag198 (N : Node_Id) return Boolean is 4405 begin 4406 pragma Assert (Nkind (N) in N_Entity); 4407 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag198; 4408 end Flag198; 4409 4410 function Flag199 (N : Node_Id) return Boolean is 4411 begin 4412 pragma Assert (Nkind (N) in N_Entity); 4413 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag199; 4414 end Flag199; 4415 4416 function Flag200 (N : Node_Id) return Boolean is 4417 begin 4418 pragma Assert (Nkind (N) in N_Entity); 4419 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag200; 4420 end Flag200; 4421 4422 function Flag201 (N : Node_Id) return Boolean is 4423 begin 4424 pragma Assert (Nkind (N) in N_Entity); 4425 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag201; 4426 end Flag201; 4427 4428 function Flag202 (N : Node_Id) return Boolean is 4429 begin 4430 pragma Assert (Nkind (N) in N_Entity); 4431 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag202; 4432 end Flag202; 4433 4434 function Flag203 (N : Node_Id) return Boolean is 4435 begin 4436 pragma Assert (Nkind (N) in N_Entity); 4437 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag203; 4438 end Flag203; 4439 4440 function Flag204 (N : Node_Id) return Boolean is 4441 begin 4442 pragma Assert (Nkind (N) in N_Entity); 4443 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag204; 4444 end Flag204; 4445 4446 function Flag205 (N : Node_Id) return Boolean is 4447 begin 4448 pragma Assert (Nkind (N) in N_Entity); 4449 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag205; 4450 end Flag205; 4451 4452 function Flag206 (N : Node_Id) return Boolean is 4453 begin 4454 pragma Assert (Nkind (N) in N_Entity); 4455 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag206; 4456 end Flag206; 4457 4458 function Flag207 (N : Node_Id) return Boolean is 4459 begin 4460 pragma Assert (Nkind (N) in N_Entity); 4461 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag207; 4462 end Flag207; 4463 4464 function Flag208 (N : Node_Id) return Boolean is 4465 begin 4466 pragma Assert (Nkind (N) in N_Entity); 4467 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag208; 4468 end Flag208; 4469 4470 function Flag209 (N : Node_Id) return Boolean is 4471 begin 4472 pragma Assert (Nkind (N) in N_Entity); 4473 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag209; 4474 end Flag209; 4475 4476 function Flag210 (N : Node_Id) return Boolean is 4477 begin 4478 pragma Assert (Nkind (N) in N_Entity); 4479 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag210; 4480 end Flag210; 4481 4482 function Flag211 (N : Node_Id) return Boolean is 4483 begin 4484 pragma Assert (Nkind (N) in N_Entity); 4485 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag211; 4486 end Flag211; 4487 4488 function Flag212 (N : Node_Id) return Boolean is 4489 begin 4490 pragma Assert (Nkind (N) in N_Entity); 4491 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag212; 4492 end Flag212; 4493 4494 function Flag213 (N : Node_Id) return Boolean is 4495 begin 4496 pragma Assert (Nkind (N) in N_Entity); 4497 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag213; 4498 end Flag213; 4499 4500 function Flag214 (N : Node_Id) return Boolean is 4501 begin 4502 pragma Assert (Nkind (N) in N_Entity); 4503 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag214; 4504 end Flag214; 4505 4506 function Flag215 (N : Node_Id) return Boolean is 4507 begin 4508 pragma Assert (Nkind (N) in N_Entity); 4509 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag215; 4510 end Flag215; 4511 4512 function Flag216 (N : Node_Id) return Boolean is 4513 begin 4514 pragma Assert (Nkind (N) in N_Entity); 4515 return Nodes.Table (N + 4).In_List; 4516 end Flag216; 4517 4518 function Flag217 (N : Node_Id) return Boolean is 4519 begin 4520 pragma Assert (Nkind (N) in N_Entity); 4521 return Nodes.Table (N + 4).Has_Aspects; 4522 end Flag217; 4523 4524 function Flag218 (N : Node_Id) return Boolean is 4525 begin 4526 pragma Assert (Nkind (N) in N_Entity); 4527 return Nodes.Table (N + 4).Rewrite_Ins; 4528 end Flag218; 4529 4530 function Flag219 (N : Node_Id) return Boolean is 4531 begin 4532 pragma Assert (Nkind (N) in N_Entity); 4533 return Nodes.Table (N + 4).Analyzed; 4534 end Flag219; 4535 4536 function Flag220 (N : Node_Id) return Boolean is 4537 begin 4538 pragma Assert (Nkind (N) in N_Entity); 4539 return Nodes.Table (N + 4).Comes_From_Source; 4540 end Flag220; 4541 4542 function Flag221 (N : Node_Id) return Boolean is 4543 begin 4544 pragma Assert (Nkind (N) in N_Entity); 4545 return Nodes.Table (N + 4).Error_Posted; 4546 end Flag221; 4547 4548 function Flag222 (N : Node_Id) return Boolean is 4549 begin 4550 pragma Assert (Nkind (N) in N_Entity); 4551 return Nodes.Table (N + 4).Flag4; 4552 end Flag222; 4553 4554 function Flag223 (N : Node_Id) return Boolean is 4555 begin 4556 pragma Assert (Nkind (N) in N_Entity); 4557 return Nodes.Table (N + 4).Flag5; 4558 end Flag223; 4559 4560 function Flag224 (N : Node_Id) return Boolean is 4561 begin 4562 pragma Assert (Nkind (N) in N_Entity); 4563 return Nodes.Table (N + 4).Flag6; 4564 end Flag224; 4565 4566 function Flag225 (N : Node_Id) return Boolean is 4567 begin 4568 pragma Assert (Nkind (N) in N_Entity); 4569 return Nodes.Table (N + 4).Flag7; 4570 end Flag225; 4571 4572 function Flag226 (N : Node_Id) return Boolean is 4573 begin 4574 pragma Assert (Nkind (N) in N_Entity); 4575 return Nodes.Table (N + 4).Flag8; 4576 end Flag226; 4577 4578 function Flag227 (N : Node_Id) return Boolean is 4579 begin 4580 pragma Assert (Nkind (N) in N_Entity); 4581 return Nodes.Table (N + 4).Flag9; 4582 end Flag227; 4583 4584 function Flag228 (N : Node_Id) return Boolean is 4585 begin 4586 pragma Assert (Nkind (N) in N_Entity); 4587 return Nodes.Table (N + 4).Flag10; 4588 end Flag228; 4589 4590 function Flag229 (N : Node_Id) return Boolean is 4591 begin 4592 pragma Assert (Nkind (N) in N_Entity); 4593 return Nodes.Table (N + 4).Flag11; 4594 end Flag229; 4595 4596 function Flag230 (N : Node_Id) return Boolean is 4597 begin 4598 pragma Assert (Nkind (N) in N_Entity); 4599 return Nodes.Table (N + 4).Flag12; 4600 end Flag230; 4601 4602 function Flag231 (N : Node_Id) return Boolean is 4603 begin 4604 pragma Assert (Nkind (N) in N_Entity); 4605 return Nodes.Table (N + 4).Flag13; 4606 end Flag231; 4607 4608 function Flag232 (N : Node_Id) return Boolean is 4609 begin 4610 pragma Assert (Nkind (N) in N_Entity); 4611 return Nodes.Table (N + 4).Flag14; 4612 end Flag232; 4613 4614 function Flag233 (N : Node_Id) return Boolean is 4615 begin 4616 pragma Assert (Nkind (N) in N_Entity); 4617 return Nodes.Table (N + 4).Flag15; 4618 end Flag233; 4619 4620 function Flag234 (N : Node_Id) return Boolean is 4621 begin 4622 pragma Assert (Nkind (N) in N_Entity); 4623 return Nodes.Table (N + 4).Flag16; 4624 end Flag234; 4625 4626 function Flag235 (N : Node_Id) return Boolean is 4627 begin 4628 pragma Assert (Nkind (N) in N_Entity); 4629 return Nodes.Table (N + 4).Flag17; 4630 end Flag235; 4631 4632 function Flag236 (N : Node_Id) return Boolean is 4633 begin 4634 pragma Assert (Nkind (N) in N_Entity); 4635 return Nodes.Table (N + 4).Flag18; 4636 end Flag236; 4637 4638 function Flag237 (N : Node_Id) return Boolean is 4639 begin 4640 pragma Assert (Nkind (N) in N_Entity); 4641 return Nodes.Table (N + 4).Pflag1; 4642 end Flag237; 4643 4644 function Flag238 (N : Node_Id) return Boolean is 4645 begin 4646 pragma Assert (Nkind (N) in N_Entity); 4647 return Nodes.Table (N + 4).Pflag2; 4648 end Flag238; 4649 4650 function Flag239 (N : Node_Id) return Boolean is 4651 begin 4652 pragma Assert (Nkind (N) in N_Entity); 4653 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag239; 4654 end Flag239; 4655 4656 function Flag240 (N : Node_Id) return Boolean is 4657 begin 4658 pragma Assert (Nkind (N) in N_Entity); 4659 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag240; 4660 end Flag240; 4661 4662 function Flag241 (N : Node_Id) return Boolean is 4663 begin 4664 pragma Assert (Nkind (N) in N_Entity); 4665 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag241; 4666 end Flag241; 4667 4668 function Flag242 (N : Node_Id) return Boolean is 4669 begin 4670 pragma Assert (Nkind (N) in N_Entity); 4671 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag242; 4672 end Flag242; 4673 4674 function Flag243 (N : Node_Id) return Boolean is 4675 begin 4676 pragma Assert (Nkind (N) in N_Entity); 4677 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag243; 4678 end Flag243; 4679 4680 function Flag244 (N : Node_Id) return Boolean is 4681 begin 4682 pragma Assert (Nkind (N) in N_Entity); 4683 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag244; 4684 end Flag244; 4685 4686 function Flag245 (N : Node_Id) return Boolean is 4687 begin 4688 pragma Assert (Nkind (N) in N_Entity); 4689 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag245; 4690 end Flag245; 4691 4692 function Flag246 (N : Node_Id) return Boolean is 4693 begin 4694 pragma Assert (Nkind (N) in N_Entity); 4695 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag246; 4696 end Flag246; 4697 4698 function Flag247 (N : Node_Id) return Boolean is 4699 begin 4700 pragma Assert (Nkind (N) in N_Entity); 4701 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag247; 4702 end Flag247; 4703 4704 function Flag248 (N : Node_Id) return Boolean is 4705 begin 4706 pragma Assert (Nkind (N) in N_Entity); 4707 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag248; 4708 end Flag248; 4709 4710 function Flag249 (N : Node_Id) return Boolean is 4711 begin 4712 pragma Assert (Nkind (N) in N_Entity); 4713 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag249; 4714 end Flag249; 4715 4716 function Flag250 (N : Node_Id) return Boolean is 4717 begin 4718 pragma Assert (Nkind (N) in N_Entity); 4719 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag250; 4720 end Flag250; 4721 4722 function Flag251 (N : Node_Id) return Boolean is 4723 begin 4724 pragma Assert (Nkind (N) in N_Entity); 4725 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag251; 4726 end Flag251; 4727 4728 function Flag252 (N : Node_Id) return Boolean is 4729 begin 4730 pragma Assert (Nkind (N) in N_Entity); 4731 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag252; 4732 end Flag252; 4733 4734 function Flag253 (N : Node_Id) return Boolean is 4735 begin 4736 pragma Assert (Nkind (N) in N_Entity); 4737 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag253; 4738 end Flag253; 4739 4740 function Flag254 (N : Node_Id) return Boolean is 4741 begin 4742 pragma Assert (Nkind (N) in N_Entity); 4743 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag254; 4744 end Flag254; 4745 4746 function Flag255 (N : Node_Id) return Boolean is 4747 begin 4748 pragma Assert (Nkind (N) in N_Entity); 4749 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag255; 4750 end Flag255; 4751 4752 function Flag256 (N : Node_Id) return Boolean is 4753 begin 4754 pragma Assert (Nkind (N) in N_Entity); 4755 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag256; 4756 end Flag256; 4757 4758 function Flag257 (N : Node_Id) return Boolean is 4759 begin 4760 pragma Assert (Nkind (N) in N_Entity); 4761 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag257; 4762 end Flag257; 4763 4764 function Flag258 (N : Node_Id) return Boolean is 4765 begin 4766 pragma Assert (Nkind (N) in N_Entity); 4767 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag258; 4768 end Flag258; 4769 4770 function Flag259 (N : Node_Id) return Boolean is 4771 begin 4772 pragma Assert (Nkind (N) in N_Entity); 4773 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag259; 4774 end Flag259; 4775 4776 function Flag260 (N : Node_Id) return Boolean is 4777 begin 4778 pragma Assert (Nkind (N) in N_Entity); 4779 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag260; 4780 end Flag260; 4781 4782 function Flag261 (N : Node_Id) return Boolean is 4783 begin 4784 pragma Assert (Nkind (N) in N_Entity); 4785 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag261; 4786 end Flag261; 4787 4788 function Flag262 (N : Node_Id) return Boolean is 4789 begin 4790 pragma Assert (Nkind (N) in N_Entity); 4791 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag262; 4792 end Flag262; 4793 4794 function Flag263 (N : Node_Id) return Boolean is 4795 begin 4796 pragma Assert (Nkind (N) in N_Entity); 4797 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag263; 4798 end Flag263; 4799 4800 function Flag264 (N : Node_Id) return Boolean is 4801 begin 4802 pragma Assert (Nkind (N) in N_Entity); 4803 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag264; 4804 end Flag264; 4805 4806 function Flag265 (N : Node_Id) return Boolean is 4807 begin 4808 pragma Assert (Nkind (N) in N_Entity); 4809 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag265; 4810 end Flag265; 4811 4812 function Flag266 (N : Node_Id) return Boolean is 4813 begin 4814 pragma Assert (Nkind (N) in N_Entity); 4815 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag266; 4816 end Flag266; 4817 4818 function Flag267 (N : Node_Id) return Boolean is 4819 begin 4820 pragma Assert (Nkind (N) in N_Entity); 4821 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag267; 4822 end Flag267; 4823 4824 function Flag268 (N : Node_Id) return Boolean is 4825 begin 4826 pragma Assert (Nkind (N) in N_Entity); 4827 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag268; 4828 end Flag268; 4829 4830 function Flag269 (N : Node_Id) return Boolean is 4831 begin 4832 pragma Assert (Nkind (N) in N_Entity); 4833 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag269; 4834 end Flag269; 4835 4836 function Flag270 (N : Node_Id) return Boolean is 4837 begin 4838 pragma Assert (Nkind (N) in N_Entity); 4839 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag270; 4840 end Flag270; 4841 4842 function Flag271 (N : Node_Id) return Boolean is 4843 begin 4844 pragma Assert (Nkind (N) in N_Entity); 4845 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag271; 4846 end Flag271; 4847 4848 function Flag272 (N : Node_Id) return Boolean is 4849 begin 4850 pragma Assert (Nkind (N) in N_Entity); 4851 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag272; 4852 end Flag272; 4853 4854 function Flag273 (N : Node_Id) return Boolean is 4855 begin 4856 pragma Assert (Nkind (N) in N_Entity); 4857 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag273; 4858 end Flag273; 4859 4860 function Flag274 (N : Node_Id) return Boolean is 4861 begin 4862 pragma Assert (Nkind (N) in N_Entity); 4863 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag274; 4864 end Flag274; 4865 4866 function Flag275 (N : Node_Id) return Boolean is 4867 begin 4868 pragma Assert (Nkind (N) in N_Entity); 4869 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag275; 4870 end Flag275; 4871 4872 function Flag276 (N : Node_Id) return Boolean is 4873 begin 4874 pragma Assert (Nkind (N) in N_Entity); 4875 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag276; 4876 end Flag276; 4877 4878 function Flag277 (N : Node_Id) return Boolean is 4879 begin 4880 pragma Assert (Nkind (N) in N_Entity); 4881 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag277; 4882 end Flag277; 4883 4884 function Flag278 (N : Node_Id) return Boolean is 4885 begin 4886 pragma Assert (Nkind (N) in N_Entity); 4887 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag278; 4888 end Flag278; 4889 4890 function Flag279 (N : Node_Id) return Boolean is 4891 begin 4892 pragma Assert (Nkind (N) in N_Entity); 4893 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag279; 4894 end Flag279; 4895 4896 function Flag280 (N : Node_Id) return Boolean is 4897 begin 4898 pragma Assert (Nkind (N) in N_Entity); 4899 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag280; 4900 end Flag280; 4901 4902 function Flag281 (N : Node_Id) return Boolean is 4903 begin 4904 pragma Assert (Nkind (N) in N_Entity); 4905 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag281; 4906 end Flag281; 4907 4908 function Flag282 (N : Node_Id) return Boolean is 4909 begin 4910 pragma Assert (Nkind (N) in N_Entity); 4911 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag282; 4912 end Flag282; 4913 4914 function Flag283 (N : Node_Id) return Boolean is 4915 begin 4916 pragma Assert (Nkind (N) in N_Entity); 4917 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag283; 4918 end Flag283; 4919 4920 function Flag284 (N : Node_Id) return Boolean is 4921 begin 4922 pragma Assert (Nkind (N) in N_Entity); 4923 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag284; 4924 end Flag284; 4925 4926 function Flag285 (N : Node_Id) return Boolean is 4927 begin 4928 pragma Assert (Nkind (N) in N_Entity); 4929 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag285; 4930 end Flag285; 4931 4932 function Flag286 (N : Node_Id) return Boolean is 4933 begin 4934 pragma Assert (Nkind (N) in N_Entity); 4935 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag286; 4936 end Flag286; 4937 4938 function Flag287 (N : Node_Id) return Boolean is 4939 begin 4940 pragma Assert (Nkind (N) in N_Entity); 4941 return Nodes.Table (N + 5).In_List; 4942 end Flag287; 4943 4944 function Flag288 (N : Node_Id) return Boolean is 4945 begin 4946 pragma Assert (Nkind (N) in N_Entity); 4947 return Nodes.Table (N + 5).Has_Aspects; 4948 end Flag288; 4949 4950 function Flag289 (N : Node_Id) return Boolean is 4951 begin 4952 pragma Assert (Nkind (N) in N_Entity); 4953 return Nodes.Table (N + 5).Rewrite_Ins; 4954 end Flag289; 4955 4956 function Flag290 (N : Node_Id) return Boolean is 4957 begin 4958 pragma Assert (Nkind (N) in N_Entity); 4959 return Nodes.Table (N + 5).Analyzed; 4960 end Flag290; 4961 4962 function Flag291 (N : Node_Id) return Boolean is 4963 begin 4964 pragma Assert (Nkind (N) in N_Entity); 4965 return Nodes.Table (N + 5).Comes_From_Source; 4966 end Flag291; 4967 4968 function Flag292 (N : Node_Id) return Boolean is 4969 begin 4970 pragma Assert (Nkind (N) in N_Entity); 4971 return Nodes.Table (N + 5).Error_Posted; 4972 end Flag292; 4973 4974 function Flag293 (N : Node_Id) return Boolean is 4975 begin 4976 pragma Assert (Nkind (N) in N_Entity); 4977 return Nodes.Table (N + 5).Flag4; 4978 end Flag293; 4979 4980 function Flag294 (N : Node_Id) return Boolean is 4981 begin 4982 pragma Assert (Nkind (N) in N_Entity); 4983 return Nodes.Table (N + 5).Flag5; 4984 end Flag294; 4985 4986 function Flag295 (N : Node_Id) return Boolean is 4987 begin 4988 pragma Assert (Nkind (N) in N_Entity); 4989 return Nodes.Table (N + 5).Flag6; 4990 end Flag295; 4991 4992 function Flag296 (N : Node_Id) return Boolean is 4993 begin 4994 pragma Assert (Nkind (N) in N_Entity); 4995 return Nodes.Table (N + 5).Flag7; 4996 end Flag296; 4997 4998 function Flag297 (N : Node_Id) return Boolean is 4999 begin 5000 pragma Assert (Nkind (N) in N_Entity); 5001 return Nodes.Table (N + 5).Flag8; 5002 end Flag297; 5003 5004 function Flag298 (N : Node_Id) return Boolean is 5005 begin 5006 pragma Assert (Nkind (N) in N_Entity); 5007 return Nodes.Table (N + 5).Flag9; 5008 end Flag298; 5009 5010 function Flag299 (N : Node_Id) return Boolean is 5011 begin 5012 pragma Assert (Nkind (N) in N_Entity); 5013 return Nodes.Table (N + 5).Flag10; 5014 end Flag299; 5015 5016 function Flag300 (N : Node_Id) return Boolean is 5017 begin 5018 pragma Assert (Nkind (N) in N_Entity); 5019 return Nodes.Table (N + 5).Flag11; 5020 end Flag300; 5021 5022 function Flag301 (N : Node_Id) return Boolean is 5023 begin 5024 pragma Assert (Nkind (N) in N_Entity); 5025 return Nodes.Table (N + 5).Flag12; 5026 end Flag301; 5027 5028 function Flag302 (N : Node_Id) return Boolean is 5029 begin 5030 pragma Assert (Nkind (N) in N_Entity); 5031 return Nodes.Table (N + 5).Flag13; 5032 end Flag302; 5033 5034 function Flag303 (N : Node_Id) return Boolean is 5035 begin 5036 pragma Assert (Nkind (N) in N_Entity); 5037 return Nodes.Table (N + 5).Flag14; 5038 end Flag303; 5039 5040 function Flag304 (N : Node_Id) return Boolean is 5041 begin 5042 pragma Assert (Nkind (N) in N_Entity); 5043 return Nodes.Table (N + 5).Flag15; 5044 end Flag304; 5045 5046 function Flag305 (N : Node_Id) return Boolean is 5047 begin 5048 pragma Assert (Nkind (N) in N_Entity); 5049 return Nodes.Table (N + 5).Flag16; 5050 end Flag305; 5051 5052 function Flag306 (N : Node_Id) return Boolean is 5053 begin 5054 pragma Assert (Nkind (N) in N_Entity); 5055 return Nodes.Table (N + 5).Flag17; 5056 end Flag306; 5057 5058 function Flag307 (N : Node_Id) return Boolean is 5059 begin 5060 pragma Assert (Nkind (N) in N_Entity); 5061 return Nodes.Table (N + 5).Flag18; 5062 end Flag307; 5063 5064 function Flag308 (N : Node_Id) return Boolean is 5065 begin 5066 pragma Assert (Nkind (N) in N_Entity); 5067 return Nodes.Table (N + 5).Pflag1; 5068 end Flag308; 5069 5070 function Flag309 (N : Node_Id) return Boolean is 5071 begin 5072 pragma Assert (Nkind (N) in N_Entity); 5073 return Nodes.Table (N + 5).Pflag2; 5074 end Flag309; 5075 5076 function Flag310 (N : Node_Id) return Boolean is 5077 begin 5078 pragma Assert (Nkind (N) in N_Entity); 5079 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag310; 5080 end Flag310; 5081 5082 function Flag311 (N : Node_Id) return Boolean is 5083 begin 5084 pragma Assert (Nkind (N) in N_Entity); 5085 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag311; 5086 end Flag311; 5087 5088 function Flag312 (N : Node_Id) return Boolean is 5089 begin 5090 pragma Assert (Nkind (N) in N_Entity); 5091 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag312; 5092 end Flag312; 5093 5094 function Flag313 (N : Node_Id) return Boolean is 5095 begin 5096 pragma Assert (Nkind (N) in N_Entity); 5097 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag313; 5098 end Flag313; 5099 5100 function Flag314 (N : Node_Id) return Boolean is 5101 begin 5102 pragma Assert (Nkind (N) in N_Entity); 5103 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag314; 5104 end Flag314; 5105 5106 function Flag315 (N : Node_Id) return Boolean is 5107 begin 5108 pragma Assert (Nkind (N) in N_Entity); 5109 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag315; 5110 end Flag315; 5111 5112 function Flag316 (N : Node_Id) return Boolean is 5113 begin 5114 pragma Assert (Nkind (N) in N_Entity); 5115 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag316; 5116 end Flag316; 5117 5118 function Flag317 (N : Node_Id) return Boolean is 5119 begin 5120 pragma Assert (Nkind (N) in N_Entity); 5121 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag317; 5122 end Flag317; 5123 5124 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is 5125 begin 5126 pragma Assert (not Locked); 5127 pragma Assert (N <= Nodes.Last); 5128 Nodes.Table (N).Nkind := Val; 5129 end Set_Nkind; 5130 5131 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is 5132 begin 5133 pragma Assert (not Locked); 5134 pragma Assert (N <= Nodes.Last); 5135 Nodes.Table (N).Field1 := Val; 5136 end Set_Field1; 5137 5138 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is 5139 begin 5140 pragma Assert (not Locked); 5141 pragma Assert (N <= Nodes.Last); 5142 Nodes.Table (N).Field2 := Val; 5143 end Set_Field2; 5144 5145 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is 5146 begin 5147 pragma Assert (not Locked); 5148 pragma Assert (N <= Nodes.Last); 5149 Nodes.Table (N).Field3 := Val; 5150 end Set_Field3; 5151 5152 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is 5153 begin 5154 pragma Assert (not Locked); 5155 pragma Assert (N <= Nodes.Last); 5156 Nodes.Table (N).Field4 := Val; 5157 end Set_Field4; 5158 5159 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is 5160 begin 5161 pragma Assert (not Locked); 5162 pragma Assert (N <= Nodes.Last); 5163 Nodes.Table (N).Field5 := Val; 5164 end Set_Field5; 5165 5166 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is 5167 begin 5168 pragma Assert (not Locked); 5169 pragma Assert (Nkind (N) in N_Entity); 5170 Nodes.Table (N + 1).Field6 := Val; 5171 end Set_Field6; 5172 5173 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is 5174 begin 5175 pragma Assert (not Locked); 5176 pragma Assert (Nkind (N) in N_Entity); 5177 Nodes.Table (N + 1).Field7 := Val; 5178 end Set_Field7; 5179 5180 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is 5181 begin 5182 pragma Assert (not Locked); 5183 pragma Assert (Nkind (N) in N_Entity); 5184 Nodes.Table (N + 1).Field8 := Val; 5185 end Set_Field8; 5186 5187 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is 5188 begin 5189 pragma Assert (not Locked); 5190 pragma Assert (Nkind (N) in N_Entity); 5191 Nodes.Table (N + 1).Field9 := Val; 5192 end Set_Field9; 5193 5194 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is 5195 begin 5196 pragma Assert (not Locked); 5197 pragma Assert (Nkind (N) in N_Entity); 5198 Nodes.Table (N + 1).Field10 := Val; 5199 end Set_Field10; 5200 5201 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is 5202 begin 5203 pragma Assert (not Locked); 5204 pragma Assert (Nkind (N) in N_Entity); 5205 Nodes.Table (N + 1).Field11 := Val; 5206 end Set_Field11; 5207 5208 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is 5209 begin 5210 pragma Assert (not Locked); 5211 pragma Assert (Nkind (N) in N_Entity); 5212 Nodes.Table (N + 1).Field12 := Val; 5213 end Set_Field12; 5214 5215 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is 5216 begin 5217 pragma Assert (not Locked); 5218 pragma Assert (Nkind (N) in N_Entity); 5219 Nodes.Table (N + 2).Field6 := Val; 5220 end Set_Field13; 5221 5222 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is 5223 begin 5224 pragma Assert (not Locked); 5225 pragma Assert (Nkind (N) in N_Entity); 5226 Nodes.Table (N + 2).Field7 := Val; 5227 end Set_Field14; 5228 5229 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is 5230 begin 5231 pragma Assert (not Locked); 5232 pragma Assert (Nkind (N) in N_Entity); 5233 Nodes.Table (N + 2).Field8 := Val; 5234 end Set_Field15; 5235 5236 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is 5237 begin 5238 pragma Assert (not Locked); 5239 pragma Assert (Nkind (N) in N_Entity); 5240 Nodes.Table (N + 2).Field9 := Val; 5241 end Set_Field16; 5242 5243 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is 5244 begin 5245 pragma Assert (not Locked); 5246 pragma Assert (Nkind (N) in N_Entity); 5247 Nodes.Table (N + 2).Field10 := Val; 5248 end Set_Field17; 5249 5250 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is 5251 begin 5252 pragma Assert (not Locked); 5253 pragma Assert (Nkind (N) in N_Entity); 5254 Nodes.Table (N + 2).Field11 := Val; 5255 end Set_Field18; 5256 5257 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is 5258 begin 5259 pragma Assert (not Locked); 5260 pragma Assert (Nkind (N) in N_Entity); 5261 Nodes.Table (N + 3).Field6 := Val; 5262 end Set_Field19; 5263 5264 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is 5265 begin 5266 pragma Assert (not Locked); 5267 pragma Assert (Nkind (N) in N_Entity); 5268 Nodes.Table (N + 3).Field7 := Val; 5269 end Set_Field20; 5270 5271 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is 5272 begin 5273 pragma Assert (not Locked); 5274 pragma Assert (Nkind (N) in N_Entity); 5275 Nodes.Table (N + 3).Field8 := Val; 5276 end Set_Field21; 5277 5278 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is 5279 begin 5280 pragma Assert (not Locked); 5281 pragma Assert (Nkind (N) in N_Entity); 5282 Nodes.Table (N + 3).Field9 := Val; 5283 end Set_Field22; 5284 5285 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is 5286 begin 5287 pragma Assert (not Locked); 5288 pragma Assert (Nkind (N) in N_Entity); 5289 Nodes.Table (N + 3).Field10 := Val; 5290 end Set_Field23; 5291 5292 procedure Set_Field24 (N : Node_Id; Val : Union_Id) is 5293 begin 5294 pragma Assert (not Locked); 5295 pragma Assert (Nkind (N) in N_Entity); 5296 Nodes.Table (N + 4).Field6 := Val; 5297 end Set_Field24; 5298 5299 procedure Set_Field25 (N : Node_Id; Val : Union_Id) is 5300 begin 5301 pragma Assert (not Locked); 5302 pragma Assert (Nkind (N) in N_Entity); 5303 Nodes.Table (N + 4).Field7 := Val; 5304 end Set_Field25; 5305 5306 procedure Set_Field26 (N : Node_Id; Val : Union_Id) is 5307 begin 5308 pragma Assert (not Locked); 5309 pragma Assert (Nkind (N) in N_Entity); 5310 Nodes.Table (N + 4).Field8 := Val; 5311 end Set_Field26; 5312 5313 procedure Set_Field27 (N : Node_Id; Val : Union_Id) is 5314 begin 5315 pragma Assert (not Locked); 5316 pragma Assert (Nkind (N) in N_Entity); 5317 Nodes.Table (N + 4).Field9 := Val; 5318 end Set_Field27; 5319 5320 procedure Set_Field28 (N : Node_Id; Val : Union_Id) is 5321 begin 5322 pragma Assert (not Locked); 5323 pragma Assert (Nkind (N) in N_Entity); 5324 Nodes.Table (N + 4).Field10 := Val; 5325 end Set_Field28; 5326 5327 procedure Set_Field29 (N : Node_Id; Val : Union_Id) is 5328 begin 5329 pragma Assert (not Locked); 5330 pragma Assert (Nkind (N) in N_Entity); 5331 Nodes.Table (N + 4).Field11 := Val; 5332 end Set_Field29; 5333 5334 procedure Set_Field30 (N : Node_Id; Val : Union_Id) is 5335 begin 5336 pragma Assert (not Locked); 5337 pragma Assert (Nkind (N) in N_Entity); 5338 Nodes.Table (N + 5).Field6 := Val; 5339 end Set_Field30; 5340 5341 procedure Set_Field31 (N : Node_Id; Val : Union_Id) is 5342 begin 5343 pragma Assert (not Locked); 5344 pragma Assert (Nkind (N) in N_Entity); 5345 Nodes.Table (N + 5).Field7 := Val; 5346 end Set_Field31; 5347 5348 procedure Set_Field32 (N : Node_Id; Val : Union_Id) is 5349 begin 5350 pragma Assert (not Locked); 5351 pragma Assert (Nkind (N) in N_Entity); 5352 Nodes.Table (N + 5).Field8 := Val; 5353 end Set_Field32; 5354 5355 procedure Set_Field33 (N : Node_Id; Val : Union_Id) is 5356 begin 5357 pragma Assert (not Locked); 5358 pragma Assert (Nkind (N) in N_Entity); 5359 Nodes.Table (N + 5).Field9 := Val; 5360 end Set_Field33; 5361 5362 procedure Set_Field34 (N : Node_Id; Val : Union_Id) is 5363 begin 5364 pragma Assert (not Locked); 5365 pragma Assert (Nkind (N) in N_Entity); 5366 Nodes.Table (N + 5).Field10 := Val; 5367 end Set_Field34; 5368 5369 procedure Set_Field35 (N : Node_Id; Val : Union_Id) is 5370 begin 5371 pragma Assert (not Locked); 5372 pragma Assert (Nkind (N) in N_Entity); 5373 Nodes.Table (N + 5).Field11 := Val; 5374 end Set_Field35; 5375 5376 procedure Set_Field36 (N : Node_Id; Val : Union_Id) is 5377 begin 5378 pragma Assert (not Locked); 5379 pragma Assert (Nkind (N) in N_Entity); 5380 Nodes.Table (N + 6).Field6 := Val; 5381 end Set_Field36; 5382 5383 procedure Set_Field37 (N : Node_Id; Val : Union_Id) is 5384 begin 5385 pragma Assert (not Locked); 5386 pragma Assert (Nkind (N) in N_Entity); 5387 Nodes.Table (N + 6).Field7 := Val; 5388 end Set_Field37; 5389 5390 procedure Set_Field38 (N : Node_Id; Val : Union_Id) is 5391 begin 5392 pragma Assert (not Locked); 5393 pragma Assert (Nkind (N) in N_Entity); 5394 Nodes.Table (N + 6).Field8 := Val; 5395 end Set_Field38; 5396 5397 procedure Set_Field39 (N : Node_Id; Val : Union_Id) is 5398 begin 5399 pragma Assert (not Locked); 5400 pragma Assert (Nkind (N) in N_Entity); 5401 Nodes.Table (N + 6).Field9 := Val; 5402 end Set_Field39; 5403 5404 procedure Set_Field40 (N : Node_Id; Val : Union_Id) is 5405 begin 5406 pragma Assert (not Locked); 5407 pragma Assert (Nkind (N) in N_Entity); 5408 Nodes.Table (N + 6).Field10 := Val; 5409 end Set_Field40; 5410 5411 procedure Set_Field41 (N : Node_Id; Val : Union_Id) is 5412 begin 5413 pragma Assert (not Locked); 5414 pragma Assert (Nkind (N) in N_Entity); 5415 Nodes.Table (N + 6).Field11 := Val; 5416 end Set_Field41; 5417 5418 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is 5419 begin 5420 pragma Assert (not Locked); 5421 pragma Assert (N <= Nodes.Last); 5422 Nodes.Table (N).Field1 := Union_Id (Val); 5423 end Set_Node1; 5424 5425 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is 5426 begin 5427 pragma Assert (not Locked); 5428 pragma Assert (N <= Nodes.Last); 5429 Nodes.Table (N).Field2 := Union_Id (Val); 5430 end Set_Node2; 5431 5432 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is 5433 begin 5434 pragma Assert (not Locked); 5435 pragma Assert (N <= Nodes.Last); 5436 Nodes.Table (N).Field3 := Union_Id (Val); 5437 end Set_Node3; 5438 5439 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is 5440 begin 5441 pragma Assert (not Locked); 5442 pragma Assert (N <= Nodes.Last); 5443 Nodes.Table (N).Field4 := Union_Id (Val); 5444 end Set_Node4; 5445 5446 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is 5447 begin 5448 pragma Assert (not Locked); 5449 pragma Assert (N <= Nodes.Last); 5450 Nodes.Table (N).Field5 := Union_Id (Val); 5451 end Set_Node5; 5452 5453 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is 5454 begin 5455 pragma Assert (not Locked); 5456 pragma Assert (Nkind (N) in N_Entity); 5457 Nodes.Table (N + 1).Field6 := Union_Id (Val); 5458 end Set_Node6; 5459 5460 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is 5461 begin 5462 pragma Assert (not Locked); 5463 pragma Assert (Nkind (N) in N_Entity); 5464 Nodes.Table (N + 1).Field7 := Union_Id (Val); 5465 end Set_Node7; 5466 5467 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is 5468 begin 5469 pragma Assert (not Locked); 5470 pragma Assert (Nkind (N) in N_Entity); 5471 Nodes.Table (N + 1).Field8 := Union_Id (Val); 5472 end Set_Node8; 5473 5474 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is 5475 begin 5476 pragma Assert (not Locked); 5477 pragma Assert (Nkind (N) in N_Entity); 5478 Nodes.Table (N + 1).Field9 := Union_Id (Val); 5479 end Set_Node9; 5480 5481 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is 5482 begin 5483 pragma Assert (not Locked); 5484 pragma Assert (Nkind (N) in N_Entity); 5485 Nodes.Table (N + 1).Field10 := Union_Id (Val); 5486 end Set_Node10; 5487 5488 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is 5489 begin 5490 pragma Assert (not Locked); 5491 pragma Assert (Nkind (N) in N_Entity); 5492 Nodes.Table (N + 1).Field11 := Union_Id (Val); 5493 end Set_Node11; 5494 5495 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is 5496 begin 5497 pragma Assert (not Locked); 5498 pragma Assert (Nkind (N) in N_Entity); 5499 Nodes.Table (N + 1).Field12 := Union_Id (Val); 5500 end Set_Node12; 5501 5502 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is 5503 begin 5504 pragma Assert (not Locked); 5505 pragma Assert (Nkind (N) in N_Entity); 5506 Nodes.Table (N + 2).Field6 := Union_Id (Val); 5507 end Set_Node13; 5508 5509 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is 5510 begin 5511 pragma Assert (not Locked); 5512 pragma Assert (Nkind (N) in N_Entity); 5513 Nodes.Table (N + 2).Field7 := Union_Id (Val); 5514 end Set_Node14; 5515 5516 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is 5517 begin 5518 pragma Assert (not Locked); 5519 pragma Assert (Nkind (N) in N_Entity); 5520 Nodes.Table (N + 2).Field8 := Union_Id (Val); 5521 end Set_Node15; 5522 5523 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is 5524 begin 5525 pragma Assert (not Locked); 5526 pragma Assert (Nkind (N) in N_Entity); 5527 Nodes.Table (N + 2).Field9 := Union_Id (Val); 5528 end Set_Node16; 5529 5530 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is 5531 begin 5532 pragma Assert (not Locked); 5533 pragma Assert (Nkind (N) in N_Entity); 5534 Nodes.Table (N + 2).Field10 := Union_Id (Val); 5535 end Set_Node17; 5536 5537 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is 5538 begin 5539 pragma Assert (not Locked); 5540 pragma Assert (Nkind (N) in N_Entity); 5541 Nodes.Table (N + 2).Field11 := Union_Id (Val); 5542 end Set_Node18; 5543 5544 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is 5545 begin 5546 pragma Assert (not Locked); 5547 pragma Assert (Nkind (N) in N_Entity); 5548 Nodes.Table (N + 3).Field6 := Union_Id (Val); 5549 end Set_Node19; 5550 5551 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is 5552 begin 5553 pragma Assert (not Locked); 5554 pragma Assert (Nkind (N) in N_Entity); 5555 Nodes.Table (N + 3).Field7 := Union_Id (Val); 5556 end Set_Node20; 5557 5558 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is 5559 begin 5560 pragma Assert (not Locked); 5561 pragma Assert (Nkind (N) in N_Entity); 5562 Nodes.Table (N + 3).Field8 := Union_Id (Val); 5563 end Set_Node21; 5564 5565 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is 5566 begin 5567 pragma Assert (not Locked); 5568 pragma Assert (Nkind (N) in N_Entity); 5569 Nodes.Table (N + 3).Field9 := Union_Id (Val); 5570 end Set_Node22; 5571 5572 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is 5573 begin 5574 pragma Assert (not Locked); 5575 pragma Assert (Nkind (N) in N_Entity); 5576 Nodes.Table (N + 3).Field10 := Union_Id (Val); 5577 end Set_Node23; 5578 5579 procedure Set_Node24 (N : Node_Id; Val : Node_Id) is 5580 begin 5581 pragma Assert (not Locked); 5582 pragma Assert (Nkind (N) in N_Entity); 5583 Nodes.Table (N + 4).Field6 := Union_Id (Val); 5584 end Set_Node24; 5585 5586 procedure Set_Node25 (N : Node_Id; Val : Node_Id) is 5587 begin 5588 pragma Assert (not Locked); 5589 pragma Assert (Nkind (N) in N_Entity); 5590 Nodes.Table (N + 4).Field7 := Union_Id (Val); 5591 end Set_Node25; 5592 5593 procedure Set_Node26 (N : Node_Id; Val : Node_Id) is 5594 begin 5595 pragma Assert (not Locked); 5596 pragma Assert (Nkind (N) in N_Entity); 5597 Nodes.Table (N + 4).Field8 := Union_Id (Val); 5598 end Set_Node26; 5599 5600 procedure Set_Node27 (N : Node_Id; Val : Node_Id) is 5601 begin 5602 pragma Assert (not Locked); 5603 pragma Assert (Nkind (N) in N_Entity); 5604 Nodes.Table (N + 4).Field9 := Union_Id (Val); 5605 end Set_Node27; 5606 5607 procedure Set_Node28 (N : Node_Id; Val : Node_Id) is 5608 begin 5609 pragma Assert (not Locked); 5610 pragma Assert (Nkind (N) in N_Entity); 5611 Nodes.Table (N + 4).Field10 := Union_Id (Val); 5612 end Set_Node28; 5613 5614 procedure Set_Node29 (N : Node_Id; Val : Node_Id) is 5615 begin 5616 pragma Assert (not Locked); 5617 pragma Assert (Nkind (N) in N_Entity); 5618 Nodes.Table (N + 4).Field11 := Union_Id (Val); 5619 end Set_Node29; 5620 5621 procedure Set_Node30 (N : Node_Id; Val : Node_Id) is 5622 begin 5623 pragma Assert (not Locked); 5624 pragma Assert (Nkind (N) in N_Entity); 5625 Nodes.Table (N + 5).Field6 := Union_Id (Val); 5626 end Set_Node30; 5627 5628 procedure Set_Node31 (N : Node_Id; Val : Node_Id) is 5629 begin 5630 pragma Assert (not Locked); 5631 pragma Assert (Nkind (N) in N_Entity); 5632 Nodes.Table (N + 5).Field7 := Union_Id (Val); 5633 end Set_Node31; 5634 5635 procedure Set_Node32 (N : Node_Id; Val : Node_Id) is 5636 begin 5637 pragma Assert (not Locked); 5638 pragma Assert (Nkind (N) in N_Entity); 5639 Nodes.Table (N + 5).Field8 := Union_Id (Val); 5640 end Set_Node32; 5641 5642 procedure Set_Node33 (N : Node_Id; Val : Node_Id) is 5643 begin 5644 pragma Assert (not Locked); 5645 pragma Assert (Nkind (N) in N_Entity); 5646 Nodes.Table (N + 5).Field9 := Union_Id (Val); 5647 end Set_Node33; 5648 5649 procedure Set_Node34 (N : Node_Id; Val : Node_Id) is 5650 begin 5651 pragma Assert (not Locked); 5652 pragma Assert (Nkind (N) in N_Entity); 5653 Nodes.Table (N + 5).Field10 := Union_Id (Val); 5654 end Set_Node34; 5655 5656 procedure Set_Node35 (N : Node_Id; Val : Node_Id) is 5657 begin 5658 pragma Assert (not Locked); 5659 pragma Assert (Nkind (N) in N_Entity); 5660 Nodes.Table (N + 5).Field11 := Union_Id (Val); 5661 end Set_Node35; 5662 5663 procedure Set_Node36 (N : Node_Id; Val : Node_Id) is 5664 begin 5665 pragma Assert (not Locked); 5666 pragma Assert (Nkind (N) in N_Entity); 5667 Nodes.Table (N + 6).Field6 := Union_Id (Val); 5668 end Set_Node36; 5669 5670 procedure Set_Node37 (N : Node_Id; Val : Node_Id) is 5671 begin 5672 pragma Assert (not Locked); 5673 pragma Assert (Nkind (N) in N_Entity); 5674 Nodes.Table (N + 6).Field7 := Union_Id (Val); 5675 end Set_Node37; 5676 5677 procedure Set_Node38 (N : Node_Id; Val : Node_Id) is 5678 begin 5679 pragma Assert (not Locked); 5680 pragma Assert (Nkind (N) in N_Entity); 5681 Nodes.Table (N + 6).Field8 := Union_Id (Val); 5682 end Set_Node38; 5683 5684 procedure Set_Node39 (N : Node_Id; Val : Node_Id) is 5685 begin 5686 pragma Assert (not Locked); 5687 pragma Assert (Nkind (N) in N_Entity); 5688 Nodes.Table (N + 6).Field9 := Union_Id (Val); 5689 end Set_Node39; 5690 5691 procedure Set_Node40 (N : Node_Id; Val : Node_Id) is 5692 begin 5693 pragma Assert (not Locked); 5694 pragma Assert (Nkind (N) in N_Entity); 5695 Nodes.Table (N + 6).Field10 := Union_Id (Val); 5696 end Set_Node40; 5697 5698 procedure Set_Node41 (N : Node_Id; Val : Node_Id) is 5699 begin 5700 pragma Assert (not Locked); 5701 pragma Assert (Nkind (N) in N_Entity); 5702 Nodes.Table (N + 6).Field11 := Union_Id (Val); 5703 end Set_Node41; 5704 5705 procedure Set_List1 (N : Node_Id; Val : List_Id) is 5706 begin 5707 pragma Assert (not Locked); 5708 pragma Assert (N <= Nodes.Last); 5709 Nodes.Table (N).Field1 := Union_Id (Val); 5710 end Set_List1; 5711 5712 procedure Set_List2 (N : Node_Id; Val : List_Id) is 5713 begin 5714 pragma Assert (not Locked); 5715 pragma Assert (N <= Nodes.Last); 5716 Nodes.Table (N).Field2 := Union_Id (Val); 5717 end Set_List2; 5718 5719 procedure Set_List3 (N : Node_Id; Val : List_Id) is 5720 begin 5721 pragma Assert (not Locked); 5722 pragma Assert (N <= Nodes.Last); 5723 Nodes.Table (N).Field3 := Union_Id (Val); 5724 end Set_List3; 5725 5726 procedure Set_List4 (N : Node_Id; Val : List_Id) is 5727 begin 5728 pragma Assert (not Locked); 5729 pragma Assert (N <= Nodes.Last); 5730 Nodes.Table (N).Field4 := Union_Id (Val); 5731 end Set_List4; 5732 5733 procedure Set_List5 (N : Node_Id; Val : List_Id) is 5734 begin 5735 pragma Assert (not Locked); 5736 pragma Assert (N <= Nodes.Last); 5737 Nodes.Table (N).Field5 := Union_Id (Val); 5738 end Set_List5; 5739 5740 procedure Set_List10 (N : Node_Id; Val : List_Id) is 5741 begin 5742 pragma Assert (not Locked); 5743 pragma Assert (Nkind (N) in N_Entity); 5744 Nodes.Table (N + 1).Field10 := Union_Id (Val); 5745 end Set_List10; 5746 5747 procedure Set_List14 (N : Node_Id; Val : List_Id) is 5748 begin 5749 pragma Assert (not Locked); 5750 pragma Assert (Nkind (N) in N_Entity); 5751 Nodes.Table (N + 2).Field7 := Union_Id (Val); 5752 end Set_List14; 5753 5754 procedure Set_List25 (N : Node_Id; Val : List_Id) is 5755 begin 5756 pragma Assert (not Locked); 5757 pragma Assert (Nkind (N) in N_Entity); 5758 Nodes.Table (N + 4).Field7 := Union_Id (Val); 5759 end Set_List25; 5760 5761 procedure Set_List38 (N : Node_Id; Val : List_Id) is 5762 begin 5763 pragma Assert (not Locked); 5764 pragma Assert (Nkind (N) in N_Entity); 5765 Nodes.Table (N + 6).Field8 := Union_Id (Val); 5766 end Set_List38; 5767 5768 procedure Set_List39 (N : Node_Id; Val : List_Id) is 5769 begin 5770 pragma Assert (not Locked); 5771 pragma Assert (Nkind (N) in N_Entity); 5772 Nodes.Table (N + 6).Field9 := Union_Id (Val); 5773 end Set_List39; 5774 5775 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is 5776 begin 5777 pragma Assert (not Locked); 5778 Nodes.Table (N).Field1 := Union_Id (Val); 5779 end Set_Elist1; 5780 5781 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is 5782 begin 5783 pragma Assert (not Locked); 5784 Nodes.Table (N).Field2 := Union_Id (Val); 5785 end Set_Elist2; 5786 5787 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is 5788 begin 5789 pragma Assert (not Locked); 5790 Nodes.Table (N).Field3 := Union_Id (Val); 5791 end Set_Elist3; 5792 5793 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is 5794 begin 5795 pragma Assert (not Locked); 5796 Nodes.Table (N).Field4 := Union_Id (Val); 5797 end Set_Elist4; 5798 5799 procedure Set_Elist5 (N : Node_Id; Val : Elist_Id) is 5800 begin 5801 pragma Assert (not Locked); 5802 Nodes.Table (N).Field5 := Union_Id (Val); 5803 end Set_Elist5; 5804 5805 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is 5806 begin 5807 pragma Assert (not Locked); 5808 pragma Assert (Nkind (N) in N_Entity); 5809 Nodes.Table (N + 1).Field8 := Union_Id (Val); 5810 end Set_Elist8; 5811 5812 procedure Set_Elist9 (N : Node_Id; Val : Elist_Id) is 5813 begin 5814 pragma Assert (not Locked); 5815 pragma Assert (Nkind (N) in N_Entity); 5816 Nodes.Table (N + 1).Field9 := Union_Id (Val); 5817 end Set_Elist9; 5818 5819 procedure Set_Elist10 (N : Node_Id; Val : Elist_Id) is 5820 begin 5821 pragma Assert (not Locked); 5822 pragma Assert (Nkind (N) in N_Entity); 5823 Nodes.Table (N + 1).Field10 := Union_Id (Val); 5824 end Set_Elist10; 5825 5826 procedure Set_Elist11 (N : Node_Id; Val : Elist_Id) is 5827 begin 5828 pragma Assert (not Locked); 5829 pragma Assert (Nkind (N) in N_Entity); 5830 Nodes.Table (N + 1).Field11 := Union_Id (Val); 5831 end Set_Elist11; 5832 5833 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is 5834 begin 5835 pragma Assert (not Locked); 5836 pragma Assert (Nkind (N) in N_Entity); 5837 Nodes.Table (N + 2).Field6 := Union_Id (Val); 5838 end Set_Elist13; 5839 5840 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is 5841 begin 5842 pragma Assert (not Locked); 5843 pragma Assert (Nkind (N) in N_Entity); 5844 Nodes.Table (N + 2).Field8 := Union_Id (Val); 5845 end Set_Elist15; 5846 5847 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is 5848 begin 5849 pragma Assert (not Locked); 5850 pragma Assert (Nkind (N) in N_Entity); 5851 Nodes.Table (N + 2).Field9 := Union_Id (Val); 5852 end Set_Elist16; 5853 5854 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is 5855 begin 5856 pragma Assert (not Locked); 5857 pragma Assert (Nkind (N) in N_Entity); 5858 Nodes.Table (N + 2).Field11 := Union_Id (Val); 5859 end Set_Elist18; 5860 5861 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is 5862 begin 5863 pragma Assert (not Locked); 5864 pragma Assert (Nkind (N) in N_Entity); 5865 Nodes.Table (N + 3).Field8 := Union_Id (Val); 5866 end Set_Elist21; 5867 5868 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is 5869 begin 5870 pragma Assert (not Locked); 5871 pragma Assert (Nkind (N) in N_Entity); 5872 Nodes.Table (N + 3).Field10 := Union_Id (Val); 5873 end Set_Elist23; 5874 5875 procedure Set_Elist24 (N : Node_Id; Val : Elist_Id) is 5876 begin 5877 pragma Assert (not Locked); 5878 pragma Assert (Nkind (N) in N_Entity); 5879 Nodes.Table (N + 4).Field6 := Union_Id (Val); 5880 end Set_Elist24; 5881 5882 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is 5883 begin 5884 pragma Assert (not Locked); 5885 pragma Assert (Nkind (N) in N_Entity); 5886 Nodes.Table (N + 4).Field7 := Union_Id (Val); 5887 end Set_Elist25; 5888 5889 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is 5890 begin 5891 pragma Assert (not Locked); 5892 pragma Assert (Nkind (N) in N_Entity); 5893 Nodes.Table (N + 4).Field8 := Union_Id (Val); 5894 end Set_Elist26; 5895 5896 procedure Set_Elist29 (N : Node_Id; Val : Elist_Id) is 5897 begin 5898 pragma Assert (not Locked); 5899 pragma Assert (Nkind (N) in N_Entity); 5900 Nodes.Table (N + 4).Field11 := Union_Id (Val); 5901 end Set_Elist29; 5902 5903 procedure Set_Elist30 (N : Node_Id; Val : Elist_Id) is 5904 begin 5905 pragma Assert (not Locked); 5906 pragma Assert (Nkind (N) in N_Entity); 5907 Nodes.Table (N + 5).Field6 := Union_Id (Val); 5908 end Set_Elist30; 5909 5910 procedure Set_Elist36 (N : Node_Id; Val : Elist_Id) is 5911 begin 5912 pragma Assert (not Locked); 5913 pragma Assert (Nkind (N) in N_Entity); 5914 Nodes.Table (N + 6).Field6 := Union_Id (Val); 5915 end Set_Elist36; 5916 5917 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is 5918 begin 5919 pragma Assert (not Locked); 5920 pragma Assert (N <= Nodes.Last); 5921 Nodes.Table (N).Field1 := Union_Id (Val); 5922 end Set_Name1; 5923 5924 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is 5925 begin 5926 pragma Assert (not Locked); 5927 pragma Assert (N <= Nodes.Last); 5928 Nodes.Table (N).Field2 := Union_Id (Val); 5929 end Set_Name2; 5930 5931 procedure Set_Str3 (N : Node_Id; Val : String_Id) is 5932 begin 5933 pragma Assert (not Locked); 5934 pragma Assert (N <= Nodes.Last); 5935 Nodes.Table (N).Field3 := Union_Id (Val); 5936 end Set_Str3; 5937 5938 procedure Set_Uint2 (N : Node_Id; Val : Uint) is 5939 begin 5940 pragma Assert (not Locked); 5941 pragma Assert (N <= Nodes.Last); 5942 Nodes.Table (N).Field2 := To_Union (Val); 5943 end Set_Uint2; 5944 5945 procedure Set_Uint3 (N : Node_Id; Val : Uint) is 5946 begin 5947 pragma Assert (not Locked); 5948 pragma Assert (N <= Nodes.Last); 5949 Nodes.Table (N).Field3 := To_Union (Val); 5950 end Set_Uint3; 5951 5952 procedure Set_Uint4 (N : Node_Id; Val : Uint) is 5953 begin 5954 pragma Assert (not Locked); 5955 pragma Assert (N <= Nodes.Last); 5956 Nodes.Table (N).Field4 := To_Union (Val); 5957 end Set_Uint4; 5958 5959 procedure Set_Uint5 (N : Node_Id; Val : Uint) is 5960 begin 5961 pragma Assert (not Locked); 5962 pragma Assert (N <= Nodes.Last); 5963 Nodes.Table (N).Field5 := To_Union (Val); 5964 end Set_Uint5; 5965 5966 procedure Set_Uint8 (N : Node_Id; Val : Uint) is 5967 begin 5968 pragma Assert (not Locked); 5969 pragma Assert (Nkind (N) in N_Entity); 5970 Nodes.Table (N + 1).Field8 := To_Union (Val); 5971 end Set_Uint8; 5972 5973 procedure Set_Uint9 (N : Node_Id; Val : Uint) is 5974 begin 5975 pragma Assert (not Locked); 5976 pragma Assert (Nkind (N) in N_Entity); 5977 Nodes.Table (N + 1).Field9 := To_Union (Val); 5978 end Set_Uint9; 5979 5980 procedure Set_Uint10 (N : Node_Id; Val : Uint) is 5981 begin 5982 pragma Assert (not Locked); 5983 pragma Assert (Nkind (N) in N_Entity); 5984 Nodes.Table (N + 1).Field10 := To_Union (Val); 5985 end Set_Uint10; 5986 5987 procedure Set_Uint11 (N : Node_Id; Val : Uint) is 5988 begin 5989 pragma Assert (not Locked); 5990 pragma Assert (Nkind (N) in N_Entity); 5991 Nodes.Table (N + 1).Field11 := To_Union (Val); 5992 end Set_Uint11; 5993 5994 procedure Set_Uint12 (N : Node_Id; Val : Uint) is 5995 begin 5996 pragma Assert (not Locked); 5997 pragma Assert (Nkind (N) in N_Entity); 5998 Nodes.Table (N + 1).Field12 := To_Union (Val); 5999 end Set_Uint12; 6000 6001 procedure Set_Uint13 (N : Node_Id; Val : Uint) is 6002 begin 6003 pragma Assert (not Locked); 6004 pragma Assert (Nkind (N) in N_Entity); 6005 Nodes.Table (N + 2).Field6 := To_Union (Val); 6006 end Set_Uint13; 6007 6008 procedure Set_Uint14 (N : Node_Id; Val : Uint) is 6009 begin 6010 pragma Assert (not Locked); 6011 pragma Assert (Nkind (N) in N_Entity); 6012 Nodes.Table (N + 2).Field7 := To_Union (Val); 6013 end Set_Uint14; 6014 6015 procedure Set_Uint15 (N : Node_Id; Val : Uint) is 6016 begin 6017 pragma Assert (not Locked); 6018 pragma Assert (Nkind (N) in N_Entity); 6019 Nodes.Table (N + 2).Field8 := To_Union (Val); 6020 end Set_Uint15; 6021 6022 procedure Set_Uint16 (N : Node_Id; Val : Uint) is 6023 begin 6024 pragma Assert (not Locked); 6025 pragma Assert (Nkind (N) in N_Entity); 6026 Nodes.Table (N + 2).Field9 := To_Union (Val); 6027 end Set_Uint16; 6028 6029 procedure Set_Uint17 (N : Node_Id; Val : Uint) is 6030 begin 6031 pragma Assert (not Locked); 6032 pragma Assert (Nkind (N) in N_Entity); 6033 Nodes.Table (N + 2).Field10 := To_Union (Val); 6034 end Set_Uint17; 6035 6036 procedure Set_Uint22 (N : Node_Id; Val : Uint) is 6037 begin 6038 pragma Assert (not Locked); 6039 pragma Assert (Nkind (N) in N_Entity); 6040 Nodes.Table (N + 3).Field9 := To_Union (Val); 6041 end Set_Uint22; 6042 6043 procedure Set_Uint24 (N : Node_Id; Val : Uint) is 6044 begin 6045 pragma Assert (not Locked); 6046 pragma Assert (Nkind (N) in N_Entity); 6047 Nodes.Table (N + 4).Field6 := To_Union (Val); 6048 end Set_Uint24; 6049 6050 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is 6051 begin 6052 pragma Assert (not Locked); 6053 pragma Assert (N <= Nodes.Last); 6054 Nodes.Table (N).Field3 := To_Union (Val); 6055 end Set_Ureal3; 6056 6057 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is 6058 begin 6059 pragma Assert (not Locked); 6060 pragma Assert (Nkind (N) in N_Entity); 6061 Nodes.Table (N + 2).Field11 := To_Union (Val); 6062 end Set_Ureal18; 6063 6064 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is 6065 begin 6066 pragma Assert (not Locked); 6067 pragma Assert (Nkind (N) in N_Entity); 6068 Nodes.Table (N + 3).Field8 := To_Union (Val); 6069 end Set_Ureal21; 6070 6071 procedure Set_Flag0 (N : Node_Id; Val : Boolean) is 6072 begin 6073 pragma Assert (not Locked); 6074 pragma Assert (N <= Nodes.Last); 6075 Flags.Table (N).Flag0 := Val; 6076 end Set_Flag0; 6077 6078 procedure Set_Flag1 (N : Node_Id; Val : Boolean) is 6079 begin 6080 pragma Assert (not Locked); 6081 pragma Assert (N <= Nodes.Last); 6082 Flags.Table (N).Flag1 := Val; 6083 end Set_Flag1; 6084 6085 procedure Set_Flag2 (N : Node_Id; Val : Boolean) is 6086 begin 6087 pragma Assert (not Locked); 6088 pragma Assert (N <= Nodes.Last); 6089 Flags.Table (N).Flag2 := Val; 6090 end Set_Flag2; 6091 6092 procedure Set_Flag3 (N : Node_Id; Val : Boolean) is 6093 begin 6094 pragma Assert (not Locked); 6095 pragma Assert (N <= Nodes.Last); 6096 Flags.Table (N).Flag3 := Val; 6097 end Set_Flag3; 6098 6099 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is 6100 begin 6101 pragma Assert (not Locked); 6102 pragma Assert (N <= Nodes.Last); 6103 Nodes.Table (N).Flag4 := Val; 6104 end Set_Flag4; 6105 6106 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is 6107 begin 6108 pragma Assert (not Locked); 6109 pragma Assert (N <= Nodes.Last); 6110 Nodes.Table (N).Flag5 := Val; 6111 end Set_Flag5; 6112 6113 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is 6114 begin 6115 pragma Assert (not Locked); 6116 pragma Assert (N <= Nodes.Last); 6117 Nodes.Table (N).Flag6 := Val; 6118 end Set_Flag6; 6119 6120 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is 6121 begin 6122 pragma Assert (not Locked); 6123 pragma Assert (N <= Nodes.Last); 6124 Nodes.Table (N).Flag7 := Val; 6125 end Set_Flag7; 6126 6127 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is 6128 begin 6129 pragma Assert (not Locked); 6130 pragma Assert (N <= Nodes.Last); 6131 Nodes.Table (N).Flag8 := Val; 6132 end Set_Flag8; 6133 6134 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is 6135 begin 6136 pragma Assert (not Locked); 6137 pragma Assert (N <= Nodes.Last); 6138 Nodes.Table (N).Flag9 := Val; 6139 end Set_Flag9; 6140 6141 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is 6142 begin 6143 pragma Assert (not Locked); 6144 pragma Assert (N <= Nodes.Last); 6145 Nodes.Table (N).Flag10 := Val; 6146 end Set_Flag10; 6147 6148 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is 6149 begin 6150 pragma Assert (not Locked); 6151 pragma Assert (N <= Nodes.Last); 6152 Nodes.Table (N).Flag11 := Val; 6153 end Set_Flag11; 6154 6155 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is 6156 begin 6157 pragma Assert (not Locked); 6158 pragma Assert (N <= Nodes.Last); 6159 Nodes.Table (N).Flag12 := Val; 6160 end Set_Flag12; 6161 6162 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is 6163 begin 6164 pragma Assert (not Locked); 6165 pragma Assert (N <= Nodes.Last); 6166 Nodes.Table (N).Flag13 := Val; 6167 end Set_Flag13; 6168 6169 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is 6170 begin 6171 pragma Assert (not Locked); 6172 pragma Assert (N <= Nodes.Last); 6173 Nodes.Table (N).Flag14 := Val; 6174 end Set_Flag14; 6175 6176 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is 6177 begin 6178 pragma Assert (not Locked); 6179 pragma Assert (N <= Nodes.Last); 6180 Nodes.Table (N).Flag15 := Val; 6181 end Set_Flag15; 6182 6183 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is 6184 begin 6185 pragma Assert (not Locked); 6186 pragma Assert (N <= Nodes.Last); 6187 Nodes.Table (N).Flag16 := Val; 6188 end Set_Flag16; 6189 6190 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is 6191 begin 6192 pragma Assert (not Locked); 6193 pragma Assert (N <= Nodes.Last); 6194 Nodes.Table (N).Flag17 := Val; 6195 end Set_Flag17; 6196 6197 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is 6198 begin 6199 pragma Assert (not Locked); 6200 pragma Assert (N <= Nodes.Last); 6201 Nodes.Table (N).Flag18 := Val; 6202 end Set_Flag18; 6203 6204 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is 6205 begin 6206 pragma Assert (not Locked); 6207 pragma Assert (Nkind (N) in N_Entity); 6208 Nodes.Table (N + 1).In_List := Val; 6209 end Set_Flag19; 6210 6211 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is 6212 begin 6213 pragma Assert (not Locked); 6214 pragma Assert (Nkind (N) in N_Entity); 6215 Nodes.Table (N + 1).Has_Aspects := Val; 6216 end Set_Flag20; 6217 6218 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is 6219 begin 6220 pragma Assert (not Locked); 6221 pragma Assert (Nkind (N) in N_Entity); 6222 Nodes.Table (N + 1).Rewrite_Ins := Val; 6223 end Set_Flag21; 6224 6225 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is 6226 begin 6227 pragma Assert (not Locked); 6228 pragma Assert (Nkind (N) in N_Entity); 6229 Nodes.Table (N + 1).Analyzed := Val; 6230 end Set_Flag22; 6231 6232 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is 6233 begin 6234 pragma Assert (not Locked); 6235 pragma Assert (Nkind (N) in N_Entity); 6236 Nodes.Table (N + 1).Comes_From_Source := Val; 6237 end Set_Flag23; 6238 6239 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is 6240 begin 6241 pragma Assert (not Locked); 6242 pragma Assert (Nkind (N) in N_Entity); 6243 Nodes.Table (N + 1).Error_Posted := Val; 6244 end Set_Flag24; 6245 6246 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is 6247 begin 6248 pragma Assert (not Locked); 6249 pragma Assert (Nkind (N) in N_Entity); 6250 Nodes.Table (N + 1).Flag4 := Val; 6251 end Set_Flag25; 6252 6253 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is 6254 begin 6255 pragma Assert (not Locked); 6256 pragma Assert (Nkind (N) in N_Entity); 6257 Nodes.Table (N + 1).Flag5 := Val; 6258 end Set_Flag26; 6259 6260 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is 6261 begin 6262 pragma Assert (not Locked); 6263 pragma Assert (Nkind (N) in N_Entity); 6264 Nodes.Table (N + 1).Flag6 := Val; 6265 end Set_Flag27; 6266 6267 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is 6268 begin 6269 pragma Assert (not Locked); 6270 pragma Assert (Nkind (N) in N_Entity); 6271 Nodes.Table (N + 1).Flag7 := Val; 6272 end Set_Flag28; 6273 6274 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is 6275 begin 6276 pragma Assert (not Locked); 6277 pragma Assert (Nkind (N) in N_Entity); 6278 Nodes.Table (N + 1).Flag8 := Val; 6279 end Set_Flag29; 6280 6281 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is 6282 begin 6283 pragma Assert (not Locked); 6284 pragma Assert (Nkind (N) in N_Entity); 6285 Nodes.Table (N + 1).Flag9 := Val; 6286 end Set_Flag30; 6287 6288 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is 6289 begin 6290 pragma Assert (not Locked); 6291 pragma Assert (Nkind (N) in N_Entity); 6292 Nodes.Table (N + 1).Flag10 := Val; 6293 end Set_Flag31; 6294 6295 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is 6296 begin 6297 pragma Assert (not Locked); 6298 pragma Assert (Nkind (N) in N_Entity); 6299 Nodes.Table (N + 1).Flag11 := Val; 6300 end Set_Flag32; 6301 6302 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is 6303 begin 6304 pragma Assert (not Locked); 6305 pragma Assert (Nkind (N) in N_Entity); 6306 Nodes.Table (N + 1).Flag12 := Val; 6307 end Set_Flag33; 6308 6309 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is 6310 begin 6311 pragma Assert (not Locked); 6312 pragma Assert (Nkind (N) in N_Entity); 6313 Nodes.Table (N + 1).Flag13 := Val; 6314 end Set_Flag34; 6315 6316 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is 6317 begin 6318 pragma Assert (not Locked); 6319 pragma Assert (Nkind (N) in N_Entity); 6320 Nodes.Table (N + 1).Flag14 := Val; 6321 end Set_Flag35; 6322 6323 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is 6324 begin 6325 pragma Assert (not Locked); 6326 pragma Assert (Nkind (N) in N_Entity); 6327 Nodes.Table (N + 1).Flag15 := Val; 6328 end Set_Flag36; 6329 6330 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is 6331 begin 6332 pragma Assert (not Locked); 6333 pragma Assert (Nkind (N) in N_Entity); 6334 Nodes.Table (N + 1).Flag16 := Val; 6335 end Set_Flag37; 6336 6337 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is 6338 begin 6339 pragma Assert (not Locked); 6340 pragma Assert (Nkind (N) in N_Entity); 6341 Nodes.Table (N + 1).Flag17 := Val; 6342 end Set_Flag38; 6343 6344 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is 6345 begin 6346 pragma Assert (not Locked); 6347 pragma Assert (Nkind (N) in N_Entity); 6348 Nodes.Table (N + 1).Flag18 := Val; 6349 end Set_Flag39; 6350 6351 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is 6352 begin 6353 pragma Assert (not Locked); 6354 pragma Assert (Nkind (N) in N_Entity); 6355 Nodes.Table (N + 2).In_List := Val; 6356 end Set_Flag40; 6357 6358 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is 6359 begin 6360 pragma Assert (not Locked); 6361 pragma Assert (Nkind (N) in N_Entity); 6362 Nodes.Table (N + 2).Has_Aspects := Val; 6363 end Set_Flag41; 6364 6365 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is 6366 begin 6367 pragma Assert (not Locked); 6368 pragma Assert (Nkind (N) in N_Entity); 6369 Nodes.Table (N + 2).Rewrite_Ins := Val; 6370 end Set_Flag42; 6371 6372 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is 6373 begin 6374 pragma Assert (not Locked); 6375 pragma Assert (Nkind (N) in N_Entity); 6376 Nodes.Table (N + 2).Analyzed := Val; 6377 end Set_Flag43; 6378 6379 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is 6380 begin 6381 pragma Assert (not Locked); 6382 pragma Assert (Nkind (N) in N_Entity); 6383 Nodes.Table (N + 2).Comes_From_Source := Val; 6384 end Set_Flag44; 6385 6386 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is 6387 begin 6388 pragma Assert (not Locked); 6389 pragma Assert (Nkind (N) in N_Entity); 6390 Nodes.Table (N + 2).Error_Posted := Val; 6391 end Set_Flag45; 6392 6393 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is 6394 begin 6395 pragma Assert (not Locked); 6396 pragma Assert (Nkind (N) in N_Entity); 6397 Nodes.Table (N + 2).Flag4 := Val; 6398 end Set_Flag46; 6399 6400 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is 6401 begin 6402 pragma Assert (not Locked); 6403 pragma Assert (Nkind (N) in N_Entity); 6404 Nodes.Table (N + 2).Flag5 := Val; 6405 end Set_Flag47; 6406 6407 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is 6408 begin 6409 pragma Assert (not Locked); 6410 pragma Assert (Nkind (N) in N_Entity); 6411 Nodes.Table (N + 2).Flag6 := Val; 6412 end Set_Flag48; 6413 6414 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is 6415 begin 6416 pragma Assert (not Locked); 6417 pragma Assert (Nkind (N) in N_Entity); 6418 Nodes.Table (N + 2).Flag7 := Val; 6419 end Set_Flag49; 6420 6421 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is 6422 begin 6423 pragma Assert (not Locked); 6424 pragma Assert (Nkind (N) in N_Entity); 6425 Nodes.Table (N + 2).Flag8 := Val; 6426 end Set_Flag50; 6427 6428 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is 6429 begin 6430 pragma Assert (not Locked); 6431 pragma Assert (Nkind (N) in N_Entity); 6432 Nodes.Table (N + 2).Flag9 := Val; 6433 end Set_Flag51; 6434 6435 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is 6436 begin 6437 pragma Assert (not Locked); 6438 pragma Assert (Nkind (N) in N_Entity); 6439 Nodes.Table (N + 2).Flag10 := Val; 6440 end Set_Flag52; 6441 6442 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is 6443 begin 6444 pragma Assert (not Locked); 6445 pragma Assert (Nkind (N) in N_Entity); 6446 Nodes.Table (N + 2).Flag11 := Val; 6447 end Set_Flag53; 6448 6449 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is 6450 begin 6451 pragma Assert (not Locked); 6452 pragma Assert (Nkind (N) in N_Entity); 6453 Nodes.Table (N + 2).Flag12 := Val; 6454 end Set_Flag54; 6455 6456 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is 6457 begin 6458 pragma Assert (not Locked); 6459 pragma Assert (Nkind (N) in N_Entity); 6460 Nodes.Table (N + 2).Flag13 := Val; 6461 end Set_Flag55; 6462 6463 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is 6464 begin 6465 pragma Assert (not Locked); 6466 pragma Assert (Nkind (N) in N_Entity); 6467 Nodes.Table (N + 2).Flag14 := Val; 6468 end Set_Flag56; 6469 6470 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is 6471 begin 6472 pragma Assert (not Locked); 6473 pragma Assert (Nkind (N) in N_Entity); 6474 Nodes.Table (N + 2).Flag15 := Val; 6475 end Set_Flag57; 6476 6477 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is 6478 begin 6479 pragma Assert (not Locked); 6480 pragma Assert (Nkind (N) in N_Entity); 6481 Nodes.Table (N + 2).Flag16 := Val; 6482 end Set_Flag58; 6483 6484 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is 6485 begin 6486 pragma Assert (not Locked); 6487 pragma Assert (Nkind (N) in N_Entity); 6488 Nodes.Table (N + 2).Flag17 := Val; 6489 end Set_Flag59; 6490 6491 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is 6492 begin 6493 pragma Assert (not Locked); 6494 pragma Assert (Nkind (N) in N_Entity); 6495 Nodes.Table (N + 2).Flag18 := Val; 6496 end Set_Flag60; 6497 6498 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is 6499 begin 6500 pragma Assert (not Locked); 6501 pragma Assert (Nkind (N) in N_Entity); 6502 Nodes.Table (N + 1).Pflag1 := Val; 6503 end Set_Flag61; 6504 6505 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is 6506 begin 6507 pragma Assert (not Locked); 6508 pragma Assert (Nkind (N) in N_Entity); 6509 Nodes.Table (N + 1).Pflag2 := Val; 6510 end Set_Flag62; 6511 6512 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is 6513 begin 6514 pragma Assert (not Locked); 6515 pragma Assert (Nkind (N) in N_Entity); 6516 Nodes.Table (N + 2).Pflag1 := Val; 6517 end Set_Flag63; 6518 6519 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is 6520 begin 6521 pragma Assert (not Locked); 6522 pragma Assert (Nkind (N) in N_Entity); 6523 Nodes.Table (N + 2).Pflag2 := Val; 6524 end Set_Flag64; 6525 6526 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is 6527 begin 6528 pragma Assert (not Locked); 6529 pragma Assert (Nkind (N) in N_Entity); 6530 To_Flag_Byte_Ptr 6531 (Node_Kind_Ptr' 6532 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val; 6533 end Set_Flag65; 6534 6535 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is 6536 begin 6537 pragma Assert (not Locked); 6538 pragma Assert (Nkind (N) in N_Entity); 6539 To_Flag_Byte_Ptr 6540 (Node_Kind_Ptr' 6541 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val; 6542 end Set_Flag66; 6543 6544 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is 6545 begin 6546 pragma Assert (not Locked); 6547 pragma Assert (Nkind (N) in N_Entity); 6548 To_Flag_Byte_Ptr 6549 (Node_Kind_Ptr' 6550 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val; 6551 end Set_Flag67; 6552 6553 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is 6554 begin 6555 pragma Assert (not Locked); 6556 pragma Assert (Nkind (N) in N_Entity); 6557 To_Flag_Byte_Ptr 6558 (Node_Kind_Ptr' 6559 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val; 6560 end Set_Flag68; 6561 6562 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is 6563 begin 6564 pragma Assert (not Locked); 6565 pragma Assert (Nkind (N) in N_Entity); 6566 To_Flag_Byte_Ptr 6567 (Node_Kind_Ptr' 6568 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val; 6569 end Set_Flag69; 6570 6571 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is 6572 begin 6573 pragma Assert (not Locked); 6574 pragma Assert (Nkind (N) in N_Entity); 6575 To_Flag_Byte_Ptr 6576 (Node_Kind_Ptr' 6577 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val; 6578 end Set_Flag70; 6579 6580 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is 6581 begin 6582 pragma Assert (not Locked); 6583 pragma Assert (Nkind (N) in N_Entity); 6584 To_Flag_Byte_Ptr 6585 (Node_Kind_Ptr' 6586 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val; 6587 end Set_Flag71; 6588 6589 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is 6590 begin 6591 pragma Assert (not Locked); 6592 pragma Assert (Nkind (N) in N_Entity); 6593 To_Flag_Byte_Ptr 6594 (Node_Kind_Ptr' 6595 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val; 6596 end Set_Flag72; 6597 6598 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is 6599 begin 6600 pragma Assert (not Locked); 6601 pragma Assert (Nkind (N) in N_Entity); 6602 To_Flag_Word_Ptr 6603 (Union_Id_Ptr' 6604 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val; 6605 end Set_Flag73; 6606 6607 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is 6608 begin 6609 pragma Assert (not Locked); 6610 pragma Assert (Nkind (N) in N_Entity); 6611 To_Flag_Word_Ptr 6612 (Union_Id_Ptr' 6613 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val; 6614 end Set_Flag74; 6615 6616 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is 6617 begin 6618 pragma Assert (not Locked); 6619 pragma Assert (Nkind (N) in N_Entity); 6620 To_Flag_Word_Ptr 6621 (Union_Id_Ptr' 6622 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val; 6623 end Set_Flag75; 6624 6625 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is 6626 begin 6627 pragma Assert (not Locked); 6628 pragma Assert (Nkind (N) in N_Entity); 6629 To_Flag_Word_Ptr 6630 (Union_Id_Ptr' 6631 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val; 6632 end Set_Flag76; 6633 6634 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is 6635 begin 6636 pragma Assert (not Locked); 6637 pragma Assert (Nkind (N) in N_Entity); 6638 To_Flag_Word_Ptr 6639 (Union_Id_Ptr' 6640 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val; 6641 end Set_Flag77; 6642 6643 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is 6644 begin 6645 pragma Assert (not Locked); 6646 pragma Assert (Nkind (N) in N_Entity); 6647 To_Flag_Word_Ptr 6648 (Union_Id_Ptr' 6649 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val; 6650 end Set_Flag78; 6651 6652 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is 6653 begin 6654 pragma Assert (not Locked); 6655 pragma Assert (Nkind (N) in N_Entity); 6656 To_Flag_Word_Ptr 6657 (Union_Id_Ptr' 6658 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val; 6659 end Set_Flag79; 6660 6661 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is 6662 begin 6663 pragma Assert (not Locked); 6664 pragma Assert (Nkind (N) in N_Entity); 6665 To_Flag_Word_Ptr 6666 (Union_Id_Ptr' 6667 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val; 6668 end Set_Flag80; 6669 6670 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is 6671 begin 6672 pragma Assert (not Locked); 6673 pragma Assert (Nkind (N) in N_Entity); 6674 To_Flag_Word_Ptr 6675 (Union_Id_Ptr' 6676 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val; 6677 end Set_Flag81; 6678 6679 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is 6680 begin 6681 pragma Assert (not Locked); 6682 pragma Assert (Nkind (N) in N_Entity); 6683 To_Flag_Word_Ptr 6684 (Union_Id_Ptr' 6685 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val; 6686 end Set_Flag82; 6687 6688 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is 6689 begin 6690 pragma Assert (not Locked); 6691 pragma Assert (Nkind (N) in N_Entity); 6692 To_Flag_Word_Ptr 6693 (Union_Id_Ptr' 6694 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val; 6695 end Set_Flag83; 6696 6697 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is 6698 begin 6699 pragma Assert (not Locked); 6700 pragma Assert (Nkind (N) in N_Entity); 6701 To_Flag_Word_Ptr 6702 (Union_Id_Ptr' 6703 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val; 6704 end Set_Flag84; 6705 6706 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is 6707 begin 6708 pragma Assert (not Locked); 6709 pragma Assert (Nkind (N) in N_Entity); 6710 To_Flag_Word_Ptr 6711 (Union_Id_Ptr' 6712 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val; 6713 end Set_Flag85; 6714 6715 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is 6716 begin 6717 pragma Assert (not Locked); 6718 pragma Assert (Nkind (N) in N_Entity); 6719 To_Flag_Word_Ptr 6720 (Union_Id_Ptr' 6721 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val; 6722 end Set_Flag86; 6723 6724 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is 6725 begin 6726 pragma Assert (not Locked); 6727 pragma Assert (Nkind (N) in N_Entity); 6728 To_Flag_Word_Ptr 6729 (Union_Id_Ptr' 6730 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val; 6731 end Set_Flag87; 6732 6733 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is 6734 begin 6735 pragma Assert (not Locked); 6736 pragma Assert (Nkind (N) in N_Entity); 6737 To_Flag_Word_Ptr 6738 (Union_Id_Ptr' 6739 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val; 6740 end Set_Flag88; 6741 6742 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is 6743 begin 6744 pragma Assert (not Locked); 6745 pragma Assert (Nkind (N) in N_Entity); 6746 To_Flag_Word_Ptr 6747 (Union_Id_Ptr' 6748 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val; 6749 end Set_Flag89; 6750 6751 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is 6752 begin 6753 pragma Assert (not Locked); 6754 pragma Assert (Nkind (N) in N_Entity); 6755 To_Flag_Word_Ptr 6756 (Union_Id_Ptr' 6757 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val; 6758 end Set_Flag90; 6759 6760 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is 6761 begin 6762 pragma Assert (not Locked); 6763 pragma Assert (Nkind (N) in N_Entity); 6764 To_Flag_Word_Ptr 6765 (Union_Id_Ptr' 6766 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val; 6767 end Set_Flag91; 6768 6769 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is 6770 begin 6771 pragma Assert (not Locked); 6772 pragma Assert (Nkind (N) in N_Entity); 6773 To_Flag_Word_Ptr 6774 (Union_Id_Ptr' 6775 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val; 6776 end Set_Flag92; 6777 6778 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is 6779 begin 6780 pragma Assert (not Locked); 6781 pragma Assert (Nkind (N) in N_Entity); 6782 To_Flag_Word_Ptr 6783 (Union_Id_Ptr' 6784 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val; 6785 end Set_Flag93; 6786 6787 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is 6788 begin 6789 pragma Assert (not Locked); 6790 pragma Assert (Nkind (N) in N_Entity); 6791 To_Flag_Word_Ptr 6792 (Union_Id_Ptr' 6793 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val; 6794 end Set_Flag94; 6795 6796 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is 6797 begin 6798 pragma Assert (not Locked); 6799 pragma Assert (Nkind (N) in N_Entity); 6800 To_Flag_Word_Ptr 6801 (Union_Id_Ptr' 6802 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val; 6803 end Set_Flag95; 6804 6805 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is 6806 begin 6807 pragma Assert (not Locked); 6808 pragma Assert (Nkind (N) in N_Entity); 6809 To_Flag_Word_Ptr 6810 (Union_Id_Ptr' 6811 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val; 6812 end Set_Flag96; 6813 6814 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is 6815 begin 6816 pragma Assert (not Locked); 6817 pragma Assert (Nkind (N) in N_Entity); 6818 To_Flag_Word2_Ptr 6819 (Union_Id_Ptr' 6820 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val; 6821 end Set_Flag97; 6822 6823 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is 6824 begin 6825 pragma Assert (not Locked); 6826 pragma Assert (Nkind (N) in N_Entity); 6827 To_Flag_Word2_Ptr 6828 (Union_Id_Ptr' 6829 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val; 6830 end Set_Flag98; 6831 6832 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is 6833 begin 6834 pragma Assert (not Locked); 6835 pragma Assert (Nkind (N) in N_Entity); 6836 To_Flag_Word2_Ptr 6837 (Union_Id_Ptr' 6838 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val; 6839 end Set_Flag99; 6840 6841 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is 6842 begin 6843 pragma Assert (not Locked); 6844 pragma Assert (Nkind (N) in N_Entity); 6845 To_Flag_Word2_Ptr 6846 (Union_Id_Ptr' 6847 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val; 6848 end Set_Flag100; 6849 6850 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is 6851 begin 6852 pragma Assert (not Locked); 6853 pragma Assert (Nkind (N) in N_Entity); 6854 To_Flag_Word2_Ptr 6855 (Union_Id_Ptr' 6856 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val; 6857 end Set_Flag101; 6858 6859 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is 6860 begin 6861 pragma Assert (not Locked); 6862 pragma Assert (Nkind (N) in N_Entity); 6863 To_Flag_Word2_Ptr 6864 (Union_Id_Ptr' 6865 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val; 6866 end Set_Flag102; 6867 6868 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is 6869 begin 6870 pragma Assert (not Locked); 6871 pragma Assert (Nkind (N) in N_Entity); 6872 To_Flag_Word2_Ptr 6873 (Union_Id_Ptr' 6874 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val; 6875 end Set_Flag103; 6876 6877 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is 6878 begin 6879 pragma Assert (not Locked); 6880 pragma Assert (Nkind (N) in N_Entity); 6881 To_Flag_Word2_Ptr 6882 (Union_Id_Ptr' 6883 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val; 6884 end Set_Flag104; 6885 6886 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is 6887 begin 6888 pragma Assert (not Locked); 6889 pragma Assert (Nkind (N) in N_Entity); 6890 To_Flag_Word2_Ptr 6891 (Union_Id_Ptr' 6892 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val; 6893 end Set_Flag105; 6894 6895 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is 6896 begin 6897 pragma Assert (not Locked); 6898 pragma Assert (Nkind (N) in N_Entity); 6899 To_Flag_Word2_Ptr 6900 (Union_Id_Ptr' 6901 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val; 6902 end Set_Flag106; 6903 6904 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is 6905 begin 6906 pragma Assert (not Locked); 6907 pragma Assert (Nkind (N) in N_Entity); 6908 To_Flag_Word2_Ptr 6909 (Union_Id_Ptr' 6910 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val; 6911 end Set_Flag107; 6912 6913 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is 6914 begin 6915 pragma Assert (not Locked); 6916 pragma Assert (Nkind (N) in N_Entity); 6917 To_Flag_Word2_Ptr 6918 (Union_Id_Ptr' 6919 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val; 6920 end Set_Flag108; 6921 6922 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is 6923 begin 6924 pragma Assert (not Locked); 6925 pragma Assert (Nkind (N) in N_Entity); 6926 To_Flag_Word2_Ptr 6927 (Union_Id_Ptr' 6928 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val; 6929 end Set_Flag109; 6930 6931 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is 6932 begin 6933 pragma Assert (not Locked); 6934 pragma Assert (Nkind (N) in N_Entity); 6935 To_Flag_Word2_Ptr 6936 (Union_Id_Ptr' 6937 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val; 6938 end Set_Flag110; 6939 6940 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is 6941 begin 6942 pragma Assert (not Locked); 6943 pragma Assert (Nkind (N) in N_Entity); 6944 To_Flag_Word2_Ptr 6945 (Union_Id_Ptr' 6946 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val; 6947 end Set_Flag111; 6948 6949 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is 6950 begin 6951 pragma Assert (not Locked); 6952 pragma Assert (Nkind (N) in N_Entity); 6953 To_Flag_Word2_Ptr 6954 (Union_Id_Ptr' 6955 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val; 6956 end Set_Flag112; 6957 6958 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is 6959 begin 6960 pragma Assert (not Locked); 6961 pragma Assert (Nkind (N) in N_Entity); 6962 To_Flag_Word2_Ptr 6963 (Union_Id_Ptr' 6964 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val; 6965 end Set_Flag113; 6966 6967 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is 6968 begin 6969 pragma Assert (not Locked); 6970 pragma Assert (Nkind (N) in N_Entity); 6971 To_Flag_Word2_Ptr 6972 (Union_Id_Ptr' 6973 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val; 6974 end Set_Flag114; 6975 6976 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is 6977 begin 6978 pragma Assert (not Locked); 6979 pragma Assert (Nkind (N) in N_Entity); 6980 To_Flag_Word2_Ptr 6981 (Union_Id_Ptr' 6982 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val; 6983 end Set_Flag115; 6984 6985 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is 6986 begin 6987 pragma Assert (not Locked); 6988 pragma Assert (Nkind (N) in N_Entity); 6989 To_Flag_Word2_Ptr 6990 (Union_Id_Ptr' 6991 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val; 6992 end Set_Flag116; 6993 6994 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is 6995 begin 6996 pragma Assert (not Locked); 6997 pragma Assert (Nkind (N) in N_Entity); 6998 To_Flag_Word2_Ptr 6999 (Union_Id_Ptr' 7000 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val; 7001 end Set_Flag117; 7002 7003 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is 7004 begin 7005 pragma Assert (not Locked); 7006 pragma Assert (Nkind (N) in N_Entity); 7007 To_Flag_Word2_Ptr 7008 (Union_Id_Ptr' 7009 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val; 7010 end Set_Flag118; 7011 7012 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is 7013 begin 7014 pragma Assert (not Locked); 7015 pragma Assert (Nkind (N) in N_Entity); 7016 To_Flag_Word2_Ptr 7017 (Union_Id_Ptr' 7018 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val; 7019 end Set_Flag119; 7020 7021 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is 7022 begin 7023 pragma Assert (not Locked); 7024 pragma Assert (Nkind (N) in N_Entity); 7025 To_Flag_Word2_Ptr 7026 (Union_Id_Ptr' 7027 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val; 7028 end Set_Flag120; 7029 7030 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is 7031 begin 7032 pragma Assert (not Locked); 7033 pragma Assert (Nkind (N) in N_Entity); 7034 To_Flag_Word2_Ptr 7035 (Union_Id_Ptr' 7036 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val; 7037 end Set_Flag121; 7038 7039 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is 7040 begin 7041 pragma Assert (not Locked); 7042 pragma Assert (Nkind (N) in N_Entity); 7043 To_Flag_Word2_Ptr 7044 (Union_Id_Ptr' 7045 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val; 7046 end Set_Flag122; 7047 7048 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is 7049 begin 7050 pragma Assert (not Locked); 7051 pragma Assert (Nkind (N) in N_Entity); 7052 To_Flag_Word2_Ptr 7053 (Union_Id_Ptr' 7054 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val; 7055 end Set_Flag123; 7056 7057 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is 7058 begin 7059 pragma Assert (not Locked); 7060 pragma Assert (Nkind (N) in N_Entity); 7061 To_Flag_Word2_Ptr 7062 (Union_Id_Ptr' 7063 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val; 7064 end Set_Flag124; 7065 7066 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is 7067 begin 7068 pragma Assert (not Locked); 7069 pragma Assert (Nkind (N) in N_Entity); 7070 To_Flag_Word2_Ptr 7071 (Union_Id_Ptr' 7072 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val; 7073 end Set_Flag125; 7074 7075 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is 7076 begin 7077 pragma Assert (not Locked); 7078 pragma Assert (Nkind (N) in N_Entity); 7079 To_Flag_Word2_Ptr 7080 (Union_Id_Ptr' 7081 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val; 7082 end Set_Flag126; 7083 7084 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is 7085 begin 7086 pragma Assert (not Locked); 7087 pragma Assert (Nkind (N) in N_Entity); 7088 To_Flag_Word2_Ptr 7089 (Union_Id_Ptr' 7090 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val; 7091 end Set_Flag127; 7092 7093 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is 7094 begin 7095 pragma Assert (not Locked); 7096 pragma Assert (Nkind (N) in N_Entity); 7097 To_Flag_Word2_Ptr 7098 (Union_Id_Ptr' 7099 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val; 7100 end Set_Flag128; 7101 7102 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is 7103 begin 7104 pragma Assert (not Locked); 7105 pragma Assert (Nkind (N) in N_Entity); 7106 Nodes.Table (N + 3).In_List := Val; 7107 end Set_Flag129; 7108 7109 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is 7110 begin 7111 pragma Assert (not Locked); 7112 pragma Assert (Nkind (N) in N_Entity); 7113 Nodes.Table (N + 3).Has_Aspects := Val; 7114 end Set_Flag130; 7115 7116 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is 7117 begin 7118 pragma Assert (not Locked); 7119 pragma Assert (Nkind (N) in N_Entity); 7120 Nodes.Table (N + 3).Rewrite_Ins := Val; 7121 end Set_Flag131; 7122 7123 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is 7124 begin 7125 pragma Assert (not Locked); 7126 pragma Assert (Nkind (N) in N_Entity); 7127 Nodes.Table (N + 3).Analyzed := Val; 7128 end Set_Flag132; 7129 7130 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is 7131 begin 7132 pragma Assert (not Locked); 7133 pragma Assert (Nkind (N) in N_Entity); 7134 Nodes.Table (N + 3).Comes_From_Source := Val; 7135 end Set_Flag133; 7136 7137 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is 7138 begin 7139 pragma Assert (not Locked); 7140 pragma Assert (Nkind (N) in N_Entity); 7141 Nodes.Table (N + 3).Error_Posted := Val; 7142 end Set_Flag134; 7143 7144 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is 7145 begin 7146 pragma Assert (not Locked); 7147 pragma Assert (Nkind (N) in N_Entity); 7148 Nodes.Table (N + 3).Flag4 := Val; 7149 end Set_Flag135; 7150 7151 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is 7152 begin 7153 pragma Assert (not Locked); 7154 pragma Assert (Nkind (N) in N_Entity); 7155 Nodes.Table (N + 3).Flag5 := Val; 7156 end Set_Flag136; 7157 7158 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is 7159 begin 7160 pragma Assert (not Locked); 7161 pragma Assert (Nkind (N) in N_Entity); 7162 Nodes.Table (N + 3).Flag6 := Val; 7163 end Set_Flag137; 7164 7165 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is 7166 begin 7167 pragma Assert (not Locked); 7168 pragma Assert (Nkind (N) in N_Entity); 7169 Nodes.Table (N + 3).Flag7 := Val; 7170 end Set_Flag138; 7171 7172 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is 7173 begin 7174 pragma Assert (not Locked); 7175 pragma Assert (Nkind (N) in N_Entity); 7176 Nodes.Table (N + 3).Flag8 := Val; 7177 end Set_Flag139; 7178 7179 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is 7180 begin 7181 pragma Assert (not Locked); 7182 pragma Assert (Nkind (N) in N_Entity); 7183 Nodes.Table (N + 3).Flag9 := Val; 7184 end Set_Flag140; 7185 7186 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is 7187 begin 7188 pragma Assert (not Locked); 7189 pragma Assert (Nkind (N) in N_Entity); 7190 Nodes.Table (N + 3).Flag10 := Val; 7191 end Set_Flag141; 7192 7193 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is 7194 begin 7195 pragma Assert (not Locked); 7196 pragma Assert (Nkind (N) in N_Entity); 7197 Nodes.Table (N + 3).Flag11 := Val; 7198 end Set_Flag142; 7199 7200 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is 7201 begin 7202 pragma Assert (not Locked); 7203 pragma Assert (Nkind (N) in N_Entity); 7204 Nodes.Table (N + 3).Flag12 := Val; 7205 end Set_Flag143; 7206 7207 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is 7208 begin 7209 pragma Assert (not Locked); 7210 pragma Assert (Nkind (N) in N_Entity); 7211 Nodes.Table (N + 3).Flag13 := Val; 7212 end Set_Flag144; 7213 7214 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is 7215 begin 7216 pragma Assert (not Locked); 7217 pragma Assert (Nkind (N) in N_Entity); 7218 Nodes.Table (N + 3).Flag14 := Val; 7219 end Set_Flag145; 7220 7221 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is 7222 begin 7223 pragma Assert (not Locked); 7224 pragma Assert (Nkind (N) in N_Entity); 7225 Nodes.Table (N + 3).Flag15 := Val; 7226 end Set_Flag146; 7227 7228 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is 7229 begin 7230 pragma Assert (not Locked); 7231 pragma Assert (Nkind (N) in N_Entity); 7232 Nodes.Table (N + 3).Flag16 := Val; 7233 end Set_Flag147; 7234 7235 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is 7236 begin 7237 pragma Assert (not Locked); 7238 pragma Assert (Nkind (N) in N_Entity); 7239 Nodes.Table (N + 3).Flag17 := Val; 7240 end Set_Flag148; 7241 7242 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is 7243 begin 7244 pragma Assert (not Locked); 7245 pragma Assert (Nkind (N) in N_Entity); 7246 Nodes.Table (N + 3).Flag18 := Val; 7247 end Set_Flag149; 7248 7249 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is 7250 begin 7251 pragma Assert (not Locked); 7252 pragma Assert (Nkind (N) in N_Entity); 7253 Nodes.Table (N + 3).Pflag1 := Val; 7254 end Set_Flag150; 7255 7256 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is 7257 begin 7258 pragma Assert (not Locked); 7259 pragma Assert (Nkind (N) in N_Entity); 7260 Nodes.Table (N + 3).Pflag2 := Val; 7261 end Set_Flag151; 7262 7263 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is 7264 begin 7265 pragma Assert (not Locked); 7266 pragma Assert (Nkind (N) in N_Entity); 7267 To_Flag_Word3_Ptr 7268 (Union_Id_Ptr' 7269 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val; 7270 end Set_Flag152; 7271 7272 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is 7273 begin 7274 pragma Assert (not Locked); 7275 pragma Assert (Nkind (N) in N_Entity); 7276 To_Flag_Word3_Ptr 7277 (Union_Id_Ptr' 7278 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val; 7279 end Set_Flag153; 7280 7281 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is 7282 begin 7283 pragma Assert (not Locked); 7284 pragma Assert (Nkind (N) in N_Entity); 7285 To_Flag_Word3_Ptr 7286 (Union_Id_Ptr' 7287 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val; 7288 end Set_Flag154; 7289 7290 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is 7291 begin 7292 pragma Assert (not Locked); 7293 pragma Assert (Nkind (N) in N_Entity); 7294 To_Flag_Word3_Ptr 7295 (Union_Id_Ptr' 7296 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val; 7297 end Set_Flag155; 7298 7299 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is 7300 begin 7301 pragma Assert (not Locked); 7302 pragma Assert (Nkind (N) in N_Entity); 7303 To_Flag_Word3_Ptr 7304 (Union_Id_Ptr' 7305 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val; 7306 end Set_Flag156; 7307 7308 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is 7309 begin 7310 pragma Assert (not Locked); 7311 pragma Assert (Nkind (N) in N_Entity); 7312 To_Flag_Word3_Ptr 7313 (Union_Id_Ptr' 7314 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val; 7315 end Set_Flag157; 7316 7317 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is 7318 begin 7319 pragma Assert (not Locked); 7320 pragma Assert (Nkind (N) in N_Entity); 7321 To_Flag_Word3_Ptr 7322 (Union_Id_Ptr' 7323 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val; 7324 end Set_Flag158; 7325 7326 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is 7327 begin 7328 pragma Assert (not Locked); 7329 pragma Assert (Nkind (N) in N_Entity); 7330 To_Flag_Word3_Ptr 7331 (Union_Id_Ptr' 7332 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val; 7333 end Set_Flag159; 7334 7335 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is 7336 begin 7337 pragma Assert (not Locked); 7338 pragma Assert (Nkind (N) in N_Entity); 7339 To_Flag_Word3_Ptr 7340 (Union_Id_Ptr' 7341 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val; 7342 end Set_Flag160; 7343 7344 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is 7345 begin 7346 pragma Assert (not Locked); 7347 pragma Assert (Nkind (N) in N_Entity); 7348 To_Flag_Word3_Ptr 7349 (Union_Id_Ptr' 7350 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val; 7351 end Set_Flag161; 7352 7353 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is 7354 begin 7355 pragma Assert (not Locked); 7356 pragma Assert (Nkind (N) in N_Entity); 7357 To_Flag_Word3_Ptr 7358 (Union_Id_Ptr' 7359 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val; 7360 end Set_Flag162; 7361 7362 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is 7363 begin 7364 pragma Assert (not Locked); 7365 pragma Assert (Nkind (N) in N_Entity); 7366 To_Flag_Word3_Ptr 7367 (Union_Id_Ptr' 7368 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val; 7369 end Set_Flag163; 7370 7371 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is 7372 begin 7373 pragma Assert (not Locked); 7374 pragma Assert (Nkind (N) in N_Entity); 7375 To_Flag_Word3_Ptr 7376 (Union_Id_Ptr' 7377 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val; 7378 end Set_Flag164; 7379 7380 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is 7381 begin 7382 pragma Assert (not Locked); 7383 pragma Assert (Nkind (N) in N_Entity); 7384 To_Flag_Word3_Ptr 7385 (Union_Id_Ptr' 7386 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val; 7387 end Set_Flag165; 7388 7389 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is 7390 begin 7391 pragma Assert (not Locked); 7392 pragma Assert (Nkind (N) in N_Entity); 7393 To_Flag_Word3_Ptr 7394 (Union_Id_Ptr' 7395 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val; 7396 end Set_Flag166; 7397 7398 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is 7399 begin 7400 pragma Assert (not Locked); 7401 pragma Assert (Nkind (N) in N_Entity); 7402 To_Flag_Word3_Ptr 7403 (Union_Id_Ptr' 7404 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val; 7405 end Set_Flag167; 7406 7407 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is 7408 begin 7409 pragma Assert (not Locked); 7410 pragma Assert (Nkind (N) in N_Entity); 7411 To_Flag_Word3_Ptr 7412 (Union_Id_Ptr' 7413 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val; 7414 end Set_Flag168; 7415 7416 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is 7417 begin 7418 pragma Assert (not Locked); 7419 pragma Assert (Nkind (N) in N_Entity); 7420 To_Flag_Word3_Ptr 7421 (Union_Id_Ptr' 7422 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val; 7423 end Set_Flag169; 7424 7425 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is 7426 begin 7427 pragma Assert (not Locked); 7428 pragma Assert (Nkind (N) in N_Entity); 7429 To_Flag_Word3_Ptr 7430 (Union_Id_Ptr' 7431 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val; 7432 end Set_Flag170; 7433 7434 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is 7435 begin 7436 pragma Assert (not Locked); 7437 pragma Assert (Nkind (N) in N_Entity); 7438 To_Flag_Word3_Ptr 7439 (Union_Id_Ptr' 7440 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val; 7441 end Set_Flag171; 7442 7443 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is 7444 begin 7445 pragma Assert (not Locked); 7446 pragma Assert (Nkind (N) in N_Entity); 7447 To_Flag_Word3_Ptr 7448 (Union_Id_Ptr' 7449 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val; 7450 end Set_Flag172; 7451 7452 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is 7453 begin 7454 pragma Assert (not Locked); 7455 pragma Assert (Nkind (N) in N_Entity); 7456 To_Flag_Word3_Ptr 7457 (Union_Id_Ptr' 7458 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val; 7459 end Set_Flag173; 7460 7461 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is 7462 begin 7463 pragma Assert (not Locked); 7464 pragma Assert (Nkind (N) in N_Entity); 7465 To_Flag_Word3_Ptr 7466 (Union_Id_Ptr' 7467 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val; 7468 end Set_Flag174; 7469 7470 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is 7471 begin 7472 pragma Assert (not Locked); 7473 pragma Assert (Nkind (N) in N_Entity); 7474 To_Flag_Word3_Ptr 7475 (Union_Id_Ptr' 7476 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val; 7477 end Set_Flag175; 7478 7479 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is 7480 begin 7481 pragma Assert (not Locked); 7482 pragma Assert (Nkind (N) in N_Entity); 7483 To_Flag_Word3_Ptr 7484 (Union_Id_Ptr' 7485 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val; 7486 end Set_Flag176; 7487 7488 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is 7489 begin 7490 pragma Assert (not Locked); 7491 pragma Assert (Nkind (N) in N_Entity); 7492 To_Flag_Word3_Ptr 7493 (Union_Id_Ptr' 7494 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val; 7495 end Set_Flag177; 7496 7497 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is 7498 begin 7499 pragma Assert (not Locked); 7500 pragma Assert (Nkind (N) in N_Entity); 7501 To_Flag_Word3_Ptr 7502 (Union_Id_Ptr' 7503 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val; 7504 end Set_Flag178; 7505 7506 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is 7507 begin 7508 pragma Assert (not Locked); 7509 pragma Assert (Nkind (N) in N_Entity); 7510 To_Flag_Word3_Ptr 7511 (Union_Id_Ptr' 7512 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val; 7513 end Set_Flag179; 7514 7515 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is 7516 begin 7517 pragma Assert (not Locked); 7518 pragma Assert (Nkind (N) in N_Entity); 7519 To_Flag_Word3_Ptr 7520 (Union_Id_Ptr' 7521 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val; 7522 end Set_Flag180; 7523 7524 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is 7525 begin 7526 pragma Assert (not Locked); 7527 pragma Assert (Nkind (N) in N_Entity); 7528 To_Flag_Word3_Ptr 7529 (Union_Id_Ptr' 7530 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val; 7531 end Set_Flag181; 7532 7533 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is 7534 begin 7535 pragma Assert (not Locked); 7536 pragma Assert (Nkind (N) in N_Entity); 7537 To_Flag_Word3_Ptr 7538 (Union_Id_Ptr' 7539 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val; 7540 end Set_Flag182; 7541 7542 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is 7543 begin 7544 pragma Assert (not Locked); 7545 pragma Assert (Nkind (N) in N_Entity); 7546 To_Flag_Word3_Ptr 7547 (Union_Id_Ptr' 7548 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val; 7549 end Set_Flag183; 7550 7551 procedure Set_Flag184 (N : Node_Id; Val : Boolean) is 7552 begin 7553 pragma Assert (not Locked); 7554 pragma Assert (Nkind (N) in N_Entity); 7555 To_Flag_Word4_Ptr 7556 (Union_Id_Ptr' 7557 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag184 := Val; 7558 end Set_Flag184; 7559 7560 procedure Set_Flag185 (N : Node_Id; Val : Boolean) is 7561 begin 7562 pragma Assert (not Locked); 7563 pragma Assert (Nkind (N) in N_Entity); 7564 To_Flag_Word4_Ptr 7565 (Union_Id_Ptr' 7566 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag185 := Val; 7567 end Set_Flag185; 7568 7569 procedure Set_Flag186 (N : Node_Id; Val : Boolean) is 7570 begin 7571 pragma Assert (not Locked); 7572 pragma Assert (Nkind (N) in N_Entity); 7573 To_Flag_Word4_Ptr 7574 (Union_Id_Ptr' 7575 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag186 := Val; 7576 end Set_Flag186; 7577 7578 procedure Set_Flag187 (N : Node_Id; Val : Boolean) is 7579 begin 7580 pragma Assert (not Locked); 7581 pragma Assert (Nkind (N) in N_Entity); 7582 To_Flag_Word4_Ptr 7583 (Union_Id_Ptr' 7584 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag187 := Val; 7585 end Set_Flag187; 7586 7587 procedure Set_Flag188 (N : Node_Id; Val : Boolean) is 7588 begin 7589 pragma Assert (not Locked); 7590 pragma Assert (Nkind (N) in N_Entity); 7591 To_Flag_Word4_Ptr 7592 (Union_Id_Ptr' 7593 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag188 := Val; 7594 end Set_Flag188; 7595 7596 procedure Set_Flag189 (N : Node_Id; Val : Boolean) is 7597 begin 7598 pragma Assert (not Locked); 7599 pragma Assert (Nkind (N) in N_Entity); 7600 To_Flag_Word4_Ptr 7601 (Union_Id_Ptr' 7602 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag189 := Val; 7603 end Set_Flag189; 7604 7605 procedure Set_Flag190 (N : Node_Id; Val : Boolean) is 7606 begin 7607 pragma Assert (not Locked); 7608 pragma Assert (Nkind (N) in N_Entity); 7609 To_Flag_Word4_Ptr 7610 (Union_Id_Ptr' 7611 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag190 := Val; 7612 end Set_Flag190; 7613 7614 procedure Set_Flag191 (N : Node_Id; Val : Boolean) is 7615 begin 7616 pragma Assert (not Locked); 7617 pragma Assert (Nkind (N) in N_Entity); 7618 To_Flag_Word4_Ptr 7619 (Union_Id_Ptr' 7620 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag191 := Val; 7621 end Set_Flag191; 7622 7623 procedure Set_Flag192 (N : Node_Id; Val : Boolean) is 7624 begin 7625 pragma Assert (not Locked); 7626 pragma Assert (Nkind (N) in N_Entity); 7627 To_Flag_Word4_Ptr 7628 (Union_Id_Ptr' 7629 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag192 := Val; 7630 end Set_Flag192; 7631 7632 procedure Set_Flag193 (N : Node_Id; Val : Boolean) is 7633 begin 7634 pragma Assert (not Locked); 7635 pragma Assert (Nkind (N) in N_Entity); 7636 To_Flag_Word4_Ptr 7637 (Union_Id_Ptr' 7638 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag193 := Val; 7639 end Set_Flag193; 7640 7641 procedure Set_Flag194 (N : Node_Id; Val : Boolean) is 7642 begin 7643 pragma Assert (not Locked); 7644 pragma Assert (Nkind (N) in N_Entity); 7645 To_Flag_Word4_Ptr 7646 (Union_Id_Ptr' 7647 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag194 := Val; 7648 end Set_Flag194; 7649 7650 procedure Set_Flag195 (N : Node_Id; Val : Boolean) is 7651 begin 7652 pragma Assert (not Locked); 7653 pragma Assert (Nkind (N) in N_Entity); 7654 To_Flag_Word4_Ptr 7655 (Union_Id_Ptr' 7656 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag195 := Val; 7657 end Set_Flag195; 7658 7659 procedure Set_Flag196 (N : Node_Id; Val : Boolean) is 7660 begin 7661 pragma Assert (not Locked); 7662 pragma Assert (Nkind (N) in N_Entity); 7663 To_Flag_Word4_Ptr 7664 (Union_Id_Ptr' 7665 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag196 := Val; 7666 end Set_Flag196; 7667 7668 procedure Set_Flag197 (N : Node_Id; Val : Boolean) is 7669 begin 7670 pragma Assert (not Locked); 7671 pragma Assert (Nkind (N) in N_Entity); 7672 To_Flag_Word4_Ptr 7673 (Union_Id_Ptr' 7674 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag197 := Val; 7675 end Set_Flag197; 7676 7677 procedure Set_Flag198 (N : Node_Id; Val : Boolean) is 7678 begin 7679 pragma Assert (not Locked); 7680 pragma Assert (Nkind (N) in N_Entity); 7681 To_Flag_Word4_Ptr 7682 (Union_Id_Ptr' 7683 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag198 := Val; 7684 end Set_Flag198; 7685 7686 procedure Set_Flag199 (N : Node_Id; Val : Boolean) is 7687 begin 7688 pragma Assert (not Locked); 7689 pragma Assert (Nkind (N) in N_Entity); 7690 To_Flag_Word4_Ptr 7691 (Union_Id_Ptr' 7692 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag199 := Val; 7693 end Set_Flag199; 7694 7695 procedure Set_Flag200 (N : Node_Id; Val : Boolean) is 7696 begin 7697 pragma Assert (not Locked); 7698 pragma Assert (Nkind (N) in N_Entity); 7699 To_Flag_Word4_Ptr 7700 (Union_Id_Ptr' 7701 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag200 := Val; 7702 end Set_Flag200; 7703 7704 procedure Set_Flag201 (N : Node_Id; Val : Boolean) is 7705 begin 7706 pragma Assert (not Locked); 7707 pragma Assert (Nkind (N) in N_Entity); 7708 To_Flag_Word4_Ptr 7709 (Union_Id_Ptr' 7710 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag201 := Val; 7711 end Set_Flag201; 7712 7713 procedure Set_Flag202 (N : Node_Id; Val : Boolean) is 7714 begin 7715 pragma Assert (not Locked); 7716 pragma Assert (Nkind (N) in N_Entity); 7717 To_Flag_Word4_Ptr 7718 (Union_Id_Ptr' 7719 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag202 := Val; 7720 end Set_Flag202; 7721 7722 procedure Set_Flag203 (N : Node_Id; Val : Boolean) is 7723 begin 7724 pragma Assert (not Locked); 7725 pragma Assert (Nkind (N) in N_Entity); 7726 To_Flag_Word4_Ptr 7727 (Union_Id_Ptr' 7728 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag203 := Val; 7729 end Set_Flag203; 7730 7731 procedure Set_Flag204 (N : Node_Id; Val : Boolean) is 7732 begin 7733 pragma Assert (not Locked); 7734 pragma Assert (Nkind (N) in N_Entity); 7735 To_Flag_Word4_Ptr 7736 (Union_Id_Ptr' 7737 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag204 := Val; 7738 end Set_Flag204; 7739 7740 procedure Set_Flag205 (N : Node_Id; Val : Boolean) is 7741 begin 7742 pragma Assert (not Locked); 7743 pragma Assert (Nkind (N) in N_Entity); 7744 To_Flag_Word4_Ptr 7745 (Union_Id_Ptr' 7746 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag205 := Val; 7747 end Set_Flag205; 7748 7749 procedure Set_Flag206 (N : Node_Id; Val : Boolean) is 7750 begin 7751 pragma Assert (not Locked); 7752 pragma Assert (Nkind (N) in N_Entity); 7753 To_Flag_Word4_Ptr 7754 (Union_Id_Ptr' 7755 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag206 := Val; 7756 end Set_Flag206; 7757 7758 procedure Set_Flag207 (N : Node_Id; Val : Boolean) is 7759 begin 7760 pragma Assert (not Locked); 7761 pragma Assert (Nkind (N) in N_Entity); 7762 To_Flag_Word4_Ptr 7763 (Union_Id_Ptr' 7764 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag207 := Val; 7765 end Set_Flag207; 7766 7767 procedure Set_Flag208 (N : Node_Id; Val : Boolean) is 7768 begin 7769 pragma Assert (not Locked); 7770 pragma Assert (Nkind (N) in N_Entity); 7771 To_Flag_Word4_Ptr 7772 (Union_Id_Ptr' 7773 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag208 := Val; 7774 end Set_Flag208; 7775 7776 procedure Set_Flag209 (N : Node_Id; Val : Boolean) is 7777 begin 7778 pragma Assert (not Locked); 7779 pragma Assert (Nkind (N) in N_Entity); 7780 To_Flag_Word4_Ptr 7781 (Union_Id_Ptr' 7782 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag209 := Val; 7783 end Set_Flag209; 7784 7785 procedure Set_Flag210 (N : Node_Id; Val : Boolean) is 7786 begin 7787 pragma Assert (not Locked); 7788 pragma Assert (Nkind (N) in N_Entity); 7789 To_Flag_Word4_Ptr 7790 (Union_Id_Ptr' 7791 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag210 := Val; 7792 end Set_Flag210; 7793 7794 procedure Set_Flag211 (N : Node_Id; Val : Boolean) is 7795 begin 7796 pragma Assert (not Locked); 7797 pragma Assert (Nkind (N) in N_Entity); 7798 To_Flag_Word4_Ptr 7799 (Union_Id_Ptr' 7800 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag211 := Val; 7801 end Set_Flag211; 7802 7803 procedure Set_Flag212 (N : Node_Id; Val : Boolean) is 7804 begin 7805 pragma Assert (not Locked); 7806 pragma Assert (Nkind (N) in N_Entity); 7807 To_Flag_Word4_Ptr 7808 (Union_Id_Ptr' 7809 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag212 := Val; 7810 end Set_Flag212; 7811 7812 procedure Set_Flag213 (N : Node_Id; Val : Boolean) is 7813 begin 7814 pragma Assert (not Locked); 7815 pragma Assert (Nkind (N) in N_Entity); 7816 To_Flag_Word4_Ptr 7817 (Union_Id_Ptr' 7818 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag213 := Val; 7819 end Set_Flag213; 7820 7821 procedure Set_Flag214 (N : Node_Id; Val : Boolean) is 7822 begin 7823 pragma Assert (not Locked); 7824 pragma Assert (Nkind (N) in N_Entity); 7825 To_Flag_Word4_Ptr 7826 (Union_Id_Ptr' 7827 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag214 := Val; 7828 end Set_Flag214; 7829 7830 procedure Set_Flag215 (N : Node_Id; Val : Boolean) is 7831 begin 7832 pragma Assert (not Locked); 7833 pragma Assert (Nkind (N) in N_Entity); 7834 To_Flag_Word4_Ptr 7835 (Union_Id_Ptr' 7836 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag215 := Val; 7837 end Set_Flag215; 7838 7839 procedure Set_Flag216 (N : Node_Id; Val : Boolean) is 7840 begin 7841 pragma Assert (not Locked); 7842 pragma Assert (Nkind (N) in N_Entity); 7843 Nodes.Table (N + 4).In_List := Val; 7844 end Set_Flag216; 7845 7846 procedure Set_Flag217 (N : Node_Id; Val : Boolean) is 7847 begin 7848 pragma Assert (not Locked); 7849 pragma Assert (Nkind (N) in N_Entity); 7850 Nodes.Table (N + 4).Has_Aspects := Val; 7851 end Set_Flag217; 7852 7853 procedure Set_Flag218 (N : Node_Id; Val : Boolean) is 7854 begin 7855 pragma Assert (not Locked); 7856 pragma Assert (Nkind (N) in N_Entity); 7857 Nodes.Table (N + 4).Rewrite_Ins := Val; 7858 end Set_Flag218; 7859 7860 procedure Set_Flag219 (N : Node_Id; Val : Boolean) is 7861 begin 7862 pragma Assert (not Locked); 7863 pragma Assert (Nkind (N) in N_Entity); 7864 Nodes.Table (N + 4).Analyzed := Val; 7865 end Set_Flag219; 7866 7867 procedure Set_Flag220 (N : Node_Id; Val : Boolean) is 7868 begin 7869 pragma Assert (not Locked); 7870 pragma Assert (Nkind (N) in N_Entity); 7871 Nodes.Table (N + 4).Comes_From_Source := Val; 7872 end Set_Flag220; 7873 7874 procedure Set_Flag221 (N : Node_Id; Val : Boolean) is 7875 begin 7876 pragma Assert (not Locked); 7877 pragma Assert (Nkind (N) in N_Entity); 7878 Nodes.Table (N + 4).Error_Posted := Val; 7879 end Set_Flag221; 7880 7881 procedure Set_Flag222 (N : Node_Id; Val : Boolean) is 7882 begin 7883 pragma Assert (not Locked); 7884 pragma Assert (Nkind (N) in N_Entity); 7885 Nodes.Table (N + 4).Flag4 := Val; 7886 end Set_Flag222; 7887 7888 procedure Set_Flag223 (N : Node_Id; Val : Boolean) is 7889 begin 7890 pragma Assert (not Locked); 7891 pragma Assert (Nkind (N) in N_Entity); 7892 Nodes.Table (N + 4).Flag5 := Val; 7893 end Set_Flag223; 7894 7895 procedure Set_Flag224 (N : Node_Id; Val : Boolean) is 7896 begin 7897 pragma Assert (not Locked); 7898 pragma Assert (Nkind (N) in N_Entity); 7899 Nodes.Table (N + 4).Flag6 := Val; 7900 end Set_Flag224; 7901 7902 procedure Set_Flag225 (N : Node_Id; Val : Boolean) is 7903 begin 7904 pragma Assert (not Locked); 7905 pragma Assert (Nkind (N) in N_Entity); 7906 Nodes.Table (N + 4).Flag7 := Val; 7907 end Set_Flag225; 7908 7909 procedure Set_Flag226 (N : Node_Id; Val : Boolean) is 7910 begin 7911 pragma Assert (not Locked); 7912 pragma Assert (Nkind (N) in N_Entity); 7913 Nodes.Table (N + 4).Flag8 := Val; 7914 end Set_Flag226; 7915 7916 procedure Set_Flag227 (N : Node_Id; Val : Boolean) is 7917 begin 7918 pragma Assert (not Locked); 7919 pragma Assert (Nkind (N) in N_Entity); 7920 Nodes.Table (N + 4).Flag9 := Val; 7921 end Set_Flag227; 7922 7923 procedure Set_Flag228 (N : Node_Id; Val : Boolean) is 7924 begin 7925 pragma Assert (not Locked); 7926 pragma Assert (Nkind (N) in N_Entity); 7927 Nodes.Table (N + 4).Flag10 := Val; 7928 end Set_Flag228; 7929 7930 procedure Set_Flag229 (N : Node_Id; Val : Boolean) is 7931 begin 7932 pragma Assert (not Locked); 7933 pragma Assert (Nkind (N) in N_Entity); 7934 Nodes.Table (N + 4).Flag11 := Val; 7935 end Set_Flag229; 7936 7937 procedure Set_Flag230 (N : Node_Id; Val : Boolean) is 7938 begin 7939 pragma Assert (not Locked); 7940 pragma Assert (Nkind (N) in N_Entity); 7941 Nodes.Table (N + 4).Flag12 := Val; 7942 end Set_Flag230; 7943 7944 procedure Set_Flag231 (N : Node_Id; Val : Boolean) is 7945 begin 7946 pragma Assert (not Locked); 7947 pragma Assert (Nkind (N) in N_Entity); 7948 Nodes.Table (N + 4).Flag13 := Val; 7949 end Set_Flag231; 7950 7951 procedure Set_Flag232 (N : Node_Id; Val : Boolean) is 7952 begin 7953 pragma Assert (not Locked); 7954 pragma Assert (Nkind (N) in N_Entity); 7955 Nodes.Table (N + 4).Flag14 := Val; 7956 end Set_Flag232; 7957 7958 procedure Set_Flag233 (N : Node_Id; Val : Boolean) is 7959 begin 7960 pragma Assert (not Locked); 7961 pragma Assert (Nkind (N) in N_Entity); 7962 Nodes.Table (N + 4).Flag15 := Val; 7963 end Set_Flag233; 7964 7965 procedure Set_Flag234 (N : Node_Id; Val : Boolean) is 7966 begin 7967 pragma Assert (not Locked); 7968 pragma Assert (Nkind (N) in N_Entity); 7969 Nodes.Table (N + 4).Flag16 := Val; 7970 end Set_Flag234; 7971 7972 procedure Set_Flag235 (N : Node_Id; Val : Boolean) is 7973 begin 7974 pragma Assert (not Locked); 7975 pragma Assert (Nkind (N) in N_Entity); 7976 Nodes.Table (N + 4).Flag17 := Val; 7977 end Set_Flag235; 7978 7979 procedure Set_Flag236 (N : Node_Id; Val : Boolean) is 7980 begin 7981 pragma Assert (not Locked); 7982 pragma Assert (Nkind (N) in N_Entity); 7983 Nodes.Table (N + 4).Flag18 := Val; 7984 end Set_Flag236; 7985 7986 procedure Set_Flag237 (N : Node_Id; Val : Boolean) is 7987 begin 7988 pragma Assert (not Locked); 7989 pragma Assert (Nkind (N) in N_Entity); 7990 Nodes.Table (N + 4).Pflag1 := Val; 7991 end Set_Flag237; 7992 7993 procedure Set_Flag238 (N : Node_Id; Val : Boolean) is 7994 begin 7995 pragma Assert (not Locked); 7996 pragma Assert (Nkind (N) in N_Entity); 7997 Nodes.Table (N + 4).Pflag2 := Val; 7998 end Set_Flag238; 7999 8000 procedure Set_Flag239 (N : Node_Id; Val : Boolean) is 8001 begin 8002 pragma Assert (not Locked); 8003 pragma Assert (Nkind (N) in N_Entity); 8004 To_Flag_Byte2_Ptr 8005 (Node_Kind_Ptr' 8006 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag239 := Val; 8007 end Set_Flag239; 8008 8009 procedure Set_Flag240 (N : Node_Id; Val : Boolean) is 8010 begin 8011 pragma Assert (not Locked); 8012 pragma Assert (Nkind (N) in N_Entity); 8013 To_Flag_Byte2_Ptr 8014 (Node_Kind_Ptr' 8015 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag240 := Val; 8016 end Set_Flag240; 8017 8018 procedure Set_Flag241 (N : Node_Id; Val : Boolean) is 8019 begin 8020 pragma Assert (not Locked); 8021 pragma Assert (Nkind (N) in N_Entity); 8022 To_Flag_Byte2_Ptr 8023 (Node_Kind_Ptr' 8024 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag241 := Val; 8025 end Set_Flag241; 8026 8027 procedure Set_Flag242 (N : Node_Id; Val : Boolean) is 8028 begin 8029 pragma Assert (not Locked); 8030 pragma Assert (Nkind (N) in N_Entity); 8031 To_Flag_Byte2_Ptr 8032 (Node_Kind_Ptr' 8033 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag242 := Val; 8034 end Set_Flag242; 8035 8036 procedure Set_Flag243 (N : Node_Id; Val : Boolean) is 8037 begin 8038 pragma Assert (not Locked); 8039 pragma Assert (Nkind (N) in N_Entity); 8040 To_Flag_Byte2_Ptr 8041 (Node_Kind_Ptr' 8042 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag243 := Val; 8043 end Set_Flag243; 8044 8045 procedure Set_Flag244 (N : Node_Id; Val : Boolean) is 8046 begin 8047 pragma Assert (not Locked); 8048 pragma Assert (Nkind (N) in N_Entity); 8049 To_Flag_Byte2_Ptr 8050 (Node_Kind_Ptr' 8051 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag244 := Val; 8052 end Set_Flag244; 8053 8054 procedure Set_Flag245 (N : Node_Id; Val : Boolean) is 8055 begin 8056 pragma Assert (not Locked); 8057 pragma Assert (Nkind (N) in N_Entity); 8058 To_Flag_Byte2_Ptr 8059 (Node_Kind_Ptr' 8060 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag245 := Val; 8061 end Set_Flag245; 8062 8063 procedure Set_Flag246 (N : Node_Id; Val : Boolean) is 8064 begin 8065 pragma Assert (not Locked); 8066 pragma Assert (Nkind (N) in N_Entity); 8067 To_Flag_Byte2_Ptr 8068 (Node_Kind_Ptr' 8069 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag246 := Val; 8070 end Set_Flag246; 8071 8072 procedure Set_Flag247 (N : Node_Id; Val : Boolean) is 8073 begin 8074 pragma Assert (not Locked); 8075 pragma Assert (Nkind (N) in N_Entity); 8076 To_Flag_Byte3_Ptr 8077 (Node_Kind_Ptr' 8078 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag247 := Val; 8079 end Set_Flag247; 8080 8081 procedure Set_Flag248 (N : Node_Id; Val : Boolean) is 8082 begin 8083 pragma Assert (not Locked); 8084 pragma Assert (Nkind (N) in N_Entity); 8085 To_Flag_Byte3_Ptr 8086 (Node_Kind_Ptr' 8087 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag248 := Val; 8088 end Set_Flag248; 8089 8090 procedure Set_Flag249 (N : Node_Id; Val : Boolean) is 8091 begin 8092 pragma Assert (not Locked); 8093 pragma Assert (Nkind (N) in N_Entity); 8094 To_Flag_Byte3_Ptr 8095 (Node_Kind_Ptr' 8096 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag249 := Val; 8097 end Set_Flag249; 8098 8099 procedure Set_Flag250 (N : Node_Id; Val : Boolean) is 8100 begin 8101 pragma Assert (not Locked); 8102 pragma Assert (Nkind (N) in N_Entity); 8103 To_Flag_Byte3_Ptr 8104 (Node_Kind_Ptr' 8105 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag250 := Val; 8106 end Set_Flag250; 8107 8108 procedure Set_Flag251 (N : Node_Id; Val : Boolean) is 8109 begin 8110 pragma Assert (not Locked); 8111 pragma Assert (Nkind (N) in N_Entity); 8112 To_Flag_Byte3_Ptr 8113 (Node_Kind_Ptr' 8114 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag251 := Val; 8115 end Set_Flag251; 8116 8117 procedure Set_Flag252 (N : Node_Id; Val : Boolean) is 8118 begin 8119 pragma Assert (not Locked); 8120 pragma Assert (Nkind (N) in N_Entity); 8121 To_Flag_Byte3_Ptr 8122 (Node_Kind_Ptr' 8123 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag252 := Val; 8124 end Set_Flag252; 8125 8126 procedure Set_Flag253 (N : Node_Id; Val : Boolean) is 8127 begin 8128 pragma Assert (not Locked); 8129 pragma Assert (Nkind (N) in N_Entity); 8130 To_Flag_Byte3_Ptr 8131 (Node_Kind_Ptr' 8132 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag253 := Val; 8133 end Set_Flag253; 8134 8135 procedure Set_Flag254 (N : Node_Id; Val : Boolean) is 8136 begin 8137 pragma Assert (not Locked); 8138 pragma Assert (Nkind (N) in N_Entity); 8139 To_Flag_Byte3_Ptr 8140 (Node_Kind_Ptr' 8141 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag254 := Val; 8142 end Set_Flag254; 8143 8144 procedure Set_Flag255 (N : Node_Id; Val : Boolean) is 8145 begin 8146 pragma Assert (not Locked); 8147 pragma Assert (Nkind (N) in N_Entity); 8148 To_Flag_Word5_Ptr 8149 (Union_Id_Ptr' 8150 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag255 := Val; 8151 end Set_Flag255; 8152 8153 procedure Set_Flag256 (N : Node_Id; Val : Boolean) is 8154 begin 8155 pragma Assert (not Locked); 8156 pragma Assert (Nkind (N) in N_Entity); 8157 To_Flag_Word5_Ptr 8158 (Union_Id_Ptr' 8159 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag256 := Val; 8160 end Set_Flag256; 8161 8162 procedure Set_Flag257 (N : Node_Id; Val : Boolean) is 8163 begin 8164 pragma Assert (not Locked); 8165 pragma Assert (Nkind (N) in N_Entity); 8166 To_Flag_Word5_Ptr 8167 (Union_Id_Ptr' 8168 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag257 := Val; 8169 end Set_Flag257; 8170 8171 procedure Set_Flag258 (N : Node_Id; Val : Boolean) is 8172 begin 8173 pragma Assert (not Locked); 8174 pragma Assert (Nkind (N) in N_Entity); 8175 To_Flag_Word5_Ptr 8176 (Union_Id_Ptr' 8177 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag258 := Val; 8178 end Set_Flag258; 8179 8180 procedure Set_Flag259 (N : Node_Id; Val : Boolean) is 8181 begin 8182 pragma Assert (not Locked); 8183 pragma Assert (Nkind (N) in N_Entity); 8184 To_Flag_Word5_Ptr 8185 (Union_Id_Ptr' 8186 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag259 := Val; 8187 end Set_Flag259; 8188 8189 procedure Set_Flag260 (N : Node_Id; Val : Boolean) is 8190 begin 8191 pragma Assert (not Locked); 8192 pragma Assert (Nkind (N) in N_Entity); 8193 To_Flag_Word5_Ptr 8194 (Union_Id_Ptr' 8195 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag260 := Val; 8196 end Set_Flag260; 8197 8198 procedure Set_Flag261 (N : Node_Id; Val : Boolean) is 8199 begin 8200 pragma Assert (not Locked); 8201 pragma Assert (Nkind (N) in N_Entity); 8202 To_Flag_Word5_Ptr 8203 (Union_Id_Ptr' 8204 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag261 := Val; 8205 end Set_Flag261; 8206 8207 procedure Set_Flag262 (N : Node_Id; Val : Boolean) is 8208 begin 8209 pragma Assert (not Locked); 8210 pragma Assert (Nkind (N) in N_Entity); 8211 To_Flag_Word5_Ptr 8212 (Union_Id_Ptr' 8213 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag262 := Val; 8214 end Set_Flag262; 8215 8216 procedure Set_Flag263 (N : Node_Id; Val : Boolean) is 8217 begin 8218 pragma Assert (not Locked); 8219 pragma Assert (Nkind (N) in N_Entity); 8220 To_Flag_Word5_Ptr 8221 (Union_Id_Ptr' 8222 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag263 := Val; 8223 end Set_Flag263; 8224 8225 procedure Set_Flag264 (N : Node_Id; Val : Boolean) is 8226 begin 8227 pragma Assert (not Locked); 8228 pragma Assert (Nkind (N) in N_Entity); 8229 To_Flag_Word5_Ptr 8230 (Union_Id_Ptr' 8231 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag264 := Val; 8232 end Set_Flag264; 8233 8234 procedure Set_Flag265 (N : Node_Id; Val : Boolean) is 8235 begin 8236 pragma Assert (not Locked); 8237 pragma Assert (Nkind (N) in N_Entity); 8238 To_Flag_Word5_Ptr 8239 (Union_Id_Ptr' 8240 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag265 := Val; 8241 end Set_Flag265; 8242 8243 procedure Set_Flag266 (N : Node_Id; Val : Boolean) is 8244 begin 8245 pragma Assert (not Locked); 8246 pragma Assert (Nkind (N) in N_Entity); 8247 To_Flag_Word5_Ptr 8248 (Union_Id_Ptr' 8249 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag266 := Val; 8250 end Set_Flag266; 8251 8252 procedure Set_Flag267 (N : Node_Id; Val : Boolean) is 8253 begin 8254 pragma Assert (not Locked); 8255 pragma Assert (Nkind (N) in N_Entity); 8256 To_Flag_Word5_Ptr 8257 (Union_Id_Ptr' 8258 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag267 := Val; 8259 end Set_Flag267; 8260 8261 procedure Set_Flag268 (N : Node_Id; Val : Boolean) is 8262 begin 8263 pragma Assert (not Locked); 8264 pragma Assert (Nkind (N) in N_Entity); 8265 To_Flag_Word5_Ptr 8266 (Union_Id_Ptr' 8267 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag268 := Val; 8268 end Set_Flag268; 8269 8270 procedure Set_Flag269 (N : Node_Id; Val : Boolean) is 8271 begin 8272 pragma Assert (not Locked); 8273 pragma Assert (Nkind (N) in N_Entity); 8274 To_Flag_Word5_Ptr 8275 (Union_Id_Ptr' 8276 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag269 := Val; 8277 end Set_Flag269; 8278 8279 procedure Set_Flag270 (N : Node_Id; Val : Boolean) is 8280 begin 8281 pragma Assert (not Locked); 8282 pragma Assert (Nkind (N) in N_Entity); 8283 To_Flag_Word5_Ptr 8284 (Union_Id_Ptr' 8285 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag270 := Val; 8286 end Set_Flag270; 8287 8288 procedure Set_Flag271 (N : Node_Id; Val : Boolean) is 8289 begin 8290 pragma Assert (not Locked); 8291 pragma Assert (Nkind (N) in N_Entity); 8292 To_Flag_Word5_Ptr 8293 (Union_Id_Ptr' 8294 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag271 := Val; 8295 end Set_Flag271; 8296 8297 procedure Set_Flag272 (N : Node_Id; Val : Boolean) is 8298 begin 8299 pragma Assert (not Locked); 8300 pragma Assert (Nkind (N) in N_Entity); 8301 To_Flag_Word5_Ptr 8302 (Union_Id_Ptr' 8303 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag272 := Val; 8304 end Set_Flag272; 8305 8306 procedure Set_Flag273 (N : Node_Id; Val : Boolean) is 8307 begin 8308 pragma Assert (not Locked); 8309 pragma Assert (Nkind (N) in N_Entity); 8310 To_Flag_Word5_Ptr 8311 (Union_Id_Ptr' 8312 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag273 := Val; 8313 end Set_Flag273; 8314 8315 procedure Set_Flag274 (N : Node_Id; Val : Boolean) is 8316 begin 8317 pragma Assert (not Locked); 8318 pragma Assert (Nkind (N) in N_Entity); 8319 To_Flag_Word5_Ptr 8320 (Union_Id_Ptr' 8321 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag274 := Val; 8322 end Set_Flag274; 8323 8324 procedure Set_Flag275 (N : Node_Id; Val : Boolean) is 8325 begin 8326 pragma Assert (not Locked); 8327 pragma Assert (Nkind (N) in N_Entity); 8328 To_Flag_Word5_Ptr 8329 (Union_Id_Ptr' 8330 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag275 := Val; 8331 end Set_Flag275; 8332 8333 procedure Set_Flag276 (N : Node_Id; Val : Boolean) is 8334 begin 8335 pragma Assert (not Locked); 8336 pragma Assert (Nkind (N) in N_Entity); 8337 To_Flag_Word5_Ptr 8338 (Union_Id_Ptr' 8339 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag276 := Val; 8340 end Set_Flag276; 8341 8342 procedure Set_Flag277 (N : Node_Id; Val : Boolean) is 8343 begin 8344 pragma Assert (not Locked); 8345 pragma Assert (Nkind (N) in N_Entity); 8346 To_Flag_Word5_Ptr 8347 (Union_Id_Ptr' 8348 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag277 := Val; 8349 end Set_Flag277; 8350 8351 procedure Set_Flag278 (N : Node_Id; Val : Boolean) is 8352 begin 8353 pragma Assert (not Locked); 8354 pragma Assert (Nkind (N) in N_Entity); 8355 To_Flag_Word5_Ptr 8356 (Union_Id_Ptr' 8357 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag278 := Val; 8358 end Set_Flag278; 8359 8360 procedure Set_Flag279 (N : Node_Id; Val : Boolean) is 8361 begin 8362 pragma Assert (not Locked); 8363 pragma Assert (Nkind (N) in N_Entity); 8364 To_Flag_Word5_Ptr 8365 (Union_Id_Ptr' 8366 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag279 := Val; 8367 end Set_Flag279; 8368 8369 procedure Set_Flag280 (N : Node_Id; Val : Boolean) is 8370 begin 8371 pragma Assert (not Locked); 8372 pragma Assert (Nkind (N) in N_Entity); 8373 To_Flag_Word5_Ptr 8374 (Union_Id_Ptr' 8375 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag280 := Val; 8376 end Set_Flag280; 8377 8378 procedure Set_Flag281 (N : Node_Id; Val : Boolean) is 8379 begin 8380 pragma Assert (not Locked); 8381 pragma Assert (Nkind (N) in N_Entity); 8382 To_Flag_Word5_Ptr 8383 (Union_Id_Ptr' 8384 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag281 := Val; 8385 end Set_Flag281; 8386 8387 procedure Set_Flag282 (N : Node_Id; Val : Boolean) is 8388 begin 8389 pragma Assert (not Locked); 8390 pragma Assert (Nkind (N) in N_Entity); 8391 To_Flag_Word5_Ptr 8392 (Union_Id_Ptr' 8393 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag282 := Val; 8394 end Set_Flag282; 8395 8396 procedure Set_Flag283 (N : Node_Id; Val : Boolean) is 8397 begin 8398 pragma Assert (not Locked); 8399 pragma Assert (Nkind (N) in N_Entity); 8400 To_Flag_Word5_Ptr 8401 (Union_Id_Ptr' 8402 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag283 := Val; 8403 end Set_Flag283; 8404 8405 procedure Set_Flag284 (N : Node_Id; Val : Boolean) is 8406 begin 8407 pragma Assert (not Locked); 8408 pragma Assert (Nkind (N) in N_Entity); 8409 To_Flag_Word5_Ptr 8410 (Union_Id_Ptr' 8411 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag284 := Val; 8412 end Set_Flag284; 8413 8414 procedure Set_Flag285 (N : Node_Id; Val : Boolean) is 8415 begin 8416 pragma Assert (not Locked); 8417 pragma Assert (Nkind (N) in N_Entity); 8418 To_Flag_Word5_Ptr 8419 (Union_Id_Ptr' 8420 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag285 := Val; 8421 end Set_Flag285; 8422 8423 procedure Set_Flag286 (N : Node_Id; Val : Boolean) is 8424 begin 8425 pragma Assert (not Locked); 8426 pragma Assert (Nkind (N) in N_Entity); 8427 To_Flag_Word5_Ptr 8428 (Union_Id_Ptr' 8429 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag286 := Val; 8430 end Set_Flag286; 8431 8432 procedure Set_Flag287 (N : Node_Id; Val : Boolean) is 8433 begin 8434 pragma Assert (not Locked); 8435 pragma Assert (Nkind (N) in N_Entity); 8436 Nodes.Table (N + 5).In_List := Val; 8437 end Set_Flag287; 8438 8439 procedure Set_Flag288 (N : Node_Id; Val : Boolean) is 8440 begin 8441 pragma Assert (not Locked); 8442 pragma Assert (Nkind (N) in N_Entity); 8443 Nodes.Table (N + 5).Has_Aspects := Val; 8444 end Set_Flag288; 8445 8446 procedure Set_Flag289 (N : Node_Id; Val : Boolean) is 8447 begin 8448 pragma Assert (not Locked); 8449 pragma Assert (Nkind (N) in N_Entity); 8450 Nodes.Table (N + 5).Rewrite_Ins := Val; 8451 end Set_Flag289; 8452 8453 procedure Set_Flag290 (N : Node_Id; Val : Boolean) is 8454 begin 8455 pragma Assert (not Locked); 8456 pragma Assert (Nkind (N) in N_Entity); 8457 Nodes.Table (N + 5).Analyzed := Val; 8458 end Set_Flag290; 8459 8460 procedure Set_Flag291 (N : Node_Id; Val : Boolean) is 8461 begin 8462 pragma Assert (not Locked); 8463 pragma Assert (Nkind (N) in N_Entity); 8464 Nodes.Table (N + 5).Comes_From_Source := Val; 8465 end Set_Flag291; 8466 8467 procedure Set_Flag292 (N : Node_Id; Val : Boolean) is 8468 begin 8469 pragma Assert (not Locked); 8470 pragma Assert (Nkind (N) in N_Entity); 8471 Nodes.Table (N + 5).Error_Posted := Val; 8472 end Set_Flag292; 8473 8474 procedure Set_Flag293 (N : Node_Id; Val : Boolean) is 8475 begin 8476 pragma Assert (not Locked); 8477 pragma Assert (Nkind (N) in N_Entity); 8478 Nodes.Table (N + 5).Flag4 := Val; 8479 end Set_Flag293; 8480 8481 procedure Set_Flag294 (N : Node_Id; Val : Boolean) is 8482 begin 8483 pragma Assert (not Locked); 8484 pragma Assert (Nkind (N) in N_Entity); 8485 Nodes.Table (N + 5).Flag5 := Val; 8486 end Set_Flag294; 8487 8488 procedure Set_Flag295 (N : Node_Id; Val : Boolean) is 8489 begin 8490 pragma Assert (not Locked); 8491 pragma Assert (Nkind (N) in N_Entity); 8492 Nodes.Table (N + 5).Flag6 := Val; 8493 end Set_Flag295; 8494 8495 procedure Set_Flag296 (N : Node_Id; Val : Boolean) is 8496 begin 8497 pragma Assert (not Locked); 8498 pragma Assert (Nkind (N) in N_Entity); 8499 Nodes.Table (N + 5).Flag7 := Val; 8500 end Set_Flag296; 8501 8502 procedure Set_Flag297 (N : Node_Id; Val : Boolean) is 8503 begin 8504 pragma Assert (not Locked); 8505 pragma Assert (Nkind (N) in N_Entity); 8506 Nodes.Table (N + 5).Flag8 := Val; 8507 end Set_Flag297; 8508 8509 procedure Set_Flag298 (N : Node_Id; Val : Boolean) is 8510 begin 8511 pragma Assert (not Locked); 8512 pragma Assert (Nkind (N) in N_Entity); 8513 Nodes.Table (N + 5).Flag9 := Val; 8514 end Set_Flag298; 8515 8516 procedure Set_Flag299 (N : Node_Id; Val : Boolean) is 8517 begin 8518 pragma Assert (not Locked); 8519 pragma Assert (Nkind (N) in N_Entity); 8520 Nodes.Table (N + 5).Flag10 := Val; 8521 end Set_Flag299; 8522 8523 procedure Set_Flag300 (N : Node_Id; Val : Boolean) is 8524 begin 8525 pragma Assert (not Locked); 8526 pragma Assert (Nkind (N) in N_Entity); 8527 Nodes.Table (N + 5).Flag11 := Val; 8528 end Set_Flag300; 8529 8530 procedure Set_Flag301 (N : Node_Id; Val : Boolean) is 8531 begin 8532 pragma Assert (not Locked); 8533 pragma Assert (Nkind (N) in N_Entity); 8534 Nodes.Table (N + 5).Flag12 := Val; 8535 end Set_Flag301; 8536 8537 procedure Set_Flag302 (N : Node_Id; Val : Boolean) is 8538 begin 8539 pragma Assert (not Locked); 8540 pragma Assert (Nkind (N) in N_Entity); 8541 Nodes.Table (N + 5).Flag13 := Val; 8542 end Set_Flag302; 8543 8544 procedure Set_Flag303 (N : Node_Id; Val : Boolean) is 8545 begin 8546 pragma Assert (not Locked); 8547 pragma Assert (Nkind (N) in N_Entity); 8548 Nodes.Table (N + 5).Flag14 := Val; 8549 end Set_Flag303; 8550 8551 procedure Set_Flag304 (N : Node_Id; Val : Boolean) is 8552 begin 8553 pragma Assert (not Locked); 8554 pragma Assert (Nkind (N) in N_Entity); 8555 Nodes.Table (N + 5).Flag15 := Val; 8556 end Set_Flag304; 8557 8558 procedure Set_Flag305 (N : Node_Id; Val : Boolean) is 8559 begin 8560 pragma Assert (not Locked); 8561 pragma Assert (Nkind (N) in N_Entity); 8562 Nodes.Table (N + 5).Flag16 := Val; 8563 end Set_Flag305; 8564 8565 procedure Set_Flag306 (N : Node_Id; Val : Boolean) is 8566 begin 8567 pragma Assert (not Locked); 8568 pragma Assert (Nkind (N) in N_Entity); 8569 Nodes.Table (N + 5).Flag17 := Val; 8570 end Set_Flag306; 8571 8572 procedure Set_Flag307 (N : Node_Id; Val : Boolean) is 8573 begin 8574 pragma Assert (not Locked); 8575 pragma Assert (Nkind (N) in N_Entity); 8576 Nodes.Table (N + 5).Flag18 := Val; 8577 end Set_Flag307; 8578 8579 procedure Set_Flag308 (N : Node_Id; Val : Boolean) is 8580 begin 8581 pragma Assert (not Locked); 8582 pragma Assert (Nkind (N) in N_Entity); 8583 Nodes.Table (N + 5).Pflag1 := Val; 8584 end Set_Flag308; 8585 8586 procedure Set_Flag309 (N : Node_Id; Val : Boolean) is 8587 begin 8588 pragma Assert (not Locked); 8589 pragma Assert (Nkind (N) in N_Entity); 8590 Nodes.Table (N + 5).Pflag2 := Val; 8591 end Set_Flag309; 8592 8593 procedure Set_Flag310 (N : Node_Id; Val : Boolean) is 8594 begin 8595 pragma Assert (not Locked); 8596 pragma Assert (Nkind (N) in N_Entity); 8597 To_Flag_Byte4_Ptr 8598 (Node_Kind_Ptr' 8599 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag310 := Val; 8600 end Set_Flag310; 8601 8602 procedure Set_Flag311 (N : Node_Id; Val : Boolean) is 8603 begin 8604 pragma Assert (not Locked); 8605 pragma Assert (Nkind (N) in N_Entity); 8606 To_Flag_Byte4_Ptr 8607 (Node_Kind_Ptr' 8608 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag311 := Val; 8609 end Set_Flag311; 8610 8611 procedure Set_Flag312 (N : Node_Id; Val : Boolean) is 8612 begin 8613 pragma Assert (not Locked); 8614 pragma Assert (Nkind (N) in N_Entity); 8615 To_Flag_Byte4_Ptr 8616 (Node_Kind_Ptr' 8617 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag312 := Val; 8618 end Set_Flag312; 8619 8620 procedure Set_Flag313 (N : Node_Id; Val : Boolean) is 8621 begin 8622 pragma Assert (not Locked); 8623 pragma Assert (Nkind (N) in N_Entity); 8624 To_Flag_Byte4_Ptr 8625 (Node_Kind_Ptr' 8626 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag313 := Val; 8627 end Set_Flag313; 8628 8629 procedure Set_Flag314 (N : Node_Id; Val : Boolean) is 8630 begin 8631 pragma Assert (not Locked); 8632 pragma Assert (Nkind (N) in N_Entity); 8633 To_Flag_Byte4_Ptr 8634 (Node_Kind_Ptr' 8635 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag314 := Val; 8636 end Set_Flag314; 8637 8638 procedure Set_Flag315 (N : Node_Id; Val : Boolean) is 8639 begin 8640 pragma Assert (not Locked); 8641 pragma Assert (Nkind (N) in N_Entity); 8642 To_Flag_Byte4_Ptr 8643 (Node_Kind_Ptr' 8644 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag315 := Val; 8645 end Set_Flag315; 8646 8647 procedure Set_Flag316 (N : Node_Id; Val : Boolean) is 8648 begin 8649 pragma Assert (not Locked); 8650 pragma Assert (Nkind (N) in N_Entity); 8651 To_Flag_Byte4_Ptr 8652 (Node_Kind_Ptr' 8653 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag316 := Val; 8654 end Set_Flag316; 8655 8656 procedure Set_Flag317 (N : Node_Id; Val : Boolean) is 8657 begin 8658 pragma Assert (not Locked); 8659 pragma Assert (Nkind (N) in N_Entity); 8660 To_Flag_Byte4_Ptr 8661 (Node_Kind_Ptr' 8662 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag317 := Val; 8663 end Set_Flag317; 8664 8665 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is 8666 begin 8667 pragma Assert (not Locked); 8668 pragma Assert (N <= Nodes.Last); 8669 8670 if Val > Error then 8671 Set_Parent (N => Val, Val => N); 8672 end if; 8673 8674 Set_Node1 (N, Val); 8675 end Set_Node1_With_Parent; 8676 8677 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is 8678 begin 8679 pragma Assert (not Locked); 8680 pragma Assert (N <= Nodes.Last); 8681 8682 if Val > Error then 8683 Set_Parent (N => Val, Val => N); 8684 end if; 8685 8686 Set_Node2 (N, Val); 8687 end Set_Node2_With_Parent; 8688 8689 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is 8690 begin 8691 pragma Assert (not Locked); 8692 pragma Assert (N <= Nodes.Last); 8693 8694 if Val > Error then 8695 Set_Parent (N => Val, Val => N); 8696 end if; 8697 8698 Set_Node3 (N, Val); 8699 end Set_Node3_With_Parent; 8700 8701 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is 8702 begin 8703 pragma Assert (not Locked); 8704 pragma Assert (N <= Nodes.Last); 8705 8706 if Val > Error then 8707 Set_Parent (N => Val, Val => N); 8708 end if; 8709 8710 Set_Node4 (N, Val); 8711 end Set_Node4_With_Parent; 8712 8713 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is 8714 begin 8715 pragma Assert (not Locked); 8716 pragma Assert (N <= Nodes.Last); 8717 8718 if Val > Error then 8719 Set_Parent (N => Val, Val => N); 8720 end if; 8721 8722 Set_Node5 (N, Val); 8723 end Set_Node5_With_Parent; 8724 8725 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is 8726 begin 8727 pragma Assert (not Locked); 8728 pragma Assert (N <= Nodes.Last); 8729 if Val /= No_List and then Val /= Error_List then 8730 Set_Parent (Val, N); 8731 end if; 8732 Set_List1 (N, Val); 8733 end Set_List1_With_Parent; 8734 8735 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is 8736 begin 8737 pragma Assert (not Locked); 8738 pragma Assert (N <= Nodes.Last); 8739 if Val /= No_List and then Val /= Error_List then 8740 Set_Parent (Val, N); 8741 end if; 8742 Set_List2 (N, Val); 8743 end Set_List2_With_Parent; 8744 8745 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is 8746 begin 8747 pragma Assert (not Locked); 8748 pragma Assert (N <= Nodes.Last); 8749 if Val /= No_List and then Val /= Error_List then 8750 Set_Parent (Val, N); 8751 end if; 8752 Set_List3 (N, Val); 8753 end Set_List3_With_Parent; 8754 8755 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is 8756 begin 8757 pragma Assert (not Locked); 8758 pragma Assert (N <= Nodes.Last); 8759 if Val /= No_List and then Val /= Error_List then 8760 Set_Parent (Val, N); 8761 end if; 8762 Set_List4 (N, Val); 8763 end Set_List4_With_Parent; 8764 8765 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is 8766 begin 8767 pragma Assert (not Locked); 8768 pragma Assert (N <= Nodes.Last); 8769 if Val /= No_List and then Val /= Error_List then 8770 Set_Parent (Val, N); 8771 end if; 8772 Set_List5 (N, Val); 8773 end Set_List5_With_Parent; 8774 8775 end Unchecked_Access; 8776 8777 ------------ 8778 -- Unlock -- 8779 ------------ 8780 8781 procedure Unlock is 8782 begin 8783 Flags.Locked := False; 8784 Orig_Nodes.Locked := False; 8785 end Unlock; 8786 8787 ------------------ 8788 -- Unlock_Nodes -- 8789 ------------------ 8790 8791 procedure Unlock_Nodes is 8792 begin 8793 pragma Assert (Locked); 8794 Locked := False; 8795 end Unlock_Nodes; 8796 8797end Atree; 8798