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