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