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