1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- A T R E E -- 6-- -- 7-- B o d y -- 8-- -- 9-- Copyright (C) 1992-2003, 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 2, or (at your option) any later ver- -- 14-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- 15-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- 16-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- 17-- for more details. You should have received a copy of the GNU General -- 18-- Public License distributed with GNAT; see file COPYING. If not, write -- 19-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -- 20-- MA 02111-1307, USA. -- 21-- -- 22-- As a special exception, if other files instantiate generics from this -- 23-- unit, or you link this unit with other files to produce an executable, -- 24-- this unit does not by itself cause the resulting executable to be -- 25-- covered by the GNU General Public License. This exception does not -- 26-- however invalidate any other reasons why the executable file might be -- 27-- covered by the GNU Public License. -- 28-- -- 29-- GNAT was originally developed by the GNAT team at New York University. -- 30-- Extensive contributions were provided by Ada Core Technologies Inc. -- 31-- -- 32------------------------------------------------------------------------------ 33 34pragma Style_Checks (All_Checks); 35-- Turn off subprogram ordering check for this package 36 37-- WARNING: There is a C version of this package. Any changes to this source 38-- file must be properly reflected in the C header a-atree.h (for inlined 39-- bodies) and the C file a-atree.c (for remaining non-inlined bodies). 40 41with Debug; use Debug; 42with Nlists; use Nlists; 43with Elists; use Elists; 44with Output; use Output; 45with Sinput; use Sinput; 46with Tree_IO; use Tree_IO; 47 48with GNAT.HTable; use GNAT.HTable; 49 50package body Atree is 51 52 Node_Count : Nat; 53 -- Count allocated nodes for Num_Nodes function 54 55 use Unchecked_Access; 56 -- We are allowed to see these from within our own body! 57 58 use Atree_Private_Part; 59 -- We are also allowed to see our private data structures! 60 61 function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind); 62 function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind); 63 -- Functions used to store Entity_Kind value in Nkind field 64 65 -- The following declarations are used to store flags 65-72 in the 66 -- Nkind field of the third component of an extended (entity) node. 67 68 type Flag_Byte is record 69 Flag65 : Boolean; 70 Flag66 : Boolean; 71 Flag67 : Boolean; 72 Flag68 : Boolean; 73 Flag69 : Boolean; 74 Flag70 : Boolean; 75 Flag71 : Boolean; 76 Flag72 : Boolean; 77 end record; 78 79 pragma Pack (Flag_Byte); 80 for Flag_Byte'Size use 8; 81 82 type Flag_Byte_Ptr is access all Flag_Byte; 83 type Node_Kind_Ptr is access all Node_Kind; 84 85 function To_Flag_Byte is new 86 Unchecked_Conversion (Node_Kind, Flag_Byte); 87 88 function To_Flag_Byte_Ptr is new 89 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr); 90 91 -- The following declarations are used to store flags 73-96 in the 92 -- Field12 field of the third component of an extended (entity) node. 93 94 type Flag_Word is record 95 Flag73 : Boolean; 96 Flag74 : Boolean; 97 Flag75 : Boolean; 98 Flag76 : Boolean; 99 Flag77 : Boolean; 100 Flag78 : Boolean; 101 Flag79 : Boolean; 102 Flag80 : Boolean; 103 104 Flag81 : Boolean; 105 Flag82 : Boolean; 106 Flag83 : Boolean; 107 Flag84 : Boolean; 108 Flag85 : Boolean; 109 Flag86 : Boolean; 110 Flag87 : Boolean; 111 Flag88 : Boolean; 112 113 Flag89 : Boolean; 114 Flag90 : Boolean; 115 Flag91 : Boolean; 116 Flag92 : Boolean; 117 Flag93 : Boolean; 118 Flag94 : Boolean; 119 Flag95 : Boolean; 120 Flag96 : Boolean; 121 122 Convention : Convention_Id; 123 end record; 124 125 pragma Pack (Flag_Word); 126 for Flag_Word'Size use 32; 127 for Flag_Word'Alignment use 4; 128 129 type Flag_Word_Ptr is access all Flag_Word; 130 type Union_Id_Ptr is access all Union_Id; 131 132 function To_Flag_Word is new 133 Unchecked_Conversion (Union_Id, Flag_Word); 134 135 function To_Flag_Word_Ptr is new 136 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr); 137 138 -- The following declarations are used to store flags 97-128 in the 139 -- Field12 field of the fourth component of an extended (entity) node. 140 141 type Flag_Word2 is record 142 Flag97 : Boolean; 143 Flag98 : Boolean; 144 Flag99 : Boolean; 145 Flag100 : Boolean; 146 Flag101 : Boolean; 147 Flag102 : Boolean; 148 Flag103 : Boolean; 149 Flag104 : Boolean; 150 151 Flag105 : Boolean; 152 Flag106 : Boolean; 153 Flag107 : Boolean; 154 Flag108 : Boolean; 155 Flag109 : Boolean; 156 Flag110 : Boolean; 157 Flag111 : Boolean; 158 Flag112 : Boolean; 159 160 Flag113 : Boolean; 161 Flag114 : Boolean; 162 Flag115 : Boolean; 163 Flag116 : Boolean; 164 Flag117 : Boolean; 165 Flag118 : Boolean; 166 Flag119 : Boolean; 167 Flag120 : Boolean; 168 169 Flag121 : Boolean; 170 Flag122 : Boolean; 171 Flag123 : Boolean; 172 Flag124 : Boolean; 173 Flag125 : Boolean; 174 Flag126 : Boolean; 175 Flag127 : Boolean; 176 Flag128 : Boolean; 177 end record; 178 179 pragma Pack (Flag_Word2); 180 for Flag_Word2'Size use 32; 181 for Flag_Word2'Alignment use 4; 182 183 type Flag_Word2_Ptr is access all Flag_Word2; 184 185 function To_Flag_Word2 is new 186 Unchecked_Conversion (Union_Id, Flag_Word2); 187 188 function To_Flag_Word2_Ptr is new 189 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr); 190 191 -- The following declarations are used to store flags 97-120 in the 192 -- Field12 field of the fourth component of an extended (entity) node. 193 194 type Flag_Word3 is record 195 Flag152 : Boolean; 196 Flag153 : Boolean; 197 Flag154 : Boolean; 198 Flag155 : Boolean; 199 Flag156 : Boolean; 200 Flag157 : Boolean; 201 Flag158 : Boolean; 202 Flag159 : Boolean; 203 204 Flag160 : Boolean; 205 Flag161 : Boolean; 206 Flag162 : Boolean; 207 Flag163 : Boolean; 208 Flag164 : Boolean; 209 Flag165 : Boolean; 210 Flag166 : Boolean; 211 Flag167 : Boolean; 212 213 Flag168 : Boolean; 214 Flag169 : Boolean; 215 Flag170 : Boolean; 216 Flag171 : Boolean; 217 Flag172 : Boolean; 218 Flag173 : Boolean; 219 Flag174 : Boolean; 220 Flag175 : Boolean; 221 222 Flag176 : Boolean; 223 Flag177 : Boolean; 224 Flag178 : Boolean; 225 Flag179 : Boolean; 226 Flag180 : Boolean; 227 Flag181 : Boolean; 228 Flag182 : Boolean; 229 Flag183 : Boolean; 230 end record; 231 232 pragma Pack (Flag_Word3); 233 for Flag_Word3'Size use 32; 234 for Flag_Word3'Alignment use 4; 235 236 type Flag_Word3_Ptr is access all Flag_Word3; 237 238 function To_Flag_Word3 is new 239 Unchecked_Conversion (Union_Id, Flag_Word3); 240 241 function To_Flag_Word3_Ptr is new 242 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr); 243 244 -- Default value used to initialize default nodes. Note that some of the 245 -- fields get overwritten, and in particular, Nkind always gets reset. 246 247 Default_Node : Node_Record := ( 248 Is_Extension => False, 249 Pflag1 => False, 250 Pflag2 => False, 251 In_List => False, 252 Unused_1 => False, 253 Rewrite_Ins => False, 254 Analyzed => False, 255 Comes_From_Source => False, -- modified by Set_Comes_From_Source_Default 256 Error_Posted => False, 257 Flag4 => False, 258 259 Flag5 => False, 260 Flag6 => False, 261 Flag7 => False, 262 Flag8 => False, 263 Flag9 => False, 264 Flag10 => False, 265 Flag11 => False, 266 Flag12 => False, 267 268 Flag13 => False, 269 Flag14 => False, 270 Flag15 => False, 271 Flag16 => False, 272 Flag17 => False, 273 Flag18 => False, 274 275 Nkind => N_Unused_At_Start, 276 277 Sloc => No_Location, 278 Link => Empty_List_Or_Node, 279 Field1 => Empty_List_Or_Node, 280 Field2 => Empty_List_Or_Node, 281 Field3 => Empty_List_Or_Node, 282 Field4 => Empty_List_Or_Node, 283 Field5 => Empty_List_Or_Node); 284 285 -- Default value used to initialize node extensions (i.e. the second 286 -- and third and fourth components of an extended node). Note we are 287 -- cheating a bit here when it comes to Node12, which really holds 288 -- flags an (for the third component), the convention. But it works 289 -- because Empty, False, Convention_Ada, all happen to be all zero bits. 290 291 Default_Node_Extension : constant Node_Record := ( 292 Is_Extension => True, 293 Pflag1 => False, 294 Pflag2 => False, 295 In_List => False, 296 Unused_1 => False, 297 Rewrite_Ins => False, 298 Analyzed => False, 299 Comes_From_Source => False, 300 Error_Posted => False, 301 Flag4 => False, 302 303 Flag5 => False, 304 Flag6 => False, 305 Flag7 => False, 306 Flag8 => False, 307 Flag9 => False, 308 Flag10 => False, 309 Flag11 => False, 310 Flag12 => False, 311 312 Flag13 => False, 313 Flag14 => False, 314 Flag15 => False, 315 Flag16 => False, 316 Flag17 => False, 317 Flag18 => False, 318 319 Nkind => E_To_N (E_Void), 320 321 Field6 => Empty_List_Or_Node, 322 Field7 => Empty_List_Or_Node, 323 Field8 => Empty_List_Or_Node, 324 Field9 => Empty_List_Or_Node, 325 Field10 => Empty_List_Or_Node, 326 Field11 => Empty_List_Or_Node, 327 Field12 => Empty_List_Or_Node); 328 329 -------------------------------------------------- 330 -- Implementation of Tree Substitution Routines -- 331 -------------------------------------------------- 332 333 -- A separate table keeps track of the mapping between rewritten nodes 334 -- and their corresponding original tree nodes. Rewrite makes an entry 335 -- in this table for use by Original_Node. By default, if no call is 336 -- Rewrite, the entry in this table points to the original unwritten node. 337 338 -- Note: eventually, this should be a field in the Node directly, but 339 -- for now we do not want to disturb the efficiency of a power of 2 340 -- for the node size 341 342 package Orig_Nodes is new Table.Table ( 343 Table_Component_Type => Node_Id, 344 Table_Index_Type => Node_Id, 345 Table_Low_Bound => First_Node_Id, 346 Table_Initial => Alloc.Orig_Nodes_Initial, 347 Table_Increment => Alloc.Orig_Nodes_Increment, 348 Table_Name => "Orig_Nodes"); 349 350 ---------------------------------------- 351 -- Global_Variables for New_Copy_Tree -- 352 ---------------------------------------- 353 354 -- These global variables are used by New_Copy_Tree. See description 355 -- of the body of this subprogram for details. Global variables can be 356 -- safely used by New_Copy_Tree, since there is no case of a recursive 357 -- call from the processing inside New_Copy_Tree. 358 359 NCT_Hash_Threshhold : constant := 20; 360 -- If there are more than this number of pairs of entries in the 361 -- map, then Hash_Tables_Used will be set, and the hash tables will 362 -- be initialized and used for the searches. 363 364 NCT_Hash_Tables_Used : Boolean := False; 365 -- Set to True if hash tables are in use 366 367 NCT_Table_Entries : Nat; 368 -- Count entries in table to see if threshhold is reached 369 370 NCT_Hash_Table_Setup : Boolean := False; 371 -- Set to True if hash table contains data. We set this True if we 372 -- setup the hash table with data, and leave it set permanently 373 -- from then on, this is a signal that second and subsequent users 374 -- of the hash table must clear the old entries before reuse. 375 376 subtype NCT_Header_Num is Int range 0 .. 511; 377 -- Defines range of headers in hash tables (512 headers) 378 379 ----------------------- 380 -- Local Subprograms -- 381 ----------------------- 382 383 procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id); 384 -- This subprogram is used to fixup parent pointers that are rendered 385 -- incorrect because of a node copy. Field is checked to see if it 386 -- points to a node, list, or element list that has a parent that 387 -- points to Old_Node. If so, the parent is reset to point to New_Node. 388 389 -------------- 390 -- Analyzed -- 391 -------------- 392 393 function Analyzed (N : Node_Id) return Boolean is 394 begin 395 pragma Assert (N in Nodes.First .. Nodes.Last); 396 return Nodes.Table (N).Analyzed; 397 end Analyzed; 398 399 ----------------- 400 -- Change_Node -- 401 ----------------- 402 403 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is 404 Save_Sloc : constant Source_Ptr := Sloc (N); 405 Save_In_List : constant Boolean := Nodes.Table (N).In_List; 406 Save_Link : constant Union_Id := Nodes.Table (N).Link; 407 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source; 408 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted; 409 Par_Count : Paren_Count_Type := 0; 410 411 begin 412 if Nkind (N) in N_Subexpr then 413 Par_Count := Paren_Count (N); 414 end if; 415 416 Nodes.Table (N) := Default_Node; 417 Nodes.Table (N).Sloc := Save_Sloc; 418 Nodes.Table (N).In_List := Save_In_List; 419 Nodes.Table (N).Link := Save_Link; 420 Nodes.Table (N).Comes_From_Source := Save_CFS; 421 Nodes.Table (N).Nkind := New_Node_Kind; 422 Nodes.Table (N).Error_Posted := Save_Posted; 423 424 if New_Node_Kind in N_Subexpr then 425 Set_Paren_Count (N, Par_Count); 426 end if; 427 end Change_Node; 428 429 ----------------------- 430 -- Comes_From_Source -- 431 ----------------------- 432 433 function Comes_From_Source (N : Node_Id) return Boolean is 434 begin 435 pragma Assert (N in Nodes.First .. Nodes.Last); 436 return Nodes.Table (N).Comes_From_Source; 437 end Comes_From_Source; 438 439 ---------------- 440 -- Convention -- 441 ---------------- 442 443 function Convention (E : Entity_Id) return Convention_Id is 444 begin 445 pragma Assert (Nkind (E) in N_Entity); 446 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention; 447 end Convention; 448 449 --------------- 450 -- Copy_Node -- 451 --------------- 452 453 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is 454 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List; 455 Save_Link : constant Union_Id := Nodes.Table (Destination).Link; 456 457 begin 458 Nodes.Table (Destination) := Nodes.Table (Source); 459 Nodes.Table (Destination).In_List := Save_In_List; 460 Nodes.Table (Destination).Link := Save_Link; 461 462 if Has_Extension (Source) then 463 pragma Assert (Has_Extension (Destination)); 464 Nodes.Table (Destination + 1) := Nodes.Table (Source + 1); 465 Nodes.Table (Destination + 2) := Nodes.Table (Source + 2); 466 Nodes.Table (Destination + 3) := Nodes.Table (Source + 3); 467 468 else 469 pragma Assert (not Has_Extension (Source)); 470 null; 471 end if; 472 end Copy_Node; 473 474 ------------------------ 475 -- Copy_Separate_Tree -- 476 ------------------------ 477 478 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is 479 New_Id : Node_Id; 480 481 function Copy_Entity (E : Entity_Id) return Entity_Id; 482 -- Copy Entity, copying only the Ekind and Chars fields 483 484 function Copy_List (List : List_Id) return List_Id; 485 -- Copy list 486 487 function Possible_Copy (Field : Union_Id) return Union_Id; 488 -- Given a field, returns a copy of the node or list if its parent 489 -- is the current source node, and otherwise returns the input 490 491 ----------------- 492 -- Copy_Entity -- 493 ----------------- 494 495 function Copy_Entity (E : Entity_Id) return Entity_Id is 496 New_Ent : Entity_Id; 497 498 begin 499 case N_Entity (Nkind (E)) is 500 when N_Defining_Identifier => 501 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E)); 502 503 when N_Defining_Character_Literal => 504 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E)); 505 506 when N_Defining_Operator_Symbol => 507 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E)); 508 end case; 509 510 Set_Chars (New_Ent, Chars (E)); 511 return New_Ent; 512 end Copy_Entity; 513 514 --------------- 515 -- Copy_List -- 516 --------------- 517 518 function Copy_List (List : List_Id) return List_Id is 519 NL : List_Id; 520 E : Node_Id; 521 522 begin 523 if List = No_List then 524 return No_List; 525 526 else 527 NL := New_List; 528 E := First (List); 529 530 while Present (E) loop 531 532 if Has_Extension (E) then 533 Append (Copy_Entity (E), NL); 534 else 535 Append (Copy_Separate_Tree (E), NL); 536 end if; 537 538 Next (E); 539 end loop; 540 541 return NL; 542 end if; 543 end Copy_List; 544 545 ------------------- 546 -- Possible_Copy -- 547 ------------------- 548 549 function Possible_Copy (Field : Union_Id) return Union_Id is 550 New_N : Union_Id; 551 552 begin 553 if Field in Node_Range then 554 555 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field))); 556 557 if Parent (Node_Id (Field)) = Source then 558 Set_Parent (Node_Id (New_N), New_Id); 559 end if; 560 561 return New_N; 562 563 elsif Field in List_Range then 564 New_N := Union_Id (Copy_List (List_Id (Field))); 565 566 if Parent (List_Id (Field)) = Source then 567 Set_Parent (List_Id (New_N), New_Id); 568 end if; 569 570 return New_N; 571 572 else 573 return Field; 574 end if; 575 end Possible_Copy; 576 577 -- Start of processing for Copy_Separate_Tree 578 579 begin 580 if Source <= Empty_Or_Error then 581 return Source; 582 583 elsif Has_Extension (Source) then 584 return Copy_Entity (Source); 585 586 else 587 Nodes.Increment_Last; 588 New_Id := Nodes.Last; 589 Nodes.Table (New_Id) := Nodes.Table (Source); 590 Nodes.Table (New_Id).Link := Empty_List_Or_Node; 591 Nodes.Table (New_Id).In_List := False; 592 Nodes.Table (New_Id).Rewrite_Ins := False; 593 Node_Count := Node_Count + 1; 594 595 Orig_Nodes.Increment_Last; 596 Allocate_List_Tables (Nodes.Last); 597 Orig_Nodes.Table (New_Id) := New_Id; 598 599 -- Recursively copy descendents 600 601 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id))); 602 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id))); 603 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id))); 604 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id))); 605 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id))); 606 607 -- Set Entity field to Empty 608 -- Why is this done??? and why is it always right to do it??? 609 610 if Nkind (New_Id) in N_Has_Entity 611 or else Nkind (New_Id) = N_Freeze_Entity 612 then 613 Set_Entity (New_Id, Empty); 614 end if; 615 616 -- All done, return copied node 617 618 return New_Id; 619 end if; 620 end Copy_Separate_Tree; 621 622 ----------------- 623 -- Delete_Node -- 624 ----------------- 625 626 procedure Delete_Node (Node : Node_Id) is 627 begin 628 pragma Assert (not Nodes.Table (Node).In_List); 629 630 if Debug_Flag_N then 631 Write_Str ("Delete node "); 632 Write_Int (Int (Node)); 633 Write_Eol; 634 end if; 635 636 Nodes.Table (Node) := Default_Node; 637 Nodes.Table (Node).Nkind := N_Unused_At_Start; 638 Node_Count := Node_Count - 1; 639 640 -- Note: for now, we are not bothering to reuse deleted nodes 641 642 end Delete_Node; 643 644 ----------------- 645 -- Delete_Tree -- 646 ----------------- 647 648 procedure Delete_Tree (Node : Node_Id) is 649 650 procedure Delete_Field (F : Union_Id); 651 -- Delete item pointed to by field F if it is a syntactic element 652 653 procedure Delete_List (L : List_Id); 654 -- Delete all elements on the given list 655 656 procedure Delete_Field (F : Union_Id) is 657 begin 658 if F = Union_Id (Empty) then 659 return; 660 661 elsif F in Node_Range 662 and then Parent (Node_Id (F)) = Node 663 then 664 Delete_Tree (Node_Id (F)); 665 666 elsif F in List_Range 667 and then Parent (List_Id (F)) = Node 668 then 669 Delete_List (List_Id (F)); 670 671 -- No need to test Elist case, there are no syntactic Elists 672 673 else 674 return; 675 end if; 676 end Delete_Field; 677 678 procedure Delete_List (L : List_Id) is 679 begin 680 while Is_Non_Empty_List (L) loop 681 Delete_Tree (Remove_Head (L)); 682 end loop; 683 end Delete_List; 684 685 -- Start of processing for Delete_Tree 686 687 begin 688 -- Delete descendents 689 690 Delete_Field (Field1 (Node)); 691 Delete_Field (Field2 (Node)); 692 Delete_Field (Field3 (Node)); 693 Delete_Field (Field4 (Node)); 694 Delete_Field (Field5 (Node)); 695 end Delete_Tree; 696 697 ----------- 698 -- Ekind -- 699 ----------- 700 701 function Ekind (E : Entity_Id) return Entity_Kind is 702 begin 703 pragma Assert (Nkind (E) in N_Entity); 704 return N_To_E (Nodes.Table (E + 1).Nkind); 705 end Ekind; 706 707 ------------------ 708 -- Error_Posted -- 709 ------------------ 710 711 function Error_Posted (N : Node_Id) return Boolean is 712 begin 713 pragma Assert (N in Nodes.First .. Nodes.Last); 714 return Nodes.Table (N).Error_Posted; 715 end Error_Posted; 716 717 ----------------------- 718 -- Exchange_Entities -- 719 ----------------------- 720 721 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is 722 Temp_Ent : Node_Record; 723 724 begin 725 pragma Assert (Has_Extension (E1) 726 and then Has_Extension (E2) 727 and then not Nodes.Table (E1).In_List 728 and then not Nodes.Table (E2).In_List); 729 730 -- Exchange the contents of the two entities 731 732 Temp_Ent := Nodes.Table (E1); 733 Nodes.Table (E1) := Nodes.Table (E2); 734 Nodes.Table (E2) := Temp_Ent; 735 Temp_Ent := Nodes.Table (E1 + 1); 736 Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1); 737 Nodes.Table (E2 + 1) := Temp_Ent; 738 Temp_Ent := Nodes.Table (E1 + 2); 739 Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2); 740 Nodes.Table (E2 + 2) := Temp_Ent; 741 Temp_Ent := Nodes.Table (E1 + 3); 742 Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3); 743 Nodes.Table (E2 + 3) := Temp_Ent; 744 745 -- That exchange exchanged the parent pointers as well, which is what 746 -- we want, but we need to patch up the defining identifier pointers 747 -- in the parent nodes (the child pointers) to match this switch 748 -- unless for Implicit types entities which have no parent, in which 749 -- case we don't do anything otherwise we won't be able to revert back 750 -- to the original situation. 751 752 -- Shouldn't this use Is_Itype instead of the Parent test 753 754 if Present (Parent (E1)) and then Present (Parent (E2)) then 755 Set_Defining_Identifier (Parent (E1), E1); 756 Set_Defining_Identifier (Parent (E2), E2); 757 end if; 758 end Exchange_Entities; 759 760 ----------------- 761 -- Extend_Node -- 762 ----------------- 763 764 function Extend_Node (Node : Node_Id) return Entity_Id is 765 Result : Entity_Id; 766 767 procedure Debug_Extend_Node; 768 -- Debug routine for debug flag N 769 770 procedure Debug_Extend_Node is 771 begin 772 if Debug_Flag_N then 773 Write_Str ("Extend node "); 774 Write_Int (Int (Node)); 775 776 if Result = Node then 777 Write_Str (" in place"); 778 else 779 Write_Str (" copied to "); 780 Write_Int (Int (Result)); 781 end if; 782 783 -- Write_Eol; 784 end if; 785 end Debug_Extend_Node; 786 787 pragma Inline (Debug_Extend_Node); 788 789 begin 790 if Node /= Nodes.Last then 791 Nodes.Increment_Last; 792 Nodes.Table (Nodes.Last) := Nodes.Table (Node); 793 Result := Nodes.Last; 794 795 Orig_Nodes.Increment_Last; 796 Orig_Nodes.Table (Nodes.Last) := Nodes.Last; 797 798 else 799 Result := Node; 800 end if; 801 802 Nodes.Increment_Last; 803 Nodes.Table (Nodes.Last) := Default_Node_Extension; 804 Nodes.Increment_Last; 805 Nodes.Table (Nodes.Last) := Default_Node_Extension; 806 Nodes.Increment_Last; 807 Nodes.Table (Nodes.Last) := Default_Node_Extension; 808 809 Orig_Nodes.Set_Last (Nodes.Last); 810 Allocate_List_Tables (Nodes.Last); 811 812 pragma Debug (Debug_Extend_Node); 813 return Result; 814 end Extend_Node; 815 816 ---------------- 817 -- Fix_Parent -- 818 ---------------- 819 820 procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id) is 821 begin 822 -- Fix parent of node that is referenced by Field. Note that we must 823 -- exclude the case where the node is a member of a list, because in 824 -- this case the parent is the parent of the list. 825 826 if Field in Node_Range 827 and then Present (Node_Id (Field)) 828 and then not Nodes.Table (Node_Id (Field)).In_List 829 and then Parent (Node_Id (Field)) = Old_Node 830 then 831 Set_Parent (Node_Id (Field), New_Node); 832 833 -- Fix parent of list that is referenced by Field 834 835 elsif Field in List_Range 836 and then Present (List_Id (Field)) 837 and then Parent (List_Id (Field)) = Old_Node 838 then 839 Set_Parent (List_Id (Field), New_Node); 840 end if; 841 end Fix_Parent; 842 843 ----------------------------------- 844 -- Get_Comes_From_Source_Default -- 845 ----------------------------------- 846 847 function Get_Comes_From_Source_Default return Boolean is 848 begin 849 return Default_Node.Comes_From_Source; 850 end Get_Comes_From_Source_Default; 851 852 ------------------- 853 -- Has_Extension -- 854 ------------------- 855 856 function Has_Extension (N : Node_Id) return Boolean is 857 begin 858 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension; 859 end Has_Extension; 860 861 ---------------- 862 -- Initialize -- 863 ---------------- 864 865 procedure Initialize is 866 Dummy : Node_Id; 867 pragma Warnings (Off, Dummy); 868 869 begin 870 Node_Count := 0; 871 Atree_Private_Part.Nodes.Init; 872 Orig_Nodes.Init; 873 874 -- Allocate Empty node 875 876 Dummy := New_Node (N_Empty, No_Location); 877 Set_Name1 (Empty, No_Name); 878 879 -- Allocate Error node, and set Error_Posted, since we certainly 880 -- only generate an Error node if we do post some kind of error! 881 882 Dummy := New_Node (N_Error, No_Location); 883 Set_Name1 (Error, Error_Name); 884 Set_Error_Posted (Error, True); 885 886 -- Set global variables for New_Copy_Tree: 887 NCT_Hash_Tables_Used := False; 888 NCT_Table_Entries := 0; 889 NCT_Hash_Table_Setup := False; 890 end Initialize; 891 892 -------------------------- 893 -- Is_Rewrite_Insertion -- 894 -------------------------- 895 896 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is 897 begin 898 return Nodes.Table (Node).Rewrite_Ins; 899 end Is_Rewrite_Insertion; 900 901 ----------------------------- 902 -- Is_Rewrite_Substitution -- 903 ----------------------------- 904 905 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is 906 begin 907 return Orig_Nodes.Table (Node) /= Node; 908 end Is_Rewrite_Substitution; 909 910 ------------------ 911 -- Last_Node_Id -- 912 ------------------ 913 914 function Last_Node_Id return Node_Id is 915 begin 916 return Nodes.Last; 917 end Last_Node_Id; 918 919 ---------- 920 -- Lock -- 921 ---------- 922 923 procedure Lock is 924 begin 925 Nodes.Locked := True; 926 Orig_Nodes.Locked := True; 927 Nodes.Release; 928 Orig_Nodes.Release; 929 end Lock; 930 931 ---------------------------- 932 -- Mark_Rewrite_Insertion -- 933 ---------------------------- 934 935 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is 936 begin 937 Nodes.Table (New_Node).Rewrite_Ins := True; 938 end Mark_Rewrite_Insertion; 939 940 -------------- 941 -- New_Copy -- 942 -------------- 943 944 function New_Copy (Source : Node_Id) return Node_Id is 945 New_Id : Node_Id; 946 947 begin 948 if Source <= Empty_Or_Error then 949 return Source; 950 951 else 952 Nodes.Increment_Last; 953 New_Id := Nodes.Last; 954 Nodes.Table (New_Id) := Nodes.Table (Source); 955 Nodes.Table (New_Id).Link := Empty_List_Or_Node; 956 Nodes.Table (New_Id).In_List := False; 957 Nodes.Table (New_Id).Rewrite_Ins := False; 958 959 Orig_Nodes.Increment_Last; 960 Orig_Nodes.Table (New_Id) := New_Id; 961 962 if Has_Extension (Source) then 963 Nodes.Increment_Last; 964 Nodes.Table (New_Id + 1) := Nodes.Table (Source + 1); 965 Nodes.Increment_Last; 966 Nodes.Table (New_Id + 2) := Nodes.Table (Source + 2); 967 Nodes.Increment_Last; 968 Nodes.Table (New_Id + 3) := Nodes.Table (Source + 3); 969 970 Orig_Nodes.Set_Last (Nodes.Last); 971 end if; 972 973 Allocate_List_Tables (Nodes.Last); 974 Node_Count := Node_Count + 1; 975 return New_Id; 976 end if; 977 end New_Copy; 978 979 ------------------- 980 -- New_Copy_Tree -- 981 ------------------- 982 983 -- Our approach here requires a two pass traversal of the tree. The 984 -- first pass visits all nodes that eventually will be copied looking 985 -- for defining Itypes. If any defining Itypes are found, then they are 986 -- copied, and an entry is added to the replacement map. In the second 987 -- phase, the tree is copied, using the replacement map to replace any 988 -- Itype references within the copied tree. 989 990 -- The following hash tables are used if the Map supplied has more 991 -- than hash threshhold entries to speed up access to the map. If 992 -- there are fewer entries, then the map is searched sequentially 993 -- (because setting up a hash table for only a few entries takes 994 -- more time than it saves. 995 996 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num; 997 -- Hash function used for hash operations 998 999 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num is 1000 begin 1001 return Nat (E) mod (NCT_Header_Num'Last + 1); 1002 end New_Copy_Hash; 1003 1004 -- The hash table NCT_Assoc associates old entities in the table 1005 -- with their corresponding new entities (i.e. the pairs of entries 1006 -- presented in the original Map argument are Key-Element pairs). 1007 1008 package NCT_Assoc is new Simple_HTable ( 1009 Header_Num => NCT_Header_Num, 1010 Element => Entity_Id, 1011 No_Element => Empty, 1012 Key => Entity_Id, 1013 Hash => New_Copy_Hash, 1014 Equal => Types."="); 1015 1016 -- The hash table NCT_Itype_Assoc contains entries only for those 1017 -- old nodes which have a non-empty Associated_Node_For_Itype set. 1018 -- The key is the associated node, and the element is the new node 1019 -- itself (NOT the associated node for the new node). 1020 1021 package NCT_Itype_Assoc is new Simple_HTable ( 1022 Header_Num => NCT_Header_Num, 1023 Element => Entity_Id, 1024 No_Element => Empty, 1025 Key => Entity_Id, 1026 Hash => New_Copy_Hash, 1027 Equal => Types."="); 1028 1029 -- Start of New_Copy_Tree function 1030 1031 function New_Copy_Tree 1032 (Source : Node_Id; 1033 Map : Elist_Id := No_Elist; 1034 New_Sloc : Source_Ptr := No_Location; 1035 New_Scope : Entity_Id := Empty) 1036 return Node_Id 1037 is 1038 Actual_Map : Elist_Id := Map; 1039 -- This is the actual map for the copy. It is initialized with the 1040 -- given elements, and then enlarged as required for Itypes that are 1041 -- copied during the first phase of the copy operation. The visit 1042 -- procedures add elements to this map as Itypes are encountered. 1043 -- The reason we cannot use Map directly, is that it may well be 1044 -- (and normally is) initialized to No_Elist, and if we have mapped 1045 -- entities, we have to reset it to point to a real Elist. 1046 1047 function Assoc (N : Node_Or_Entity_Id) return Node_Id; 1048 -- Called during second phase to map entities into their corresponding 1049 -- copies using Actual_Map. If the argument is not an entity, or is not 1050 -- in Actual_Map, then it is returned unchanged. 1051 1052 procedure Build_NCT_Hash_Tables; 1053 -- Builds hash tables (number of elements >= threshold value) 1054 1055 function Copy_Elist_With_Replacement 1056 (Old_Elist : Elist_Id) 1057 return Elist_Id; 1058 -- Called during second phase to copy element list doing replacements. 1059 1060 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id); 1061 -- Called during the second phase to process a copied Itype. The actual 1062 -- copy happened during the first phase (so that we could make the entry 1063 -- in the mapping), but we still have to deal with the descendents of 1064 -- the copied Itype and copy them where necessary. 1065 1066 function Copy_List_With_Replacement (Old_List : List_Id) return List_Id; 1067 -- Called during second phase to copy list doing replacements. 1068 1069 function Copy_Node_With_Replacement (Old_Node : Node_Id) return Node_Id; 1070 -- Called during second phase to copy node doing replacements 1071 1072 procedure Visit_Elist (E : Elist_Id); 1073 -- Called during first phase to visit all elements of an Elist 1074 1075 procedure Visit_Field (F : Union_Id; N : Node_Id); 1076 -- Visit a single field, recursing to call Visit_Node or Visit_List 1077 -- if the field is a syntactic descendent of the current node (i.e. 1078 -- its parent is Node N). 1079 1080 procedure Visit_Itype (Old_Itype : Entity_Id); 1081 -- Called during first phase to visit subsidiary fields of a defining 1082 -- Itype, and also create a copy and make an entry in the replacement 1083 -- map for the new copy. 1084 1085 procedure Visit_List (L : List_Id); 1086 -- Called during first phase to visit all elements of a List 1087 1088 procedure Visit_Node (N : Node_Or_Entity_Id); 1089 -- Called during first phase to visit a node and all its subtrees 1090 1091 ----------- 1092 -- Assoc -- 1093 ----------- 1094 1095 function Assoc (N : Node_Or_Entity_Id) return Node_Id is 1096 E : Elmt_Id; 1097 Ent : Entity_Id; 1098 1099 begin 1100 if not Has_Extension (N) or else No (Actual_Map) then 1101 return N; 1102 1103 elsif NCT_Hash_Tables_Used then 1104 Ent := NCT_Assoc.Get (Entity_Id (N)); 1105 1106 if Present (Ent) then 1107 return Ent; 1108 else 1109 return N; 1110 end if; 1111 1112 -- No hash table used, do serial search 1113 1114 else 1115 E := First_Elmt (Actual_Map); 1116 while Present (E) loop 1117 if Node (E) = N then 1118 return Node (Next_Elmt (E)); 1119 else 1120 E := Next_Elmt (Next_Elmt (E)); 1121 end if; 1122 end loop; 1123 end if; 1124 1125 return N; 1126 end Assoc; 1127 1128 --------------------------- 1129 -- Build_NCT_Hash_Tables -- 1130 --------------------------- 1131 1132 procedure Build_NCT_Hash_Tables is 1133 Elmt : Elmt_Id; 1134 Ent : Entity_Id; 1135 begin 1136 if NCT_Hash_Table_Setup then 1137 NCT_Assoc.Reset; 1138 NCT_Itype_Assoc.Reset; 1139 end if; 1140 1141 Elmt := First_Elmt (Actual_Map); 1142 while Present (Elmt) loop 1143 Ent := Node (Elmt); 1144 Next_Elmt (Elmt); 1145 NCT_Assoc.Set (Ent, Node (Elmt)); 1146 Next_Elmt (Elmt); 1147 1148 if Is_Type (Ent) then 1149 declare 1150 Anode : constant Entity_Id := 1151 Associated_Node_For_Itype (Ent); 1152 1153 begin 1154 if Present (Anode) then 1155 NCT_Itype_Assoc.Set (Anode, Node (Elmt)); 1156 end if; 1157 end; 1158 end if; 1159 end loop; 1160 1161 NCT_Hash_Tables_Used := True; 1162 NCT_Hash_Table_Setup := True; 1163 end Build_NCT_Hash_Tables; 1164 1165 --------------------------------- 1166 -- Copy_Elist_With_Replacement -- 1167 --------------------------------- 1168 1169 function Copy_Elist_With_Replacement 1170 (Old_Elist : Elist_Id) 1171 return Elist_Id 1172 is 1173 M : Elmt_Id; 1174 New_Elist : Elist_Id; 1175 1176 begin 1177 if No (Old_Elist) then 1178 return No_Elist; 1179 1180 else 1181 New_Elist := New_Elmt_List; 1182 M := First_Elmt (Old_Elist); 1183 1184 while Present (M) loop 1185 Append_Elmt (Copy_Node_With_Replacement (Node (M)), New_Elist); 1186 Next_Elmt (M); 1187 end loop; 1188 end if; 1189 1190 return New_Elist; 1191 end Copy_Elist_With_Replacement; 1192 1193 --------------------------------- 1194 -- Copy_Itype_With_Replacement -- 1195 --------------------------------- 1196 1197 -- This routine exactly parallels its phase one analog Visit_Itype, 1198 -- and like that routine, knows far too many semantic details about 1199 -- the descendents of Itypes and whether they need copying or not. 1200 1201 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id) is 1202 begin 1203 -- Translate Next_Entity, Scope and Etype fields, in case they 1204 -- reference entities that have been mapped into copies. 1205 1206 Set_Next_Entity (New_Itype, Assoc (Next_Entity (New_Itype))); 1207 Set_Etype (New_Itype, Assoc (Etype (New_Itype))); 1208 1209 if Present (New_Scope) then 1210 Set_Scope (New_Itype, New_Scope); 1211 else 1212 Set_Scope (New_Itype, Assoc (Scope (New_Itype))); 1213 end if; 1214 1215 -- Copy referenced fields 1216 1217 if Is_Discrete_Type (New_Itype) then 1218 Set_Scalar_Range (New_Itype, 1219 Copy_Node_With_Replacement (Scalar_Range (New_Itype))); 1220 1221 elsif Has_Discriminants (Base_Type (New_Itype)) then 1222 Set_Discriminant_Constraint (New_Itype, 1223 Copy_Elist_With_Replacement 1224 (Discriminant_Constraint (New_Itype))); 1225 1226 elsif Is_Array_Type (New_Itype) then 1227 if Present (First_Index (New_Itype)) then 1228 Set_First_Index (New_Itype, 1229 First (Copy_List_With_Replacement 1230 (List_Containing (First_Index (New_Itype))))); 1231 end if; 1232 1233 if Is_Packed (New_Itype) then 1234 Set_Packed_Array_Type (New_Itype, 1235 Copy_Node_With_Replacement 1236 (Packed_Array_Type (New_Itype))); 1237 end if; 1238 end if; 1239 end Copy_Itype_With_Replacement; 1240 1241 -------------------------------- 1242 -- Copy_List_With_Replacement -- 1243 -------------------------------- 1244 1245 function Copy_List_With_Replacement 1246 (Old_List : List_Id) 1247 return List_Id 1248 is 1249 New_List : List_Id; 1250 E : Node_Id; 1251 1252 begin 1253 if Old_List = No_List then 1254 return No_List; 1255 1256 else 1257 New_List := Empty_List; 1258 E := First (Old_List); 1259 while Present (E) loop 1260 Append (Copy_Node_With_Replacement (E), New_List); 1261 Next (E); 1262 end loop; 1263 1264 return New_List; 1265 end if; 1266 end Copy_List_With_Replacement; 1267 1268 -------------------------------- 1269 -- Copy_Node_With_Replacement -- 1270 -------------------------------- 1271 1272 function Copy_Node_With_Replacement 1273 (Old_Node : Node_Id) 1274 return Node_Id 1275 is 1276 New_Node : Node_Id; 1277 1278 function Copy_Field_With_Replacement 1279 (Field : Union_Id) 1280 return Union_Id; 1281 -- Given Field, which is a field of Old_Node, return a copy of it 1282 -- if it is a syntactic field (i.e. its parent is Node), setting 1283 -- the parent of the copy to poit to New_Node. Otherwise returns 1284 -- the field (possibly mapped if it is an entity). 1285 1286 --------------------------------- 1287 -- Copy_Field_With_Replacement -- 1288 --------------------------------- 1289 1290 function Copy_Field_With_Replacement 1291 (Field : Union_Id) 1292 return Union_Id 1293 is 1294 begin 1295 if Field = Union_Id (Empty) then 1296 return Field; 1297 1298 elsif Field in Node_Range then 1299 declare 1300 Old_N : constant Node_Id := Node_Id (Field); 1301 New_N : Node_Id; 1302 1303 begin 1304 -- If syntactic field, as indicated by the parent pointer 1305 -- being set, then copy the referenced node recursively. 1306 1307 if Parent (Old_N) = Old_Node then 1308 New_N := Copy_Node_With_Replacement (Old_N); 1309 1310 if New_N /= Old_N then 1311 Set_Parent (New_N, New_Node); 1312 end if; 1313 1314 -- For semantic fields, update possible entity reference 1315 -- from the replacement map. 1316 1317 else 1318 New_N := Assoc (Old_N); 1319 end if; 1320 1321 return Union_Id (New_N); 1322 end; 1323 1324 elsif Field in List_Range then 1325 declare 1326 Old_L : constant List_Id := List_Id (Field); 1327 New_L : List_Id; 1328 1329 begin 1330 -- If syntactic field, as indicated by the parent pointer, 1331 -- then recursively copy the entire referenced list. 1332 1333 if Parent (Old_L) = Old_Node then 1334 New_L := Copy_List_With_Replacement (Old_L); 1335 Set_Parent (New_L, New_Node); 1336 1337 -- For semantic list, just returned unchanged 1338 1339 else 1340 New_L := Old_L; 1341 end if; 1342 1343 return Union_Id (New_L); 1344 end; 1345 1346 -- Anything other than a list or a node is returned unchanged 1347 1348 else 1349 return Field; 1350 end if; 1351 end Copy_Field_With_Replacement; 1352 1353 -- Start of processing for Copy_Node_With_Replacement 1354 1355 begin 1356 if Old_Node <= Empty_Or_Error then 1357 return Old_Node; 1358 1359 elsif Has_Extension (Old_Node) then 1360 return Assoc (Old_Node); 1361 1362 else 1363 Nodes.Increment_Last; 1364 New_Node := Nodes.Last; 1365 Nodes.Table (New_Node) := Nodes.Table (Old_Node); 1366 Nodes.Table (New_Node).Link := Empty_List_Or_Node; 1367 Nodes.Table (New_Node).In_List := False; 1368 Node_Count := Node_Count + 1; 1369 1370 Orig_Nodes.Increment_Last; 1371 Allocate_List_Tables (Nodes.Last); 1372 1373 Orig_Nodes.Table (Nodes.Last) := Nodes.Last; 1374 1375 -- If the node we are copying is the associated node of a 1376 -- previously copied Itype, then adjust the associated node 1377 -- of the copy of that Itype accordingly. 1378 1379 if Present (Actual_Map) then 1380 declare 1381 E : Elmt_Id; 1382 Ent : Entity_Id; 1383 1384 begin 1385 -- Case of hash table used 1386 1387 if NCT_Hash_Tables_Used then 1388 Ent := NCT_Itype_Assoc.Get (Old_Node); 1389 1390 if Present (Ent) then 1391 Set_Associated_Node_For_Itype (Ent, New_Node); 1392 end if; 1393 1394 -- Case of no hash table used 1395 1396 else 1397 E := First_Elmt (Actual_Map); 1398 while Present (E) loop 1399 if Is_Itype (Node (E)) 1400 and then 1401 Old_Node = Associated_Node_For_Itype (Node (E)) 1402 then 1403 Set_Associated_Node_For_Itype 1404 (Node (Next_Elmt (E)), New_Node); 1405 end if; 1406 1407 E := Next_Elmt (Next_Elmt (E)); 1408 end loop; 1409 end if; 1410 end; 1411 end if; 1412 1413 -- Recursively copy descendents 1414 1415 Set_Field1 1416 (New_Node, Copy_Field_With_Replacement (Field1 (New_Node))); 1417 Set_Field2 1418 (New_Node, Copy_Field_With_Replacement (Field2 (New_Node))); 1419 Set_Field3 1420 (New_Node, Copy_Field_With_Replacement (Field3 (New_Node))); 1421 Set_Field4 1422 (New_Node, Copy_Field_With_Replacement (Field4 (New_Node))); 1423 Set_Field5 1424 (New_Node, Copy_Field_With_Replacement (Field5 (New_Node))); 1425 1426 -- If the original is marked as a rewrite insertion, then unmark 1427 -- the copy, since we inserted the original, not the copy. 1428 1429 Nodes.Table (New_Node).Rewrite_Ins := False; 1430 1431 -- Adjust Sloc of new node if necessary 1432 1433 if New_Sloc /= No_Location then 1434 Set_Sloc (New_Node, New_Sloc); 1435 1436 -- If we adjust the Sloc, then we are essentially making 1437 -- a completely new node, so the Comes_From_Source flag 1438 -- should be reset to the proper default value. 1439 1440 Nodes.Table (New_Node).Comes_From_Source := 1441 Default_Node.Comes_From_Source; 1442 end if; 1443 1444 -- Reset First_Real_Statement for Handled_Sequence_Of_Statements. 1445 -- The replacement mechanism applies to entities, and is not used 1446 -- here. Eventually we may need a more general graph-copying 1447 -- routine. For now, do a sequential search to find desired node. 1448 1449 if Nkind (Old_Node) = N_Handled_Sequence_Of_Statements 1450 and then Present (First_Real_Statement (Old_Node)) 1451 then 1452 declare 1453 Old_F : constant Node_Id := First_Real_Statement (Old_Node); 1454 N1, N2 : Node_Id; 1455 1456 begin 1457 N1 := First (Statements (Old_Node)); 1458 N2 := First (Statements (New_Node)); 1459 1460 while N1 /= Old_F loop 1461 Next (N1); 1462 Next (N2); 1463 end loop; 1464 1465 Set_First_Real_Statement (New_Node, N2); 1466 end; 1467 end if; 1468 end if; 1469 1470 -- All done, return copied node 1471 1472 return New_Node; 1473 end Copy_Node_With_Replacement; 1474 1475 ----------------- 1476 -- Visit_Elist -- 1477 ----------------- 1478 1479 procedure Visit_Elist (E : Elist_Id) is 1480 Elmt : Elmt_Id; 1481 1482 begin 1483 if Present (E) then 1484 Elmt := First_Elmt (E); 1485 1486 while Elmt /= No_Elmt loop 1487 Visit_Node (Node (Elmt)); 1488 Next_Elmt (Elmt); 1489 end loop; 1490 end if; 1491 end Visit_Elist; 1492 1493 ----------------- 1494 -- Visit_Field -- 1495 ----------------- 1496 1497 procedure Visit_Field (F : Union_Id; N : Node_Id) is 1498 begin 1499 if F = Union_Id (Empty) then 1500 return; 1501 1502 elsif F in Node_Range then 1503 1504 -- Copy node if it is syntactic, i.e. its parent pointer is 1505 -- set to point to the field that referenced it (certain 1506 -- Itypes will also meet this criterion, which is fine, since 1507 -- these are clearly Itypes that do need to be copied, since 1508 -- we are copying their parent.) 1509 1510 if Parent (Node_Id (F)) = N then 1511 Visit_Node (Node_Id (F)); 1512 return; 1513 1514 -- Another case, if we are pointing to an Itype, then we want 1515 -- to copy it if its associated node is somewhere in the tree 1516 -- being copied. 1517 1518 -- Note: the exclusion of self-referential copies is just an 1519 -- optimization, since the search of the already copied list 1520 -- would catch it, but it is a common case (Etype pointing 1521 -- to itself for an Itype that is a base type). 1522 1523 elsif Has_Extension (Node_Id (F)) 1524 and then Is_Itype (Entity_Id (F)) 1525 and then Node_Id (F) /= N 1526 then 1527 declare 1528 P : Node_Id; 1529 1530 begin 1531 P := Associated_Node_For_Itype (Node_Id (F)); 1532 while Present (P) loop 1533 if P = Source then 1534 Visit_Node (Node_Id (F)); 1535 return; 1536 else 1537 P := Parent (P); 1538 end if; 1539 end loop; 1540 1541 -- An Itype whose parent is not being copied definitely 1542 -- should NOT be copied, since it does not belong in any 1543 -- sense to the copied subtree. 1544 1545 return; 1546 end; 1547 end if; 1548 1549 elsif F in List_Range 1550 and then Parent (List_Id (F)) = N 1551 then 1552 Visit_List (List_Id (F)); 1553 return; 1554 end if; 1555 end Visit_Field; 1556 1557 ----------------- 1558 -- Visit_Itype -- 1559 ----------------- 1560 1561 -- Note: we are relying on far too much semantic knowledge in this 1562 -- routine, it really should just do a blind replacement of all 1563 -- fields, or at least a more blind replacement. For example, we 1564 -- do not deal with corresponding record types, and that works 1565 -- because we have no Itypes of task types, but nowhere is there 1566 -- a guarantee that this will always be the case. ??? 1567 1568 procedure Visit_Itype (Old_Itype : Entity_Id) is 1569 New_Itype : Entity_Id; 1570 E : Elmt_Id; 1571 Ent : Entity_Id; 1572 1573 begin 1574 -- Itypes that describe the designated type of access to subprograms 1575 -- have the structure of subprogram declarations, with signatures, 1576 -- etc. Either we duplicate the signatures completely, or choose to 1577 -- share such itypes, which is fine because their elaboration will 1578 -- have no side effects. In any case, this is additional semantic 1579 -- information that seems awkward to have in atree. 1580 1581 if Ekind (Old_Itype) = E_Subprogram_Type then 1582 return; 1583 end if; 1584 1585 New_Itype := New_Copy (Old_Itype); 1586 1587 -- If our associated node is an entity that has already been copied, 1588 -- then set the associated node of the copy to point to the right 1589 -- copy. If we have copied an Itype that is itself the associated 1590 -- node of some previously copied Itype, then we set the right 1591 -- pointer in the other direction. 1592 1593 if Present (Actual_Map) then 1594 1595 -- Case of hash tables used 1596 1597 if NCT_Hash_Tables_Used then 1598 1599 Ent := NCT_Assoc.Get (Associated_Node_For_Itype (Old_Itype)); 1600 if Present (Ent) then 1601 Set_Associated_Node_For_Itype (New_Itype, Ent); 1602 end if; 1603 1604 Ent := NCT_Itype_Assoc.Get (Old_Itype); 1605 if Present (Ent) then 1606 Set_Associated_Node_For_Itype (Ent, New_Itype); 1607 end if; 1608 1609 -- Case of hash tables not used 1610 1611 else 1612 E := First_Elmt (Actual_Map); 1613 while Present (E) loop 1614 if Associated_Node_For_Itype (Old_Itype) = Node (E) then 1615 Set_Associated_Node_For_Itype 1616 (New_Itype, Node (Next_Elmt (E))); 1617 end if; 1618 1619 if Is_Type (Node (E)) 1620 and then 1621 Old_Itype = Associated_Node_For_Itype (Node (E)) 1622 then 1623 Set_Associated_Node_For_Itype 1624 (Node (Next_Elmt (E)), New_Itype); 1625 end if; 1626 1627 E := Next_Elmt (Next_Elmt (E)); 1628 end loop; 1629 end if; 1630 end if; 1631 1632 if Present (Freeze_Node (New_Itype)) then 1633 Set_Is_Frozen (New_Itype, False); 1634 Set_Freeze_Node (New_Itype, Empty); 1635 end if; 1636 1637 -- Add new association to map 1638 1639 if No (Actual_Map) then 1640 Actual_Map := New_Elmt_List; 1641 end if; 1642 1643 Append_Elmt (Old_Itype, Actual_Map); 1644 Append_Elmt (New_Itype, Actual_Map); 1645 1646 if NCT_Hash_Tables_Used then 1647 NCT_Assoc.Set (Old_Itype, New_Itype); 1648 1649 else 1650 NCT_Table_Entries := NCT_Table_Entries + 1; 1651 1652 if NCT_Table_Entries > NCT_Hash_Threshhold then 1653 Build_NCT_Hash_Tables; 1654 end if; 1655 end if; 1656 1657 -- If a record subtype is simply copied, the entity list will be 1658 -- shared. Thus cloned_Subtype must be set to indicate the sharing. 1659 1660 if Ekind (Old_Itype) = E_Record_Subtype 1661 or else Ekind (Old_Itype) = E_Class_Wide_Subtype 1662 then 1663 Set_Cloned_Subtype (New_Itype, Old_Itype); 1664 end if; 1665 1666 -- Visit descendents that eventually get copied 1667 1668 Visit_Field (Union_Id (Etype (Old_Itype)), Old_Itype); 1669 1670 if Is_Discrete_Type (Old_Itype) then 1671 Visit_Field (Union_Id (Scalar_Range (Old_Itype)), Old_Itype); 1672 1673 elsif Has_Discriminants (Base_Type (Old_Itype)) then 1674 -- ??? This should involve call to Visit_Field. 1675 Visit_Elist (Discriminant_Constraint (Old_Itype)); 1676 1677 elsif Is_Array_Type (Old_Itype) then 1678 if Present (First_Index (Old_Itype)) then 1679 Visit_Field (Union_Id (List_Containing 1680 (First_Index (Old_Itype))), 1681 Old_Itype); 1682 end if; 1683 1684 if Is_Packed (Old_Itype) then 1685 Visit_Field (Union_Id (Packed_Array_Type (Old_Itype)), 1686 Old_Itype); 1687 end if; 1688 end if; 1689 end Visit_Itype; 1690 1691 ---------------- 1692 -- Visit_List -- 1693 ---------------- 1694 1695 procedure Visit_List (L : List_Id) is 1696 N : Node_Id; 1697 1698 begin 1699 if L /= No_List then 1700 N := First (L); 1701 1702 while Present (N) loop 1703 Visit_Node (N); 1704 Next (N); 1705 end loop; 1706 end if; 1707 end Visit_List; 1708 1709 ---------------- 1710 -- Visit_Node -- 1711 ---------------- 1712 1713 procedure Visit_Node (N : Node_Or_Entity_Id) is 1714 1715 -- Start of processing for Visit_Node 1716 1717 begin 1718 -- Handle case of an Itype, which must be copied 1719 1720 if Has_Extension (N) 1721 and then Is_Itype (N) 1722 then 1723 -- Nothing to do if already in the list. This can happen with an 1724 -- Itype entity that appears more than once in the tree. 1725 -- Note that we do not want to visit descendents in this case. 1726 1727 -- Test for already in list when hash table is used 1728 1729 if NCT_Hash_Tables_Used then 1730 if Present (NCT_Assoc.Get (Entity_Id (N))) then 1731 return; 1732 end if; 1733 1734 -- Test for already in list when hash table not used 1735 1736 else 1737 declare 1738 E : Elmt_Id; 1739 1740 begin 1741 if Present (Actual_Map) then 1742 E := First_Elmt (Actual_Map); 1743 while Present (E) loop 1744 if Node (E) = N then 1745 return; 1746 else 1747 E := Next_Elmt (Next_Elmt (E)); 1748 end if; 1749 end loop; 1750 end if; 1751 end; 1752 end if; 1753 1754 Visit_Itype (N); 1755 end if; 1756 1757 -- Visit descendents 1758 1759 Visit_Field (Field1 (N), N); 1760 Visit_Field (Field2 (N), N); 1761 Visit_Field (Field3 (N), N); 1762 Visit_Field (Field4 (N), N); 1763 Visit_Field (Field5 (N), N); 1764 end Visit_Node; 1765 1766 -- Start of processing for New_Copy_Tree 1767 1768 begin 1769 Actual_Map := Map; 1770 1771 -- See if we should use hash table 1772 1773 if No (Actual_Map) then 1774 NCT_Hash_Tables_Used := False; 1775 1776 else 1777 declare 1778 Elmt : Elmt_Id; 1779 1780 begin 1781 NCT_Table_Entries := 0; 1782 Elmt := First_Elmt (Actual_Map); 1783 while Present (Elmt) loop 1784 NCT_Table_Entries := NCT_Table_Entries + 1; 1785 Next_Elmt (Elmt); 1786 Next_Elmt (Elmt); 1787 end loop; 1788 1789 if NCT_Table_Entries > NCT_Hash_Threshhold then 1790 Build_NCT_Hash_Tables; 1791 else 1792 NCT_Hash_Tables_Used := False; 1793 end if; 1794 end; 1795 end if; 1796 1797 -- Hash table set up if required, now start phase one by visiting 1798 -- top node (we will recursively visit the descendents). 1799 1800 Visit_Node (Source); 1801 1802 -- Now the second phase of the copy can start. First we process 1803 -- all the mapped entities, copying their descendents. 1804 1805 if Present (Actual_Map) then 1806 declare 1807 Elmt : Elmt_Id; 1808 New_Itype : Entity_Id; 1809 1810 begin 1811 Elmt := First_Elmt (Actual_Map); 1812 while Present (Elmt) loop 1813 Next_Elmt (Elmt); 1814 New_Itype := Node (Elmt); 1815 Copy_Itype_With_Replacement (New_Itype); 1816 Next_Elmt (Elmt); 1817 end loop; 1818 end; 1819 end if; 1820 1821 -- Now we can copy the actual tree 1822 1823 return Copy_Node_With_Replacement (Source); 1824 end New_Copy_Tree; 1825 1826 ---------------- 1827 -- New_Entity -- 1828 ---------------- 1829 1830 function New_Entity 1831 (New_Node_Kind : Node_Kind; 1832 New_Sloc : Source_Ptr) 1833 return Entity_Id 1834 is 1835 Ent : Entity_Id; 1836 1837 procedure New_Entity_Debugging_Output; 1838 -- Debugging routine for debug flag N 1839 1840 --------------------------------- 1841 -- New_Entity_Debugging_Output -- 1842 --------------------------------- 1843 1844 procedure New_Entity_Debugging_Output is 1845 begin 1846 if Debug_Flag_N then 1847 Write_Str ("Allocate entity, Id = "); 1848 Write_Int (Int (Nodes.Last)); 1849 Write_Str (" "); 1850 Write_Location (New_Sloc); 1851 Write_Str (" "); 1852 Write_Str (Node_Kind'Image (New_Node_Kind)); 1853 Write_Eol; 1854 end if; 1855 end New_Entity_Debugging_Output; 1856 1857 pragma Inline (New_Entity_Debugging_Output); 1858 1859 -- Start of processing for New_Entity 1860 1861 begin 1862 pragma Assert (New_Node_Kind in N_Entity); 1863 1864 Nodes.Increment_Last; 1865 Ent := Nodes.Last; 1866 1867 -- If this is a node with a real location and we are generating 1868 -- source nodes, then reset Current_Error_Node. This is useful 1869 -- if we bomb during parsing to get a error location for the bomb. 1870 1871 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then 1872 Current_Error_Node := Ent; 1873 end if; 1874 1875 Nodes.Table (Nodes.Last) := Default_Node; 1876 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind; 1877 Nodes.Table (Nodes.Last).Sloc := New_Sloc; 1878 pragma Debug (New_Entity_Debugging_Output); 1879 1880 Orig_Nodes.Increment_Last; 1881 Orig_Nodes.Table (Nodes.Last) := Nodes.Last; 1882 1883 Nodes.Increment_Last; 1884 Nodes.Table (Nodes.Last) := Default_Node_Extension; 1885 1886 Nodes.Increment_Last; 1887 Nodes.Table (Nodes.Last) := Default_Node_Extension; 1888 1889 Nodes.Increment_Last; 1890 Nodes.Table (Nodes.Last) := Default_Node_Extension; 1891 1892 Orig_Nodes.Set_Last (Nodes.Last); 1893 Allocate_List_Tables (Nodes.Last); 1894 Node_Count := Node_Count + 1; 1895 return Ent; 1896 end New_Entity; 1897 1898 -------------- 1899 -- New_Node -- 1900 -------------- 1901 1902 function New_Node 1903 (New_Node_Kind : Node_Kind; 1904 New_Sloc : Source_Ptr) 1905 return Node_Id 1906 is 1907 Nod : Node_Id; 1908 1909 procedure New_Node_Debugging_Output; 1910 -- Debugging routine for debug flag N 1911 1912 -------------------------- 1913 -- New_Debugging_Output -- 1914 -------------------------- 1915 1916 procedure New_Node_Debugging_Output is 1917 begin 1918 if Debug_Flag_N then 1919 Write_Str ("Allocate node, Id = "); 1920 Write_Int (Int (Nodes.Last)); 1921 Write_Str (" "); 1922 Write_Location (New_Sloc); 1923 Write_Str (" "); 1924 Write_Str (Node_Kind'Image (New_Node_Kind)); 1925 Write_Eol; 1926 end if; 1927 end New_Node_Debugging_Output; 1928 1929 pragma Inline (New_Node_Debugging_Output); 1930 1931 -- Start of processing for New_Node 1932 1933 begin 1934 pragma Assert (New_Node_Kind not in N_Entity); 1935 Nodes.Increment_Last; 1936 Nodes.Table (Nodes.Last) := Default_Node; 1937 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind; 1938 Nodes.Table (Nodes.Last).Sloc := New_Sloc; 1939 pragma Debug (New_Node_Debugging_Output); 1940 Nod := Nodes.Last; 1941 1942 -- If this is a node with a real location and we are generating 1943 -- source nodes, then reset Current_Error_Node. This is useful 1944 -- if we bomb during parsing to get a error location for the bomb. 1945 1946 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then 1947 Current_Error_Node := Nod; 1948 end if; 1949 1950 Node_Count := Node_Count + 1; 1951 Orig_Nodes.Increment_Last; 1952 Allocate_List_Tables (Nodes.Last); 1953 Orig_Nodes.Table (Nodes.Last) := Nodes.Last; 1954 return Nod; 1955 end New_Node; 1956 1957 ----------- 1958 -- Nkind -- 1959 ----------- 1960 1961 function Nkind (N : Node_Id) return Node_Kind is 1962 begin 1963 return Nodes.Table (N).Nkind; 1964 end Nkind; 1965 1966 -------- 1967 -- No -- 1968 -------- 1969 1970 function No (N : Node_Id) return Boolean is 1971 begin 1972 return N = Empty; 1973 end No; 1974 1975 ------------------- 1976 -- Nodes_Address -- 1977 ------------------- 1978 1979 function Nodes_Address return System.Address is 1980 begin 1981 return Nodes.Table (First_Node_Id)'Address; 1982 end Nodes_Address; 1983 1984 --------------- 1985 -- Num_Nodes -- 1986 --------------- 1987 1988 function Num_Nodes return Nat is 1989 begin 1990 return Node_Count; 1991 end Num_Nodes; 1992 1993 ------------------- 1994 -- Original_Node -- 1995 ------------------- 1996 1997 function Original_Node (Node : Node_Id) return Node_Id is 1998 begin 1999 return Orig_Nodes.Table (Node); 2000 end Original_Node; 2001 2002 ----------------- 2003 -- Paren_Count -- 2004 ----------------- 2005 2006 function Paren_Count (N : Node_Id) return Paren_Count_Type is 2007 C : Paren_Count_Type := 0; 2008 2009 begin 2010 pragma Assert (N in Nodes.First .. Nodes.Last); 2011 2012 if Nodes.Table (N).Pflag1 then 2013 C := C + 1; 2014 end if; 2015 2016 if Nodes.Table (N).Pflag2 then 2017 C := C + 2; 2018 end if; 2019 2020 return C; 2021 end Paren_Count; 2022 2023 ------------ 2024 -- Parent -- 2025 ------------ 2026 2027 function Parent (N : Node_Id) return Node_Id is 2028 begin 2029 if Is_List_Member (N) then 2030 return Parent (List_Containing (N)); 2031 else 2032 return Node_Id (Nodes.Table (N).Link); 2033 end if; 2034 end Parent; 2035 2036 ------------- 2037 -- Present -- 2038 ------------- 2039 2040 function Present (N : Node_Id) return Boolean is 2041 begin 2042 return N /= Empty; 2043 end Present; 2044 2045 -------------------------------- 2046 -- Preserve_Comes_From_Source -- 2047 -------------------------------- 2048 2049 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is 2050 begin 2051 Nodes.Table (NewN).Comes_From_Source := 2052 Nodes.Table (OldN).Comes_From_Source; 2053 end Preserve_Comes_From_Source; 2054 2055 ------------------- 2056 -- Relocate_Node -- 2057 ------------------- 2058 2059 function Relocate_Node (Source : Node_Id) return Node_Id is 2060 New_Node : Node_Id; 2061 2062 begin 2063 if No (Source) then 2064 return Empty; 2065 end if; 2066 2067 New_Node := New_Copy (Source); 2068 Fix_Parent (Field1 (Source), Source, New_Node); 2069 Fix_Parent (Field2 (Source), Source, New_Node); 2070 Fix_Parent (Field3 (Source), Source, New_Node); 2071 Fix_Parent (Field4 (Source), Source, New_Node); 2072 Fix_Parent (Field5 (Source), Source, New_Node); 2073 2074 -- We now set the parent of the new node to be the same as the 2075 -- parent of the source. Almost always this parent will be 2076 -- replaced by a new value when the relocated node is reattached 2077 -- to the tree, but by doing it now, we ensure that this node is 2078 -- not even temporarily disconnected from the tree. Note that this 2079 -- does not happen free, because in the list case, the parent does 2080 -- not get set. 2081 2082 Set_Parent (New_Node, Parent (Source)); 2083 2084 -- If the node being relocated was a rewriting of some original 2085 -- node, then the relocated node has the same original node. 2086 2087 if Orig_Nodes.Table (Source) /= Source then 2088 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source); 2089 end if; 2090 2091 return New_Node; 2092 end Relocate_Node; 2093 2094 ------------- 2095 -- Replace -- 2096 ------------- 2097 2098 procedure Replace (Old_Node, New_Node : Node_Id) is 2099 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link; 2100 Old_InL : constant Boolean := Nodes.Table (Old_Node).In_List; 2101 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted; 2102 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source; 2103 2104 begin 2105 pragma Assert 2106 (not Has_Extension (Old_Node) 2107 and not Has_Extension (New_Node) 2108 and not Nodes.Table (New_Node).In_List); 2109 2110 -- Do copy, preserving link and in list status and comes from source 2111 2112 Nodes.Table (Old_Node) := Nodes.Table (New_Node); 2113 Nodes.Table (Old_Node).Link := Old_Link; 2114 Nodes.Table (Old_Node).In_List := Old_InL; 2115 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS; 2116 Nodes.Table (Old_Node).Error_Posted := Old_Post; 2117 2118 -- Fix parents of substituted node, since it has changed identity 2119 2120 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node); 2121 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node); 2122 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node); 2123 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node); 2124 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node); 2125 2126 -- Since we are doing a replace, we assume that the original node 2127 -- is intended to become the new replaced node. The call would be 2128 -- to Rewrite_Substitute_Node if there were an intention to save 2129 -- the original node. 2130 2131 Orig_Nodes.Table (Old_Node) := Old_Node; 2132 2133 -- Finally delete the source, since it is now copied 2134 2135 Delete_Node (New_Node); 2136 end Replace; 2137 2138 ------------- 2139 -- Rewrite -- 2140 ------------- 2141 2142 procedure Rewrite (Old_Node, New_Node : Node_Id) is 2143 2144 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link; 2145 Old_In_List : constant Boolean := Nodes.Table (Old_Node).In_List; 2146 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted; 2147 -- These three fields are always preserved in the new node 2148 2149 Old_Paren_Count : Paren_Count_Type; 2150 Old_Must_Not_Freeze : Boolean; 2151 -- These fields are preserved in the new node only if the new node 2152 -- and the old node are both subexpression nodes. 2153 2154 -- Note: it is a violation of abstraction levels for Must_Not_Freeze 2155 -- to be referenced like this. ??? 2156 2157 Sav_Node : Node_Id; 2158 2159 begin 2160 pragma Assert 2161 (not Has_Extension (Old_Node) 2162 and not Has_Extension (New_Node) 2163 and not Nodes.Table (New_Node).In_List); 2164 2165 if Nkind (Old_Node) in N_Subexpr then 2166 Old_Paren_Count := Paren_Count (Old_Node); 2167 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node); 2168 else 2169 Old_Paren_Count := 0; 2170 Old_Must_Not_Freeze := False; 2171 end if; 2172 2173 -- Allocate a new node, to be used to preserve the original contents 2174 -- of the Old_Node, for possible later retrival by Original_Node and 2175 -- make an entry in the Orig_Nodes table. This is only done if we have 2176 -- not already rewritten the node, as indicated by an Orig_Nodes entry 2177 -- that does not reference the Old_Node. 2178 2179 if Orig_Nodes.Table (Old_Node) = Old_Node then 2180 Nodes.Increment_Last; 2181 Sav_Node := Nodes.Last; 2182 Nodes.Table (Sav_Node) := Nodes.Table (Old_Node); 2183 Nodes.Table (Sav_Node).In_List := False; 2184 Nodes.Table (Sav_Node).Link := Union_Id (Parent (Old_Node)); 2185 2186 Orig_Nodes.Increment_Last; 2187 Allocate_List_Tables (Nodes.Last); 2188 2189 Orig_Nodes.Table (Sav_Node) := Sav_Node; 2190 Orig_Nodes.Table (Old_Node) := Sav_Node; 2191 end if; 2192 2193 -- Copy substitute node into place, preserving old fields as required 2194 2195 Nodes.Table (Old_Node) := Nodes.Table (New_Node); 2196 Nodes.Table (Old_Node).Link := Old_Link; 2197 Nodes.Table (Old_Node).In_List := Old_In_List; 2198 Nodes.Table (Old_Node).Error_Posted := Old_Error_P; 2199 2200 if Nkind (New_Node) in N_Subexpr then 2201 Set_Paren_Count (Old_Node, Old_Paren_Count); 2202 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze); 2203 end if; 2204 2205 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node); 2206 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node); 2207 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node); 2208 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node); 2209 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node); 2210 end Rewrite; 2211 2212 ------------------ 2213 -- Set_Analyzed -- 2214 ------------------ 2215 2216 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is 2217 begin 2218 Nodes.Table (N).Analyzed := Val; 2219 end Set_Analyzed; 2220 2221 --------------------------- 2222 -- Set_Comes_From_Source -- 2223 --------------------------- 2224 2225 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is 2226 begin 2227 pragma Assert (N in Nodes.First .. Nodes.Last); 2228 Nodes.Table (N).Comes_From_Source := Val; 2229 end Set_Comes_From_Source; 2230 2231 ----------------------------------- 2232 -- Set_Comes_From_Source_Default -- 2233 ----------------------------------- 2234 2235 procedure Set_Comes_From_Source_Default (Default : Boolean) is 2236 begin 2237 Default_Node.Comes_From_Source := Default; 2238 end Set_Comes_From_Source_Default; 2239 2240 -------------------- 2241 -- Set_Convention -- 2242 -------------------- 2243 2244 procedure Set_Convention (E : Entity_Id; Val : Convention_Id) is 2245 begin 2246 pragma Assert (Nkind (E) in N_Entity); 2247 To_Flag_Word_Ptr 2248 (Union_Id_Ptr' 2249 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := 2250 Val; 2251 end Set_Convention; 2252 2253 --------------- 2254 -- Set_Ekind -- 2255 --------------- 2256 2257 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is 2258 begin 2259 pragma Assert (Nkind (E) in N_Entity); 2260 Nodes.Table (E + 1).Nkind := E_To_N (Val); 2261 end Set_Ekind; 2262 2263 ---------------------- 2264 -- Set_Error_Posted -- 2265 ---------------------- 2266 2267 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is 2268 begin 2269 Nodes.Table (N).Error_Posted := Val; 2270 end Set_Error_Posted; 2271 2272 --------------------- 2273 -- Set_Paren_Count -- 2274 --------------------- 2275 2276 procedure Set_Paren_Count (N : Node_Id; Val : Paren_Count_Type) is 2277 begin 2278 pragma Assert (Nkind (N) in N_Subexpr); 2279 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0); 2280 Nodes.Table (N).Pflag2 := (Val >= 2); 2281 end Set_Paren_Count; 2282 2283 ---------------- 2284 -- Set_Parent -- 2285 ---------------- 2286 2287 procedure Set_Parent (N : Node_Id; Val : Node_Id) is 2288 begin 2289 pragma Assert (not Nodes.Table (N).In_List); 2290 Nodes.Table (N).Link := Union_Id (Val); 2291 end Set_Parent; 2292 2293 -------------- 2294 -- Set_Sloc -- 2295 -------------- 2296 2297 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is 2298 begin 2299 Nodes.Table (N).Sloc := Val; 2300 end Set_Sloc; 2301 2302 ---------- 2303 -- Sloc -- 2304 ---------- 2305 2306 function Sloc (N : Node_Id) return Source_Ptr is 2307 begin 2308 return Nodes.Table (N).Sloc; 2309 end Sloc; 2310 2311 ------------------- 2312 -- Traverse_Func -- 2313 ------------------- 2314 2315 function Traverse_Func (Node : Node_Id) return Traverse_Result is 2316 2317 function Traverse_Field (Fld : Union_Id) return Traverse_Result; 2318 -- Fld is one of the fields of Node. If the field points to a 2319 -- syntactic node or list, then this node or list is traversed, 2320 -- and the result is the result of this traversal. Otherwise 2321 -- a value of True is returned with no processing. 2322 2323 -------------------- 2324 -- Traverse_Field -- 2325 -------------------- 2326 2327 function Traverse_Field (Fld : Union_Id) return Traverse_Result is 2328 begin 2329 if Fld = Union_Id (Empty) then 2330 return OK; 2331 2332 -- Descendent is a node 2333 2334 elsif Fld in Node_Range then 2335 2336 -- Traverse descendent that is syntactic subtree node 2337 2338 if Parent (Node_Id (Fld)) = Node 2339 or else Original_Node (Parent (Node_Id (Fld))) = Node 2340 then 2341 return Traverse_Func (Node_Id (Fld)); 2342 2343 -- Node that is not a syntactic subtree 2344 2345 else 2346 return OK; 2347 end if; 2348 2349 -- Descendent is a list 2350 2351 elsif Fld in List_Range then 2352 2353 -- Traverse descendent that is a syntactic subtree list 2354 2355 if Parent (List_Id (Fld)) = Node 2356 or else Original_Node (Parent (List_Id (Fld))) = Node 2357 then 2358 declare 2359 Elmt : Node_Id := First (List_Id (Fld)); 2360 begin 2361 while Present (Elmt) loop 2362 if Traverse_Func (Elmt) = Abandon then 2363 return Abandon; 2364 else 2365 Next (Elmt); 2366 end if; 2367 end loop; 2368 2369 return OK; 2370 end; 2371 2372 -- List that is not a syntactic subtree 2373 2374 else 2375 return OK; 2376 end if; 2377 2378 -- Field was not a node or a list 2379 2380 else 2381 return OK; 2382 end if; 2383 end Traverse_Field; 2384 2385 -- Start of processing for Traverse_Func 2386 2387 begin 2388 case Process (Node) is 2389 when Abandon => 2390 return Abandon; 2391 2392 when Skip => 2393 return OK; 2394 2395 when OK => 2396 if Traverse_Field (Union_Id (Field1 (Node))) = Abandon 2397 or else 2398 Traverse_Field (Union_Id (Field2 (Node))) = Abandon 2399 or else 2400 Traverse_Field (Union_Id (Field3 (Node))) = Abandon 2401 or else 2402 Traverse_Field (Union_Id (Field4 (Node))) = Abandon 2403 or else 2404 Traverse_Field (Union_Id (Field5 (Node))) = Abandon 2405 then 2406 return Abandon; 2407 2408 else 2409 return OK; 2410 end if; 2411 2412 when OK_Orig => 2413 declare 2414 Onode : constant Node_Id := Original_Node (Node); 2415 2416 begin 2417 if Traverse_Field (Union_Id (Field1 (Onode))) = Abandon 2418 or else 2419 Traverse_Field (Union_Id (Field2 (Onode))) = Abandon 2420 or else 2421 Traverse_Field (Union_Id (Field3 (Onode))) = Abandon 2422 or else 2423 Traverse_Field (Union_Id (Field4 (Onode))) = Abandon 2424 or else 2425 Traverse_Field (Union_Id (Field5 (Onode))) = Abandon 2426 then 2427 return Abandon; 2428 2429 else 2430 return OK_Orig; 2431 end if; 2432 end; 2433 end case; 2434 end Traverse_Func; 2435 2436 ------------------- 2437 -- Traverse_Proc -- 2438 ------------------- 2439 2440 procedure Traverse_Proc (Node : Node_Id) is 2441 function Traverse is new Traverse_Func (Process); 2442 Discard : Traverse_Result; 2443 pragma Warnings (Off, Discard); 2444 2445 begin 2446 Discard := Traverse (Node); 2447 end Traverse_Proc; 2448 2449 --------------- 2450 -- Tree_Read -- 2451 --------------- 2452 2453 procedure Tree_Read is 2454 begin 2455 Tree_Read_Int (Node_Count); 2456 Nodes.Tree_Read; 2457 Orig_Nodes.Tree_Read; 2458 end Tree_Read; 2459 2460 ---------------- 2461 -- Tree_Write -- 2462 ---------------- 2463 2464 procedure Tree_Write is 2465 begin 2466 Tree_Write_Int (Node_Count); 2467 Nodes.Tree_Write; 2468 Orig_Nodes.Tree_Write; 2469 end Tree_Write; 2470 2471 ------------------------------ 2472 -- Unchecked Access Package -- 2473 ------------------------------ 2474 2475 package body Unchecked_Access is 2476 2477 function Field1 (N : Node_Id) return Union_Id is 2478 begin 2479 pragma Assert (N in Nodes.First .. Nodes.Last); 2480 return Nodes.Table (N).Field1; 2481 end Field1; 2482 2483 function Field2 (N : Node_Id) return Union_Id is 2484 begin 2485 pragma Assert (N in Nodes.First .. Nodes.Last); 2486 return Nodes.Table (N).Field2; 2487 end Field2; 2488 2489 function Field3 (N : Node_Id) return Union_Id is 2490 begin 2491 pragma Assert (N in Nodes.First .. Nodes.Last); 2492 return Nodes.Table (N).Field3; 2493 end Field3; 2494 2495 function Field4 (N : Node_Id) return Union_Id is 2496 begin 2497 pragma Assert (N in Nodes.First .. Nodes.Last); 2498 return Nodes.Table (N).Field4; 2499 end Field4; 2500 2501 function Field5 (N : Node_Id) return Union_Id is 2502 begin 2503 pragma Assert (N in Nodes.First .. Nodes.Last); 2504 return Nodes.Table (N).Field5; 2505 end Field5; 2506 2507 function Field6 (N : Node_Id) return Union_Id is 2508 begin 2509 pragma Assert (Nkind (N) in N_Entity); 2510 return Nodes.Table (N + 1).Field6; 2511 end Field6; 2512 2513 function Field7 (N : Node_Id) return Union_Id is 2514 begin 2515 pragma Assert (Nkind (N) in N_Entity); 2516 return Nodes.Table (N + 1).Field7; 2517 end Field7; 2518 2519 function Field8 (N : Node_Id) return Union_Id is 2520 begin 2521 pragma Assert (Nkind (N) in N_Entity); 2522 return Nodes.Table (N + 1).Field8; 2523 end Field8; 2524 2525 function Field9 (N : Node_Id) return Union_Id is 2526 begin 2527 pragma Assert (Nkind (N) in N_Entity); 2528 return Nodes.Table (N + 1).Field9; 2529 end Field9; 2530 2531 function Field10 (N : Node_Id) return Union_Id is 2532 begin 2533 pragma Assert (Nkind (N) in N_Entity); 2534 return Nodes.Table (N + 1).Field10; 2535 end Field10; 2536 2537 function Field11 (N : Node_Id) return Union_Id is 2538 begin 2539 pragma Assert (Nkind (N) in N_Entity); 2540 return Nodes.Table (N + 1).Field11; 2541 end Field11; 2542 2543 function Field12 (N : Node_Id) return Union_Id is 2544 begin 2545 pragma Assert (Nkind (N) in N_Entity); 2546 return Nodes.Table (N + 1).Field12; 2547 end Field12; 2548 2549 function Field13 (N : Node_Id) return Union_Id is 2550 begin 2551 pragma Assert (Nkind (N) in N_Entity); 2552 return Nodes.Table (N + 2).Field6; 2553 end Field13; 2554 2555 function Field14 (N : Node_Id) return Union_Id is 2556 begin 2557 pragma Assert (Nkind (N) in N_Entity); 2558 return Nodes.Table (N + 2).Field7; 2559 end Field14; 2560 2561 function Field15 (N : Node_Id) return Union_Id is 2562 begin 2563 pragma Assert (Nkind (N) in N_Entity); 2564 return Nodes.Table (N + 2).Field8; 2565 end Field15; 2566 2567 function Field16 (N : Node_Id) return Union_Id is 2568 begin 2569 pragma Assert (Nkind (N) in N_Entity); 2570 return Nodes.Table (N + 2).Field9; 2571 end Field16; 2572 2573 function Field17 (N : Node_Id) return Union_Id is 2574 begin 2575 pragma Assert (Nkind (N) in N_Entity); 2576 return Nodes.Table (N + 2).Field10; 2577 end Field17; 2578 2579 function Field18 (N : Node_Id) return Union_Id is 2580 begin 2581 pragma Assert (Nkind (N) in N_Entity); 2582 return Nodes.Table (N + 2).Field11; 2583 end Field18; 2584 2585 function Field19 (N : Node_Id) return Union_Id is 2586 begin 2587 pragma Assert (Nkind (N) in N_Entity); 2588 return Nodes.Table (N + 3).Field6; 2589 end Field19; 2590 2591 function Field20 (N : Node_Id) return Union_Id is 2592 begin 2593 pragma Assert (Nkind (N) in N_Entity); 2594 return Nodes.Table (N + 3).Field7; 2595 end Field20; 2596 2597 function Field21 (N : Node_Id) return Union_Id is 2598 begin 2599 pragma Assert (Nkind (N) in N_Entity); 2600 return Nodes.Table (N + 3).Field8; 2601 end Field21; 2602 2603 function Field22 (N : Node_Id) return Union_Id is 2604 begin 2605 pragma Assert (Nkind (N) in N_Entity); 2606 return Nodes.Table (N + 3).Field9; 2607 end Field22; 2608 2609 function Field23 (N : Node_Id) return Union_Id is 2610 begin 2611 pragma Assert (Nkind (N) in N_Entity); 2612 return Nodes.Table (N + 3).Field10; 2613 end Field23; 2614 2615 function Node1 (N : Node_Id) return Node_Id is 2616 begin 2617 pragma Assert (N in Nodes.First .. Nodes.Last); 2618 return Node_Id (Nodes.Table (N).Field1); 2619 end Node1; 2620 2621 function Node2 (N : Node_Id) return Node_Id is 2622 begin 2623 pragma Assert (N in Nodes.First .. Nodes.Last); 2624 return Node_Id (Nodes.Table (N).Field2); 2625 end Node2; 2626 2627 function Node3 (N : Node_Id) return Node_Id is 2628 begin 2629 pragma Assert (N in Nodes.First .. Nodes.Last); 2630 return Node_Id (Nodes.Table (N).Field3); 2631 end Node3; 2632 2633 function Node4 (N : Node_Id) return Node_Id is 2634 begin 2635 pragma Assert (N in Nodes.First .. Nodes.Last); 2636 return Node_Id (Nodes.Table (N).Field4); 2637 end Node4; 2638 2639 function Node5 (N : Node_Id) return Node_Id is 2640 begin 2641 pragma Assert (N in Nodes.First .. Nodes.Last); 2642 return Node_Id (Nodes.Table (N).Field5); 2643 end Node5; 2644 2645 function Node6 (N : Node_Id) return Node_Id is 2646 begin 2647 pragma Assert (Nkind (N) in N_Entity); 2648 return Node_Id (Nodes.Table (N + 1).Field6); 2649 end Node6; 2650 2651 function Node7 (N : Node_Id) return Node_Id is 2652 begin 2653 pragma Assert (Nkind (N) in N_Entity); 2654 return Node_Id (Nodes.Table (N + 1).Field7); 2655 end Node7; 2656 2657 function Node8 (N : Node_Id) return Node_Id is 2658 begin 2659 pragma Assert (Nkind (N) in N_Entity); 2660 return Node_Id (Nodes.Table (N + 1).Field8); 2661 end Node8; 2662 2663 function Node9 (N : Node_Id) return Node_Id is 2664 begin 2665 pragma Assert (Nkind (N) in N_Entity); 2666 return Node_Id (Nodes.Table (N + 1).Field9); 2667 end Node9; 2668 2669 function Node10 (N : Node_Id) return Node_Id is 2670 begin 2671 pragma Assert (Nkind (N) in N_Entity); 2672 return Node_Id (Nodes.Table (N + 1).Field10); 2673 end Node10; 2674 2675 function Node11 (N : Node_Id) return Node_Id is 2676 begin 2677 pragma Assert (Nkind (N) in N_Entity); 2678 return Node_Id (Nodes.Table (N + 1).Field11); 2679 end Node11; 2680 2681 function Node12 (N : Node_Id) return Node_Id is 2682 begin 2683 pragma Assert (Nkind (N) in N_Entity); 2684 return Node_Id (Nodes.Table (N + 1).Field12); 2685 end Node12; 2686 2687 function Node13 (N : Node_Id) return Node_Id is 2688 begin 2689 pragma Assert (Nkind (N) in N_Entity); 2690 return Node_Id (Nodes.Table (N + 2).Field6); 2691 end Node13; 2692 2693 function Node14 (N : Node_Id) return Node_Id is 2694 begin 2695 pragma Assert (Nkind (N) in N_Entity); 2696 return Node_Id (Nodes.Table (N + 2).Field7); 2697 end Node14; 2698 2699 function Node15 (N : Node_Id) return Node_Id is 2700 begin 2701 pragma Assert (Nkind (N) in N_Entity); 2702 return Node_Id (Nodes.Table (N + 2).Field8); 2703 end Node15; 2704 2705 function Node16 (N : Node_Id) return Node_Id is 2706 begin 2707 pragma Assert (Nkind (N) in N_Entity); 2708 return Node_Id (Nodes.Table (N + 2).Field9); 2709 end Node16; 2710 2711 function Node17 (N : Node_Id) return Node_Id is 2712 begin 2713 pragma Assert (Nkind (N) in N_Entity); 2714 return Node_Id (Nodes.Table (N + 2).Field10); 2715 end Node17; 2716 2717 function Node18 (N : Node_Id) return Node_Id is 2718 begin 2719 pragma Assert (Nkind (N) in N_Entity); 2720 return Node_Id (Nodes.Table (N + 2).Field11); 2721 end Node18; 2722 2723 function Node19 (N : Node_Id) return Node_Id is 2724 begin 2725 pragma Assert (Nkind (N) in N_Entity); 2726 return Node_Id (Nodes.Table (N + 3).Field6); 2727 end Node19; 2728 2729 function Node20 (N : Node_Id) return Node_Id is 2730 begin 2731 pragma Assert (Nkind (N) in N_Entity); 2732 return Node_Id (Nodes.Table (N + 3).Field7); 2733 end Node20; 2734 2735 function Node21 (N : Node_Id) return Node_Id is 2736 begin 2737 pragma Assert (Nkind (N) in N_Entity); 2738 return Node_Id (Nodes.Table (N + 3).Field8); 2739 end Node21; 2740 2741 function Node22 (N : Node_Id) return Node_Id is 2742 begin 2743 pragma Assert (Nkind (N) in N_Entity); 2744 return Node_Id (Nodes.Table (N + 3).Field9); 2745 end Node22; 2746 2747 function Node23 (N : Node_Id) return Node_Id is 2748 begin 2749 pragma Assert (Nkind (N) in N_Entity); 2750 return Node_Id (Nodes.Table (N + 3).Field10); 2751 end Node23; 2752 2753 function List1 (N : Node_Id) return List_Id is 2754 begin 2755 pragma Assert (N in Nodes.First .. Nodes.Last); 2756 return List_Id (Nodes.Table (N).Field1); 2757 end List1; 2758 2759 function List2 (N : Node_Id) return List_Id is 2760 begin 2761 pragma Assert (N in Nodes.First .. Nodes.Last); 2762 return List_Id (Nodes.Table (N).Field2); 2763 end List2; 2764 2765 function List3 (N : Node_Id) return List_Id is 2766 begin 2767 pragma Assert (N in Nodes.First .. Nodes.Last); 2768 return List_Id (Nodes.Table (N).Field3); 2769 end List3; 2770 2771 function List4 (N : Node_Id) return List_Id is 2772 begin 2773 pragma Assert (N in Nodes.First .. Nodes.Last); 2774 return List_Id (Nodes.Table (N).Field4); 2775 end List4; 2776 2777 function List5 (N : Node_Id) return List_Id is 2778 begin 2779 pragma Assert (N in Nodes.First .. Nodes.Last); 2780 return List_Id (Nodes.Table (N).Field5); 2781 end List5; 2782 2783 function List10 (N : Node_Id) return List_Id is 2784 begin 2785 pragma Assert (Nkind (N) in N_Entity); 2786 return List_Id (Nodes.Table (N + 1).Field10); 2787 end List10; 2788 2789 function List14 (N : Node_Id) return List_Id is 2790 begin 2791 pragma Assert (Nkind (N) in N_Entity); 2792 return List_Id (Nodes.Table (N + 2).Field7); 2793 end List14; 2794 2795 function Elist2 (N : Node_Id) return Elist_Id is 2796 begin 2797 return Elist_Id (Nodes.Table (N).Field2); 2798 end Elist2; 2799 2800 function Elist3 (N : Node_Id) return Elist_Id is 2801 begin 2802 return Elist_Id (Nodes.Table (N).Field3); 2803 end Elist3; 2804 2805 function Elist4 (N : Node_Id) return Elist_Id is 2806 begin 2807 return Elist_Id (Nodes.Table (N).Field4); 2808 end Elist4; 2809 2810 function Elist8 (N : Node_Id) return Elist_Id is 2811 begin 2812 pragma Assert (Nkind (N) in N_Entity); 2813 return Elist_Id (Nodes.Table (N + 1).Field8); 2814 end Elist8; 2815 2816 function Elist13 (N : Node_Id) return Elist_Id is 2817 begin 2818 pragma Assert (Nkind (N) in N_Entity); 2819 return Elist_Id (Nodes.Table (N + 2).Field6); 2820 end Elist13; 2821 2822 function Elist15 (N : Node_Id) return Elist_Id is 2823 begin 2824 pragma Assert (Nkind (N) in N_Entity); 2825 return Elist_Id (Nodes.Table (N + 2).Field8); 2826 end Elist15; 2827 2828 function Elist16 (N : Node_Id) return Elist_Id is 2829 begin 2830 pragma Assert (Nkind (N) in N_Entity); 2831 return Elist_Id (Nodes.Table (N + 2).Field9); 2832 end Elist16; 2833 2834 function Elist18 (N : Node_Id) return Elist_Id is 2835 begin 2836 pragma Assert (Nkind (N) in N_Entity); 2837 return Elist_Id (Nodes.Table (N + 2).Field11); 2838 end Elist18; 2839 2840 function Elist21 (N : Node_Id) return Elist_Id is 2841 begin 2842 pragma Assert (Nkind (N) in N_Entity); 2843 return Elist_Id (Nodes.Table (N + 3).Field8); 2844 end Elist21; 2845 2846 function Elist23 (N : Node_Id) return Elist_Id is 2847 begin 2848 pragma Assert (Nkind (N) in N_Entity); 2849 return Elist_Id (Nodes.Table (N + 3).Field10); 2850 end Elist23; 2851 2852 function Name1 (N : Node_Id) return Name_Id is 2853 begin 2854 pragma Assert (N in Nodes.First .. Nodes.Last); 2855 return Name_Id (Nodes.Table (N).Field1); 2856 end Name1; 2857 2858 function Name2 (N : Node_Id) return Name_Id is 2859 begin 2860 pragma Assert (N in Nodes.First .. Nodes.Last); 2861 return Name_Id (Nodes.Table (N).Field2); 2862 end Name2; 2863 2864 function Str3 (N : Node_Id) return String_Id is 2865 begin 2866 pragma Assert (N in Nodes.First .. Nodes.Last); 2867 return String_Id (Nodes.Table (N).Field3); 2868 end Str3; 2869 2870 function Char_Code2 (N : Node_Id) return Char_Code is 2871 begin 2872 pragma Assert (N in Nodes.First .. Nodes.Last); 2873 return Char_Code (Nodes.Table (N).Field2 - Char_Code_Bias); 2874 end Char_Code2; 2875 2876 function Uint3 (N : Node_Id) return Uint is 2877 pragma Assert (N in Nodes.First .. Nodes.Last); 2878 U : constant Union_Id := Nodes.Table (N).Field3; 2879 2880 begin 2881 if U = 0 then 2882 return Uint_0; 2883 else 2884 return From_Union (U); 2885 end if; 2886 end Uint3; 2887 2888 function Uint4 (N : Node_Id) return Uint is 2889 pragma Assert (N in Nodes.First .. Nodes.Last); 2890 U : constant Union_Id := Nodes.Table (N).Field4; 2891 2892 begin 2893 if U = 0 then 2894 return Uint_0; 2895 else 2896 return From_Union (U); 2897 end if; 2898 end Uint4; 2899 2900 function Uint5 (N : Node_Id) return Uint is 2901 pragma Assert (N in Nodes.First .. Nodes.Last); 2902 U : constant Union_Id := Nodes.Table (N).Field5; 2903 2904 begin 2905 if U = 0 then 2906 return Uint_0; 2907 else 2908 return From_Union (U); 2909 end if; 2910 end Uint5; 2911 2912 function Uint8 (N : Node_Id) return Uint is 2913 pragma Assert (Nkind (N) in N_Entity); 2914 U : constant Union_Id := Nodes.Table (N + 1).Field8; 2915 2916 begin 2917 if U = 0 then 2918 return Uint_0; 2919 else 2920 return From_Union (U); 2921 end if; 2922 end Uint8; 2923 2924 function Uint9 (N : Node_Id) return Uint is 2925 pragma Assert (Nkind (N) in N_Entity); 2926 U : constant Union_Id := Nodes.Table (N + 1).Field9; 2927 2928 begin 2929 if U = 0 then 2930 return Uint_0; 2931 else 2932 return From_Union (U); 2933 end if; 2934 end Uint9; 2935 2936 function Uint11 (N : Node_Id) return Uint is 2937 pragma Assert (Nkind (N) in N_Entity); 2938 U : constant Union_Id := Nodes.Table (N + 1).Field11; 2939 2940 begin 2941 if U = 0 then 2942 return Uint_0; 2943 else 2944 return From_Union (U); 2945 end if; 2946 end Uint11; 2947 2948 function Uint10 (N : Node_Id) return Uint is 2949 pragma Assert (Nkind (N) in N_Entity); 2950 U : constant Union_Id := Nodes.Table (N + 1).Field10; 2951 2952 begin 2953 if U = 0 then 2954 return Uint_0; 2955 else 2956 return From_Union (U); 2957 end if; 2958 end Uint10; 2959 2960 function Uint12 (N : Node_Id) return Uint is 2961 pragma Assert (Nkind (N) in N_Entity); 2962 U : constant Union_Id := Nodes.Table (N + 1).Field12; 2963 2964 begin 2965 if U = 0 then 2966 return Uint_0; 2967 else 2968 return From_Union (U); 2969 end if; 2970 end Uint12; 2971 2972 function Uint13 (N : Node_Id) return Uint is 2973 pragma Assert (Nkind (N) in N_Entity); 2974 U : constant Union_Id := Nodes.Table (N + 2).Field6; 2975 2976 begin 2977 if U = 0 then 2978 return Uint_0; 2979 else 2980 return From_Union (U); 2981 end if; 2982 end Uint13; 2983 2984 function Uint14 (N : Node_Id) return Uint is 2985 pragma Assert (Nkind (N) in N_Entity); 2986 U : constant Union_Id := Nodes.Table (N + 2).Field7; 2987 2988 begin 2989 if U = 0 then 2990 return Uint_0; 2991 else 2992 return From_Union (U); 2993 end if; 2994 end Uint14; 2995 2996 function Uint15 (N : Node_Id) return Uint is 2997 pragma Assert (Nkind (N) in N_Entity); 2998 U : constant Union_Id := Nodes.Table (N + 2).Field8; 2999 3000 begin 3001 if U = 0 then 3002 return Uint_0; 3003 else 3004 return From_Union (U); 3005 end if; 3006 end Uint15; 3007 3008 function Uint16 (N : Node_Id) return Uint is 3009 pragma Assert (Nkind (N) in N_Entity); 3010 U : constant Union_Id := Nodes.Table (N + 2).Field9; 3011 3012 begin 3013 if U = 0 then 3014 return Uint_0; 3015 else 3016 return From_Union (U); 3017 end if; 3018 end Uint16; 3019 3020 function Uint17 (N : Node_Id) return Uint is 3021 pragma Assert (Nkind (N) in N_Entity); 3022 U : constant Union_Id := Nodes.Table (N + 2).Field10; 3023 3024 begin 3025 if U = 0 then 3026 return Uint_0; 3027 else 3028 return From_Union (U); 3029 end if; 3030 end Uint17; 3031 3032 function Uint22 (N : Node_Id) return Uint is 3033 pragma Assert (Nkind (N) in N_Entity); 3034 U : constant Union_Id := Nodes.Table (N + 3).Field9; 3035 3036 begin 3037 if U = 0 then 3038 return Uint_0; 3039 else 3040 return From_Union (U); 3041 end if; 3042 end Uint22; 3043 3044 function Ureal3 (N : Node_Id) return Ureal is 3045 begin 3046 pragma Assert (N in Nodes.First .. Nodes.Last); 3047 return From_Union (Nodes.Table (N).Field3); 3048 end Ureal3; 3049 3050 function Ureal18 (N : Node_Id) return Ureal is 3051 begin 3052 pragma Assert (Nkind (N) in N_Entity); 3053 return From_Union (Nodes.Table (N + 2).Field11); 3054 end Ureal18; 3055 3056 function Ureal21 (N : Node_Id) return Ureal is 3057 begin 3058 pragma Assert (Nkind (N) in N_Entity); 3059 return From_Union (Nodes.Table (N + 3).Field8); 3060 end Ureal21; 3061 3062 function Flag4 (N : Node_Id) return Boolean is 3063 begin 3064 pragma Assert (N in Nodes.First .. Nodes.Last); 3065 return Nodes.Table (N).Flag4; 3066 end Flag4; 3067 3068 function Flag5 (N : Node_Id) return Boolean is 3069 begin 3070 pragma Assert (N in Nodes.First .. Nodes.Last); 3071 return Nodes.Table (N).Flag5; 3072 end Flag5; 3073 3074 function Flag6 (N : Node_Id) return Boolean is 3075 begin 3076 pragma Assert (N in Nodes.First .. Nodes.Last); 3077 return Nodes.Table (N).Flag6; 3078 end Flag6; 3079 3080 function Flag7 (N : Node_Id) return Boolean is 3081 begin 3082 pragma Assert (N in Nodes.First .. Nodes.Last); 3083 return Nodes.Table (N).Flag7; 3084 end Flag7; 3085 3086 function Flag8 (N : Node_Id) return Boolean is 3087 begin 3088 pragma Assert (N in Nodes.First .. Nodes.Last); 3089 return Nodes.Table (N).Flag8; 3090 end Flag8; 3091 3092 function Flag9 (N : Node_Id) return Boolean is 3093 begin 3094 pragma Assert (N in Nodes.First .. Nodes.Last); 3095 return Nodes.Table (N).Flag9; 3096 end Flag9; 3097 3098 function Flag10 (N : Node_Id) return Boolean is 3099 begin 3100 pragma Assert (N in Nodes.First .. Nodes.Last); 3101 return Nodes.Table (N).Flag10; 3102 end Flag10; 3103 3104 function Flag11 (N : Node_Id) return Boolean is 3105 begin 3106 pragma Assert (N in Nodes.First .. Nodes.Last); 3107 return Nodes.Table (N).Flag11; 3108 end Flag11; 3109 3110 function Flag12 (N : Node_Id) return Boolean is 3111 begin 3112 pragma Assert (N in Nodes.First .. Nodes.Last); 3113 return Nodes.Table (N).Flag12; 3114 end Flag12; 3115 3116 function Flag13 (N : Node_Id) return Boolean is 3117 begin 3118 pragma Assert (N in Nodes.First .. Nodes.Last); 3119 return Nodes.Table (N).Flag13; 3120 end Flag13; 3121 3122 function Flag14 (N : Node_Id) return Boolean is 3123 begin 3124 pragma Assert (N in Nodes.First .. Nodes.Last); 3125 return Nodes.Table (N).Flag14; 3126 end Flag14; 3127 3128 function Flag15 (N : Node_Id) return Boolean is 3129 begin 3130 pragma Assert (N in Nodes.First .. Nodes.Last); 3131 return Nodes.Table (N).Flag15; 3132 end Flag15; 3133 3134 function Flag16 (N : Node_Id) return Boolean is 3135 begin 3136 pragma Assert (N in Nodes.First .. Nodes.Last); 3137 return Nodes.Table (N).Flag16; 3138 end Flag16; 3139 3140 function Flag17 (N : Node_Id) return Boolean is 3141 begin 3142 pragma Assert (N in Nodes.First .. Nodes.Last); 3143 return Nodes.Table (N).Flag17; 3144 end Flag17; 3145 3146 function Flag18 (N : Node_Id) return Boolean is 3147 begin 3148 pragma Assert (N in Nodes.First .. Nodes.Last); 3149 return Nodes.Table (N).Flag18; 3150 end Flag18; 3151 3152 function Flag19 (N : Node_Id) return Boolean is 3153 begin 3154 pragma Assert (Nkind (N) in N_Entity); 3155 return Nodes.Table (N + 1).In_List; 3156 end Flag19; 3157 3158 function Flag20 (N : Node_Id) return Boolean is 3159 begin 3160 pragma Assert (Nkind (N) in N_Entity); 3161 return Nodes.Table (N + 1).Unused_1; 3162 end Flag20; 3163 3164 function Flag21 (N : Node_Id) return Boolean is 3165 begin 3166 pragma Assert (Nkind (N) in N_Entity); 3167 return Nodes.Table (N + 1).Rewrite_Ins; 3168 end Flag21; 3169 3170 function Flag22 (N : Node_Id) return Boolean is 3171 begin 3172 pragma Assert (Nkind (N) in N_Entity); 3173 return Nodes.Table (N + 1).Analyzed; 3174 end Flag22; 3175 3176 function Flag23 (N : Node_Id) return Boolean is 3177 begin 3178 pragma Assert (Nkind (N) in N_Entity); 3179 return Nodes.Table (N + 1).Comes_From_Source; 3180 end Flag23; 3181 3182 function Flag24 (N : Node_Id) return Boolean is 3183 begin 3184 pragma Assert (Nkind (N) in N_Entity); 3185 return Nodes.Table (N + 1).Error_Posted; 3186 end Flag24; 3187 3188 function Flag25 (N : Node_Id) return Boolean is 3189 begin 3190 pragma Assert (Nkind (N) in N_Entity); 3191 return Nodes.Table (N + 1).Flag4; 3192 end Flag25; 3193 3194 function Flag26 (N : Node_Id) return Boolean is 3195 begin 3196 pragma Assert (Nkind (N) in N_Entity); 3197 return Nodes.Table (N + 1).Flag5; 3198 end Flag26; 3199 3200 function Flag27 (N : Node_Id) return Boolean is 3201 begin 3202 pragma Assert (Nkind (N) in N_Entity); 3203 return Nodes.Table (N + 1).Flag6; 3204 end Flag27; 3205 3206 function Flag28 (N : Node_Id) return Boolean is 3207 begin 3208 pragma Assert (Nkind (N) in N_Entity); 3209 return Nodes.Table (N + 1).Flag7; 3210 end Flag28; 3211 3212 function Flag29 (N : Node_Id) return Boolean is 3213 begin 3214 pragma Assert (Nkind (N) in N_Entity); 3215 return Nodes.Table (N + 1).Flag8; 3216 end Flag29; 3217 3218 function Flag30 (N : Node_Id) return Boolean is 3219 begin 3220 pragma Assert (Nkind (N) in N_Entity); 3221 return Nodes.Table (N + 1).Flag9; 3222 end Flag30; 3223 3224 function Flag31 (N : Node_Id) return Boolean is 3225 begin 3226 pragma Assert (Nkind (N) in N_Entity); 3227 return Nodes.Table (N + 1).Flag10; 3228 end Flag31; 3229 3230 function Flag32 (N : Node_Id) return Boolean is 3231 begin 3232 pragma Assert (Nkind (N) in N_Entity); 3233 return Nodes.Table (N + 1).Flag11; 3234 end Flag32; 3235 3236 function Flag33 (N : Node_Id) return Boolean is 3237 begin 3238 pragma Assert (Nkind (N) in N_Entity); 3239 return Nodes.Table (N + 1).Flag12; 3240 end Flag33; 3241 3242 function Flag34 (N : Node_Id) return Boolean is 3243 begin 3244 pragma Assert (Nkind (N) in N_Entity); 3245 return Nodes.Table (N + 1).Flag13; 3246 end Flag34; 3247 3248 function Flag35 (N : Node_Id) return Boolean is 3249 begin 3250 pragma Assert (Nkind (N) in N_Entity); 3251 return Nodes.Table (N + 1).Flag14; 3252 end Flag35; 3253 3254 function Flag36 (N : Node_Id) return Boolean is 3255 begin 3256 pragma Assert (Nkind (N) in N_Entity); 3257 return Nodes.Table (N + 1).Flag15; 3258 end Flag36; 3259 3260 function Flag37 (N : Node_Id) return Boolean is 3261 begin 3262 pragma Assert (Nkind (N) in N_Entity); 3263 return Nodes.Table (N + 1).Flag16; 3264 end Flag37; 3265 3266 function Flag38 (N : Node_Id) return Boolean is 3267 begin 3268 pragma Assert (Nkind (N) in N_Entity); 3269 return Nodes.Table (N + 1).Flag17; 3270 end Flag38; 3271 3272 function Flag39 (N : Node_Id) return Boolean is 3273 begin 3274 pragma Assert (Nkind (N) in N_Entity); 3275 return Nodes.Table (N + 1).Flag18; 3276 end Flag39; 3277 3278 function Flag40 (N : Node_Id) return Boolean is 3279 begin 3280 pragma Assert (Nkind (N) in N_Entity); 3281 return Nodes.Table (N + 2).In_List; 3282 end Flag40; 3283 3284 function Flag41 (N : Node_Id) return Boolean is 3285 begin 3286 pragma Assert (Nkind (N) in N_Entity); 3287 return Nodes.Table (N + 2).Unused_1; 3288 end Flag41; 3289 3290 function Flag42 (N : Node_Id) return Boolean is 3291 begin 3292 pragma Assert (Nkind (N) in N_Entity); 3293 return Nodes.Table (N + 2).Rewrite_Ins; 3294 end Flag42; 3295 3296 function Flag43 (N : Node_Id) return Boolean is 3297 begin 3298 pragma Assert (Nkind (N) in N_Entity); 3299 return Nodes.Table (N + 2).Analyzed; 3300 end Flag43; 3301 3302 function Flag44 (N : Node_Id) return Boolean is 3303 begin 3304 pragma Assert (Nkind (N) in N_Entity); 3305 return Nodes.Table (N + 2).Comes_From_Source; 3306 end Flag44; 3307 3308 function Flag45 (N : Node_Id) return Boolean is 3309 begin 3310 pragma Assert (Nkind (N) in N_Entity); 3311 return Nodes.Table (N + 2).Error_Posted; 3312 end Flag45; 3313 3314 function Flag46 (N : Node_Id) return Boolean is 3315 begin 3316 pragma Assert (Nkind (N) in N_Entity); 3317 return Nodes.Table (N + 2).Flag4; 3318 end Flag46; 3319 3320 function Flag47 (N : Node_Id) return Boolean is 3321 begin 3322 pragma Assert (Nkind (N) in N_Entity); 3323 return Nodes.Table (N + 2).Flag5; 3324 end Flag47; 3325 3326 function Flag48 (N : Node_Id) return Boolean is 3327 begin 3328 pragma Assert (Nkind (N) in N_Entity); 3329 return Nodes.Table (N + 2).Flag6; 3330 end Flag48; 3331 3332 function Flag49 (N : Node_Id) return Boolean is 3333 begin 3334 pragma Assert (Nkind (N) in N_Entity); 3335 return Nodes.Table (N + 2).Flag7; 3336 end Flag49; 3337 3338 function Flag50 (N : Node_Id) return Boolean is 3339 begin 3340 pragma Assert (Nkind (N) in N_Entity); 3341 return Nodes.Table (N + 2).Flag8; 3342 end Flag50; 3343 3344 function Flag51 (N : Node_Id) return Boolean is 3345 begin 3346 pragma Assert (Nkind (N) in N_Entity); 3347 return Nodes.Table (N + 2).Flag9; 3348 end Flag51; 3349 3350 function Flag52 (N : Node_Id) return Boolean is 3351 begin 3352 pragma Assert (Nkind (N) in N_Entity); 3353 return Nodes.Table (N + 2).Flag10; 3354 end Flag52; 3355 3356 function Flag53 (N : Node_Id) return Boolean is 3357 begin 3358 pragma Assert (Nkind (N) in N_Entity); 3359 return Nodes.Table (N + 2).Flag11; 3360 end Flag53; 3361 3362 function Flag54 (N : Node_Id) return Boolean is 3363 begin 3364 pragma Assert (Nkind (N) in N_Entity); 3365 return Nodes.Table (N + 2).Flag12; 3366 end Flag54; 3367 3368 function Flag55 (N : Node_Id) return Boolean is 3369 begin 3370 pragma Assert (Nkind (N) in N_Entity); 3371 return Nodes.Table (N + 2).Flag13; 3372 end Flag55; 3373 3374 function Flag56 (N : Node_Id) return Boolean is 3375 begin 3376 pragma Assert (Nkind (N) in N_Entity); 3377 return Nodes.Table (N + 2).Flag14; 3378 end Flag56; 3379 3380 function Flag57 (N : Node_Id) return Boolean is 3381 begin 3382 pragma Assert (Nkind (N) in N_Entity); 3383 return Nodes.Table (N + 2).Flag15; 3384 end Flag57; 3385 3386 function Flag58 (N : Node_Id) return Boolean is 3387 begin 3388 pragma Assert (Nkind (N) in N_Entity); 3389 return Nodes.Table (N + 2).Flag16; 3390 end Flag58; 3391 3392 function Flag59 (N : Node_Id) return Boolean is 3393 begin 3394 pragma Assert (Nkind (N) in N_Entity); 3395 return Nodes.Table (N + 2).Flag17; 3396 end Flag59; 3397 3398 function Flag60 (N : Node_Id) return Boolean is 3399 begin 3400 pragma Assert (Nkind (N) in N_Entity); 3401 return Nodes.Table (N + 2).Flag18; 3402 end Flag60; 3403 3404 function Flag61 (N : Node_Id) return Boolean is 3405 begin 3406 pragma Assert (Nkind (N) in N_Entity); 3407 return Nodes.Table (N + 1).Pflag1; 3408 end Flag61; 3409 3410 function Flag62 (N : Node_Id) return Boolean is 3411 begin 3412 pragma Assert (Nkind (N) in N_Entity); 3413 return Nodes.Table (N + 1).Pflag2; 3414 end Flag62; 3415 3416 function Flag63 (N : Node_Id) return Boolean is 3417 begin 3418 pragma Assert (Nkind (N) in N_Entity); 3419 return Nodes.Table (N + 2).Pflag1; 3420 end Flag63; 3421 3422 function Flag64 (N : Node_Id) return Boolean is 3423 begin 3424 pragma Assert (Nkind (N) in N_Entity); 3425 return Nodes.Table (N + 2).Pflag2; 3426 end Flag64; 3427 3428 function Flag65 (N : Node_Id) return Boolean is 3429 begin 3430 pragma Assert (Nkind (N) in N_Entity); 3431 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65; 3432 end Flag65; 3433 3434 function Flag66 (N : Node_Id) return Boolean is 3435 begin 3436 pragma Assert (Nkind (N) in N_Entity); 3437 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66; 3438 end Flag66; 3439 3440 function Flag67 (N : Node_Id) return Boolean is 3441 begin 3442 pragma Assert (Nkind (N) in N_Entity); 3443 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67; 3444 end Flag67; 3445 3446 function Flag68 (N : Node_Id) return Boolean is 3447 begin 3448 pragma Assert (Nkind (N) in N_Entity); 3449 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68; 3450 end Flag68; 3451 3452 function Flag69 (N : Node_Id) return Boolean is 3453 begin 3454 pragma Assert (Nkind (N) in N_Entity); 3455 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69; 3456 end Flag69; 3457 3458 function Flag70 (N : Node_Id) return Boolean is 3459 begin 3460 pragma Assert (Nkind (N) in N_Entity); 3461 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70; 3462 end Flag70; 3463 3464 function Flag71 (N : Node_Id) return Boolean is 3465 begin 3466 pragma Assert (Nkind (N) in N_Entity); 3467 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71; 3468 end Flag71; 3469 3470 function Flag72 (N : Node_Id) return Boolean is 3471 begin 3472 pragma Assert (Nkind (N) in N_Entity); 3473 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72; 3474 end Flag72; 3475 3476 function Flag73 (N : Node_Id) return Boolean is 3477 begin 3478 pragma Assert (Nkind (N) in N_Entity); 3479 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73; 3480 end Flag73; 3481 3482 function Flag74 (N : Node_Id) return Boolean is 3483 begin 3484 pragma Assert (Nkind (N) in N_Entity); 3485 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74; 3486 end Flag74; 3487 3488 function Flag75 (N : Node_Id) return Boolean is 3489 begin 3490 pragma Assert (Nkind (N) in N_Entity); 3491 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75; 3492 end Flag75; 3493 3494 function Flag76 (N : Node_Id) return Boolean is 3495 begin 3496 pragma Assert (Nkind (N) in N_Entity); 3497 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76; 3498 end Flag76; 3499 3500 function Flag77 (N : Node_Id) return Boolean is 3501 begin 3502 pragma Assert (Nkind (N) in N_Entity); 3503 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77; 3504 end Flag77; 3505 3506 function Flag78 (N : Node_Id) return Boolean is 3507 begin 3508 pragma Assert (Nkind (N) in N_Entity); 3509 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78; 3510 end Flag78; 3511 3512 function Flag79 (N : Node_Id) return Boolean is 3513 begin 3514 pragma Assert (Nkind (N) in N_Entity); 3515 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79; 3516 end Flag79; 3517 3518 function Flag80 (N : Node_Id) return Boolean is 3519 begin 3520 pragma Assert (Nkind (N) in N_Entity); 3521 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80; 3522 end Flag80; 3523 3524 function Flag81 (N : Node_Id) return Boolean is 3525 begin 3526 pragma Assert (Nkind (N) in N_Entity); 3527 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81; 3528 end Flag81; 3529 3530 function Flag82 (N : Node_Id) return Boolean is 3531 begin 3532 pragma Assert (Nkind (N) in N_Entity); 3533 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82; 3534 end Flag82; 3535 3536 function Flag83 (N : Node_Id) return Boolean is 3537 begin 3538 pragma Assert (Nkind (N) in N_Entity); 3539 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83; 3540 end Flag83; 3541 3542 function Flag84 (N : Node_Id) return Boolean is 3543 begin 3544 pragma Assert (Nkind (N) in N_Entity); 3545 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84; 3546 end Flag84; 3547 3548 function Flag85 (N : Node_Id) return Boolean is 3549 begin 3550 pragma Assert (Nkind (N) in N_Entity); 3551 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85; 3552 end Flag85; 3553 3554 function Flag86 (N : Node_Id) return Boolean is 3555 begin 3556 pragma Assert (Nkind (N) in N_Entity); 3557 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86; 3558 end Flag86; 3559 3560 function Flag87 (N : Node_Id) return Boolean is 3561 begin 3562 pragma Assert (Nkind (N) in N_Entity); 3563 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87; 3564 end Flag87; 3565 3566 function Flag88 (N : Node_Id) return Boolean is 3567 begin 3568 pragma Assert (Nkind (N) in N_Entity); 3569 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88; 3570 end Flag88; 3571 3572 function Flag89 (N : Node_Id) return Boolean is 3573 begin 3574 pragma Assert (Nkind (N) in N_Entity); 3575 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89; 3576 end Flag89; 3577 3578 function Flag90 (N : Node_Id) return Boolean is 3579 begin 3580 pragma Assert (Nkind (N) in N_Entity); 3581 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90; 3582 end Flag90; 3583 3584 function Flag91 (N : Node_Id) return Boolean is 3585 begin 3586 pragma Assert (Nkind (N) in N_Entity); 3587 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91; 3588 end Flag91; 3589 3590 function Flag92 (N : Node_Id) return Boolean is 3591 begin 3592 pragma Assert (Nkind (N) in N_Entity); 3593 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92; 3594 end Flag92; 3595 3596 function Flag93 (N : Node_Id) return Boolean is 3597 begin 3598 pragma Assert (Nkind (N) in N_Entity); 3599 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93; 3600 end Flag93; 3601 3602 function Flag94 (N : Node_Id) return Boolean is 3603 begin 3604 pragma Assert (Nkind (N) in N_Entity); 3605 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94; 3606 end Flag94; 3607 3608 function Flag95 (N : Node_Id) return Boolean is 3609 begin 3610 pragma Assert (Nkind (N) in N_Entity); 3611 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95; 3612 end Flag95; 3613 3614 function Flag96 (N : Node_Id) return Boolean is 3615 begin 3616 pragma Assert (Nkind (N) in N_Entity); 3617 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96; 3618 end Flag96; 3619 3620 function Flag97 (N : Node_Id) return Boolean is 3621 begin 3622 pragma Assert (Nkind (N) in N_Entity); 3623 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97; 3624 end Flag97; 3625 3626 function Flag98 (N : Node_Id) return Boolean is 3627 begin 3628 pragma Assert (Nkind (N) in N_Entity); 3629 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98; 3630 end Flag98; 3631 3632 function Flag99 (N : Node_Id) return Boolean is 3633 begin 3634 pragma Assert (Nkind (N) in N_Entity); 3635 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99; 3636 end Flag99; 3637 3638 function Flag100 (N : Node_Id) return Boolean is 3639 begin 3640 pragma Assert (Nkind (N) in N_Entity); 3641 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100; 3642 end Flag100; 3643 3644 function Flag101 (N : Node_Id) return Boolean is 3645 begin 3646 pragma Assert (Nkind (N) in N_Entity); 3647 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101; 3648 end Flag101; 3649 3650 function Flag102 (N : Node_Id) return Boolean is 3651 begin 3652 pragma Assert (Nkind (N) in N_Entity); 3653 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102; 3654 end Flag102; 3655 3656 function Flag103 (N : Node_Id) return Boolean is 3657 begin 3658 pragma Assert (Nkind (N) in N_Entity); 3659 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103; 3660 end Flag103; 3661 3662 function Flag104 (N : Node_Id) return Boolean is 3663 begin 3664 pragma Assert (Nkind (N) in N_Entity); 3665 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104; 3666 end Flag104; 3667 3668 function Flag105 (N : Node_Id) return Boolean is 3669 begin 3670 pragma Assert (Nkind (N) in N_Entity); 3671 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105; 3672 end Flag105; 3673 3674 function Flag106 (N : Node_Id) return Boolean is 3675 begin 3676 pragma Assert (Nkind (N) in N_Entity); 3677 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106; 3678 end Flag106; 3679 3680 function Flag107 (N : Node_Id) return Boolean is 3681 begin 3682 pragma Assert (Nkind (N) in N_Entity); 3683 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107; 3684 end Flag107; 3685 3686 function Flag108 (N : Node_Id) return Boolean is 3687 begin 3688 pragma Assert (Nkind (N) in N_Entity); 3689 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108; 3690 end Flag108; 3691 3692 function Flag109 (N : Node_Id) return Boolean is 3693 begin 3694 pragma Assert (Nkind (N) in N_Entity); 3695 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109; 3696 end Flag109; 3697 3698 function Flag110 (N : Node_Id) return Boolean is 3699 begin 3700 pragma Assert (Nkind (N) in N_Entity); 3701 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110; 3702 end Flag110; 3703 3704 function Flag111 (N : Node_Id) return Boolean is 3705 begin 3706 pragma Assert (Nkind (N) in N_Entity); 3707 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111; 3708 end Flag111; 3709 3710 function Flag112 (N : Node_Id) return Boolean is 3711 begin 3712 pragma Assert (Nkind (N) in N_Entity); 3713 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112; 3714 end Flag112; 3715 3716 function Flag113 (N : Node_Id) return Boolean is 3717 begin 3718 pragma Assert (Nkind (N) in N_Entity); 3719 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113; 3720 end Flag113; 3721 3722 function Flag114 (N : Node_Id) return Boolean is 3723 begin 3724 pragma Assert (Nkind (N) in N_Entity); 3725 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114; 3726 end Flag114; 3727 3728 function Flag115 (N : Node_Id) return Boolean is 3729 begin 3730 pragma Assert (Nkind (N) in N_Entity); 3731 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115; 3732 end Flag115; 3733 3734 function Flag116 (N : Node_Id) return Boolean is 3735 begin 3736 pragma Assert (Nkind (N) in N_Entity); 3737 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116; 3738 end Flag116; 3739 3740 function Flag117 (N : Node_Id) return Boolean is 3741 begin 3742 pragma Assert (Nkind (N) in N_Entity); 3743 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117; 3744 end Flag117; 3745 3746 function Flag118 (N : Node_Id) return Boolean is 3747 begin 3748 pragma Assert (Nkind (N) in N_Entity); 3749 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118; 3750 end Flag118; 3751 3752 function Flag119 (N : Node_Id) return Boolean is 3753 begin 3754 pragma Assert (Nkind (N) in N_Entity); 3755 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119; 3756 end Flag119; 3757 3758 function Flag120 (N : Node_Id) return Boolean is 3759 begin 3760 pragma Assert (Nkind (N) in N_Entity); 3761 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120; 3762 end Flag120; 3763 3764 function Flag121 (N : Node_Id) return Boolean is 3765 begin 3766 pragma Assert (Nkind (N) in N_Entity); 3767 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121; 3768 end Flag121; 3769 3770 function Flag122 (N : Node_Id) return Boolean is 3771 begin 3772 pragma Assert (Nkind (N) in N_Entity); 3773 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122; 3774 end Flag122; 3775 3776 function Flag123 (N : Node_Id) return Boolean is 3777 begin 3778 pragma Assert (Nkind (N) in N_Entity); 3779 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123; 3780 end Flag123; 3781 3782 function Flag124 (N : Node_Id) return Boolean is 3783 begin 3784 pragma Assert (Nkind (N) in N_Entity); 3785 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124; 3786 end Flag124; 3787 3788 function Flag125 (N : Node_Id) return Boolean is 3789 begin 3790 pragma Assert (Nkind (N) in N_Entity); 3791 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125; 3792 end Flag125; 3793 3794 function Flag126 (N : Node_Id) return Boolean is 3795 begin 3796 pragma Assert (Nkind (N) in N_Entity); 3797 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126; 3798 end Flag126; 3799 3800 function Flag127 (N : Node_Id) return Boolean is 3801 begin 3802 pragma Assert (Nkind (N) in N_Entity); 3803 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127; 3804 end Flag127; 3805 3806 function Flag128 (N : Node_Id) return Boolean is 3807 begin 3808 pragma Assert (Nkind (N) in N_Entity); 3809 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128; 3810 end Flag128; 3811 3812 function Flag129 (N : Node_Id) return Boolean is 3813 begin 3814 pragma Assert (Nkind (N) in N_Entity); 3815 return Nodes.Table (N + 3).In_List; 3816 end Flag129; 3817 3818 function Flag130 (N : Node_Id) return Boolean is 3819 begin 3820 pragma Assert (Nkind (N) in N_Entity); 3821 return Nodes.Table (N + 3).Unused_1; 3822 end Flag130; 3823 3824 function Flag131 (N : Node_Id) return Boolean is 3825 begin 3826 pragma Assert (Nkind (N) in N_Entity); 3827 return Nodes.Table (N + 3).Rewrite_Ins; 3828 end Flag131; 3829 3830 function Flag132 (N : Node_Id) return Boolean is 3831 begin 3832 pragma Assert (Nkind (N) in N_Entity); 3833 return Nodes.Table (N + 3).Analyzed; 3834 end Flag132; 3835 3836 function Flag133 (N : Node_Id) return Boolean is 3837 begin 3838 pragma Assert (Nkind (N) in N_Entity); 3839 return Nodes.Table (N + 3).Comes_From_Source; 3840 end Flag133; 3841 3842 function Flag134 (N : Node_Id) return Boolean is 3843 begin 3844 pragma Assert (Nkind (N) in N_Entity); 3845 return Nodes.Table (N + 3).Error_Posted; 3846 end Flag134; 3847 3848 function Flag135 (N : Node_Id) return Boolean is 3849 begin 3850 pragma Assert (Nkind (N) in N_Entity); 3851 return Nodes.Table (N + 3).Flag4; 3852 end Flag135; 3853 3854 function Flag136 (N : Node_Id) return Boolean is 3855 begin 3856 pragma Assert (Nkind (N) in N_Entity); 3857 return Nodes.Table (N + 3).Flag5; 3858 end Flag136; 3859 3860 function Flag137 (N : Node_Id) return Boolean is 3861 begin 3862 pragma Assert (Nkind (N) in N_Entity); 3863 return Nodes.Table (N + 3).Flag6; 3864 end Flag137; 3865 3866 function Flag138 (N : Node_Id) return Boolean is 3867 begin 3868 pragma Assert (Nkind (N) in N_Entity); 3869 return Nodes.Table (N + 3).Flag7; 3870 end Flag138; 3871 3872 function Flag139 (N : Node_Id) return Boolean is 3873 begin 3874 pragma Assert (Nkind (N) in N_Entity); 3875 return Nodes.Table (N + 3).Flag8; 3876 end Flag139; 3877 3878 function Flag140 (N : Node_Id) return Boolean is 3879 begin 3880 pragma Assert (Nkind (N) in N_Entity); 3881 return Nodes.Table (N + 3).Flag9; 3882 end Flag140; 3883 3884 function Flag141 (N : Node_Id) return Boolean is 3885 begin 3886 pragma Assert (Nkind (N) in N_Entity); 3887 return Nodes.Table (N + 3).Flag10; 3888 end Flag141; 3889 3890 function Flag142 (N : Node_Id) return Boolean is 3891 begin 3892 pragma Assert (Nkind (N) in N_Entity); 3893 return Nodes.Table (N + 3).Flag11; 3894 end Flag142; 3895 3896 function Flag143 (N : Node_Id) return Boolean is 3897 begin 3898 pragma Assert (Nkind (N) in N_Entity); 3899 return Nodes.Table (N + 3).Flag12; 3900 end Flag143; 3901 3902 function Flag144 (N : Node_Id) return Boolean is 3903 begin 3904 pragma Assert (Nkind (N) in N_Entity); 3905 return Nodes.Table (N + 3).Flag13; 3906 end Flag144; 3907 3908 function Flag145 (N : Node_Id) return Boolean is 3909 begin 3910 pragma Assert (Nkind (N) in N_Entity); 3911 return Nodes.Table (N + 3).Flag14; 3912 end Flag145; 3913 3914 function Flag146 (N : Node_Id) return Boolean is 3915 begin 3916 pragma Assert (Nkind (N) in N_Entity); 3917 return Nodes.Table (N + 3).Flag15; 3918 end Flag146; 3919 3920 function Flag147 (N : Node_Id) return Boolean is 3921 begin 3922 pragma Assert (Nkind (N) in N_Entity); 3923 return Nodes.Table (N + 3).Flag16; 3924 end Flag147; 3925 3926 function Flag148 (N : Node_Id) return Boolean is 3927 begin 3928 pragma Assert (Nkind (N) in N_Entity); 3929 return Nodes.Table (N + 3).Flag17; 3930 end Flag148; 3931 3932 function Flag149 (N : Node_Id) return Boolean is 3933 begin 3934 pragma Assert (Nkind (N) in N_Entity); 3935 return Nodes.Table (N + 3).Flag18; 3936 end Flag149; 3937 3938 function Flag150 (N : Node_Id) return Boolean is 3939 begin 3940 pragma Assert (Nkind (N) in N_Entity); 3941 return Nodes.Table (N + 3).Pflag1; 3942 end Flag150; 3943 3944 function Flag151 (N : Node_Id) return Boolean is 3945 begin 3946 pragma Assert (Nkind (N) in N_Entity); 3947 return Nodes.Table (N + 3).Pflag2; 3948 end Flag151; 3949 3950 function Flag152 (N : Node_Id) return Boolean is 3951 begin 3952 pragma Assert (Nkind (N) in N_Entity); 3953 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152; 3954 end Flag152; 3955 3956 function Flag153 (N : Node_Id) return Boolean is 3957 begin 3958 pragma Assert (Nkind (N) in N_Entity); 3959 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153; 3960 end Flag153; 3961 3962 function Flag154 (N : Node_Id) return Boolean is 3963 begin 3964 pragma Assert (Nkind (N) in N_Entity); 3965 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154; 3966 end Flag154; 3967 3968 function Flag155 (N : Node_Id) return Boolean is 3969 begin 3970 pragma Assert (Nkind (N) in N_Entity); 3971 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155; 3972 end Flag155; 3973 3974 function Flag156 (N : Node_Id) return Boolean is 3975 begin 3976 pragma Assert (Nkind (N) in N_Entity); 3977 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156; 3978 end Flag156; 3979 3980 function Flag157 (N : Node_Id) return Boolean is 3981 begin 3982 pragma Assert (Nkind (N) in N_Entity); 3983 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157; 3984 end Flag157; 3985 3986 function Flag158 (N : Node_Id) return Boolean is 3987 begin 3988 pragma Assert (Nkind (N) in N_Entity); 3989 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158; 3990 end Flag158; 3991 3992 function Flag159 (N : Node_Id) return Boolean is 3993 begin 3994 pragma Assert (Nkind (N) in N_Entity); 3995 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159; 3996 end Flag159; 3997 3998 function Flag160 (N : Node_Id) return Boolean is 3999 begin 4000 pragma Assert (Nkind (N) in N_Entity); 4001 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160; 4002 end Flag160; 4003 4004 function Flag161 (N : Node_Id) return Boolean is 4005 begin 4006 pragma Assert (Nkind (N) in N_Entity); 4007 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161; 4008 end Flag161; 4009 4010 function Flag162 (N : Node_Id) return Boolean is 4011 begin 4012 pragma Assert (Nkind (N) in N_Entity); 4013 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162; 4014 end Flag162; 4015 4016 function Flag163 (N : Node_Id) return Boolean is 4017 begin 4018 pragma Assert (Nkind (N) in N_Entity); 4019 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163; 4020 end Flag163; 4021 4022 function Flag164 (N : Node_Id) return Boolean is 4023 begin 4024 pragma Assert (Nkind (N) in N_Entity); 4025 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164; 4026 end Flag164; 4027 4028 function Flag165 (N : Node_Id) return Boolean is 4029 begin 4030 pragma Assert (Nkind (N) in N_Entity); 4031 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165; 4032 end Flag165; 4033 4034 function Flag166 (N : Node_Id) return Boolean is 4035 begin 4036 pragma Assert (Nkind (N) in N_Entity); 4037 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166; 4038 end Flag166; 4039 4040 function Flag167 (N : Node_Id) return Boolean is 4041 begin 4042 pragma Assert (Nkind (N) in N_Entity); 4043 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167; 4044 end Flag167; 4045 4046 function Flag168 (N : Node_Id) return Boolean is 4047 begin 4048 pragma Assert (Nkind (N) in N_Entity); 4049 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168; 4050 end Flag168; 4051 4052 function Flag169 (N : Node_Id) return Boolean is 4053 begin 4054 pragma Assert (Nkind (N) in N_Entity); 4055 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169; 4056 end Flag169; 4057 4058 function Flag170 (N : Node_Id) return Boolean is 4059 begin 4060 pragma Assert (Nkind (N) in N_Entity); 4061 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170; 4062 end Flag170; 4063 4064 function Flag171 (N : Node_Id) return Boolean is 4065 begin 4066 pragma Assert (Nkind (N) in N_Entity); 4067 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171; 4068 end Flag171; 4069 4070 function Flag172 (N : Node_Id) return Boolean is 4071 begin 4072 pragma Assert (Nkind (N) in N_Entity); 4073 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172; 4074 end Flag172; 4075 4076 function Flag173 (N : Node_Id) return Boolean is 4077 begin 4078 pragma Assert (Nkind (N) in N_Entity); 4079 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173; 4080 end Flag173; 4081 4082 function Flag174 (N : Node_Id) return Boolean is 4083 begin 4084 pragma Assert (Nkind (N) in N_Entity); 4085 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174; 4086 end Flag174; 4087 4088 function Flag175 (N : Node_Id) return Boolean is 4089 begin 4090 pragma Assert (Nkind (N) in N_Entity); 4091 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175; 4092 end Flag175; 4093 4094 function Flag176 (N : Node_Id) return Boolean is 4095 begin 4096 pragma Assert (Nkind (N) in N_Entity); 4097 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176; 4098 end Flag176; 4099 4100 function Flag177 (N : Node_Id) return Boolean is 4101 begin 4102 pragma Assert (Nkind (N) in N_Entity); 4103 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177; 4104 end Flag177; 4105 4106 function Flag178 (N : Node_Id) return Boolean is 4107 begin 4108 pragma Assert (Nkind (N) in N_Entity); 4109 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178; 4110 end Flag178; 4111 4112 function Flag179 (N : Node_Id) return Boolean is 4113 begin 4114 pragma Assert (Nkind (N) in N_Entity); 4115 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179; 4116 end Flag179; 4117 4118 function Flag180 (N : Node_Id) return Boolean is 4119 begin 4120 pragma Assert (Nkind (N) in N_Entity); 4121 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180; 4122 end Flag180; 4123 4124 function Flag181 (N : Node_Id) return Boolean is 4125 begin 4126 pragma Assert (Nkind (N) in N_Entity); 4127 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181; 4128 end Flag181; 4129 4130 function Flag182 (N : Node_Id) return Boolean is 4131 begin 4132 pragma Assert (Nkind (N) in N_Entity); 4133 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182; 4134 end Flag182; 4135 4136 function Flag183 (N : Node_Id) return Boolean is 4137 begin 4138 pragma Assert (Nkind (N) in N_Entity); 4139 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183; 4140 end Flag183; 4141 4142 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is 4143 begin 4144 pragma Assert (N in Nodes.First .. Nodes.Last); 4145 Nodes.Table (N).Nkind := Val; 4146 end Set_Nkind; 4147 4148 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is 4149 begin 4150 pragma Assert (N in Nodes.First .. Nodes.Last); 4151 Nodes.Table (N).Field1 := Val; 4152 end Set_Field1; 4153 4154 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is 4155 begin 4156 pragma Assert (N in Nodes.First .. Nodes.Last); 4157 Nodes.Table (N).Field2 := Val; 4158 end Set_Field2; 4159 4160 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is 4161 begin 4162 pragma Assert (N in Nodes.First .. Nodes.Last); 4163 Nodes.Table (N).Field3 := Val; 4164 end Set_Field3; 4165 4166 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is 4167 begin 4168 pragma Assert (N in Nodes.First .. Nodes.Last); 4169 Nodes.Table (N).Field4 := Val; 4170 end Set_Field4; 4171 4172 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is 4173 begin 4174 pragma Assert (N in Nodes.First .. Nodes.Last); 4175 Nodes.Table (N).Field5 := Val; 4176 end Set_Field5; 4177 4178 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is 4179 begin 4180 pragma Assert (Nkind (N) in N_Entity); 4181 Nodes.Table (N + 1).Field6 := Val; 4182 end Set_Field6; 4183 4184 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is 4185 begin 4186 pragma Assert (Nkind (N) in N_Entity); 4187 Nodes.Table (N + 1).Field7 := Val; 4188 end Set_Field7; 4189 4190 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is 4191 begin 4192 pragma Assert (Nkind (N) in N_Entity); 4193 Nodes.Table (N + 1).Field8 := Val; 4194 end Set_Field8; 4195 4196 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is 4197 begin 4198 pragma Assert (Nkind (N) in N_Entity); 4199 Nodes.Table (N + 1).Field9 := Val; 4200 end Set_Field9; 4201 4202 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is 4203 begin 4204 pragma Assert (Nkind (N) in N_Entity); 4205 Nodes.Table (N + 1).Field10 := Val; 4206 end Set_Field10; 4207 4208 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is 4209 begin 4210 pragma Assert (Nkind (N) in N_Entity); 4211 Nodes.Table (N + 1).Field11 := Val; 4212 end Set_Field11; 4213 4214 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is 4215 begin 4216 pragma Assert (Nkind (N) in N_Entity); 4217 Nodes.Table (N + 1).Field12 := Val; 4218 end Set_Field12; 4219 4220 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is 4221 begin 4222 pragma Assert (Nkind (N) in N_Entity); 4223 Nodes.Table (N + 2).Field6 := Val; 4224 end Set_Field13; 4225 4226 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is 4227 begin 4228 pragma Assert (Nkind (N) in N_Entity); 4229 Nodes.Table (N + 2).Field7 := Val; 4230 end Set_Field14; 4231 4232 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is 4233 begin 4234 pragma Assert (Nkind (N) in N_Entity); 4235 Nodes.Table (N + 2).Field8 := Val; 4236 end Set_Field15; 4237 4238 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is 4239 begin 4240 pragma Assert (Nkind (N) in N_Entity); 4241 Nodes.Table (N + 2).Field9 := Val; 4242 end Set_Field16; 4243 4244 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is 4245 begin 4246 pragma Assert (Nkind (N) in N_Entity); 4247 Nodes.Table (N + 2).Field10 := Val; 4248 end Set_Field17; 4249 4250 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is 4251 begin 4252 pragma Assert (Nkind (N) in N_Entity); 4253 Nodes.Table (N + 2).Field11 := Val; 4254 end Set_Field18; 4255 4256 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is 4257 begin 4258 pragma Assert (Nkind (N) in N_Entity); 4259 Nodes.Table (N + 3).Field6 := Val; 4260 end Set_Field19; 4261 4262 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is 4263 begin 4264 pragma Assert (Nkind (N) in N_Entity); 4265 Nodes.Table (N + 3).Field7 := Val; 4266 end Set_Field20; 4267 4268 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is 4269 begin 4270 pragma Assert (Nkind (N) in N_Entity); 4271 Nodes.Table (N + 3).Field8 := Val; 4272 end Set_Field21; 4273 4274 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is 4275 begin 4276 pragma Assert (Nkind (N) in N_Entity); 4277 Nodes.Table (N + 3).Field9 := Val; 4278 end Set_Field22; 4279 4280 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is 4281 begin 4282 pragma Assert (Nkind (N) in N_Entity); 4283 Nodes.Table (N + 3).Field10 := Val; 4284 end Set_Field23; 4285 4286 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is 4287 begin 4288 pragma Assert (N in Nodes.First .. Nodes.Last); 4289 Nodes.Table (N).Field1 := Union_Id (Val); 4290 end Set_Node1; 4291 4292 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is 4293 begin 4294 pragma Assert (N in Nodes.First .. Nodes.Last); 4295 Nodes.Table (N).Field2 := Union_Id (Val); 4296 end Set_Node2; 4297 4298 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is 4299 begin 4300 pragma Assert (N in Nodes.First .. Nodes.Last); 4301 Nodes.Table (N).Field3 := Union_Id (Val); 4302 end Set_Node3; 4303 4304 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is 4305 begin 4306 pragma Assert (N in Nodes.First .. Nodes.Last); 4307 Nodes.Table (N).Field4 := Union_Id (Val); 4308 end Set_Node4; 4309 4310 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is 4311 begin 4312 pragma Assert (N in Nodes.First .. Nodes.Last); 4313 Nodes.Table (N).Field5 := Union_Id (Val); 4314 end Set_Node5; 4315 4316 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is 4317 begin 4318 pragma Assert (Nkind (N) in N_Entity); 4319 Nodes.Table (N + 1).Field6 := Union_Id (Val); 4320 end Set_Node6; 4321 4322 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is 4323 begin 4324 pragma Assert (Nkind (N) in N_Entity); 4325 Nodes.Table (N + 1).Field7 := Union_Id (Val); 4326 end Set_Node7; 4327 4328 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is 4329 begin 4330 pragma Assert (Nkind (N) in N_Entity); 4331 Nodes.Table (N + 1).Field8 := Union_Id (Val); 4332 end Set_Node8; 4333 4334 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is 4335 begin 4336 pragma Assert (Nkind (N) in N_Entity); 4337 Nodes.Table (N + 1).Field9 := Union_Id (Val); 4338 end Set_Node9; 4339 4340 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is 4341 begin 4342 pragma Assert (Nkind (N) in N_Entity); 4343 Nodes.Table (N + 1).Field10 := Union_Id (Val); 4344 end Set_Node10; 4345 4346 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is 4347 begin 4348 pragma Assert (Nkind (N) in N_Entity); 4349 Nodes.Table (N + 1).Field11 := Union_Id (Val); 4350 end Set_Node11; 4351 4352 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is 4353 begin 4354 pragma Assert (Nkind (N) in N_Entity); 4355 Nodes.Table (N + 1).Field12 := Union_Id (Val); 4356 end Set_Node12; 4357 4358 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is 4359 begin 4360 pragma Assert (Nkind (N) in N_Entity); 4361 Nodes.Table (N + 2).Field6 := Union_Id (Val); 4362 end Set_Node13; 4363 4364 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is 4365 begin 4366 pragma Assert (Nkind (N) in N_Entity); 4367 Nodes.Table (N + 2).Field7 := Union_Id (Val); 4368 end Set_Node14; 4369 4370 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is 4371 begin 4372 pragma Assert (Nkind (N) in N_Entity); 4373 Nodes.Table (N + 2).Field8 := Union_Id (Val); 4374 end Set_Node15; 4375 4376 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is 4377 begin 4378 pragma Assert (Nkind (N) in N_Entity); 4379 Nodes.Table (N + 2).Field9 := Union_Id (Val); 4380 end Set_Node16; 4381 4382 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is 4383 begin 4384 pragma Assert (Nkind (N) in N_Entity); 4385 Nodes.Table (N + 2).Field10 := Union_Id (Val); 4386 end Set_Node17; 4387 4388 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is 4389 begin 4390 pragma Assert (Nkind (N) in N_Entity); 4391 Nodes.Table (N + 2).Field11 := Union_Id (Val); 4392 end Set_Node18; 4393 4394 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is 4395 begin 4396 pragma Assert (Nkind (N) in N_Entity); 4397 Nodes.Table (N + 3).Field6 := Union_Id (Val); 4398 end Set_Node19; 4399 4400 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is 4401 begin 4402 pragma Assert (Nkind (N) in N_Entity); 4403 Nodes.Table (N + 3).Field7 := Union_Id (Val); 4404 end Set_Node20; 4405 4406 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is 4407 begin 4408 pragma Assert (Nkind (N) in N_Entity); 4409 Nodes.Table (N + 3).Field8 := Union_Id (Val); 4410 end Set_Node21; 4411 4412 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is 4413 begin 4414 pragma Assert (Nkind (N) in N_Entity); 4415 Nodes.Table (N + 3).Field9 := Union_Id (Val); 4416 end Set_Node22; 4417 4418 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is 4419 begin 4420 pragma Assert (Nkind (N) in N_Entity); 4421 Nodes.Table (N + 3).Field10 := Union_Id (Val); 4422 end Set_Node23; 4423 4424 procedure Set_List1 (N : Node_Id; Val : List_Id) is 4425 begin 4426 pragma Assert (N in Nodes.First .. Nodes.Last); 4427 Nodes.Table (N).Field1 := Union_Id (Val); 4428 end Set_List1; 4429 4430 procedure Set_List2 (N : Node_Id; Val : List_Id) is 4431 begin 4432 pragma Assert (N in Nodes.First .. Nodes.Last); 4433 Nodes.Table (N).Field2 := Union_Id (Val); 4434 end Set_List2; 4435 4436 procedure Set_List3 (N : Node_Id; Val : List_Id) is 4437 begin 4438 pragma Assert (N in Nodes.First .. Nodes.Last); 4439 Nodes.Table (N).Field3 := Union_Id (Val); 4440 end Set_List3; 4441 4442 procedure Set_List4 (N : Node_Id; Val : List_Id) is 4443 begin 4444 pragma Assert (N in Nodes.First .. Nodes.Last); 4445 Nodes.Table (N).Field4 := Union_Id (Val); 4446 end Set_List4; 4447 4448 procedure Set_List5 (N : Node_Id; Val : List_Id) is 4449 begin 4450 pragma Assert (N in Nodes.First .. Nodes.Last); 4451 Nodes.Table (N).Field5 := Union_Id (Val); 4452 end Set_List5; 4453 4454 procedure Set_List10 (N : Node_Id; Val : List_Id) is 4455 begin 4456 pragma Assert (Nkind (N) in N_Entity); 4457 Nodes.Table (N + 1).Field10 := Union_Id (Val); 4458 end Set_List10; 4459 4460 procedure Set_List14 (N : Node_Id; Val : List_Id) is 4461 begin 4462 pragma Assert (Nkind (N) in N_Entity); 4463 Nodes.Table (N + 2).Field7 := Union_Id (Val); 4464 end Set_List14; 4465 4466 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is 4467 begin 4468 Nodes.Table (N).Field2 := Union_Id (Val); 4469 end Set_Elist2; 4470 4471 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is 4472 begin 4473 Nodes.Table (N).Field3 := Union_Id (Val); 4474 end Set_Elist3; 4475 4476 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is 4477 begin 4478 Nodes.Table (N).Field4 := Union_Id (Val); 4479 end Set_Elist4; 4480 4481 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is 4482 begin 4483 pragma Assert (Nkind (N) in N_Entity); 4484 Nodes.Table (N + 1).Field8 := Union_Id (Val); 4485 end Set_Elist8; 4486 4487 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is 4488 begin 4489 pragma Assert (Nkind (N) in N_Entity); 4490 Nodes.Table (N + 2).Field6 := Union_Id (Val); 4491 end Set_Elist13; 4492 4493 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is 4494 begin 4495 pragma Assert (Nkind (N) in N_Entity); 4496 Nodes.Table (N + 2).Field8 := Union_Id (Val); 4497 end Set_Elist15; 4498 4499 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is 4500 begin 4501 pragma Assert (Nkind (N) in N_Entity); 4502 Nodes.Table (N + 2).Field9 := Union_Id (Val); 4503 end Set_Elist16; 4504 4505 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is 4506 begin 4507 pragma Assert (Nkind (N) in N_Entity); 4508 Nodes.Table (N + 2).Field11 := Union_Id (Val); 4509 end Set_Elist18; 4510 4511 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is 4512 begin 4513 pragma Assert (Nkind (N) in N_Entity); 4514 Nodes.Table (N + 3).Field8 := Union_Id (Val); 4515 end Set_Elist21; 4516 4517 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is 4518 begin 4519 pragma Assert (Nkind (N) in N_Entity); 4520 Nodes.Table (N + 3).Field10 := Union_Id (Val); 4521 end Set_Elist23; 4522 4523 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is 4524 begin 4525 pragma Assert (N in Nodes.First .. Nodes.Last); 4526 Nodes.Table (N).Field1 := Union_Id (Val); 4527 end Set_Name1; 4528 4529 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is 4530 begin 4531 pragma Assert (N in Nodes.First .. Nodes.Last); 4532 Nodes.Table (N).Field2 := Union_Id (Val); 4533 end Set_Name2; 4534 4535 procedure Set_Str3 (N : Node_Id; Val : String_Id) is 4536 begin 4537 pragma Assert (N in Nodes.First .. Nodes.Last); 4538 Nodes.Table (N).Field3 := Union_Id (Val); 4539 end Set_Str3; 4540 4541 procedure Set_Uint3 (N : Node_Id; Val : Uint) is 4542 begin 4543 pragma Assert (N in Nodes.First .. Nodes.Last); 4544 Nodes.Table (N).Field3 := To_Union (Val); 4545 end Set_Uint3; 4546 4547 procedure Set_Uint4 (N : Node_Id; Val : Uint) is 4548 begin 4549 pragma Assert (N in Nodes.First .. Nodes.Last); 4550 Nodes.Table (N).Field4 := To_Union (Val); 4551 end Set_Uint4; 4552 4553 procedure Set_Uint5 (N : Node_Id; Val : Uint) is 4554 begin 4555 pragma Assert (N in Nodes.First .. Nodes.Last); 4556 Nodes.Table (N).Field5 := To_Union (Val); 4557 end Set_Uint5; 4558 4559 procedure Set_Uint8 (N : Node_Id; Val : Uint) is 4560 begin 4561 pragma Assert (Nkind (N) in N_Entity); 4562 Nodes.Table (N + 1).Field8 := To_Union (Val); 4563 end Set_Uint8; 4564 4565 procedure Set_Uint9 (N : Node_Id; Val : Uint) is 4566 begin 4567 pragma Assert (Nkind (N) in N_Entity); 4568 Nodes.Table (N + 1).Field9 := To_Union (Val); 4569 end Set_Uint9; 4570 4571 procedure Set_Uint10 (N : Node_Id; Val : Uint) is 4572 begin 4573 pragma Assert (Nkind (N) in N_Entity); 4574 Nodes.Table (N + 1).Field10 := To_Union (Val); 4575 end Set_Uint10; 4576 4577 procedure Set_Uint11 (N : Node_Id; Val : Uint) is 4578 begin 4579 pragma Assert (Nkind (N) in N_Entity); 4580 Nodes.Table (N + 1).Field11 := To_Union (Val); 4581 end Set_Uint11; 4582 4583 procedure Set_Uint12 (N : Node_Id; Val : Uint) is 4584 begin 4585 pragma Assert (Nkind (N) in N_Entity); 4586 Nodes.Table (N + 1).Field12 := To_Union (Val); 4587 end Set_Uint12; 4588 4589 procedure Set_Uint13 (N : Node_Id; Val : Uint) is 4590 begin 4591 pragma Assert (Nkind (N) in N_Entity); 4592 Nodes.Table (N + 2).Field6 := To_Union (Val); 4593 end Set_Uint13; 4594 4595 procedure Set_Uint14 (N : Node_Id; Val : Uint) is 4596 begin 4597 pragma Assert (Nkind (N) in N_Entity); 4598 Nodes.Table (N + 2).Field7 := To_Union (Val); 4599 end Set_Uint14; 4600 4601 procedure Set_Uint15 (N : Node_Id; Val : Uint) is 4602 begin 4603 pragma Assert (Nkind (N) in N_Entity); 4604 Nodes.Table (N + 2).Field8 := To_Union (Val); 4605 end Set_Uint15; 4606 4607 procedure Set_Uint16 (N : Node_Id; Val : Uint) is 4608 begin 4609 pragma Assert (Nkind (N) in N_Entity); 4610 Nodes.Table (N + 2).Field9 := To_Union (Val); 4611 end Set_Uint16; 4612 4613 procedure Set_Uint17 (N : Node_Id; Val : Uint) is 4614 begin 4615 pragma Assert (Nkind (N) in N_Entity); 4616 Nodes.Table (N + 2).Field10 := To_Union (Val); 4617 end Set_Uint17; 4618 4619 procedure Set_Uint22 (N : Node_Id; Val : Uint) is 4620 begin 4621 pragma Assert (Nkind (N) in N_Entity); 4622 Nodes.Table (N + 3).Field9 := To_Union (Val); 4623 end Set_Uint22; 4624 4625 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is 4626 begin 4627 pragma Assert (N in Nodes.First .. Nodes.Last); 4628 Nodes.Table (N).Field3 := To_Union (Val); 4629 end Set_Ureal3; 4630 4631 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is 4632 begin 4633 pragma Assert (Nkind (N) in N_Entity); 4634 Nodes.Table (N + 2).Field11 := To_Union (Val); 4635 end Set_Ureal18; 4636 4637 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is 4638 begin 4639 pragma Assert (Nkind (N) in N_Entity); 4640 Nodes.Table (N + 3).Field8 := To_Union (Val); 4641 end Set_Ureal21; 4642 4643 procedure Set_Char_Code2 (N : Node_Id; Val : Char_Code) is 4644 begin 4645 pragma Assert (N in Nodes.First .. Nodes.Last); 4646 Nodes.Table (N).Field2 := Union_Id (Val) + Char_Code_Bias; 4647 end Set_Char_Code2; 4648 4649 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is 4650 begin 4651 pragma Assert (N in Nodes.First .. Nodes.Last); 4652 Nodes.Table (N).Flag4 := Val; 4653 end Set_Flag4; 4654 4655 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is 4656 begin 4657 pragma Assert (N in Nodes.First .. Nodes.Last); 4658 Nodes.Table (N).Flag5 := Val; 4659 end Set_Flag5; 4660 4661 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is 4662 begin 4663 pragma Assert (N in Nodes.First .. Nodes.Last); 4664 Nodes.Table (N).Flag6 := Val; 4665 end Set_Flag6; 4666 4667 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is 4668 begin 4669 pragma Assert (N in Nodes.First .. Nodes.Last); 4670 Nodes.Table (N).Flag7 := Val; 4671 end Set_Flag7; 4672 4673 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is 4674 begin 4675 pragma Assert (N in Nodes.First .. Nodes.Last); 4676 Nodes.Table (N).Flag8 := Val; 4677 end Set_Flag8; 4678 4679 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is 4680 begin 4681 pragma Assert (N in Nodes.First .. Nodes.Last); 4682 Nodes.Table (N).Flag9 := Val; 4683 end Set_Flag9; 4684 4685 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is 4686 begin 4687 pragma Assert (N in Nodes.First .. Nodes.Last); 4688 Nodes.Table (N).Flag10 := Val; 4689 end Set_Flag10; 4690 4691 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is 4692 begin 4693 pragma Assert (N in Nodes.First .. Nodes.Last); 4694 Nodes.Table (N).Flag11 := Val; 4695 end Set_Flag11; 4696 4697 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is 4698 begin 4699 pragma Assert (N in Nodes.First .. Nodes.Last); 4700 Nodes.Table (N).Flag12 := Val; 4701 end Set_Flag12; 4702 4703 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is 4704 begin 4705 pragma Assert (N in Nodes.First .. Nodes.Last); 4706 Nodes.Table (N).Flag13 := Val; 4707 end Set_Flag13; 4708 4709 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is 4710 begin 4711 pragma Assert (N in Nodes.First .. Nodes.Last); 4712 Nodes.Table (N).Flag14 := Val; 4713 end Set_Flag14; 4714 4715 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is 4716 begin 4717 pragma Assert (N in Nodes.First .. Nodes.Last); 4718 Nodes.Table (N).Flag15 := Val; 4719 end Set_Flag15; 4720 4721 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is 4722 begin 4723 pragma Assert (N in Nodes.First .. Nodes.Last); 4724 Nodes.Table (N).Flag16 := Val; 4725 end Set_Flag16; 4726 4727 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is 4728 begin 4729 pragma Assert (N in Nodes.First .. Nodes.Last); 4730 Nodes.Table (N).Flag17 := Val; 4731 end Set_Flag17; 4732 4733 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is 4734 begin 4735 pragma Assert (N in Nodes.First .. Nodes.Last); 4736 Nodes.Table (N).Flag18 := Val; 4737 end Set_Flag18; 4738 4739 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is 4740 begin 4741 pragma Assert (Nkind (N) in N_Entity); 4742 Nodes.Table (N + 1).In_List := Val; 4743 end Set_Flag19; 4744 4745 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is 4746 begin 4747 pragma Assert (Nkind (N) in N_Entity); 4748 Nodes.Table (N + 1).Unused_1 := Val; 4749 end Set_Flag20; 4750 4751 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is 4752 begin 4753 pragma Assert (Nkind (N) in N_Entity); 4754 Nodes.Table (N + 1).Rewrite_Ins := Val; 4755 end Set_Flag21; 4756 4757 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is 4758 begin 4759 pragma Assert (Nkind (N) in N_Entity); 4760 Nodes.Table (N + 1).Analyzed := Val; 4761 end Set_Flag22; 4762 4763 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is 4764 begin 4765 pragma Assert (Nkind (N) in N_Entity); 4766 Nodes.Table (N + 1).Comes_From_Source := Val; 4767 end Set_Flag23; 4768 4769 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is 4770 begin 4771 pragma Assert (Nkind (N) in N_Entity); 4772 Nodes.Table (N + 1).Error_Posted := Val; 4773 end Set_Flag24; 4774 4775 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is 4776 begin 4777 pragma Assert (Nkind (N) in N_Entity); 4778 Nodes.Table (N + 1).Flag4 := Val; 4779 end Set_Flag25; 4780 4781 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is 4782 begin 4783 pragma Assert (Nkind (N) in N_Entity); 4784 Nodes.Table (N + 1).Flag5 := Val; 4785 end Set_Flag26; 4786 4787 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is 4788 begin 4789 pragma Assert (Nkind (N) in N_Entity); 4790 Nodes.Table (N + 1).Flag6 := Val; 4791 end Set_Flag27; 4792 4793 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is 4794 begin 4795 pragma Assert (Nkind (N) in N_Entity); 4796 Nodes.Table (N + 1).Flag7 := Val; 4797 end Set_Flag28; 4798 4799 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is 4800 begin 4801 pragma Assert (Nkind (N) in N_Entity); 4802 Nodes.Table (N + 1).Flag8 := Val; 4803 end Set_Flag29; 4804 4805 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is 4806 begin 4807 pragma Assert (Nkind (N) in N_Entity); 4808 Nodes.Table (N + 1).Flag9 := Val; 4809 end Set_Flag30; 4810 4811 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is 4812 begin 4813 pragma Assert (Nkind (N) in N_Entity); 4814 Nodes.Table (N + 1).Flag10 := Val; 4815 end Set_Flag31; 4816 4817 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is 4818 begin 4819 pragma Assert (Nkind (N) in N_Entity); 4820 Nodes.Table (N + 1).Flag11 := Val; 4821 end Set_Flag32; 4822 4823 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is 4824 begin 4825 pragma Assert (Nkind (N) in N_Entity); 4826 Nodes.Table (N + 1).Flag12 := Val; 4827 end Set_Flag33; 4828 4829 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is 4830 begin 4831 pragma Assert (Nkind (N) in N_Entity); 4832 Nodes.Table (N + 1).Flag13 := Val; 4833 end Set_Flag34; 4834 4835 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is 4836 begin 4837 pragma Assert (Nkind (N) in N_Entity); 4838 Nodes.Table (N + 1).Flag14 := Val; 4839 end Set_Flag35; 4840 4841 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is 4842 begin 4843 pragma Assert (Nkind (N) in N_Entity); 4844 Nodes.Table (N + 1).Flag15 := Val; 4845 end Set_Flag36; 4846 4847 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is 4848 begin 4849 pragma Assert (Nkind (N) in N_Entity); 4850 Nodes.Table (N + 1).Flag16 := Val; 4851 end Set_Flag37; 4852 4853 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is 4854 begin 4855 pragma Assert (Nkind (N) in N_Entity); 4856 Nodes.Table (N + 1).Flag17 := Val; 4857 end Set_Flag38; 4858 4859 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is 4860 begin 4861 pragma Assert (Nkind (N) in N_Entity); 4862 Nodes.Table (N + 1).Flag18 := Val; 4863 end Set_Flag39; 4864 4865 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is 4866 begin 4867 pragma Assert (Nkind (N) in N_Entity); 4868 Nodes.Table (N + 2).In_List := Val; 4869 end Set_Flag40; 4870 4871 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is 4872 begin 4873 pragma Assert (Nkind (N) in N_Entity); 4874 Nodes.Table (N + 2).Unused_1 := Val; 4875 end Set_Flag41; 4876 4877 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is 4878 begin 4879 pragma Assert (Nkind (N) in N_Entity); 4880 Nodes.Table (N + 2).Rewrite_Ins := Val; 4881 end Set_Flag42; 4882 4883 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is 4884 begin 4885 pragma Assert (Nkind (N) in N_Entity); 4886 Nodes.Table (N + 2).Analyzed := Val; 4887 end Set_Flag43; 4888 4889 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is 4890 begin 4891 pragma Assert (Nkind (N) in N_Entity); 4892 Nodes.Table (N + 2).Comes_From_Source := Val; 4893 end Set_Flag44; 4894 4895 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is 4896 begin 4897 pragma Assert (Nkind (N) in N_Entity); 4898 Nodes.Table (N + 2).Error_Posted := Val; 4899 end Set_Flag45; 4900 4901 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is 4902 begin 4903 pragma Assert (Nkind (N) in N_Entity); 4904 Nodes.Table (N + 2).Flag4 := Val; 4905 end Set_Flag46; 4906 4907 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is 4908 begin 4909 pragma Assert (Nkind (N) in N_Entity); 4910 Nodes.Table (N + 2).Flag5 := Val; 4911 end Set_Flag47; 4912 4913 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is 4914 begin 4915 pragma Assert (Nkind (N) in N_Entity); 4916 Nodes.Table (N + 2).Flag6 := Val; 4917 end Set_Flag48; 4918 4919 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is 4920 begin 4921 pragma Assert (Nkind (N) in N_Entity); 4922 Nodes.Table (N + 2).Flag7 := Val; 4923 end Set_Flag49; 4924 4925 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is 4926 begin 4927 pragma Assert (Nkind (N) in N_Entity); 4928 Nodes.Table (N + 2).Flag8 := Val; 4929 end Set_Flag50; 4930 4931 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is 4932 begin 4933 pragma Assert (Nkind (N) in N_Entity); 4934 Nodes.Table (N + 2).Flag9 := Val; 4935 end Set_Flag51; 4936 4937 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is 4938 begin 4939 pragma Assert (Nkind (N) in N_Entity); 4940 Nodes.Table (N + 2).Flag10 := Val; 4941 end Set_Flag52; 4942 4943 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is 4944 begin 4945 pragma Assert (Nkind (N) in N_Entity); 4946 Nodes.Table (N + 2).Flag11 := Val; 4947 end Set_Flag53; 4948 4949 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is 4950 begin 4951 pragma Assert (Nkind (N) in N_Entity); 4952 Nodes.Table (N + 2).Flag12 := Val; 4953 end Set_Flag54; 4954 4955 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is 4956 begin 4957 pragma Assert (Nkind (N) in N_Entity); 4958 Nodes.Table (N + 2).Flag13 := Val; 4959 end Set_Flag55; 4960 4961 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is 4962 begin 4963 pragma Assert (Nkind (N) in N_Entity); 4964 Nodes.Table (N + 2).Flag14 := Val; 4965 end Set_Flag56; 4966 4967 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is 4968 begin 4969 pragma Assert (Nkind (N) in N_Entity); 4970 Nodes.Table (N + 2).Flag15 := Val; 4971 end Set_Flag57; 4972 4973 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is 4974 begin 4975 pragma Assert (Nkind (N) in N_Entity); 4976 Nodes.Table (N + 2).Flag16 := Val; 4977 end Set_Flag58; 4978 4979 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is 4980 begin 4981 pragma Assert (Nkind (N) in N_Entity); 4982 Nodes.Table (N + 2).Flag17 := Val; 4983 end Set_Flag59; 4984 4985 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is 4986 begin 4987 pragma Assert (Nkind (N) in N_Entity); 4988 Nodes.Table (N + 2).Flag18 := Val; 4989 end Set_Flag60; 4990 4991 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is 4992 begin 4993 pragma Assert (Nkind (N) in N_Entity); 4994 Nodes.Table (N + 1).Pflag1 := Val; 4995 end Set_Flag61; 4996 4997 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is 4998 begin 4999 pragma Assert (Nkind (N) in N_Entity); 5000 Nodes.Table (N + 1).Pflag2 := Val; 5001 end Set_Flag62; 5002 5003 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is 5004 begin 5005 pragma Assert (Nkind (N) in N_Entity); 5006 Nodes.Table (N + 2).Pflag1 := Val; 5007 end Set_Flag63; 5008 5009 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is 5010 begin 5011 pragma Assert (Nkind (N) in N_Entity); 5012 Nodes.Table (N + 2).Pflag2 := Val; 5013 end Set_Flag64; 5014 5015 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is 5016 begin 5017 pragma Assert (Nkind (N) in N_Entity); 5018 To_Flag_Byte_Ptr 5019 (Node_Kind_Ptr' 5020 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val; 5021 end Set_Flag65; 5022 5023 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is 5024 begin 5025 pragma Assert (Nkind (N) in N_Entity); 5026 To_Flag_Byte_Ptr 5027 (Node_Kind_Ptr' 5028 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val; 5029 end Set_Flag66; 5030 5031 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is 5032 begin 5033 pragma Assert (Nkind (N) in N_Entity); 5034 To_Flag_Byte_Ptr 5035 (Node_Kind_Ptr' 5036 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val; 5037 end Set_Flag67; 5038 5039 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is 5040 begin 5041 pragma Assert (Nkind (N) in N_Entity); 5042 To_Flag_Byte_Ptr 5043 (Node_Kind_Ptr' 5044 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val; 5045 end Set_Flag68; 5046 5047 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is 5048 begin 5049 pragma Assert (Nkind (N) in N_Entity); 5050 To_Flag_Byte_Ptr 5051 (Node_Kind_Ptr' 5052 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val; 5053 end Set_Flag69; 5054 5055 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is 5056 begin 5057 pragma Assert (Nkind (N) in N_Entity); 5058 To_Flag_Byte_Ptr 5059 (Node_Kind_Ptr' 5060 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val; 5061 end Set_Flag70; 5062 5063 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is 5064 begin 5065 pragma Assert (Nkind (N) in N_Entity); 5066 To_Flag_Byte_Ptr 5067 (Node_Kind_Ptr' 5068 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val; 5069 end Set_Flag71; 5070 5071 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is 5072 begin 5073 pragma Assert (Nkind (N) in N_Entity); 5074 To_Flag_Byte_Ptr 5075 (Node_Kind_Ptr' 5076 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val; 5077 end Set_Flag72; 5078 5079 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is 5080 begin 5081 pragma Assert (Nkind (N) in N_Entity); 5082 To_Flag_Word_Ptr 5083 (Union_Id_Ptr' 5084 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val; 5085 end Set_Flag73; 5086 5087 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is 5088 begin 5089 pragma Assert (Nkind (N) in N_Entity); 5090 To_Flag_Word_Ptr 5091 (Union_Id_Ptr' 5092 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val; 5093 end Set_Flag74; 5094 5095 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is 5096 begin 5097 pragma Assert (Nkind (N) in N_Entity); 5098 To_Flag_Word_Ptr 5099 (Union_Id_Ptr' 5100 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val; 5101 end Set_Flag75; 5102 5103 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is 5104 begin 5105 pragma Assert (Nkind (N) in N_Entity); 5106 To_Flag_Word_Ptr 5107 (Union_Id_Ptr' 5108 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val; 5109 end Set_Flag76; 5110 5111 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is 5112 begin 5113 pragma Assert (Nkind (N) in N_Entity); 5114 To_Flag_Word_Ptr 5115 (Union_Id_Ptr' 5116 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val; 5117 end Set_Flag77; 5118 5119 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is 5120 begin 5121 pragma Assert (Nkind (N) in N_Entity); 5122 To_Flag_Word_Ptr 5123 (Union_Id_Ptr' 5124 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val; 5125 end Set_Flag78; 5126 5127 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is 5128 begin 5129 pragma Assert (Nkind (N) in N_Entity); 5130 To_Flag_Word_Ptr 5131 (Union_Id_Ptr' 5132 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val; 5133 end Set_Flag79; 5134 5135 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is 5136 begin 5137 pragma Assert (Nkind (N) in N_Entity); 5138 To_Flag_Word_Ptr 5139 (Union_Id_Ptr' 5140 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val; 5141 end Set_Flag80; 5142 5143 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is 5144 begin 5145 pragma Assert (Nkind (N) in N_Entity); 5146 To_Flag_Word_Ptr 5147 (Union_Id_Ptr' 5148 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val; 5149 end Set_Flag81; 5150 5151 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is 5152 begin 5153 pragma Assert (Nkind (N) in N_Entity); 5154 To_Flag_Word_Ptr 5155 (Union_Id_Ptr' 5156 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val; 5157 end Set_Flag82; 5158 5159 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is 5160 begin 5161 pragma Assert (Nkind (N) in N_Entity); 5162 To_Flag_Word_Ptr 5163 (Union_Id_Ptr' 5164 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val; 5165 end Set_Flag83; 5166 5167 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is 5168 begin 5169 pragma Assert (Nkind (N) in N_Entity); 5170 To_Flag_Word_Ptr 5171 (Union_Id_Ptr' 5172 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val; 5173 end Set_Flag84; 5174 5175 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is 5176 begin 5177 pragma Assert (Nkind (N) in N_Entity); 5178 To_Flag_Word_Ptr 5179 (Union_Id_Ptr' 5180 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val; 5181 end Set_Flag85; 5182 5183 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is 5184 begin 5185 pragma Assert (Nkind (N) in N_Entity); 5186 To_Flag_Word_Ptr 5187 (Union_Id_Ptr' 5188 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val; 5189 end Set_Flag86; 5190 5191 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is 5192 begin 5193 pragma Assert (Nkind (N) in N_Entity); 5194 To_Flag_Word_Ptr 5195 (Union_Id_Ptr' 5196 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val; 5197 end Set_Flag87; 5198 5199 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is 5200 begin 5201 pragma Assert (Nkind (N) in N_Entity); 5202 To_Flag_Word_Ptr 5203 (Union_Id_Ptr' 5204 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val; 5205 end Set_Flag88; 5206 5207 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is 5208 begin 5209 pragma Assert (Nkind (N) in N_Entity); 5210 To_Flag_Word_Ptr 5211 (Union_Id_Ptr' 5212 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val; 5213 end Set_Flag89; 5214 5215 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is 5216 begin 5217 pragma Assert (Nkind (N) in N_Entity); 5218 To_Flag_Word_Ptr 5219 (Union_Id_Ptr' 5220 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val; 5221 end Set_Flag90; 5222 5223 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is 5224 begin 5225 pragma Assert (Nkind (N) in N_Entity); 5226 To_Flag_Word_Ptr 5227 (Union_Id_Ptr' 5228 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val; 5229 end Set_Flag91; 5230 5231 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is 5232 begin 5233 pragma Assert (Nkind (N) in N_Entity); 5234 To_Flag_Word_Ptr 5235 (Union_Id_Ptr' 5236 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val; 5237 end Set_Flag92; 5238 5239 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is 5240 begin 5241 pragma Assert (Nkind (N) in N_Entity); 5242 To_Flag_Word_Ptr 5243 (Union_Id_Ptr' 5244 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val; 5245 end Set_Flag93; 5246 5247 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is 5248 begin 5249 pragma Assert (Nkind (N) in N_Entity); 5250 To_Flag_Word_Ptr 5251 (Union_Id_Ptr' 5252 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val; 5253 end Set_Flag94; 5254 5255 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is 5256 begin 5257 pragma Assert (Nkind (N) in N_Entity); 5258 To_Flag_Word_Ptr 5259 (Union_Id_Ptr' 5260 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val; 5261 end Set_Flag95; 5262 5263 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is 5264 begin 5265 pragma Assert (Nkind (N) in N_Entity); 5266 To_Flag_Word_Ptr 5267 (Union_Id_Ptr' 5268 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val; 5269 end Set_Flag96; 5270 5271 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is 5272 begin 5273 pragma Assert (Nkind (N) in N_Entity); 5274 To_Flag_Word2_Ptr 5275 (Union_Id_Ptr' 5276 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val; 5277 end Set_Flag97; 5278 5279 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is 5280 begin 5281 pragma Assert (Nkind (N) in N_Entity); 5282 To_Flag_Word2_Ptr 5283 (Union_Id_Ptr' 5284 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val; 5285 end Set_Flag98; 5286 5287 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is 5288 begin 5289 pragma Assert (Nkind (N) in N_Entity); 5290 To_Flag_Word2_Ptr 5291 (Union_Id_Ptr' 5292 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val; 5293 end Set_Flag99; 5294 5295 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is 5296 begin 5297 pragma Assert (Nkind (N) in N_Entity); 5298 To_Flag_Word2_Ptr 5299 (Union_Id_Ptr' 5300 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val; 5301 end Set_Flag100; 5302 5303 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is 5304 begin 5305 pragma Assert (Nkind (N) in N_Entity); 5306 To_Flag_Word2_Ptr 5307 (Union_Id_Ptr' 5308 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val; 5309 end Set_Flag101; 5310 5311 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is 5312 begin 5313 pragma Assert (Nkind (N) in N_Entity); 5314 To_Flag_Word2_Ptr 5315 (Union_Id_Ptr' 5316 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val; 5317 end Set_Flag102; 5318 5319 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is 5320 begin 5321 pragma Assert (Nkind (N) in N_Entity); 5322 To_Flag_Word2_Ptr 5323 (Union_Id_Ptr' 5324 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val; 5325 end Set_Flag103; 5326 5327 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is 5328 begin 5329 pragma Assert (Nkind (N) in N_Entity); 5330 To_Flag_Word2_Ptr 5331 (Union_Id_Ptr' 5332 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val; 5333 end Set_Flag104; 5334 5335 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is 5336 begin 5337 pragma Assert (Nkind (N) in N_Entity); 5338 To_Flag_Word2_Ptr 5339 (Union_Id_Ptr' 5340 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val; 5341 end Set_Flag105; 5342 5343 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is 5344 begin 5345 pragma Assert (Nkind (N) in N_Entity); 5346 To_Flag_Word2_Ptr 5347 (Union_Id_Ptr' 5348 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val; 5349 end Set_Flag106; 5350 5351 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is 5352 begin 5353 pragma Assert (Nkind (N) in N_Entity); 5354 To_Flag_Word2_Ptr 5355 (Union_Id_Ptr' 5356 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val; 5357 end Set_Flag107; 5358 5359 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is 5360 begin 5361 pragma Assert (Nkind (N) in N_Entity); 5362 To_Flag_Word2_Ptr 5363 (Union_Id_Ptr' 5364 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val; 5365 end Set_Flag108; 5366 5367 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is 5368 begin 5369 pragma Assert (Nkind (N) in N_Entity); 5370 To_Flag_Word2_Ptr 5371 (Union_Id_Ptr' 5372 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val; 5373 end Set_Flag109; 5374 5375 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is 5376 begin 5377 pragma Assert (Nkind (N) in N_Entity); 5378 To_Flag_Word2_Ptr 5379 (Union_Id_Ptr' 5380 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val; 5381 end Set_Flag110; 5382 5383 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is 5384 begin 5385 pragma Assert (Nkind (N) in N_Entity); 5386 To_Flag_Word2_Ptr 5387 (Union_Id_Ptr' 5388 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val; 5389 end Set_Flag111; 5390 5391 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is 5392 begin 5393 pragma Assert (Nkind (N) in N_Entity); 5394 To_Flag_Word2_Ptr 5395 (Union_Id_Ptr' 5396 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val; 5397 end Set_Flag112; 5398 5399 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is 5400 begin 5401 pragma Assert (Nkind (N) in N_Entity); 5402 To_Flag_Word2_Ptr 5403 (Union_Id_Ptr' 5404 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val; 5405 end Set_Flag113; 5406 5407 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is 5408 begin 5409 pragma Assert (Nkind (N) in N_Entity); 5410 To_Flag_Word2_Ptr 5411 (Union_Id_Ptr' 5412 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val; 5413 end Set_Flag114; 5414 5415 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is 5416 begin 5417 pragma Assert (Nkind (N) in N_Entity); 5418 To_Flag_Word2_Ptr 5419 (Union_Id_Ptr' 5420 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val; 5421 end Set_Flag115; 5422 5423 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is 5424 begin 5425 pragma Assert (Nkind (N) in N_Entity); 5426 To_Flag_Word2_Ptr 5427 (Union_Id_Ptr' 5428 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val; 5429 end Set_Flag116; 5430 5431 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is 5432 begin 5433 pragma Assert (Nkind (N) in N_Entity); 5434 To_Flag_Word2_Ptr 5435 (Union_Id_Ptr' 5436 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val; 5437 end Set_Flag117; 5438 5439 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is 5440 begin 5441 pragma Assert (Nkind (N) in N_Entity); 5442 To_Flag_Word2_Ptr 5443 (Union_Id_Ptr' 5444 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val; 5445 end Set_Flag118; 5446 5447 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is 5448 begin 5449 pragma Assert (Nkind (N) in N_Entity); 5450 To_Flag_Word2_Ptr 5451 (Union_Id_Ptr' 5452 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val; 5453 end Set_Flag119; 5454 5455 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is 5456 begin 5457 pragma Assert (Nkind (N) in N_Entity); 5458 To_Flag_Word2_Ptr 5459 (Union_Id_Ptr' 5460 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val; 5461 end Set_Flag120; 5462 5463 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is 5464 begin 5465 pragma Assert (Nkind (N) in N_Entity); 5466 To_Flag_Word2_Ptr 5467 (Union_Id_Ptr' 5468 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val; 5469 end Set_Flag121; 5470 5471 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is 5472 begin 5473 pragma Assert (Nkind (N) in N_Entity); 5474 To_Flag_Word2_Ptr 5475 (Union_Id_Ptr' 5476 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val; 5477 end Set_Flag122; 5478 5479 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is 5480 begin 5481 pragma Assert (Nkind (N) in N_Entity); 5482 To_Flag_Word2_Ptr 5483 (Union_Id_Ptr' 5484 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val; 5485 end Set_Flag123; 5486 5487 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is 5488 begin 5489 pragma Assert (Nkind (N) in N_Entity); 5490 To_Flag_Word2_Ptr 5491 (Union_Id_Ptr' 5492 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val; 5493 end Set_Flag124; 5494 5495 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is 5496 begin 5497 pragma Assert (Nkind (N) in N_Entity); 5498 To_Flag_Word2_Ptr 5499 (Union_Id_Ptr' 5500 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val; 5501 end Set_Flag125; 5502 5503 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is 5504 begin 5505 pragma Assert (Nkind (N) in N_Entity); 5506 To_Flag_Word2_Ptr 5507 (Union_Id_Ptr' 5508 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val; 5509 end Set_Flag126; 5510 5511 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is 5512 begin 5513 pragma Assert (Nkind (N) in N_Entity); 5514 To_Flag_Word2_Ptr 5515 (Union_Id_Ptr' 5516 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val; 5517 end Set_Flag127; 5518 5519 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is 5520 begin 5521 pragma Assert (Nkind (N) in N_Entity); 5522 To_Flag_Word2_Ptr 5523 (Union_Id_Ptr' 5524 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val; 5525 end Set_Flag128; 5526 5527 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is 5528 begin 5529 pragma Assert (Nkind (N) in N_Entity); 5530 Nodes.Table (N + 3).In_List := Val; 5531 end Set_Flag129; 5532 5533 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is 5534 begin 5535 pragma Assert (Nkind (N) in N_Entity); 5536 Nodes.Table (N + 3).Unused_1 := Val; 5537 end Set_Flag130; 5538 5539 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is 5540 begin 5541 pragma Assert (Nkind (N) in N_Entity); 5542 Nodes.Table (N + 3).Rewrite_Ins := Val; 5543 end Set_Flag131; 5544 5545 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is 5546 begin 5547 pragma Assert (Nkind (N) in N_Entity); 5548 Nodes.Table (N + 3).Analyzed := Val; 5549 end Set_Flag132; 5550 5551 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is 5552 begin 5553 pragma Assert (Nkind (N) in N_Entity); 5554 Nodes.Table (N + 3).Comes_From_Source := Val; 5555 end Set_Flag133; 5556 5557 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is 5558 begin 5559 pragma Assert (Nkind (N) in N_Entity); 5560 Nodes.Table (N + 3).Error_Posted := Val; 5561 end Set_Flag134; 5562 5563 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is 5564 begin 5565 pragma Assert (Nkind (N) in N_Entity); 5566 Nodes.Table (N + 3).Flag4 := Val; 5567 end Set_Flag135; 5568 5569 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is 5570 begin 5571 pragma Assert (Nkind (N) in N_Entity); 5572 Nodes.Table (N + 3).Flag5 := Val; 5573 end Set_Flag136; 5574 5575 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is 5576 begin 5577 pragma Assert (Nkind (N) in N_Entity); 5578 Nodes.Table (N + 3).Flag6 := Val; 5579 end Set_Flag137; 5580 5581 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is 5582 begin 5583 pragma Assert (Nkind (N) in N_Entity); 5584 Nodes.Table (N + 3).Flag7 := Val; 5585 end Set_Flag138; 5586 5587 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is 5588 begin 5589 pragma Assert (Nkind (N) in N_Entity); 5590 Nodes.Table (N + 3).Flag8 := Val; 5591 end Set_Flag139; 5592 5593 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is 5594 begin 5595 pragma Assert (Nkind (N) in N_Entity); 5596 Nodes.Table (N + 3).Flag9 := Val; 5597 end Set_Flag140; 5598 5599 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is 5600 begin 5601 pragma Assert (Nkind (N) in N_Entity); 5602 Nodes.Table (N + 3).Flag10 := Val; 5603 end Set_Flag141; 5604 5605 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is 5606 begin 5607 pragma Assert (Nkind (N) in N_Entity); 5608 Nodes.Table (N + 3).Flag11 := Val; 5609 end Set_Flag142; 5610 5611 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is 5612 begin 5613 pragma Assert (Nkind (N) in N_Entity); 5614 Nodes.Table (N + 3).Flag12 := Val; 5615 end Set_Flag143; 5616 5617 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is 5618 begin 5619 pragma Assert (Nkind (N) in N_Entity); 5620 Nodes.Table (N + 3).Flag13 := Val; 5621 end Set_Flag144; 5622 5623 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is 5624 begin 5625 pragma Assert (Nkind (N) in N_Entity); 5626 Nodes.Table (N + 3).Flag14 := Val; 5627 end Set_Flag145; 5628 5629 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is 5630 begin 5631 pragma Assert (Nkind (N) in N_Entity); 5632 Nodes.Table (N + 3).Flag15 := Val; 5633 end Set_Flag146; 5634 5635 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is 5636 begin 5637 pragma Assert (Nkind (N) in N_Entity); 5638 Nodes.Table (N + 3).Flag16 := Val; 5639 end Set_Flag147; 5640 5641 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is 5642 begin 5643 pragma Assert (Nkind (N) in N_Entity); 5644 Nodes.Table (N + 3).Flag17 := Val; 5645 end Set_Flag148; 5646 5647 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is 5648 begin 5649 pragma Assert (Nkind (N) in N_Entity); 5650 Nodes.Table (N + 3).Flag18 := Val; 5651 end Set_Flag149; 5652 5653 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is 5654 begin 5655 pragma Assert (Nkind (N) in N_Entity); 5656 Nodes.Table (N + 3).Pflag1 := Val; 5657 end Set_Flag150; 5658 5659 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is 5660 begin 5661 pragma Assert (Nkind (N) in N_Entity); 5662 Nodes.Table (N + 3).Pflag2 := Val; 5663 end Set_Flag151; 5664 5665 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is 5666 begin 5667 pragma Assert (Nkind (N) in N_Entity); 5668 To_Flag_Word3_Ptr 5669 (Union_Id_Ptr' 5670 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val; 5671 end Set_Flag152; 5672 5673 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is 5674 begin 5675 pragma Assert (Nkind (N) in N_Entity); 5676 To_Flag_Word3_Ptr 5677 (Union_Id_Ptr' 5678 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val; 5679 end Set_Flag153; 5680 5681 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is 5682 begin 5683 pragma Assert (Nkind (N) in N_Entity); 5684 To_Flag_Word3_Ptr 5685 (Union_Id_Ptr' 5686 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val; 5687 end Set_Flag154; 5688 5689 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is 5690 begin 5691 pragma Assert (Nkind (N) in N_Entity); 5692 To_Flag_Word3_Ptr 5693 (Union_Id_Ptr' 5694 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val; 5695 end Set_Flag155; 5696 5697 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is 5698 begin 5699 pragma Assert (Nkind (N) in N_Entity); 5700 To_Flag_Word3_Ptr 5701 (Union_Id_Ptr' 5702 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val; 5703 end Set_Flag156; 5704 5705 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is 5706 begin 5707 pragma Assert (Nkind (N) in N_Entity); 5708 To_Flag_Word3_Ptr 5709 (Union_Id_Ptr' 5710 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val; 5711 end Set_Flag157; 5712 5713 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is 5714 begin 5715 pragma Assert (Nkind (N) in N_Entity); 5716 To_Flag_Word3_Ptr 5717 (Union_Id_Ptr' 5718 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val; 5719 end Set_Flag158; 5720 5721 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is 5722 begin 5723 pragma Assert (Nkind (N) in N_Entity); 5724 To_Flag_Word3_Ptr 5725 (Union_Id_Ptr' 5726 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val; 5727 end Set_Flag159; 5728 5729 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is 5730 begin 5731 pragma Assert (Nkind (N) in N_Entity); 5732 To_Flag_Word3_Ptr 5733 (Union_Id_Ptr' 5734 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val; 5735 end Set_Flag160; 5736 5737 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is 5738 begin 5739 pragma Assert (Nkind (N) in N_Entity); 5740 To_Flag_Word3_Ptr 5741 (Union_Id_Ptr' 5742 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val; 5743 end Set_Flag161; 5744 5745 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is 5746 begin 5747 pragma Assert (Nkind (N) in N_Entity); 5748 To_Flag_Word3_Ptr 5749 (Union_Id_Ptr' 5750 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val; 5751 end Set_Flag162; 5752 5753 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is 5754 begin 5755 pragma Assert (Nkind (N) in N_Entity); 5756 To_Flag_Word3_Ptr 5757 (Union_Id_Ptr' 5758 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val; 5759 end Set_Flag163; 5760 5761 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is 5762 begin 5763 pragma Assert (Nkind (N) in N_Entity); 5764 To_Flag_Word3_Ptr 5765 (Union_Id_Ptr' 5766 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val; 5767 end Set_Flag164; 5768 5769 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is 5770 begin 5771 pragma Assert (Nkind (N) in N_Entity); 5772 To_Flag_Word3_Ptr 5773 (Union_Id_Ptr' 5774 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val; 5775 end Set_Flag165; 5776 5777 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is 5778 begin 5779 pragma Assert (Nkind (N) in N_Entity); 5780 To_Flag_Word3_Ptr 5781 (Union_Id_Ptr' 5782 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val; 5783 end Set_Flag166; 5784 5785 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is 5786 begin 5787 pragma Assert (Nkind (N) in N_Entity); 5788 To_Flag_Word3_Ptr 5789 (Union_Id_Ptr' 5790 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val; 5791 end Set_Flag167; 5792 5793 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is 5794 begin 5795 pragma Assert (Nkind (N) in N_Entity); 5796 To_Flag_Word3_Ptr 5797 (Union_Id_Ptr' 5798 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val; 5799 end Set_Flag168; 5800 5801 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is 5802 begin 5803 pragma Assert (Nkind (N) in N_Entity); 5804 To_Flag_Word3_Ptr 5805 (Union_Id_Ptr' 5806 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val; 5807 end Set_Flag169; 5808 5809 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is 5810 begin 5811 pragma Assert (Nkind (N) in N_Entity); 5812 To_Flag_Word3_Ptr 5813 (Union_Id_Ptr' 5814 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val; 5815 end Set_Flag170; 5816 5817 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is 5818 begin 5819 pragma Assert (Nkind (N) in N_Entity); 5820 To_Flag_Word3_Ptr 5821 (Union_Id_Ptr' 5822 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val; 5823 end Set_Flag171; 5824 5825 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is 5826 begin 5827 pragma Assert (Nkind (N) in N_Entity); 5828 To_Flag_Word3_Ptr 5829 (Union_Id_Ptr' 5830 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val; 5831 end Set_Flag172; 5832 5833 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is 5834 begin 5835 pragma Assert (Nkind (N) in N_Entity); 5836 To_Flag_Word3_Ptr 5837 (Union_Id_Ptr' 5838 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val; 5839 end Set_Flag173; 5840 5841 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is 5842 begin 5843 pragma Assert (Nkind (N) in N_Entity); 5844 To_Flag_Word3_Ptr 5845 (Union_Id_Ptr' 5846 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val; 5847 end Set_Flag174; 5848 5849 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is 5850 begin 5851 pragma Assert (Nkind (N) in N_Entity); 5852 To_Flag_Word3_Ptr 5853 (Union_Id_Ptr' 5854 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val; 5855 end Set_Flag175; 5856 5857 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is 5858 begin 5859 pragma Assert (Nkind (N) in N_Entity); 5860 To_Flag_Word3_Ptr 5861 (Union_Id_Ptr' 5862 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val; 5863 end Set_Flag176; 5864 5865 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is 5866 begin 5867 pragma Assert (Nkind (N) in N_Entity); 5868 To_Flag_Word3_Ptr 5869 (Union_Id_Ptr' 5870 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val; 5871 end Set_Flag177; 5872 5873 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is 5874 begin 5875 pragma Assert (Nkind (N) in N_Entity); 5876 To_Flag_Word3_Ptr 5877 (Union_Id_Ptr' 5878 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val; 5879 end Set_Flag178; 5880 5881 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is 5882 begin 5883 pragma Assert (Nkind (N) in N_Entity); 5884 To_Flag_Word3_Ptr 5885 (Union_Id_Ptr' 5886 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val; 5887 end Set_Flag179; 5888 5889 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is 5890 begin 5891 pragma Assert (Nkind (N) in N_Entity); 5892 To_Flag_Word3_Ptr 5893 (Union_Id_Ptr' 5894 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val; 5895 end Set_Flag180; 5896 5897 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is 5898 begin 5899 pragma Assert (Nkind (N) in N_Entity); 5900 To_Flag_Word3_Ptr 5901 (Union_Id_Ptr' 5902 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val; 5903 end Set_Flag181; 5904 5905 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is 5906 begin 5907 pragma Assert (Nkind (N) in N_Entity); 5908 To_Flag_Word3_Ptr 5909 (Union_Id_Ptr' 5910 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val; 5911 end Set_Flag182; 5912 5913 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is 5914 begin 5915 pragma Assert (Nkind (N) in N_Entity); 5916 To_Flag_Word3_Ptr 5917 (Union_Id_Ptr' 5918 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val; 5919 end Set_Flag183; 5920 5921 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is 5922 begin 5923 pragma Assert (N in Nodes.First .. Nodes.Last); 5924 if Val > Error then Set_Parent (Val, N); end if; 5925 Set_Node1 (N, Val); 5926 end Set_Node1_With_Parent; 5927 5928 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is 5929 begin 5930 pragma Assert (N in Nodes.First .. Nodes.Last); 5931 if Val > Error then Set_Parent (Val, N); end if; 5932 Set_Node2 (N, Val); 5933 end Set_Node2_With_Parent; 5934 5935 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is 5936 begin 5937 pragma Assert (N in Nodes.First .. Nodes.Last); 5938 if Val > Error then Set_Parent (Val, N); end if; 5939 Set_Node3 (N, Val); 5940 end Set_Node3_With_Parent; 5941 5942 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is 5943 begin 5944 pragma Assert (N in Nodes.First .. Nodes.Last); 5945 if Val > Error then Set_Parent (Val, N); end if; 5946 Set_Node4 (N, Val); 5947 end Set_Node4_With_Parent; 5948 5949 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is 5950 begin 5951 pragma Assert (N in Nodes.First .. Nodes.Last); 5952 if Val > Error then Set_Parent (Val, N); end if; 5953 Set_Node5 (N, Val); 5954 end Set_Node5_With_Parent; 5955 5956 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is 5957 begin 5958 pragma Assert (N in Nodes.First .. Nodes.Last); 5959 if Val /= No_List and then Val /= Error_List then 5960 Set_Parent (Val, N); 5961 end if; 5962 Set_List1 (N, Val); 5963 end Set_List1_With_Parent; 5964 5965 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is 5966 begin 5967 pragma Assert (N in Nodes.First .. Nodes.Last); 5968 if Val /= No_List and then Val /= Error_List then 5969 Set_Parent (Val, N); 5970 end if; 5971 Set_List2 (N, Val); 5972 end Set_List2_With_Parent; 5973 5974 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is 5975 begin 5976 pragma Assert (N in Nodes.First .. Nodes.Last); 5977 if Val /= No_List and then Val /= Error_List then 5978 Set_Parent (Val, N); 5979 end if; 5980 Set_List3 (N, Val); 5981 end Set_List3_With_Parent; 5982 5983 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is 5984 begin 5985 pragma Assert (N in Nodes.First .. Nodes.Last); 5986 if Val /= No_List and then Val /= Error_List then 5987 Set_Parent (Val, N); 5988 end if; 5989 Set_List4 (N, Val); 5990 end Set_List4_With_Parent; 5991 5992 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is 5993 begin 5994 pragma Assert (N in Nodes.First .. Nodes.Last); 5995 if Val /= No_List and then Val /= Error_List then 5996 Set_Parent (Val, N); 5997 end if; 5998 Set_List5 (N, Val); 5999 end Set_List5_With_Parent; 6000 6001 end Unchecked_Access; 6002 6003end Atree; 6004