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