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