1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- E X P _ C H 1 3 -- 6-- -- 7-- B o d y -- 8-- -- 9-- Copyright (C) 1992-2018, Free Software Foundation, Inc. -- 10-- -- 11-- GNAT is free software; you can redistribute it and/or modify it under -- 12-- terms of the GNU General Public License as published by the Free Soft- -- 13-- ware Foundation; either version 3, or (at your option) any later ver- -- 14-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- 15-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- 16-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- 17-- for more details. You should have received a copy of the GNU General -- 18-- Public License distributed with GNAT; see file COPYING3. If not, go to -- 19-- http://www.gnu.org/licenses for a complete copy of the license. -- 20-- -- 21-- GNAT was originally developed by the GNAT team at New York University. -- 22-- Extensive contributions were provided by Ada Core Technologies Inc. -- 23-- -- 24------------------------------------------------------------------------------ 25 26with Atree; use Atree; 27with Checks; use Checks; 28with Einfo; use Einfo; 29with Exp_Ch3; use Exp_Ch3; 30with Exp_Ch6; 31with Exp_Imgv; use Exp_Imgv; 32with Exp_Tss; use Exp_Tss; 33with Exp_Util; use Exp_Util; 34with Freeze; use Freeze; 35with Namet; use Namet; 36with Nlists; use Nlists; 37with Nmake; use Nmake; 38with Opt; use Opt; 39with Restrict; use Restrict; 40with Rident; use Rident; 41with Rtsfind; use Rtsfind; 42with Sem; use Sem; 43with Sem_Aux; use Sem_Aux; 44with Sem_Ch7; use Sem_Ch7; 45with Sem_Ch8; use Sem_Ch8; 46with Sem_Eval; use Sem_Eval; 47with Sem_Util; use Sem_Util; 48with Sinfo; use Sinfo; 49with Snames; use Snames; 50with Tbuild; use Tbuild; 51with Uintp; use Uintp; 52with Validsw; use Validsw; 53 54package body Exp_Ch13 is 55 56 ------------------------------------------ 57 -- Expand_N_Attribute_Definition_Clause -- 58 ------------------------------------------ 59 60 -- Expansion action depends on attribute involved 61 62 procedure Expand_N_Attribute_Definition_Clause (N : Node_Id) is 63 Loc : constant Source_Ptr := Sloc (N); 64 Exp : constant Node_Id := Expression (N); 65 Ent : Entity_Id; 66 V : Node_Id; 67 68 begin 69 Ent := Entity (Name (N)); 70 71 if Is_Type (Ent) then 72 Ent := Underlying_Type (Ent); 73 end if; 74 75 case Get_Attribute_Id (Chars (N)) is 76 77 ------------- 78 -- Address -- 79 ------------- 80 81 when Attribute_Address => 82 83 -- If there is an initialization which did not come from the 84 -- source program, then it is an artifact of our expansion, and we 85 -- suppress it. The case we are most concerned about here is the 86 -- initialization of a packed array to all false, which seems 87 -- inappropriate for variable to which an address clause is 88 -- applied. The expression may itself have been rewritten if the 89 -- type is packed array, so we need to examine whether the 90 -- original node is in the source. An exception though is the case 91 -- of an access variable which is default initialized to null, and 92 -- such initialization is retained. 93 94 -- Furthermore, if the initialization is the equivalent aggregate 95 -- of the type initialization procedure, it replaces an implicit 96 -- call to the init proc, and must be respected. Note that for 97 -- packed types we do not build equivalent aggregates. 98 99 -- Also, if Init_Or_Norm_Scalars applies, then we need to retain 100 -- any default initialization for objects of scalar types and 101 -- types with scalar components. Normally a composite type will 102 -- have an init_proc in the presence of Init_Or_Norm_Scalars, 103 -- so when that flag is set we have just have to do a test for 104 -- scalar and string types (the predefined string types such as 105 -- String and Wide_String don't have an init_proc). 106 107 declare 108 Decl : constant Node_Id := Declaration_Node (Ent); 109 Typ : constant Entity_Id := Etype (Ent); 110 111 begin 112 if Nkind (Decl) = N_Object_Declaration 113 and then Present (Expression (Decl)) 114 and then Nkind (Expression (Decl)) /= N_Null 115 and then 116 not Comes_From_Source (Original_Node (Expression (Decl))) 117 then 118 if Present (Base_Init_Proc (Typ)) 119 and then 120 Present (Static_Initialization (Base_Init_Proc (Typ))) 121 then 122 null; 123 124 elsif Init_Or_Norm_Scalars 125 and then (Is_Scalar_Type (Typ) 126 or else Is_String_Type (Typ)) 127 then 128 null; 129 130 else 131 Set_Expression (Decl, Empty); 132 end if; 133 134 -- An object declaration to which an address clause applies 135 -- has a delayed freeze, but the address expression itself 136 -- must be elaborated at the point it appears. If the object 137 -- is controlled, additional checks apply elsewhere. 138 -- If the attribute comes from an aspect specification it 139 -- is being elaborated at the freeze point and side effects 140 -- need not be removed (and shouldn't, if the expression 141 -- depends on other entities that have delayed freeze). 142 -- This is another consequence of the delayed analysis of 143 -- aspects, and a real semantic difference. 144 145 elsif Nkind (Decl) = N_Object_Declaration 146 and then not Needs_Constant_Address (Decl, Typ) 147 and then not From_Aspect_Specification (N) 148 then 149 Remove_Side_Effects (Exp); 150 end if; 151 end; 152 153 --------------- 154 -- Alignment -- 155 --------------- 156 157 when Attribute_Alignment => 158 159 -- As required by Gigi, we guarantee that the operand is an 160 -- integer literal (this simplifies things in Gigi). 161 162 if Nkind (Exp) /= N_Integer_Literal then 163 Rewrite (Exp, Make_Integer_Literal (Loc, Expr_Value (Exp))); 164 end if; 165 166 -- A complex case arises if the alignment clause applies to an 167 -- unconstrained object initialized with a function call. The 168 -- result of the call is placed on the secondary stack, and the 169 -- declaration is rewritten as a renaming of a dereference, which 170 -- fails expansion. We must introduce a temporary and assign its 171 -- value to the existing entity. 172 173 if Nkind (Parent (Ent)) = N_Object_Renaming_Declaration 174 and then not Is_Entity_Name (Renamed_Object (Ent)) 175 then 176 declare 177 Decl : constant Node_Id := Parent (Ent); 178 Loc : constant Source_Ptr := Sloc (N); 179 Temp : constant Entity_Id := Make_Temporary (Loc, 'T'); 180 181 New_Decl : Node_Id; 182 183 begin 184 -- Replace entity with temporary and reanalyze 185 186 Set_Defining_Identifier (Decl, Temp); 187 Set_Analyzed (Decl, False); 188 Analyze (Decl); 189 190 -- Introduce new declaration for entity but do not reanalyze 191 -- because entity is already in scope. Type and expression 192 -- are already resolved. 193 194 New_Decl := 195 Make_Object_Declaration (Loc, 196 Defining_Identifier => Ent, 197 Object_Definition => 198 New_Occurrence_Of (Etype (Ent), Loc), 199 Expression => New_Occurrence_Of (Temp, Loc)); 200 201 Set_Renamed_Object (Ent, Empty); 202 Insert_After (Decl, New_Decl); 203 Set_Analyzed (Decl); 204 end; 205 end if; 206 207 ------------------ 208 -- Storage_Size -- 209 ------------------ 210 211 when Attribute_Storage_Size => 212 213 -- If the type is a task type, then assign the value of the 214 -- storage size to the Size variable associated with the task. 215 -- Insert the assignment right after the declaration of the Size 216 -- variable. 217 218 -- Generate: 219 220 -- task_typeZ := expression 221 222 if Ekind (Ent) = E_Task_Type then 223 declare 224 Assign : Node_Id; 225 226 begin 227 Assign := 228 Make_Assignment_Statement (Loc, 229 Name => 230 New_Occurrence_Of (Storage_Size_Variable (Ent), Loc), 231 Expression => 232 Convert_To (RTE (RE_Size_Type), Expression (N))); 233 234 -- If the clause is not generated by an aspect, insert 235 -- the assignment here. Freezing rules ensure that this 236 -- is safe, or clause will have been rejected already. 237 238 if Is_List_Member (N) then 239 Insert_After (N, Assign); 240 241 -- Otherwise, insert assignment after task declaration. 242 243 else 244 Insert_After 245 (Parent (Storage_Size_Variable (Entity (N))), Assign); 246 end if; 247 248 Analyze (Assign); 249 end; 250 251 -- For Storage_Size for an access type, create a variable to hold 252 -- the value of the specified size with name typeV and expand an 253 -- assignment statement to initialize this value. 254 255 elsif Is_Access_Type (Ent) then 256 257 -- We don't need the variable for a storage size of zero 258 259 if not No_Pool_Assigned (Ent) then 260 V := 261 Make_Defining_Identifier (Loc, 262 Chars => New_External_Name (Chars (Ent), 'V')); 263 264 -- Insert the declaration of the object 265 266 Insert_Action (N, 267 Make_Object_Declaration (Loc, 268 Defining_Identifier => V, 269 Object_Definition => 270 New_Occurrence_Of (RTE (RE_Storage_Offset), Loc), 271 Expression => 272 Convert_To (RTE (RE_Storage_Offset), Expression (N)))); 273 274 Set_Storage_Size_Variable (Ent, Entity_Id (V)); 275 end if; 276 end if; 277 278 -- Other attributes require no expansion 279 280 when others => 281 null; 282 end case; 283 end Expand_N_Attribute_Definition_Clause; 284 285 ----------------------------- 286 -- Expand_N_Free_Statement -- 287 ----------------------------- 288 289 procedure Expand_N_Free_Statement (N : Node_Id) is 290 Expr : constant Node_Id := Expression (N); 291 Typ : Entity_Id; 292 293 begin 294 -- Certain run-time configurations and targets do not provide support 295 -- for controlled types. 296 297 if Restriction_Active (No_Finalization) then 298 return; 299 end if; 300 301 -- Use the base type to perform the check for finalization master 302 303 Typ := Etype (Expr); 304 305 if Ekind (Typ) = E_Access_Subtype then 306 Typ := Etype (Typ); 307 end if; 308 309 -- Handle private access types 310 311 if Is_Private_Type (Typ) 312 and then Present (Full_View (Typ)) 313 then 314 Typ := Full_View (Typ); 315 end if; 316 317 -- Do not create a custom Deallocate when freeing an object with 318 -- suppressed finalization. In such cases the object is never attached 319 -- to a master, so it does not need to be detached. Use a regular free 320 -- statement instead. 321 322 if No (Finalization_Master (Typ)) then 323 return; 324 end if; 325 326 -- Use a temporary to store the result of a complex expression. Perform 327 -- the following transformation: 328 -- 329 -- Free (Complex_Expression); 330 -- 331 -- Temp : constant Type_Of_Expression := Complex_Expression; 332 -- Free (Temp); 333 334 if Nkind (Expr) /= N_Identifier then 335 declare 336 Expr_Typ : constant Entity_Id := Etype (Expr); 337 Loc : constant Source_Ptr := Sloc (N); 338 New_Expr : Node_Id; 339 Temp_Id : Entity_Id; 340 341 begin 342 Temp_Id := Make_Temporary (Loc, 'T'); 343 Insert_Action (N, 344 Make_Object_Declaration (Loc, 345 Defining_Identifier => Temp_Id, 346 Object_Definition => New_Occurrence_Of (Expr_Typ, Loc), 347 Expression => Relocate_Node (Expr))); 348 349 New_Expr := New_Occurrence_Of (Temp_Id, Loc); 350 Set_Etype (New_Expr, Expr_Typ); 351 352 Set_Expression (N, New_Expr); 353 end; 354 end if; 355 356 -- Create a custom Deallocate for a controlled object. This routine 357 -- ensures that the hidden list header will be deallocated along with 358 -- the actual object. 359 360 Build_Allocate_Deallocate_Proc (N, Is_Allocate => False); 361 end Expand_N_Free_Statement; 362 363 ---------------------------- 364 -- Expand_N_Freeze_Entity -- 365 ---------------------------- 366 367 procedure Expand_N_Freeze_Entity (N : Node_Id) is 368 E : constant Entity_Id := Entity (N); 369 370 Decl : Node_Id; 371 Delete : Boolean := False; 372 E_Scope : Entity_Id; 373 In_Other_Scope : Boolean; 374 In_Outer_Scope : Boolean; 375 376 begin 377 -- If there are delayed aspect specifications, we insert them just 378 -- before the freeze node. They are already analyzed so we don't need 379 -- to reanalyze them (they were analyzed before the type was frozen), 380 -- but we want them in the tree for the back end, and so that the 381 -- listing from sprint is clearer on where these occur logically. 382 383 if Has_Delayed_Aspects (E) then 384 declare 385 Aitem : Node_Id; 386 Ritem : Node_Id; 387 388 begin 389 -- Look for aspect specs for this entity 390 391 Ritem := First_Rep_Item (E); 392 while Present (Ritem) loop 393 if Nkind (Ritem) = N_Aspect_Specification 394 and then Entity (Ritem) = E 395 then 396 Aitem := Aspect_Rep_Item (Ritem); 397 398 -- Skip this for aspects (e.g. Current_Value) for which 399 -- there is no corresponding pragma or attribute. 400 401 if Present (Aitem) 402 403 -- Also skip if we have a null statement rather than a 404 -- delayed aspect (this happens when we are ignoring rep 405 -- items from use of the -gnatI switch). 406 407 and then Nkind (Aitem) /= N_Null_Statement 408 then 409 pragma Assert (Is_Delayed_Aspect (Aitem)); 410 Insert_Before (N, Aitem); 411 end if; 412 end if; 413 414 Next_Rep_Item (Ritem); 415 end loop; 416 end; 417 end if; 418 419 -- Processing for objects 420 421 if Is_Object (E) then 422 if Present (Address_Clause (E)) then 423 Apply_Address_Clause_Check (E, N); 424 end if; 425 426 -- Analyze actions in freeze node, if any 427 428 if Present (Actions (N)) then 429 declare 430 Act : Node_Id; 431 begin 432 Act := First (Actions (N)); 433 while Present (Act) loop 434 Analyze (Act); 435 Next (Act); 436 end loop; 437 end; 438 end if; 439 440 -- If initialization statements have been captured in a compound 441 -- statement, insert them back into the tree now. 442 443 Explode_Initialization_Compound_Statement (E); 444 return; 445 446 -- Only other items requiring any front end action are types and 447 -- subprograms. 448 449 elsif not Is_Type (E) and then not Is_Subprogram (E) then 450 return; 451 end if; 452 453 -- Here E is a type or a subprogram 454 455 E_Scope := Scope (E); 456 457 -- This is an error protection against previous errors 458 459 if No (E_Scope) then 460 Check_Error_Detected; 461 return; 462 end if; 463 464 -- The entity may be a subtype declared for a constrained record 465 -- component, in which case the relevant scope is the scope of 466 -- the record. This happens for class-wide subtypes created for 467 -- a constrained type extension with inherited discriminants. 468 469 if Is_Type (E_Scope) 470 and then Ekind (E_Scope) not in Concurrent_Kind 471 then 472 E_Scope := Scope (E_Scope); 473 end if; 474 475 -- Remember that we are processing a freezing entity and its freezing 476 -- nodes. This flag (non-zero = set) is used to avoid the need of 477 -- climbing through the tree while processing the freezing actions (ie. 478 -- to avoid generating spurious warnings or to avoid killing constant 479 -- indications while processing the code associated with freezing 480 -- actions). We use a counter to deal with nesting. 481 482 Inside_Freezing_Actions := Inside_Freezing_Actions + 1; 483 484 -- If we are freezing entities defined in protected types, they belong 485 -- in the enclosing scope, given that the original type has been 486 -- expanded away. The same is true for entities in task types, in 487 -- particular the parameter records of entries (Entities in bodies are 488 -- all frozen within the body). If we are in the task body, this is a 489 -- proper scope. If we are within a subprogram body, the proper scope 490 -- is the corresponding spec. This may happen for itypes generated in 491 -- the bodies of protected operations. 492 493 if Ekind (E_Scope) = E_Protected_Type 494 or else (Ekind (E_Scope) = E_Task_Type 495 and then not Has_Completion (E_Scope)) 496 then 497 E_Scope := Scope (E_Scope); 498 499 elsif Ekind (E_Scope) = E_Subprogram_Body then 500 E_Scope := Corresponding_Spec (Unit_Declaration_Node (E_Scope)); 501 end if; 502 503 -- If the scope of the entity is in open scopes, it is the current one 504 -- or an enclosing one, including a loop, a block, or a subprogram. 505 506 if In_Open_Scopes (E_Scope) then 507 In_Other_Scope := False; 508 In_Outer_Scope := E_Scope /= Current_Scope; 509 510 -- Otherwise it is a local package or a different compilation unit 511 512 else 513 In_Other_Scope := True; 514 In_Outer_Scope := False; 515 end if; 516 517 -- If the entity being frozen is defined in a scope that is not 518 -- currently on the scope stack, we must establish the proper 519 -- visibility before freezing the entity and related subprograms. 520 521 if In_Other_Scope then 522 Push_Scope (E_Scope); 523 524 -- Finalizers are little odd in terms of freezing. The spec of the 525 -- procedure appears in the declarations while the body appears in 526 -- the statement part of a single construct. Since the finalizer must 527 -- be called by the At_End handler of the construct, the spec is 528 -- manually frozen right after its declaration. The only side effect 529 -- of this action appears in contexts where the construct is not in 530 -- its final resting place. These contexts are: 531 532 -- * Entry bodies - The declarations and statements are moved to 533 -- the procedure equivalen of the entry. 534 -- * Protected subprograms - The declarations and statements are 535 -- moved to the non-protected version of the subprogram. 536 -- * Task bodies - The declarations and statements are moved to the 537 -- task body procedure. 538 539 -- Visible declarations do not need to be installed in these three 540 -- cases since it does not make semantic sense to do so. All entities 541 -- referenced by a finalizer are visible and already resolved, plus 542 -- the enclosing scope may not have visible declarations at all. 543 544 if Ekind (E) = E_Procedure 545 and then Is_Finalizer (E) 546 and then 547 (Is_Entry (E_Scope) 548 or else (Is_Subprogram (E_Scope) 549 and then Is_Protected_Type (Scope (E_Scope))) 550 or else Is_Task_Type (E_Scope)) 551 then 552 null; 553 else 554 Install_Visible_Declarations (E_Scope); 555 end if; 556 557 if Is_Package_Or_Generic_Package (E_Scope) or else 558 Is_Protected_Type (E_Scope) or else 559 Is_Task_Type (E_Scope) 560 then 561 Install_Private_Declarations (E_Scope); 562 end if; 563 564 -- If the entity is in an outer scope, then that scope needs to 565 -- temporarily become the current scope so that operations created 566 -- during type freezing will be declared in the right scope and 567 -- can properly override any corresponding inherited operations. 568 569 elsif In_Outer_Scope then 570 Push_Scope (E_Scope); 571 end if; 572 573 -- If type, freeze the type 574 575 if Is_Type (E) then 576 Delete := Freeze_Type (N); 577 578 -- And for enumeration type, build the enumeration tables 579 580 if Is_Enumeration_Type (E) then 581 Build_Enumeration_Image_Tables (E, N); 582 end if; 583 584 -- If subprogram, freeze the subprogram 585 586 elsif Is_Subprogram (E) then 587 Exp_Ch6.Freeze_Subprogram (N); 588 589 -- Ada 2005 (AI-251): Remove the freezing node associated with the 590 -- entities internally used by the frontend to register primitives 591 -- covering abstract interfaces. The call to Freeze_Subprogram has 592 -- already expanded the code that fills the corresponding entry in 593 -- its secondary dispatch table and therefore the code generator 594 -- has nothing else to do with this freezing node. 595 596 Delete := Present (Interface_Alias (E)); 597 end if; 598 599 -- Analyze actions generated by freezing. The init_proc contains source 600 -- expressions that may raise Constraint_Error, and the assignment 601 -- procedure for complex types needs checks on individual component 602 -- assignments, but all other freezing actions should be compiled with 603 -- all checks off. 604 605 if Present (Actions (N)) then 606 Decl := First (Actions (N)); 607 while Present (Decl) loop 608 if Nkind (Decl) = N_Subprogram_Body 609 and then (Is_Init_Proc (Defining_Entity (Decl)) 610 or else 611 Chars (Defining_Entity (Decl)) = Name_uAssign) 612 then 613 Analyze (Decl); 614 615 -- A subprogram body created for a renaming_as_body completes 616 -- a previous declaration, which may be in a different scope. 617 -- Establish the proper scope before analysis. 618 619 elsif Nkind (Decl) = N_Subprogram_Body 620 and then Present (Corresponding_Spec (Decl)) 621 and then Scope (Corresponding_Spec (Decl)) /= Current_Scope 622 then 623 Push_Scope (Scope (Corresponding_Spec (Decl))); 624 Analyze (Decl, Suppress => All_Checks); 625 Pop_Scope; 626 627 -- We treat generated equality specially, if validity checks are 628 -- enabled, in order to detect components default-initialized 629 -- with invalid values. 630 631 elsif Nkind (Decl) = N_Subprogram_Body 632 and then Chars (Defining_Entity (Decl)) = Name_Op_Eq 633 and then Validity_Checks_On 634 and then Initialize_Scalars 635 then 636 declare 637 Save_Force : constant Boolean := Force_Validity_Checks; 638 begin 639 Force_Validity_Checks := True; 640 Analyze (Decl); 641 Force_Validity_Checks := Save_Force; 642 end; 643 644 -- All other freezing actions 645 646 else 647 Analyze (Decl, Suppress => All_Checks); 648 end if; 649 650 Next (Decl); 651 end loop; 652 end if; 653 654 -- If we are to delete this N_Freeze_Entity, do so by rewriting so that 655 -- a loop on all nodes being inserted will work propertly. 656 657 if Delete then 658 Rewrite (N, Make_Null_Statement (Sloc (N))); 659 end if; 660 661 -- Pop scope if we installed one for the analysis 662 663 if In_Other_Scope then 664 if Ekind (Current_Scope) = E_Package then 665 End_Package_Scope (E_Scope); 666 else 667 End_Scope; 668 end if; 669 670 elsif In_Outer_Scope then 671 Pop_Scope; 672 end if; 673 674 -- Restore previous value of the nesting-level counter that records 675 -- whether we are inside a (possibly nested) call to this procedure. 676 677 Inside_Freezing_Actions := Inside_Freezing_Actions - 1; 678 end Expand_N_Freeze_Entity; 679 680 ------------------------------------------- 681 -- Expand_N_Record_Representation_Clause -- 682 ------------------------------------------- 683 684 -- The only expansion required is for the case of a mod clause present, 685 -- which is removed, and translated into an alignment representation 686 -- clause inserted immediately after the record rep clause with any 687 -- initial pragmas inserted at the start of the component clause list. 688 689 procedure Expand_N_Record_Representation_Clause (N : Node_Id) is 690 Loc : constant Source_Ptr := Sloc (N); 691 Rectype : constant Entity_Id := Entity (Identifier (N)); 692 Mod_Val : Uint; 693 Citems : List_Id; 694 Repitem : Node_Id; 695 AtM_Nod : Node_Id; 696 697 begin 698 if Present (Mod_Clause (N)) and then not Ignore_Rep_Clauses then 699 Mod_Val := Expr_Value (Expression (Mod_Clause (N))); 700 Citems := Pragmas_Before (Mod_Clause (N)); 701 702 if Present (Citems) then 703 Append_List_To (Citems, Component_Clauses (N)); 704 Set_Component_Clauses (N, Citems); 705 end if; 706 707 AtM_Nod := 708 Make_Attribute_Definition_Clause (Loc, 709 Name => New_Occurrence_Of (Base_Type (Rectype), Loc), 710 Chars => Name_Alignment, 711 Expression => Make_Integer_Literal (Loc, Mod_Val)); 712 713 Set_From_At_Mod (AtM_Nod); 714 Insert_After (N, AtM_Nod); 715 Set_Mod_Clause (N, Empty); 716 end if; 717 718 -- If the record representation clause has no components, then 719 -- completely remove it. Note that we also have to remove 720 -- ourself from the Rep Item list. 721 722 if Is_Empty_List (Component_Clauses (N)) then 723 if First_Rep_Item (Rectype) = N then 724 Set_First_Rep_Item (Rectype, Next_Rep_Item (N)); 725 else 726 Repitem := First_Rep_Item (Rectype); 727 while Present (Next_Rep_Item (Repitem)) loop 728 if Next_Rep_Item (Repitem) = N then 729 Set_Next_Rep_Item (Repitem, Next_Rep_Item (N)); 730 exit; 731 end if; 732 733 Next_Rep_Item (Repitem); 734 end loop; 735 end if; 736 737 Rewrite (N, 738 Make_Null_Statement (Loc)); 739 end if; 740 end Expand_N_Record_Representation_Clause; 741 742end Exp_Ch13; 743