diff options
| author | Ian Lance Taylor <ian@gcc.gnu.org> | 2019-09-18 18:28:45 +0000 |
|---|---|---|
| committer | Ian Lance Taylor <ian@gcc.gnu.org> | 2019-09-18 18:28:45 +0000 |
| commit | 58a73f6da5d0ed7dc1b04cbfb90c0205a3c50e3f (patch) | |
| tree | 41687c822ea825dcc079e7f471d9ec806d311374 /gcc/ada | |
| parent | 281de4253d972d89f21b2bc3ef4050f88e3fcf3c (diff) | |
| parent | ba7c8cb5715a162ac41ca5241628e7e02ecd217f (diff) | |
| download | gcc-58a73f6da5d0ed7dc1b04cbfb90c0205a3c50e3f.zip gcc-58a73f6da5d0ed7dc1b04cbfb90c0205a3c50e3f.tar.gz gcc-58a73f6da5d0ed7dc1b04cbfb90c0205a3c50e3f.tar.bz2 | |
Merge from trunk revision 275890.
From-SVN: r275900
Diffstat (limited to 'gcc/ada')
86 files changed, 4009 insertions, 1965 deletions
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 53ecd1a..c42498e 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,571 @@ +2019-09-18 Bob Duff <duff@adacore.com> + + * exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Move call + to RTE_Available later, so it doesn't disturb the elab order. + The RE_Copy_Bitfield entity is defined in package + System.Bitfields which has a dependency on package + System.Bitfield_Utils, which has it its spec: + pragma Elaborate_Body; + The query on RTE_Available forces loading and analyzing + System.Bitfields and all its withed units. + +2019-09-18 Eric Botcazou <ebotcazou@adacore.com> + + * checks.ads (Alignment_Warnings_Record): Add P component. + * checks.adb (Apply_Address_Clause_Check): Be prepared to kill + the warning also if the clause is of the form X'Address. + (Validate_Alignment_Check_Warning): Kill the warning if the + clause is of the form X'Address and the alignment of X is + compatible. + +2019-09-18 Ed Schonberg <schonberg@adacore.com> + + * sem_res.adb (Set_Mixed_Node_Expression): If a conditional + expression has universal_real alternaitves and the context is + Universal_Fixed, as when it is an operand in a fixed-point + multiplication or division, resolve the expression with a + visible fixed-point type, which must be unique. + +2019-09-18 Ed Schonberg <schonberg@adacore.com> + + * sem_ch3.adb (Constrain_Component_Type): For a discriminated + type, handle the case of a constraint given by a conversion of a + discriminant of the enclosing type. Necessary when compiling a + discriminated task for a restricted run-time, when the generated + Secondary_Stack component may be set by means of an aspect on + the task type. + +2019-09-18 Ed Schonberg <schonberg@adacore.com> + + * exp_aggr.adb (Expand_Record_Aggregate, Rewrite_Discriminant): + After rewriting a reference to an outer discriminant as a + selected component of the enclosing object, analyze the selected + component to ensure that the entity of the selector name is + properly set. This is necessary when the aggregate appears + within an expression that may have been analyzed already. + +2019-09-18 Justin Squirek <squirek@adacore.com> + + * sem_ch8.adb (Use_One_Type): Add guard to prevent warning on a + reundant use package clause where there is no previous + use_clause in the chain. + +2019-09-18 Justin Squirek <squirek@adacore.com> + + * exp_ch4.adb (Expand_N_Type_Conversion): Add calculation of an + alternative operand for the purposes of generating accessibility + checks. + +2019-09-18 Eric Botcazou <ebotcazou@adacore.com> + + * exp_aggr.adb (Build_Array_Aggr_Code): In STEP 1 (c), duplicate + the expression and reset the Loop_Actions for each loop + generated for an others choice. + +2019-09-18 Justin Squirek <squirek@adacore.com> + + * einfo.adb, einfo.ads (Minimum_Accessibility): Added new field. + (Set_Minimum_Accessibility): Added to set new field. + (Minimum_Accessibility): Added to fetch new field. + * exp_ch6.adb (Expand_Subprogram_Call): Modify calls to fetch + accessibility levels to the new subprogram Get_Accessibility + which handles cases where minimum accessibility might be needed. + * sem_ch6.adb (Analyze_Subprogram_Body_Helper): Add section to + generate a Minimum_Accessibility object within relevant + subprograms. + * sem_util.adb, sem_util.ads (Dynamic_Accessibility_Level): + Additional documentation added and modify section to use new + function Get_Accessibility. + (Get_Accessibility): Added to centralize processing of + accessibility levels. + +2019-09-18 Steve Baird <baird@adacore.com> + + * sem_util.ads (Interval_Lists): A new visible package. This + package is visible because it is also intended for eventual use + in Sem_Eval.Subtypes_Statically_Compatible when that function is + someday upgraded to handle static predicates correctly. This + new package doesn't really need to be visible for now, but it + still seems like a good idea. + * sem_util.adb (Gather_Components): Implement AI12-0086 via the + following strategy. The existing code knows how to take a static + discriminant value and identify the corresponding variant; in + the newly-permitted case of a non-static value of a static + subtype, we arbitrarily select a value of the subtype and find + the corresponding variant using the existing code. Subsequently, + we check that every other value of the discriminant's subtype + corresponds to the same variant; this is done using the newly + introduced Interval_Lists package. + (Interval_Lists): Provide a body for the new package. + +2019-09-18 Javier Miranda <miranda@adacore.com> + + * exp_ch4.adb (Expand_N_Op_Eq): The frontend assumes that we can + do a bit-for-bit comparison of two access to protected + subprogram pointers. However, there are two reasons why we may + not be able to do that: (1) there may be padding bits for + alignment before the access to subprogram, and (2) the access to + subprogram itself may not be compared bit-for- bit because the + activation record part is undefined: two pointers are equal iff + the subprogram addresses are equal. This patch fixes it by + forcing a field-by-field comparison. + * bindgen.adb (Gen_Adainit): The type No_Param_Proc is defined + in the library as having Favor_Top_Level, but when we create an + object of that type in the binder file we don't have that + pragma, so the types are different. This patch fixes this issue. + * libgnarl/s-interr.adb, libgnarl/s-interr__hwint.adb, + libgnarl/s-interr__sigaction.adb, libgnarl/s-interr__vxworks.adb + (Is_Registered): This routine erroneously assumes that the + access to protected subprogram is two addresses. We need to + create the same record that the compiler makes to ensure that + any padding is the same. Then we have to look at just the first + word of the access to subprogram. This patch fixes this issue. + +2019-09-18 Bob Duff <duff@adacore.com> + + * exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): The call + to Copy_Bitfield is now enabled. + (Expand_Assign_Array_Bitfield): Multiply 'Length times + 'Component_Size "by hand" instead of using 'Size. + +2019-09-18 Vasiliy Fofanov <fofanov@adacore.com> + + * doc/gnat_rm/implementation_defined_pragmas.rst: Fix minor + formatting issue. + +2019-09-18 Javier Miranda <miranda@adacore.com> + + * exp_disp.adb (Make_DT, Make_Secondary_DT): Remove generation + of alignment representation clause for the following tables: + Predef_Prims, Iface_DT, TSD, ITable, DT. + +2019-09-18 Steve Baird <baird@adacore.com> + + * sem_eval.adb (Expr_Value): Do not fail "the type of a null + literal must be an access type" assertion if errors have already + been posted on the given node. + +2019-09-18 Piotr Trojanek <trojanek@adacore.com> + + * exp_dbug.ads, exp_dbug.adb (Get_Homonym_Number): Refine type + from Nat to Pos. + * sem_util.adb (Add_Homonym_Suffix): Refine type of a local + variable. + +2019-09-18 Yannick Moy <moy@adacore.com> + + * exp_dbug.adb (Append_Homonym_Number): Use new function + Get_Homonym_Number. + (Get_Homonym_Number): New function to return the homonym number. + (Qualify_Entity_Name): Remove special case for GNATprove. + * exp_dbug.ads (Get_Homonym_Number): Make the new function + public for use in GNATprove. + * frontend.adb (Frontend): Do not qualify names in GNATprove + mode. + * sem_util.adb (Unique_Name): Append homonym suffix where needed + for entities which have local homonyms in the same scope. + +2019-09-18 Nicolas Roche <roche@adacore.com> + + * libgnat/s-valrea.adb (Scan_Integral_Digits): New procedure. + (Scan_Decimal_Digits): New procedure. + (As_Digit): New function. + (Scan_Real): Use Scan_Integral_Digits and Scan_Decimal_Digits. + +2019-09-18 Claire Dross <dross@adacore.com> + + * exp_attr.adb (Expand_N_Attribute_Reference): Call routine from + Exp_Util to know the value of the Constrained attribute in the + static case. + * exp_spark.adb (Expand_SPARK_N_Attribute_Reference): Make + implicit dereferences inside the Constrained attribute explicit. + * exp_util.ads, exp_util.adb + (Attribute_Constrained_Static_Value): New routine to compute the + value of a statically known reference to the Constrained + attribute. + +2019-09-18 Vadim Godunko <godunko@adacore.com> + + * libgnat/g-expect.adb (Expect_Internal): Don't include invalid + file descriptors into the set of file descriptors for Poll. + Raise Process_Died exception when computed set of file + descriptors to monitor is empty. + +2019-09-18 Frederic Konrad <konrad@adacore.com> + + * adaint.c: Include dosFsLib.h and vwModNum.h for VxWorks 6. + (__gnat_rename): Map S_dosFsLib_FILE_NOT_FOUND to ENOENT. + +2019-09-18 Steve Baird <baird@adacore.com> + + * freeze.adb (Freeze_Object_Declaration): Do not call + Check_Large_Modular_Array when the object declaration being + frozen is an ignored ghost entity. + +2019-09-18 Tom Tromey <tromey@adacore.com> + + * make.adb (Initialize): Fix typo. + +2019-09-18 Olivier Hainque <hainque@adacore.com> + + * libgnat/s-win32.ads (DWORD_PTR): New type, pointer size + unsigned int. + (SYSTEM_INFO): Use it for dwActiveProcessorMask. + +2019-09-18 Arnaud Charlet <charlet@adacore.com> + + * doc/gnat_rm/implementation_defined_pragmas.rst: Improve doc on + Warning_As_Error. + * gnat_rm.texi: Regenerate. + +2019-09-18 Arnaud Charlet <charlet@adacore.com> + + * doc/gnat_rm/implementation_defined_characteristics.rst, + doc/gnat_rm/implementation_defined_pragmas.rst, + doc/gnat_rm/implementation_of_specific_ada_features.rst: Remove + remaining references to VMS support + * gnat_rm.texi: Regenerate. + +2019-09-18 Arnaud Charlet <charlet@adacore.com> + + * libgnat/s-stausa.adb: Fix a typo + +2019-09-18 Bob Duff <duff@adacore.com> + + * libgnat/a-cbhama.adb, libgnat/a-cbhase.adb, + libgnat/a-cbmutr.adb, libgnat/a-cborma.adb, + libgnat/a-cborse.adb, libgnat/a-cobove.adb (Copy): Avoid reading + the uninitialized variable C in the Checks = False case. Change + variable to be a constant. + +2019-09-18 Claire Dross <dross@adacore.com> + + * libgnat/a-cofuma.adb (Remove, Elements_Equal_Except, + Keys_Included, Keys_Included_Except): Rename loop indexes and + global constants from I to J. + +2019-09-18 Arnaud Charlet <charlet@adacore.com> + + * exp_unst.adb (Unnest_Subprograms): Refine previous change. + +2019-09-17 Claire Dross <dross@adacore.com> + + * libgnat/a-cofuma.ads, libgnat/a-cofuma.adb (Remove): New + function which returns a copy of the input container without a + given mapping. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * libgnat/s-arit64.adb (Double_Divide): Correctly handle the + special case when rounding. + +2019-09-17 Javier Miranda <miranda@adacore.com> + + * sem_ch3.adb (Complete_Private_Subtype): Propagate attributes + Has_Attributes and Predicate_Function to the cloned subtype. + +2019-09-17 Eric Botcazou <ebotcazou@adacore.com> + + * sem.adb (Do_Analyze): Save Style_Check_Max_Line_Length on + entry and restore it on exit instead of recomputing it. + +2019-09-17 Tom Tromey <tromey@adacore.com> + + * exp_dbug.ads: Update character type comment. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * libgnat/s-arit64.adb (Double_Divide): Simplify needlessly + complex computation. Fix comments. + (Scaled_Divide): Fix comments. Explain why implementation does + not suffer from bugs in Algorithm D from 2nd Edition of TAOCP. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * libgnat/s-arit64.adb (Scaled_Divide): Add protection against + undesirable wrap-around. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * libgnat/s-arit64.adb (Double_Divide): Fix two possible + overflows. + +2019-09-17 Dmitriy Anisimkov <anisimko@adacore.com> + + * make_util.ads (On_Windows): Move... + * osint.ads (On_Windows): There. + * osint.adb (OS_Time_To_GNAT_Time): If odd incremented on + Windows before conversion to Time_Stamp_Type. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * sem_spark.adb (Check_Declaration): Do not check the assignment + from an illegal declaration. + +2019-09-17 Bob Duff <duff@adacore.com> + + * doc/gnat_ugn/gnat_and_program_execution.rst: Clarify + documentation. + * gnat_ugn.texi: Regenerate. + * libgnat/s-stausa.ads: Clarify comments. + +2019-09-17 Steve Baird <baird@adacore.com> + + * sem_util.adb (Wrong_Type): In deciding to suppress a message, + it is not enough for In_Instance to be True; in addition, + In_Generic_Actual (Expr) must be False. + * sem_type.adb (In_Generic_Actual): Fix bug where traversal of + parents skips every other node. + +2019-09-17 Claire Dross <dross@adacore.com> + + * sem_spark.adb (Get_Observed_Or_Borrowed_Expr): If the + definition of a local borrower contains calls to traversal + functions, the borrowed expression is the first parameter of the + first traversal function call in the definition. + +2019-09-17 Ed Falis <falis@adacore.com> + + * doc/gnat_rm/implementation_defined_pragmas.rst: Remove + section. + * gnat_rm.texi, gnat_ugn.texi: Regenerate. + +2019-09-17 Vadim Godunko <godunko@adacore.com> + + * libgnat/g-exptty.ads (Close_Input): New subprogram. + * libgnat/g-exptty.adb (Close_Input): New subprogram. + (Close): Move close of TTY to Close_Input. + * terminals.c (__gnat_close_tty): Set file descriptors to + invalid value after close. + +2019-09-17 Vadim Godunko <godunko@adacore.com> + + * libgnat/g-expect.adb (Expect_Internal): Try to call 'poll' few + times. + +2019-09-17 Vadim Godunko <godunko@adacore.com> + + * libgnat/g-expect.ads, libgnat/g-expect.adb (Close_Input): New + subprogram. + (Get_Command_Output): Call Close_Input to close input stream. + (Expect_Internal): Likewise. + (Close): Likewise. + * libgnat/g-exptty.adb (Close): Likewise. + +2019-09-17 Piotr Trojanek <trojanek@adacore.com> + + * sem_util.ads, sem_util.adb (Is_Attribute_Old): New utility + routine. + +2019-09-17 Yannick Moy <moy@adacore.com> + + * inline.adb (Can_Be_Inlined_In_GNATprove_Mode): Add handling + for dispatching operations. + +2019-09-17 Ed Schonberg <schonberg@adacore.com> + + * sem_ch13.adb (Check_Aspect_At_End_Of_Declarations): In a + generic context, for a Predicate aspect, use + Preanalyze_Spec_Expression to verify conformance. + +2019-09-17 Javier Miranda <miranda@adacore.com> + + * sem_ch3.adb (Constrain_Corresponding_Record): Propagate + attribute Is_Tagged_Type. + +2019-09-17 Javier Miranda <miranda@adacore.com> + + * exp_ch3.adb (Build_Record_Init_Proc): Do not generate code to + adjust the tag component when the record is initialized with a + raise expression. + * sem_aggr.adb (Valid_Limited_Ancestor): Return True for + N_Raise_Expression nodes. + (Valid_Ancestor_Type): Return True for raise expressions. + * sem_ch3.adb (Analyze_Component_Declaration): Do not report an + error when a component is initialized with a raise expression. + * sem_ch4.adb (Analyze_Qualified_Expression): Do not report an + error when the aggregate has a raise expression. + +2019-09-17 Piotr Trojanek <trojanek@adacore.com> + + * ali.ads: Fix casing in comment. + * ali-util.ads, ali-util.adb (Read_Withed_ALIs): Remove + Ignore_Errors parameter; it was only set to non-default value of + True when running in GNATprove_Mode and wrongly reset to False + when calling this routine recursively. Now in GNATprove mode we + want it to be always True, so in fact it is equivalent to + GNATProve_Mode flag itself (which was already used in this + routine). + +2019-09-17 Arnaud Charlet <charlet@adacore.com> + + * adaint.c (_REENTRANT, _THREAD_SAFE): Only define if needed. + +2019-09-17 Arnaud Charlet <charlet@adacore.com> + + * libgnat/s-bitfie.ads (Val_Bits, Val_Bytes): Define from + Long_Long_Integer'Size. + +2019-09-17 Javier Miranda <miranda@adacore.com> + + * exp_ch6.ads (Needs_BIP_Task_Actuals): New subprogram. + * exp_ch6.adb (Add_Task_Actuals_To_Build_In_Place_Call): Code + cleanup. + (Check_Number_Of_Actuals): New subprogram. + (Make_Build_In_Place_Call_In_Allocator): Adding assertion. + (Make_Build_In_Place_Call_In_Anonymous_Context): Adding + assertion. + (Make_Build_In_Place_Call_In_Assignment): Adding assertion. + (Make_Build_In_Place_Call_In_Object_Declaration): Code cleanup + plus assertion addition. + (Needs_BIP_Task_Actuals): New subprogram. + * sem_ch6.adb (Create_Extra_Formals): Rely on + Needs_BIP_Task_Actuals() to check if the master of the tasks to + be created, and the caller's activation chain formals are + needed. + +2019-09-17 Bob Duff <duff@adacore.com> + + * libgnat/s-bituti.adb (Get_Val_2, Set_Val_2): Use new routines + for getting and setting a Val_2, avoiding touching the second + half when that half might not exist. + * exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Correct + tests for potential volatile or independent components. In + particular, do not call Prefix unless we know it's a slice. + +2019-09-17 Dmitriy Anisimkov <anisimko@adacore.com> + + * gsocket.h: Include sys/un.h. + * s-oscons-tmplt.c (AF_UNIX): New constant generation. + (SIZEOF_sockaddr_un): Idem. + * libgnat/g-socket.ads (Family_Type): New value Family_Unix + added. + (Family_Inet_4_6): New subtype only for network families. + (Sock_Addr_Type): Add Unbounded_String field for Family_Unix + variant. + (Unix_Socket_Address): Create Sock_Addr_Type from socket + pathname. + (Network_Socket_Address): Create Sock_Addr_Type from + Inet_Addr_Type and Port_Type parameters. + * libgnat/g-socket.adb: Support local unix address in socket + routines. + (Get_Address_Info): Disable warning about Result may be + referenced before it has a value. Remove duplicated code to exit + from Look_For_Supported. + * libgnat/g-sothco.ads (Unix_Name_Length): New constant defining + maximum number of characters in local socket address path. + (Sockaddr): Add variant for Family_Unix address family. Move + Sin_Port and Sin_Family to Family_Inet section. Add Sin6_Port + and Sin6_Family to Family_Inet6 section. + (Set_Address): Add out parameter Length to return valuable + Sockaddr data length. + (Get_Address): Add input parameter Length to set valuable + Sockaddr data length. + * libgnat/g-sothco.adb: Support local unix address in socket + routines. + +2019-09-17 Eric Botcazou <ebotcazou@adacore.com> + + * exp_attr.adb (Expand_Size_Attribute): Chain the special cases + on the back-end path and rewrite the attribute appled to slices + of bit-packed arrays into the product of the Length and the + Compoent_Size attributes of the slices. + * exp_ch5.adb (Expand_Assign_Array_Bitfield): Use Size attribute + directly to compute the bitfield's size. + +2019-09-17 Bob Duff <duff@adacore.com> + + * exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Add tests + for potential volatile or independent components. + * libgnat/s-bituti.adb (Copy_Small_Bitfield, + Copy_Large_Bitfield): Move declarations to more appropriate + place. + +2019-09-13 Maciej W. Rozycki <macro@wdc.com> + + * make.adb (Scan_Make_Arg): Also accept `--sysroot=' for the + compiler and the linker. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/decl.c (maybe_saturate_size): New function. + (gnat_to_gnu_entity): Invoke it on the Esize of types before sending + it for back-annotations. + * gcc-interface/trans.c: Fix typo. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/ada-tree.h (DECL_FORCED_BY_REF_P): New macro. + * gcc-interface/decl.c (gnat_to_gnu_param): Set it on parameters + whose mechanism was forced to by-reference. + * gcc-interface/trans.c (Call_to_gnu): Do not issue a warning about a + misaligned actual parameter if it is based on a CONSTRUCTOR. Remove + obsolete warning for users of Starlet. Issue a warning if a temporary + is make around the call for a parameter with DECL_FORCED_BY_REF_P set. + (addressable_p): Return true for REAL_CST and ADDR_EXPR. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/trans.c (gnat_to_gnu): Do not set the location on an + expression used for a tag. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/gigi.h (aggregate_type_contains_array_p): Declare. + * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Record_Type>: For an + extension, test Has_Record_Rep_Clause instead of Has_Specified_Layout. + (adjust_packed): Return 0 if the type of the field is an aggregate + type that contains (or is) a self-referential array. + (type_has_variable_size): Delete. + * gcc-interface/utils.c (inish_record_type): Constify a variable. + (aggregate_type_contains_array_p): Add parameter SELF_REFERENTIAL. + <RECORD_TYPE>: Pass it in the recursive call. + <ARRAY_TYPE>: If it is true, return true only if the array type is + self-referential. + (create_field_decl): Streamline the setting of the alignment on the + field. Pass false to aggregate_type_contains_array_p. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/trans.c (lvalue_required_p) <N_Slice>: Adjust GNU_TYPE + in the recursive call. + <N_Selected_Component>: Likewise. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/utils.c (build_template): Deal with parameters + passed by pointer to component of multi-dimensional arrays. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/decl.c (annotate_value) <CALL_EXPR>: Inline the call + also if List_Representation_Info is greater than 3. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/trans.c (Attribute_to_gnu) <Attr_Size>: Add assertion. + +2019-08-30 Eric Botcazou <ebotcazou@adacore.com> + + * gcc-interface/gigi.h (gigi_checking_assert): New macro. + * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Modular_Integer_Type>: + Remove redundant test and adjust comments. Minor tweaks. + * gcc-interface/trans.c (Call_to_gnu): Do not generate range checks, + instead assert that the Do_Range_Check flag is not set. Adjust call + to convert_with_check. + (gnat_to_gnu): Likewise. + (assoc_to_constructor): Likewise. + (pos_to_constructor): Likewise. Remove GNAT_COMPONENT_TYPE parameter. + (emit_range_check): Delete. + (convert_with_check): Remove RANGE_P parameter and adjust. Do a single + overflow check for modular types. + +2019-08-23 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/91283 + * gcc-interface/misc.c (gnat_post_options): Set flag_excess_precision + instead of flag_excess_precision_cmdline. + 2019-08-21 Vadim Godunko <godunko@adacore.com> * libgnat/g-expect.adb (Expect_Internal): Attempt to read diff --git a/gcc/ada/adaint.c b/gcc/ada/adaint.c index 7290f7a..595abf8 100644 --- a/gcc/ada/adaint.c +++ b/gcc/ada/adaint.c @@ -35,8 +35,14 @@ library calls directly. This file contains all other routines. */ /* Ensure access to errno is thread safe. */ + +#ifndef _REENTRANT #define _REENTRANT +#endif + +#ifndef _THREAD_SAFE #define _THREAD_SAFE +#endif /* Use 64 bit Large File API */ #if defined (__QNX__) @@ -68,6 +74,12 @@ (such as chmod) are only available on VxWorks 6. */ #include "version.h" +/* vwModNum.h and dosFsLib.h are needed for the VxWorks 6 rename workaround. + See below. */ +#if (_WRS_VXWORKS_MAJOR == 6) +#include <vwModNum.h> +#include <dosFsLib.h> +#endif /* 6.x */ #endif /* VxWorks */ #if defined (__APPLE__) @@ -748,6 +760,20 @@ __gnat_rename (char *from, char *to) S2WSC (wto, to, GNAT_MAX_PATH_LEN); return _trename (wfrom, wto); } +#elif defined (__vxworks) && (_WRS_VXWORKS_MAJOR == 6) + { + /* When used on a dos filesystem under VxWorks 6.9 rename will trigger a + S_dosFsLib_FILE_NOT_FOUND errno when the file is not found. Let's map + that to ENOENT so Ada.Directory.Rename can detect that and raise the + Name_Error exception. */ + int ret = rename (from, to); + + if (ret && (errno == S_dosFsLib_FILE_NOT_FOUND)) + { + errno = ENOENT; + } + return ret; + } #else return rename (from, to); #endif diff --git a/gcc/ada/ali-util.adb b/gcc/ada/ali-util.adb index 0d9a22a..1efad4d 100644 --- a/gcc/ada/ali-util.adb +++ b/gcc/ada/ali-util.adb @@ -215,10 +215,7 @@ package body ALI.Util is -- Read_Withed_ALIs -- ---------------------- - procedure Read_Withed_ALIs - (Id : ALI_Id; - Ignore_Errors : Boolean := False) - is + procedure Read_Withed_ALIs (Id : ALI_Id) is Afile : File_Name_Type; Text : Text_Buffer_Ptr; Idread : ALI_Id; @@ -240,14 +237,14 @@ package body ALI.Util is then Text := Read_Library_Info (Afile); - -- Unless Ignore_Errors is true, return with an error if source + -- Unless in GNATprove mode, return with an error if source -- cannot be found. We used to skip this check when we did not -- compile library generics separately, but we now always do, -- so there is no special case here anymore. if Text = null then - if not Ignore_Errors then + if not GNATprove_Mode then Error_Msg_File_1 := Afile; Error_Msg_File_2 := Withs.Table (W).Sfile; Error_Msg ("{ not found, { must be compiled"); @@ -268,7 +265,7 @@ package body ALI.Util is Free (Text); if ALIs.Table (Idread).Compile_Errors - and then not Ignore_Errors + and then not GNATprove_Mode then Error_Msg_File_1 := Withs.Table (W).Sfile; Error_Msg ("{ had errors, must be fixed, and recompiled"); @@ -279,7 +276,6 @@ package body ALI.Util is elsif ALIs.Table (Idread).No_Object and then not GNATprove_Mode - and then not Ignore_Errors then Error_Msg_File_1 := Withs.Table (W).Sfile; Error_Msg ("{ must be recompiled"); diff --git a/gcc/ada/ali-util.ads b/gcc/ada/ali-util.ads index 3023d00..7b3f9a5 100644 --- a/gcc/ada/ali-util.ads +++ b/gcc/ada/ali-util.ads @@ -107,15 +107,13 @@ package ALI.Util is -- Subprograms for Manipulating ALI Information -- -------------------------------------------------- - procedure Read_Withed_ALIs - (Id : ALI_Id; - Ignore_Errors : Boolean := False); + procedure Read_Withed_ALIs (Id : ALI_Id); -- Process an ALI file which has been read and scanned by looping through -- all withed units in the ALI file, checking if they have been processed. -- Each unit that has not yet been processed will be read, scanned, and - -- processed recursively. If Ignore_Errors is True, then failure to read an - -- ALI file is not reported as an error, and scanning continues with other - -- ALI files. + -- processed recursively. In GNATprove mode a failure to read an ALI file + -- is not reported as an error, and scanning continues with other ALI + -- files. procedure Set_Source_Table (A : ALI_Id); -- Build source table entry corresponding to the ALI file whose id is A diff --git a/gcc/ada/ali.ads b/gcc/ada/ali.ads index 5e2ec71..7e12c7b 100644 --- a/gcc/ada/ali.ads +++ b/gcc/ada/ali.ads @@ -1429,7 +1429,7 @@ package ALI is -- both. If both are provided then only the Read_Lines value is used, -- and the Ignore_Lines parameter is ignored. -- - -- Read_XREF is set True to read and acquire the cross-reference + -- Read_Xref is set True to read and acquire the cross-reference -- information. If Read_XREF is set to True, then the effect is to ignore -- all lines other than U, W, D and X lines and the Ignore_Lines and -- Read_Lines parameters are ignored (i.e. the use of True for Read_XREF diff --git a/gcc/ada/bindgen.adb b/gcc/ada/bindgen.adb index 153043c..e60cb7a 100644 --- a/gcc/ada/bindgen.adb +++ b/gcc/ada/bindgen.adb @@ -524,6 +524,7 @@ package body Bindgen is and then not Configurable_Run_Time_On_Target then WBI (" type No_Param_Proc is access procedure;"); + WBI (" pragma Favor_Top_Level (No_Param_Proc);"); WBI (""); end if; diff --git a/gcc/ada/checks.adb b/gcc/ada/checks.adb index caee9ad..9ca1cf0 100644 --- a/gcc/ada/checks.adb +++ b/gcc/ada/checks.adb @@ -808,7 +808,21 @@ package body Checks is if Compile_Time_Known_Value (Expr) then Alignment_Warnings.Append - ((E => E, A => Expr_Value (Expr), W => Warning_Msg)); + ((E => E, + A => Expr_Value (Expr), + P => Empty, + W => Warning_Msg)); + + -- Likewise if the expression is of the form X'Address + + elsif Nkind (Expr) = N_Attribute_Reference + and then Attribute_Name (Expr) = Name_Address + then + Alignment_Warnings.Append + ((E => E, + A => No_Uint, + P => Prefix (Expr), + W => Warning_Msg)); -- Add explanation of the warning generated by the check @@ -10925,7 +10939,12 @@ package body Checks is renames Alignment_Warnings.Table (J); begin if Known_Alignment (AWR.E) - and then AWR.A mod Alignment (AWR.E) = 0 + and then ((AWR.A /= No_Uint + and then AWR.A mod Alignment (AWR.E) = 0) + or else (Present (AWR.P) + and then Has_Compatible_Alignment + (AWR.E, AWR.P, True) = + Known_Compatible)) then Delete_Warning_And_Continuations (AWR.W); end if; diff --git a/gcc/ada/checks.ads b/gcc/ada/checks.ads index 9bf2908..a1538a3 100644 --- a/gcc/ada/checks.ads +++ b/gcc/ada/checks.ads @@ -90,7 +90,7 @@ package Checks is -- When we have address clauses, there is an issue of whether the address -- specified is appropriate to the alignment. In the general case where the -- address is dynamic, we generate a check and a possible warning (this - -- warning occurs for example if we have a restricted run time with the + -- warning occurs for example if we have a restricted runtime with the -- restriction No_Exception_Propagation). We also issue this warning in -- the case where the address is static, but we don't know the alignment -- at the time we process the address clause. In such a case, we issue the @@ -98,7 +98,7 @@ package Checks is -- annotated the actual alignment chosen) that the warning was not needed. -- To deal with deleting these potentially annoying warnings, we save the - -- warning information in a table, and then delete the waranings in the + -- warning information in a table, and then delete the warnings in the -- post compilation validation stage if we can tell that the check would -- never fail (in general the back end will also optimize away the check -- in such cases). @@ -113,6 +113,9 @@ package Checks is -- Compile time known value of address clause for which the alignment -- is to be checked once we know the alignment. + P : Node_Id; + -- Prefix of address clause when it is of the form X'Address + W : Error_Msg_Id; -- Id of warning message we might delete end record; diff --git a/gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst b/gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst index 67ad7e7..a5425da 100644 --- a/gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst +++ b/gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst @@ -772,9 +772,8 @@ Convention Name Interpretation be present at all. This convention is useful during development for the inclusion of subprograms whose body has not yet been written. In addition, all otherwise unrecognized convention names are also - treated as being synonymous with convention C. In all implementations - except for VMS, use of such other names results in a warning. In VMS - implementations, these names are accepted silently. + treated as being synonymous with convention C. In all implementations, + use of such other names results in a warning. ======================= ============================================================================== * diff --git a/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst b/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst index 625a38f..126aaf8 100644 --- a/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst +++ b/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst @@ -3254,7 +3254,7 @@ Ada exceptions, or used to implement run-time functions such as the Pragma ``Interrupt_State`` provides a general mechanism for overriding such uses of interrupts. It subsumes the functionality of pragma ``Unreserve_All_Interrupts``. Pragma ``Interrupt_State`` is not -available on Windows or VMS. On all other platforms than VxWorks, +available on Windows. On all other platforms than VxWorks, it applies to signals; on VxWorks, it applies to vectored hardware interrupts and may be used to mark interrupts required by the board support package as reserved. @@ -4049,22 +4049,6 @@ Note that in Ada 2005 mode, this pragma is part of the language. It is available in all earlier versions of Ada as an implementation-defined pragma. -Pragma No_Run_Time -================== - -Syntax: - - -.. code-block:: ada - - pragma No_Run_Time; - - -This is an obsolete configuration pragma that historically was used to -set up a runtime library with no object code. It is now used only for -internal testing. The pragma has been superseded by the reconfigurable -runtime capability of GNAT. - Pragma No_Strict_Aliasing ========================= @@ -6195,7 +6179,7 @@ usually supplied automatically by the project manager. A pragma Source_File_Name cannot appear after a :ref:`Pragma_Source_File_Name_Project`. For more details on the use of the ``Source_File_Name`` pragma, see the -sections on ``Using Other File Names`` and `Alternative File Naming Schemes' +sections on `Using Other File Names` and `Alternative File Naming Schemes` in the :title:`GNAT User's Guide`. .. _Pragma_Source_File_Name_Project: @@ -7505,9 +7489,11 @@ message string (it is not necessary to put an asterisk at the start and the end of the message, since this is implied). Another possibility for the static_string_EXPRESSION which works whether -or not error tags are enabled (*-gnatw.d*) is to use the +or not error tags are enabled (*-gnatw.d*) is to use a single *-gnatw* tag string, enclosed in brackets, -as shown in the example below, to treat a class of warnings as errors. +as shown in the example below, to treat one category of warnings as errors. +Note that if you want to treat multiple categories of warnings as errors, +you can use multiple pragma Warning_As_Error. The above use of patterns to match the message applies only to warning messages generated by the front end. This pragma can also be applied to @@ -7705,7 +7691,7 @@ asterisks is similar in effect to specifying ``pragma Warnings (Off)`` except (i ``pragma Warnings (On, "***")`` will be required. This can be helpful in avoiding forgetting to turn warnings back on. -Note: the debug flag :switch:`-gnatd.i` (``/NOWARNINGS_PRAGMAS`` in VMS) can be +Note: the debug flag :switch:`-gnatd.i` can be used to cause the compiler to entirely ignore all WARNINGS pragmas. This can be useful in checking whether obsolete pragmas in existing programs are hiding real problems. diff --git a/gcc/ada/doc/gnat_rm/implementation_of_specific_ada_features.rst b/gcc/ada/doc/gnat_rm/implementation_of_specific_ada_features.rst index 3f55dc3..e818ab5 100644 --- a/gcc/ada/doc/gnat_rm/implementation_of_specific_ada_features.rst +++ b/gcc/ada/doc/gnat_rm/implementation_of_specific_ada_features.rst @@ -410,9 +410,6 @@ is created in the shared memory directory. This is used to provide the required locking semantics for proper protected object synchronization. -GNAT supports shared passive packages on all platforms -except for OpenVMS. - .. _Code_Generation_for_Array_Aggregates: Code Generation for Array Aggregates diff --git a/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst b/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst index d2675c7..56ee103 100644 --- a/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst +++ b/gcc/ada/doc/gnat_ugn/gnat_and_program_execution.rst @@ -3396,8 +3396,11 @@ adding a switch to ``gnatbind``, as: $ gnatbind -u0 file -With this option, at each task termination, its stack usage is output on +With this option, at each task termination, its stack usage is output on :file:`stderr`. +Note that this switch is not compatible with tools like +Valgrind and DrMemory; they will report errors. + It is not always convenient to output the stack usage when the program is still running. Hence, it is possible to delay this output until program termination. for a given number of tasks specified as the argument of the diff --git a/gcc/ada/einfo.adb b/gcc/ada/einfo.adb index ebef3a0..dcbeac5 100644 --- a/gcc/ada/einfo.adb +++ b/gcc/ada/einfo.adb @@ -215,6 +215,7 @@ package body Einfo is -- Stored_Constraint Elist23 -- Incomplete_Actuals Elist24 + -- Minimum_Accessibility Node24 -- Related_Expression Node24 -- Subps_Index Uint24 @@ -2847,6 +2848,12 @@ package body Einfo is return UI_To_Int (Uint8 (Id)); end Mechanism; + function Minimum_Accessibility (Id : E) return E is + begin + pragma Assert (Ekind (Id) in Formal_Kind); + return Node24 (Id); + end Minimum_Accessibility; + function Modulus (Id : E) return Uint is begin pragma Assert (Is_Modular_Integer_Type (Id)); @@ -6076,6 +6083,12 @@ package body Einfo is Set_Uint8 (Id, UI_From_Int (V)); end Set_Mechanism; + procedure Set_Minimum_Accessibility (Id : E; V : E) is + begin + pragma Assert (Ekind (Id) in Formal_Kind); + Set_Node24 (Id, V); + end Set_Minimum_Accessibility; + procedure Set_Modulus (Id : E; V : U) is begin pragma Assert (Ekind (Id) = E_Modular_Integer_Type); @@ -10913,6 +10926,9 @@ package body Einfo is => Write_Str ("Related_Expression"); + when Formal_Kind => + Write_Str ("Minimum_Accessibility"); + when E_Function | E_Operator | E_Procedure diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads index e93a837..3e968a2 100644 --- a/gcc/ada/einfo.ads +++ b/gcc/ada/einfo.ads @@ -3516,6 +3516,14 @@ package Einfo is -- is also set (to the default value of zero = Default_Mechanism) in a -- subprogram body entity but not used in this context. +-- Minimum_Accessibility (Node24) +-- Defined in formal parameters in the non-generic case. Normally Empty, +-- but if expansion is active, and a parameter exists for which a +-- dynamic accessibility check is required, then an object is generated +-- within such a subprogram representing the accessibility level of the +-- subprogram or the formal's Extra_Accessibility - whichever one is +-- lesser. The Minimum_Accessibility field then points to this object. + -- Modulus (Uint17) [base type only] -- Defined in modular types. Contains the modulus. For the binary case, -- this will be a power of 2, but if Non_Binary_Modulus is set, then it @@ -6273,6 +6281,7 @@ package Einfo is -- Default_Expr_Function (Node21) -- Protected_Formal (Node22) -- Extra_Constrained (Node23) + -- Minimum_Accessibility (Node24) -- Last_Assignment (Node26) (OUT, IN-OUT only) -- Activation_Record_Component (Node31) -- Has_Initial_Value (Flag219) @@ -7398,6 +7407,7 @@ package Einfo is function Materialize_Entity (Id : E) return B; function May_Inherit_Delayed_Rep_Aspects (Id : E) return B; function Mechanism (Id : E) return M; + function Minimum_Accessibility (Id : E) return E; function Modulus (Id : E) return U; function Must_Be_On_Byte_Boundary (Id : E) return B; function Must_Have_Preelab_Init (Id : E) return B; @@ -8103,6 +8113,7 @@ package Einfo is procedure Set_Materialize_Entity (Id : E; V : B := True); procedure Set_May_Inherit_Delayed_Rep_Aspects (Id : E; V : B := True); procedure Set_Mechanism (Id : E; V : M); + procedure Set_Minimum_Accessibility (Id : E; V : E); procedure Set_Modulus (Id : E; V : U); procedure Set_Must_Be_On_Byte_Boundary (Id : E; V : B := True); procedure Set_Must_Have_Preelab_Init (Id : E; V : B := True); @@ -8973,6 +8984,7 @@ package Einfo is pragma Inline (Materialize_Entity); pragma Inline (May_Inherit_Delayed_Rep_Aspects); pragma Inline (Mechanism); + pragma Inline (Minimum_Accessibility); pragma Inline (Modulus); pragma Inline (Must_Be_On_Byte_Boundary); pragma Inline (Must_Have_Preelab_Init); @@ -9466,6 +9478,7 @@ package Einfo is pragma Inline (Set_Materialize_Entity); pragma Inline (Set_May_Inherit_Delayed_Rep_Aspects); pragma Inline (Set_Mechanism); + pragma Inline (Set_Minimum_Accessibility); pragma Inline (Set_Modulus); pragma Inline (Set_Must_Be_On_Byte_Boundary); pragma Inline (Set_Must_Have_Preelab_Init); diff --git a/gcc/ada/exp_aggr.adb b/gcc/ada/exp_aggr.adb index 7f11b41..63f9d1a 100644 --- a/gcc/ada/exp_aggr.adb +++ b/gcc/ada/exp_aggr.adb @@ -2075,7 +2075,6 @@ package body Exp_Aggr is Choice := First (Choice_List (Assoc)); while Present (Choice) loop if Nkind (Choice) = N_Others_Choice then - Set_Loop_Actions (Assoc, New_List); Others_Assoc := Assoc; exit; end if; @@ -2122,7 +2121,8 @@ package body Exp_Aggr is if Present (Others_Assoc) then declare - First : Boolean := True; + First : Boolean := True; + Dup_Expr : Node_Id; begin for J in 0 .. Nb_Choices loop @@ -2160,9 +2160,19 @@ package body Exp_Aggr is or else not Empty_Range (Low, High) then First := False; + + -- Duplicate the expression in case we will be generating + -- several loops. As a result the expression is no longer + -- shared between the loops and is reevaluated for each + -- such loop. + + Expr := Get_Assoc_Expr (Others_Assoc); + Dup_Expr := New_Copy_Tree (Expr); + Set_Parent (Dup_Expr, Parent (Expr)); + + Set_Loop_Actions (Others_Assoc, New_List); Append_List - (Gen_Loop (Low, High, - Get_Assoc_Expr (Others_Assoc)), To => New_Code); + (Gen_Loop (Low, High, Dup_Expr), To => New_Code); end if; end loop; end; @@ -3093,6 +3103,13 @@ package body Exp_Aggr is Make_Selected_Component (Loc, Prefix => New_Copy_Tree (Lhs), Selector_Name => Make_Identifier (Loc, Chars (Expr)))); + + -- The generated code will be reanalyzed, but if the reference + -- to the discriminant appears within an already analyzed + -- expression (e.g. a conditional) we must set its proper entity + -- now. Context is an initialization procedure. + + Analyze (Expr); end if; return OK; diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index c7d1647..a8e68bb 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -2770,40 +2770,6 @@ package body Exp_Attr is when Attribute_Constrained => Constrained : declare Formal_Ent : constant Entity_Id := Param_Entity (Pref); - function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean; - -- Ada 2005 (AI-363): Returns True if the object name Obj denotes a - -- view of an aliased object whose subtype is constrained. - - --------------------------------- - -- Is_Constrained_Aliased_View -- - --------------------------------- - - function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean is - E : Entity_Id; - - begin - if Is_Entity_Name (Obj) then - E := Entity (Obj); - - if Present (Renamed_Object (E)) then - return Is_Constrained_Aliased_View (Renamed_Object (E)); - else - return Is_Aliased (E) and then Is_Constrained (Etype (E)); - end if; - - else - return Is_Aliased_View (Obj) - and then - (Is_Constrained (Etype (Obj)) - or else - (Nkind (Obj) = N_Explicit_Dereference - and then - not Object_Type_Has_Constrained_Partial_View - (Typ => Base_Type (Etype (Obj)), - Scop => Current_Scope))); - end if; - end Is_Constrained_Aliased_View; - -- Start of processing for Constrained begin @@ -2844,115 +2810,23 @@ package body Exp_Attr is New_Occurrence_Of (Extra_Constrained (Entity (Pref)), Sloc (N))); - -- For all other entity names, we can tell at compile time - - elsif Is_Entity_Name (Pref) then - declare - Ent : constant Entity_Id := Entity (Pref); - Res : Boolean; - - begin - -- (RM J.4) obsolescent cases - - if Is_Type (Ent) then - - -- Private type - - if Is_Private_Type (Ent) then - Res := not Has_Discriminants (Ent) - or else Is_Constrained (Ent); - - -- It not a private type, must be a generic actual type - -- that corresponded to a private type. We know that this - -- correspondence holds, since otherwise the reference - -- within the generic template would have been illegal. - - else - if Is_Composite_Type (Underlying_Type (Ent)) then - Res := Is_Constrained (Ent); - else - Res := True; - end if; - end if; - - else - -- For access type, apply access check as needed - - if Is_Access_Type (Ptyp) then - Apply_Access_Check (N); - end if; - - -- If the prefix is not a variable or is aliased, then - -- definitely true; if it's a formal parameter without an - -- associated extra formal, then treat it as constrained. - - -- Ada 2005 (AI-363): An aliased prefix must be known to be - -- constrained in order to set the attribute to True. - - if not Is_Variable (Pref) - or else Present (Formal_Ent) - or else (Ada_Version < Ada_2005 - and then Is_Aliased_View (Pref)) - or else (Ada_Version >= Ada_2005 - and then Is_Constrained_Aliased_View (Pref)) - then - Res := True; - - -- Variable case, look at type to see if it is constrained. - -- Note that the one case where this is not accurate (the - -- procedure formal case), has been handled above. + -- For all other cases, we can tell at compile time - -- We use the Underlying_Type here (and below) in case the - -- type is private without discriminants, but the full type - -- has discriminants. This case is illegal, but we generate - -- it internally for passing to the Extra_Constrained - -- parameter. - - else - -- In Ada 2012, test for case of a limited tagged type, - -- in which case the attribute is always required to - -- return True. The underlying type is tested, to make - -- sure we also return True for cases where there is an - -- unconstrained object with an untagged limited partial - -- view which has defaulted discriminants (such objects - -- always produce a False in earlier versions of - -- Ada). (Ada 2012: AI05-0214) - - Res := - Is_Constrained (Underlying_Type (Etype (Ent))) - or else - (Ada_Version >= Ada_2012 - and then Is_Tagged_Type (Underlying_Type (Ptyp)) - and then Is_Limited_Type (Ptyp)); - end if; - end if; - - Rewrite (N, New_Occurrence_Of (Boolean_Literals (Res), Loc)); - end; + else + -- For access type, apply access check as needed - -- Prefix is not an entity name. These are also cases where we can - -- always tell at compile time by looking at the form and type of the - -- prefix. If an explicit dereference of an object with constrained - -- partial view, this is unconstrained (Ada 2005: AI95-0363). If the - -- underlying type is a limited tagged type, then Constrained is - -- required to always return True (Ada 2012: AI05-0214). + if Is_Entity_Name (Pref) + and then not Is_Type (Entity (Pref)) + and then Is_Access_Type (Ptyp) + then + Apply_Access_Check (N); + end if; - else Rewrite (N, - New_Occurrence_Of ( - Boolean_Literals ( - not Is_Variable (Pref) - or else - (Nkind (Pref) = N_Explicit_Dereference - and then - not Object_Type_Has_Constrained_Partial_View - (Typ => Base_Type (Ptyp), - Scop => Current_Scope)) - or else Is_Constrained (Underlying_Type (Ptyp)) - or else (Ada_Version >= Ada_2012 - and then Is_Tagged_Type (Underlying_Type (Ptyp)) - and then Is_Limited_Type (Ptyp))), - Loc)); + New_Occurrence_Of + (Boolean_Literals + (Exp_Util.Attribute_Constrained_Static_Value + (Pref)), Sloc (N))); end if; Analyze_And_Resolve (N, Standard_Boolean); @@ -7600,18 +7474,36 @@ package body Exp_Attr is New_Occurrence_Of (Get_Actual_Subtype (Pref), Loc), Attribute_Name => Name_Size)); Analyze_And_Resolve (N, Typ); - end if; - -- If Size applies to a dereference of an access to unconstrained + -- If Size is applied to a dereference of an access to unconstrained -- packed array, the back end needs to see its unconstrained nominal -- type, but also a hint to the actual constrained type. - if Nkind (Pref) = N_Explicit_Dereference + elsif Nkind (Pref) = N_Explicit_Dereference and then Is_Array_Type (Ptyp) and then not Is_Constrained (Ptyp) and then Is_Packed (Ptyp) then Set_Actual_Designated_Subtype (Pref, Get_Actual_Subtype (Pref)); + + -- If Size was applied to a slice of a bit-packed array, we rewrite + -- it into the product of Length and Component_Size. We need to do so + -- because bit-packed arrays are represented internally as arrays of + -- System.Unsigned_Types.Packed_Byte for code generation purposes so + -- the size is always rounded up in the back end. + + elsif Nkind (Original_Node (Pref)) = N_Slice + and then Is_Bit_Packed_Array (Ptyp) + then + Rewrite (N, + Make_Op_Multiply (Loc, + Make_Attribute_Reference (Loc, + Prefix => Duplicate_Subexpr (Pref, True), + Attribute_Name => Name_Length), + Make_Attribute_Reference (Loc, + Prefix => Duplicate_Subexpr (Pref, True), + Attribute_Name => Name_Component_Size))); + Analyze_And_Resolve (N, Typ); end if; return; diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index 8763600..b08f51c 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -1922,9 +1922,15 @@ package body Exp_Ch3 is -- Adjust the tag if tagged (because of possible view conversions). -- Suppress the tag adjustment when not Tagged_Type_Expansion because - -- tags are represented implicitly in objects. + -- tags are represented implicitly in objects, and when the record is + -- initialized with a raise expression. - if Is_Tagged_Type (Typ) and then Tagged_Type_Expansion then + if Is_Tagged_Type (Typ) + and then Tagged_Type_Expansion + and then Nkind (Exp) /= N_Raise_Expression + and then (Nkind (Exp) /= N_Qualified_Expression + or else Nkind (Expression (Exp)) /= N_Raise_Expression) + then Append_To (Res, Make_Assignment_Statement (Default_Loc, Name => diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index c288d6a..a20469c 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -8221,6 +8221,32 @@ package body Exp_Ch4 is Insert_Actions (N, Bodies, Suppress => All_Checks); Analyze_And_Resolve (N, Standard_Boolean, Suppress => All_Checks); end if; + + -- If unnesting, handle elementary types whose Equivalent_Types are + -- records because there may be padding or undefined fields. + + elsif Unnest_Subprogram_Mode + and then Ekind_In (Typl, E_Class_Wide_Type, + E_Class_Wide_Subtype, + E_Access_Subprogram_Type, + E_Access_Protected_Subprogram_Type, + E_Anonymous_Access_Protected_Subprogram_Type, + E_Access_Subprogram_Type, + E_Exception_Type) + and then Present (Equivalent_Type (Typl)) + and then Is_Record_Type (Equivalent_Type (Typl)) + then + Typl := Equivalent_Type (Typl); + Remove_Side_Effects (Lhs); + Remove_Side_Effects (Rhs); + Rewrite (N, + Expand_Record_Equality (N, Typl, + Unchecked_Convert_To (Typl, Lhs), + Unchecked_Convert_To (Typl, Rhs), + Bodies)); + + Insert_Actions (N, Bodies, Suppress => All_Checks); + Analyze_And_Resolve (N, Standard_Boolean, Suppress => All_Checks); end if; -- Test if result is known at compile time @@ -9497,10 +9523,21 @@ package body Exp_Ch4 is Typ : constant Entity_Id := Etype (Left_Opnd (N)); begin - -- Case of elementary type with standard operator + -- Case of elementary type with standard operator. But if + -- unnesting, handle elementary types whose Equivalent_Types are + -- records because there may be padding or undefined fields. if Is_Elementary_Type (Typ) and then Sloc (Entity (N)) = Standard_Location + and then not (Ekind_In (Typ, E_Class_Wide_Type, + E_Class_Wide_Subtype, + E_Access_Subprogram_Type, + E_Access_Protected_Subprogram_Type, + E_Anonymous_Access_Protected_Subprogram_Type, + E_Access_Subprogram_Type, + E_Exception_Type) + and then Present (Equivalent_Type (Typ)) + and then Is_Record_Type (Equivalent_Type (Typ))) then Binary_Op_Validity_Checks (N); @@ -10964,6 +11001,7 @@ package body Exp_Ch4 is procedure Expand_N_Type_Conversion (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Operand : constant Node_Id := Expression (N); + Operand_Acc : Node_Id := Operand; Target_Type : Entity_Id := Etype (N); Operand_Type : Entity_Id := Etype (Operand); @@ -11681,6 +11719,15 @@ package body Exp_Ch4 is -- Case of converting to an access type if Is_Access_Type (Target_Type) then + -- In terms of accessibility rules, an anonymous access discriminant + -- is not considered separate from its parent object. + + if Nkind (Operand) = N_Selected_Component + and then Ekind (Entity (Selector_Name (Operand))) = E_Discriminant + and then Ekind (Operand_Type) = E_Anonymous_Access_Type + then + Operand_Acc := Original_Node (Prefix (Operand)); + end if; -- If this type conversion was internally generated by the front end -- to displace the pointer to the object to reference an interface @@ -11704,9 +11751,9 @@ package body Exp_Ch4 is -- other checks may still need to be applied below (such as tagged -- type checks). - elsif Is_Entity_Name (Operand) - and then Has_Extra_Accessibility (Entity (Operand)) - and then Ekind (Etype (Operand)) = E_Anonymous_Access_Type + elsif Is_Entity_Name (Operand_Acc) + and then Has_Extra_Accessibility (Entity (Operand_Acc)) + and then Ekind (Etype (Operand_Acc)) = E_Anonymous_Access_Type and then (Nkind (Original_Node (N)) /= N_Attribute_Reference or else Attribute_Name (Original_Node (N)) = Name_Access) then @@ -11721,7 +11768,7 @@ package body Exp_Ch4 is else Apply_Accessibility_Check - (Operand, Target_Type, Insert_Node => Operand); + (Operand_Acc, Target_Type, Insert_Node => Operand); end if; -- If the level of the operand type is statically deeper than the diff --git a/gcc/ada/exp_ch5.adb b/gcc/ada/exp_ch5.adb index ba0b793..4bbe86a 100644 --- a/gcc/ada/exp_ch5.adb +++ b/gcc/ada/exp_ch5.adb @@ -1408,12 +1408,13 @@ package body Exp_Ch5 is Expressions => New_List (New_Copy_Tree (Right_Lo))), Attribute_Name => Name_Bit); - -- Compute the Size of the bitfield. ???We can't use Size here, because - -- it doesn't work properly for slices of packed arrays, so we compute - -- the L'Size as L'Length*L'Component_Size. - -- + -- Compute the Size of the bitfield + -- Note that the length check has already been done, so we can use the - -- size of either L or R. + -- size of either L or R; they are equal. We can't use 'Size here, + -- because sometimes bit fields get copied into a temp, and the 'Size + -- ends up being the size of the temp (e.g. an 8-bit temp containing + -- a 4-bit bit field). Size : constant Node_Id := Make_Op_Multiply (Loc, @@ -1448,23 +1449,46 @@ package body Exp_Ch5 is is Slices : constant Boolean := Nkind (Name (N)) = N_Slice or else Nkind (Expression (N)) = N_Slice; + L_Prefix_Comp : constant Boolean := + -- True if the left-hand side is a slice of a component or slice + Nkind (Name (N)) = N_Slice + and then Nkind_In (Prefix (Name (N)), + N_Selected_Component, + N_Indexed_Component, + N_Slice); + R_Prefix_Comp : constant Boolean := + -- Likewise for the right-hand side + Nkind (Expression (N)) = N_Slice + and then Nkind_In (Prefix (Expression (N)), + N_Selected_Component, + N_Indexed_Component, + N_Slice); begin -- Determine whether Copy_Bitfield is appropriate (will work, and will -- be more efficient than component-by-component copy). Copy_Bitfield - -- doesn't work for reversed storage orders. It is efficient only for - -- slices of bit-packed arrays. - - -- Note that Expand_Assign_Array_Bitfield is disabled for now - - if False -- ??? - and then Is_Bit_Packed_Array (L_Type) + -- doesn't work for reversed storage orders. It is efficient for slices + -- of bit-packed arrays. Copy_Bitfield can read and write bits that are + -- not part of the objects being copied, so we don't want to use it if + -- there are volatile or independent components. If the Prefix of the + -- slice is a component or slice, then it might be a part of an object + -- with some other volatile or independent components, so we disable the + -- optimization in that case as well. We could complicate this code by + -- actually looking for such volatile and independent components. + + if Is_Bit_Packed_Array (L_Type) and then Is_Bit_Packed_Array (R_Type) - and then RTE_Available (RE_Copy_Bitfield) and then not Reverse_Storage_Order (L_Type) and then not Reverse_Storage_Order (R_Type) and then Ndim = 1 and then not Rev and then Slices + and then not Has_Volatile_Component (L_Type) + and then not Has_Volatile_Component (R_Type) + and then not Has_Independent_Components (L_Type) + and then not Has_Independent_Components (R_Type) + and then not L_Prefix_Comp + and then not R_Prefix_Comp + and then RTE_Available (RE_Copy_Bitfield) then return Expand_Assign_Array_Bitfield (N, Larray, Rarray, L_Type, R_Type, Rev); diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index e3109c2..78a1496 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -146,6 +146,12 @@ package body Exp_Ch6 is -- access discriminants do not require secondary stack use. Note we must -- always use the secondary stack for dispatching-on-result calls. + function Check_Number_Of_Actuals + (Subp_Call : Node_Id; + Subp_Id : Entity_Id) return Boolean; + -- Given a subprogram call to the given subprogram return True if the + -- number of actual parameters (including extra actuals) is correct. + procedure Check_Overriding_Operation (Subp : Entity_Id); -- Subp is a dispatching operation. Check whether it may override an -- inherited private operation, in which case its DT entry is that of @@ -543,8 +549,6 @@ package body Exp_Ch6 is Chain : Node_Id := Empty) is Loc : constant Source_Ptr := Sloc (Function_Call); - Result_Subt : constant Entity_Id := - Available_View (Etype (Function_Id)); Actual : Node_Id; Chain_Actual : Node_Id; Chain_Formal : Node_Id; @@ -553,7 +557,7 @@ package body Exp_Ch6 is begin -- No such extra parameters are needed if there are no tasks - if not Has_Task (Result_Subt) then + if not Needs_BIP_Task_Actuals (Function_Id) then return; end if; @@ -869,6 +873,33 @@ package body Exp_Ch6 is or else not Requires_Transient_Scope (Underlying_Type (Result_Subt)); end Caller_Known_Size; + ----------------------------- + -- Check_Number_Of_Actuals -- + ----------------------------- + + function Check_Number_Of_Actuals + (Subp_Call : Node_Id; + Subp_Id : Entity_Id) return Boolean + is + Formal : Entity_Id; + Actual : Node_Id; + + begin + pragma Assert (Nkind_In (Subp_Call, N_Entry_Call_Statement, + N_Function_Call, + N_Procedure_Call_Statement)); + + Formal := First_Formal_With_Extras (Subp_Id); + Actual := First_Actual (Subp_Call); + + while Present (Formal) and then Present (Actual) loop + Next_Formal_With_Extras (Formal); + Next_Actual (Actual); + end loop; + + return No (Formal) and then No (Actual); + end Check_Number_Of_Actuals; + -------------------------------- -- Check_Overriding_Operation -- -------------------------------- @@ -3190,7 +3221,7 @@ package body Exp_Ch6 is -- Create possible extra actual for accessibility level - if Present (Extra_Accessibility (Formal)) then + if Present (Get_Accessibility (Formal)) then -- Ada 2005 (AI-252): If the actual was rewritten as an Access -- attribute, then the original actual may be an aliased object @@ -3266,8 +3297,8 @@ package body Exp_Ch6 is Add_Extra_Actual (Expr => - New_Occurrence_Of (Extra_Accessibility (Parm_Ent), Loc), - EF => Extra_Accessibility (Formal)); + New_Occurrence_Of (Get_Accessibility (Parm_Ent), Loc), + EF => Get_Accessibility (Formal)); end; elsif Is_Entity_Name (Prev_Orig) then @@ -3296,12 +3327,12 @@ package body Exp_Ch6 is begin pragma Assert (Present (Parm_Ent)); - if Present (Extra_Accessibility (Parm_Ent)) then + if Present (Get_Accessibility (Parm_Ent)) then Add_Extra_Actual (Expr => New_Occurrence_Of - (Extra_Accessibility (Parm_Ent), Loc), - EF => Extra_Accessibility (Formal)); + (Get_Accessibility (Parm_Ent), Loc), + EF => Get_Accessibility (Formal)); -- If the actual access parameter does not have an -- associated extra formal providing its scope level, @@ -3313,7 +3344,7 @@ package body Exp_Ch6 is (Expr => Make_Integer_Literal (Loc, Intval => Scope_Depth (Standard_Standard)), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); end if; end; @@ -3323,7 +3354,7 @@ package body Exp_Ch6 is else Add_Extra_Actual (Expr => Dynamic_Accessibility_Level (Prev_Orig), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); end if; -- If the actual is an access discriminant, then pass the level @@ -3339,7 +3370,7 @@ package body Exp_Ch6 is (Expr => Make_Integer_Literal (Loc, Intval => Object_Access_Level (Prefix (Prev_Orig))), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); -- All other cases @@ -3409,19 +3440,19 @@ package body Exp_Ch6 is Make_Integer_Literal (Loc, Intval => Type_Access_Level (Pref_Entity)), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); elsif Nkind (Prev_Orig) = N_Explicit_Dereference and then Present (Pref_Entity) and then Is_Formal (Pref_Entity) and then Present - (Extra_Accessibility (Pref_Entity)) + (Get_Accessibility (Pref_Entity)) then Add_Extra_Actual (Expr => New_Occurrence_Of - (Extra_Accessibility (Pref_Entity), Loc), - EF => Extra_Accessibility (Formal)); + (Get_Accessibility (Pref_Entity), Loc), + EF => Get_Accessibility (Formal)); else Add_Extra_Actual @@ -3429,7 +3460,7 @@ package body Exp_Ch6 is Make_Integer_Literal (Loc, Intval => Object_Access_Level (Prev_Orig)), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); end if; -- Treat the unchecked attributes as library-level @@ -3441,7 +3472,7 @@ package body Exp_Ch6 is (Expr => Make_Integer_Literal (Loc, Intval => Scope_Depth (Standard_Standard)), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); -- No other cases of attributes returning access -- values that can be passed to access parameters. @@ -3463,7 +3494,7 @@ package body Exp_Ch6 is (Expr => Make_Integer_Literal (Loc, Intval => Scope_Depth (Current_Scope) + 1), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); -- For most other cases we simply pass the level of the -- actual's access type. The type is retrieved from @@ -3474,7 +3505,7 @@ package body Exp_Ch6 is when others => Add_Extra_Actual (Expr => Dynamic_Accessibility_Level (Prev), - EF => Extra_Accessibility (Formal)); + EF => Get_Accessibility (Formal)); end case; end if; end if; @@ -8335,6 +8366,7 @@ package body Exp_Ch6 is Rewrite (Allocator, New_Occurrence_Of (Return_Obj_Access, Loc)); Analyze_And_Resolve (Allocator, Acc_Type); + pragma Assert (Check_Number_Of_Actuals (Func_Call, Function_Id)); end Make_Build_In_Place_Call_In_Allocator; --------------------------------------------------- @@ -8456,6 +8488,8 @@ package body Exp_Ch6 is Add_Access_Actual_To_Build_In_Place_Call (Func_Call, Function_Id, New_Occurrence_Of (Return_Obj_Id, Loc)); + pragma Assert (Check_Number_Of_Actuals (Func_Call, Function_Id)); + -- When the result subtype is unconstrained, the function must allocate -- the return object in the secondary stack, so appropriate implicit -- parameters are added to the call to indicate that. A transient @@ -8479,6 +8513,8 @@ package body Exp_Ch6 is Add_Access_Actual_To_Build_In_Place_Call (Func_Call, Function_Id, Empty); + + pragma Assert (Check_Number_Of_Actuals (Func_Call, Function_Id)); end if; end Make_Build_In_Place_Call_In_Anonymous_Context; @@ -8584,6 +8620,7 @@ package body Exp_Ch6 is Insert_After_And_Analyze (Ptr_Typ_Decl, Obj_Decl); Rewrite (Assign, Make_Null_Statement (Loc)); + pragma Assert (Check_Number_Of_Actuals (Func_Call, Func_Id)); end Make_Build_In_Place_Call_In_Assignment; ---------------------------------------------------- @@ -8908,7 +8945,7 @@ package body Exp_Ch6 is Master_Exp => Fmaster_Actual); if Nkind (Parent (Obj_Decl)) = N_Extended_Return_Statement - and then Has_Task (Result_Subt) + and then Needs_BIP_Task_Actuals (Function_Id) then -- Here we're passing along the master that was passed in to this -- function. @@ -9025,6 +9062,8 @@ package body Exp_Ch6 is Replace_Renaming_Declaration_Id (Obj_Decl, Original_Node (Obj_Decl)); end if; + + pragma Assert (Check_Number_Of_Actuals (Func_Call, Function_Id)); end Make_Build_In_Place_Call_In_Object_Declaration; ------------------------------------------------- @@ -9296,6 +9335,17 @@ package body Exp_Ch6 is Analyze_And_Resolve (Allocator, Acc_Type); end Make_CPP_Constructor_Call_In_Allocator; + ---------------------------- + -- Needs_BIP_Task_Actuals -- + ---------------------------- + + function Needs_BIP_Task_Actuals (Func_Id : Entity_Id) return Boolean is + pragma Assert (Is_Build_In_Place_Function (Func_Id)); + Func_Typ : constant Entity_Id := Underlying_Type (Etype (Func_Id)); + begin + return Has_Task (Func_Typ); + end Needs_BIP_Task_Actuals; + ----------------------------------- -- Needs_BIP_Finalization_Master -- ----------------------------------- diff --git a/gcc/ada/exp_ch6.ads b/gcc/ada/exp_ch6.ads index bf453d9..13ccb2a 100644 --- a/gcc/ada/exp_ch6.ads +++ b/gcc/ada/exp_ch6.ads @@ -244,6 +244,9 @@ package Exp_Ch6 is -- functions with tagged result types, since they can be invoked via -- dispatching calls, and descendant types may require finalization. + function Needs_BIP_Task_Actuals (Func_Id : Entity_Id) return Boolean; + -- Return True if the function returns an object of a type that has tasks. + function Needs_Result_Accessibility_Level (Func_Id : Entity_Id) return Boolean; -- Ada 2012 (AI05-0234): Return True if the function needs an implicit diff --git a/gcc/ada/exp_dbug.adb b/gcc/ada/exp_dbug.adb index 3dbe9ad..c2d2318 100644 --- a/gcc/ada/exp_dbug.adb +++ b/gcc/ada/exp_dbug.adb @@ -219,26 +219,12 @@ package body Exp_Dbug is begin if Has_Homonym (E) then - declare - H : Entity_Id := Homonym (E); - Nr : Nat := 1; - - begin - while Present (H) loop - if Scope (H) = Scope (E) then - Nr := Nr + 1; - end if; - - H := Homonym (H); - end loop; - - if Homonym_Len > 0 then - Homonym_Len := Homonym_Len + 1; - Homonym_Numbers (Homonym_Len) := '_'; - end if; + if Homonym_Len > 0 then + Homonym_Len := Homonym_Len + 1; + Homonym_Numbers (Homonym_Len) := '_'; + end if; - Add_Nat_To_H (Nr); - end; + Add_Nat_To_H (Get_Homonym_Number (E)); end if; end Append_Homonym_Number; @@ -1068,6 +1054,26 @@ package body Exp_Dbug is end loop; end Build_Subprogram_Instance_Renamings; + ------------------------ + -- Get_Homonym_Number -- + ------------------------ + + function Get_Homonym_Number (E : Entity_Id) return Pos is + H : Entity_Id := Homonym (E); + Nr : Pos := 1; + + begin + while Present (H) loop + if Scope (H) = Scope (E) then + Nr := Nr + 1; + end if; + + H := Homonym (H); + end loop; + + return Nr; + end Get_Homonym_Number; + ------------------------------------ -- Get_Secondary_DT_External_Name -- ------------------------------------ @@ -1451,25 +1457,6 @@ package body Exp_Dbug is if Has_Qualified_Name (Ent) then return; - -- In formal verification mode, simply append a suffix for homonyms. - -- We used to qualify entity names as full expansion does, but this was - -- removed as this prevents the verification back-end from using a short - -- name for debugging and user interaction. The verification back-end - -- already takes care of qualifying names when needed. Still mark the - -- name as being qualified, as Qualify_Entity_Name may be called more - -- than once on the same entity. - - elsif GNATprove_Mode then - if Has_Homonym (Ent) then - Get_Name_String (Chars (Ent)); - Append_Homonym_Number (Ent); - Output_Homonym_Numbers_Suffix; - Set_Chars (Ent, Name_Enter); - end if; - - Set_Has_Qualified_Name (Ent); - return; - -- If the entity is a variable encoding the debug name for an object -- renaming, then the qualified name of the entity associated with the -- renamed object can now be incorporated in the debug name. diff --git a/gcc/ada/exp_dbug.ads b/gcc/ada/exp_dbug.ads index 5768734..ac40a40 100644 --- a/gcc/ada/exp_dbug.ads +++ b/gcc/ada/exp_dbug.ads @@ -460,6 +460,10 @@ package Exp_Dbug is -- Subprograms for Handling Qualification -- -------------------------------------------- + function Get_Homonym_Number (E : Entity_Id) return Pos; + -- Return the homonym number for E, which is its position in the homonym + -- chain starting at 1. This is exported for use in GNATprove. + procedure Qualify_Entity_Names (N : Node_Id); -- Given a node N, that represents a block, subprogram body, or package -- body or spec, or protected or task type, sets a fully qualified name @@ -1452,18 +1456,21 @@ package Exp_Dbug is -- a character literal, the name is encoded as described in the following -- paragraph. - -- A name QUhh, where each 'h' is a lower-case hexadecimal digit, stands - -- for a character whose Unicode encoding is hh, and QWhhhh likewise stands - -- for a wide character whose encoding is hhhh. The representation values - -- are encoded as for ordinary enumeration literals (and have no necessary - -- relationship to the values encoded in the names). + -- The characters 'a'..'z' and '0'..'9' are represented as Qc, where 'c' + -- stands for the character itself. A name QUhh, where each 'h' is a + -- lower-case hexadecimal digit, stands for a character whose Unicode + -- encoding is hh, and QWhhhh likewise stands for a wide character whose + -- encoding is hhhh. The representation values are encoded as for ordinary + -- enumeration literals (and have no necessary relationship to the values + -- encoded in the names). -- For example, given the type declaration - -- type x is (A, 'C', B); + -- type x is (A, 'C', 'b'); -- the second enumeration literal would be named QU43 and the value - -- assigned to it would be 1. + -- assigned to it would be 1, and the third enumeration literal would be + -- named Qb and the value assigned to it would be 2. ----------------------------------------------- -- Secondary Dispatch tables of tagged types -- diff --git a/gcc/ada/exp_disp.adb b/gcc/ada/exp_disp.adb index 640d205..84caa92 100644 --- a/gcc/ada/exp_disp.adb +++ b/gcc/ada/exp_disp.adb @@ -4041,7 +4041,6 @@ package body Exp_Disp is -- predef-prim-op-thunk-2'address, -- ... -- predef-prim-op-thunk-n'address); - -- for Predef_Prims'Alignment use Address'Alignment -- Create the thunks associated with the predefined primitives and -- save their entity to fill the aggregate. @@ -4125,16 +4124,6 @@ package body Exp_Disp is Object_Definition => New_Occurrence_Of (Defining_Identifier (Decl), Loc), Expression => New_Node)); - - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (Predef_Prims, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); end; -- Generate @@ -4143,6 +4132,7 @@ package body Exp_Disp is -- (OSD_Table => (1 => <value>, -- ... -- N => <value>)); + -- for OSD'Alignment use Address'Alignment; -- Iface_DT : Dispatch_Table (Nb_Prims) := -- ([ Signature => <sig-value> ], @@ -4154,7 +4144,6 @@ package body Exp_Disp is -- prim-op-2'address, -- ... -- prim-op-n'address)); - -- for Iface_DT'Alignment use Address'Alignment; -- Stage 3: Initialize the discriminant and the record components @@ -4454,17 +4443,6 @@ package body Exp_Disp is Make_Aggregate (Loc, Expressions => DT_Aggr_List))); - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (Iface_DT, Loc), - Chars => Name_Alignment, - - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - if Exporting_Table then Export_DT (Typ, Iface_DT, Suffix_Index); @@ -4946,7 +4924,6 @@ package body Exp_Disp is -- Generate: -- DT : No_Dispatch_Table_Wrapper; - -- for DT'Alignment use Address'Alignment; -- DT_Ptr : Tag := !Tag (DT.NDT_Prims_Ptr'Address); if not Has_DT (Typ) then @@ -4960,16 +4937,6 @@ package body Exp_Disp is (RTE (RE_No_Dispatch_Table_Wrapper), Loc))); Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (DT, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - - Append_To (Result, Make_Object_Declaration (Loc, Defining_Identifier => DT_Ptr, Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc), @@ -5008,7 +4975,6 @@ package body Exp_Disp is -- Generate: -- DT : Dispatch_Table_Wrapper (Nb_Prim); - -- for DT'Alignment use Address'Alignment; -- DT_Ptr : Tag := !Tag (DT.Prims_Ptr'Address); else @@ -5037,16 +5003,6 @@ package body Exp_Disp is Constraints => DT_Constr_List)))); Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (DT, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - - Append_To (Result, Make_Object_Declaration (Loc, Defining_Identifier => DT_Ptr, Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc), @@ -5161,7 +5117,6 @@ package body Exp_Disp is -- Tags_Table => (0 => null, -- 1 => Parent'Tag -- ...); - -- for TSD'Alignment use Address'Alignment TSD_Aggr_List := New_List; @@ -5699,16 +5654,6 @@ package body Exp_Disp is Make_Integer_Literal (Loc, Num_Ifaces), Make_Aggregate (Loc, TSD_Ifaces_List))))); - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (ITable, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - Iface_Table_Node := Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (ITable, Loc), @@ -5859,16 +5804,6 @@ package body Exp_Disp is Set_Is_True_Constant (TSD, Building_Static_DT (Typ)); - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (TSD, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - -- Initialize or declare the dispatch table object if not Has_DT (Typ) then @@ -5906,7 +5841,6 @@ package body Exp_Disp is -- DT : aliased constant No_Dispatch_Table := -- (NDT_TSD => TSD'Address; -- NDT_Prims_Ptr => 0); - -- for DT'Alignment use Address'Alignment; else Append_To (Result, @@ -5918,16 +5852,6 @@ package body Exp_Disp is New_Occurrence_Of (RTE (RE_No_Dispatch_Table_Wrapper), Loc), Expression => Make_Aggregate (Loc, DT_Aggr_List))); - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (DT, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - Export_DT (Typ, DT); end if; @@ -5940,7 +5864,6 @@ package body Exp_Disp is -- predef-prim-op-2'address, -- ... -- predef-prim-op-n'address); - -- for Predef_Prims'Alignment use Address'Alignment -- DT : Dispatch_Table (Nb_Prims) := -- (Signature => <sig-value>, @@ -6025,16 +5948,6 @@ package body Exp_Disp is -- Remember aggregates initializing dispatch tables Append_Elmt (New_Node, DT_Aggr); - - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (Predef_Prims, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); end; -- Stage 1: Initialize the discriminant and the record components @@ -6221,16 +6134,6 @@ package body Exp_Disp is Constraints => DT_Constr_List)), Expression => Make_Aggregate (Loc, DT_Aggr_List))); - Append_To (Result, - Make_Attribute_Definition_Clause (Loc, - Name => New_Occurrence_Of (DT, Loc), - Chars => Name_Alignment, - Expression => - Make_Attribute_Reference (Loc, - Prefix => - New_Occurrence_Of (RTE (RE_Integer_Address), Loc), - Attribute_Name => Name_Alignment))); - Export_DT (Typ, DT); end if; end if; diff --git a/gcc/ada/exp_spark.adb b/gcc/ada/exp_spark.adb index e64babe..28484aa 100644 --- a/gcc/ada/exp_spark.adb +++ b/gcc/ada/exp_spark.adb @@ -176,6 +176,7 @@ package body Exp_SPARK is Aname : constant Name_Id := Attribute_Name (N); Attr_Id : constant Attribute_Id := Get_Attribute_Id (Aname); Loc : constant Source_Ptr := Sloc (N); + Pref : constant Node_Id := Prefix (N); Typ : constant Entity_Id := Etype (N); Expr : Node_Id; @@ -302,6 +303,20 @@ package body Exp_SPARK is Set_Do_Overflow_Check (N); end if; end; + + elsif Attr_Id = Attribute_Constrained then + + -- If the prefix is an access to object, the attribute applies to + -- the designated object, so rewrite with an explicit dereference. + + if Is_Access_Type (Etype (Pref)) + and then + (not Is_Entity_Name (Pref) or else Is_Object (Entity (Pref))) + then + Rewrite (Pref, + Make_Explicit_Dereference (Loc, Relocate_Node (Pref))); + Analyze_And_Resolve (N, Standard_Boolean); + end if; end if; end Expand_SPARK_N_Attribute_Reference; diff --git a/gcc/ada/exp_unst.adb b/gcc/ada/exp_unst.adb index 7cc9a6a4..8c492bc 100644 --- a/gcc/ada/exp_unst.adb +++ b/gcc/ada/exp_unst.adb @@ -2592,9 +2592,9 @@ package body Exp_Unst is then Subp_Body := Parent (Declaration_Node (Corresponding_Body (Subp_Body))); - Unnest_Subprogram (Subp, Subp_Body, For_Inline => True); end if; + Unnest_Subprogram (Subp, Subp_Body, For_Inline => True); Next_Inlined_Subprogram (Subp); end loop; end Unnest_Subprograms; diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb index c3c5e79..06f5cc3 100644 --- a/gcc/ada/exp_util.adb +++ b/gcc/ada/exp_util.adb @@ -32,6 +32,7 @@ with Einfo; use Einfo; with Elists; use Elists; with Errout; use Errout; with Exp_Aggr; use Exp_Aggr; +with Exp_Ch2; use Exp_Ch2; with Exp_Ch6; use Exp_Ch6; with Exp_Ch7; use Exp_Ch7; with Exp_Ch11; use Exp_Ch11; @@ -472,6 +473,169 @@ package body Exp_Util is end if; end Append_Freeze_Actions; + -------------------------------------- + -- Attr_Constrained_Statically_True -- + -------------------------------------- + + function Attribute_Constrained_Static_Value (Pref : Node_Id) return Boolean + is + Ptyp : constant Entity_Id := Etype (Pref); + Formal_Ent : constant Entity_Id := Param_Entity (Pref); + + function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean; + -- Ada 2005 (AI-363): Returns True if the object name Obj denotes a + -- view of an aliased object whose subtype is constrained. + + --------------------------------- + -- Is_Constrained_Aliased_View -- + --------------------------------- + + function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean is + E : Entity_Id; + + begin + if Is_Entity_Name (Obj) then + E := Entity (Obj); + + if Present (Renamed_Object (E)) then + return Is_Constrained_Aliased_View (Renamed_Object (E)); + else + return Is_Aliased (E) and then Is_Constrained (Etype (E)); + end if; + + else + return Is_Aliased_View (Obj) + and then + (Is_Constrained (Etype (Obj)) + or else + (Nkind (Obj) = N_Explicit_Dereference + and then + not Object_Type_Has_Constrained_Partial_View + (Typ => Base_Type (Etype (Obj)), + Scop => Current_Scope))); + end if; + end Is_Constrained_Aliased_View; + + -- Start of processing for Attribute_Constrained_Static_Value + + begin + -- We are in a case where the attribute is known statically, and + -- implicit dereferences have been rewritten. + + pragma Assert + (not (Present (Formal_Ent) + and then Ekind (Formal_Ent) /= E_Constant + and then Present (Extra_Constrained (Formal_Ent))) + and then + not (Is_Access_Type (Etype (Pref)) + and then (not Is_Entity_Name (Pref) + or else Is_Object (Entity (Pref)))) + and then + not (Nkind (Pref) = N_Identifier + and then Ekind (Entity (Pref)) = E_Variable + and then Present (Extra_Constrained (Entity (Pref))))); + + if Is_Entity_Name (Pref) then + declare + Ent : constant Entity_Id := Entity (Pref); + Res : Boolean; + + begin + -- (RM J.4) obsolescent cases + + if Is_Type (Ent) then + + -- Private type + + if Is_Private_Type (Ent) then + Res := not Has_Discriminants (Ent) + or else Is_Constrained (Ent); + + -- It not a private type, must be a generic actual type + -- that corresponded to a private type. We know that this + -- correspondence holds, since otherwise the reference + -- within the generic template would have been illegal. + + else + if Is_Composite_Type (Underlying_Type (Ent)) then + Res := Is_Constrained (Ent); + else + Res := True; + end if; + end if; + + else + + -- If the prefix is not a variable or is aliased, then + -- definitely true; if it's a formal parameter without an + -- associated extra formal, then treat it as constrained. + + -- Ada 2005 (AI-363): An aliased prefix must be known to be + -- constrained in order to set the attribute to True. + + if not Is_Variable (Pref) + or else Present (Formal_Ent) + or else (Ada_Version < Ada_2005 + and then Is_Aliased_View (Pref)) + or else (Ada_Version >= Ada_2005 + and then Is_Constrained_Aliased_View (Pref)) + then + Res := True; + + -- Variable case, look at type to see if it is constrained. + -- Note that the one case where this is not accurate (the + -- procedure formal case), has been handled above. + + -- We use the Underlying_Type here (and below) in case the + -- type is private without discriminants, but the full type + -- has discriminants. This case is illegal, but we generate + -- it internally for passing to the Extra_Constrained + -- parameter. + + else + -- In Ada 2012, test for case of a limited tagged type, + -- in which case the attribute is always required to + -- return True. The underlying type is tested, to make + -- sure we also return True for cases where there is an + -- unconstrained object with an untagged limited partial + -- view which has defaulted discriminants (such objects + -- always produce a False in earlier versions of + -- Ada). (Ada 2012: AI05-0214) + + Res := + Is_Constrained (Underlying_Type (Etype (Ent))) + or else + (Ada_Version >= Ada_2012 + and then Is_Tagged_Type (Underlying_Type (Ptyp)) + and then Is_Limited_Type (Ptyp)); + end if; + end if; + + return Res; + end; + + -- Prefix is not an entity name. These are also cases where we can + -- always tell at compile time by looking at the form and type of the + -- prefix. If an explicit dereference of an object with constrained + -- partial view, this is unconstrained (Ada 2005: AI95-0363). If the + -- underlying type is a limited tagged type, then Constrained is + -- required to always return True (Ada 2012: AI05-0214). + + else + return not Is_Variable (Pref) + or else + (Nkind (Pref) = N_Explicit_Dereference + and then + not Object_Type_Has_Constrained_Partial_View + (Typ => Base_Type (Ptyp), + Scop => Current_Scope)) + or else Is_Constrained (Underlying_Type (Ptyp)) + or else (Ada_Version >= Ada_2012 + and then Is_Tagged_Type (Underlying_Type (Ptyp)) + and then Is_Limited_Type (Ptyp)); + end if; + end Attribute_Constrained_Static_Value; + ------------------------------------ -- Build_Allocate_Deallocate_Proc -- ------------------------------------ diff --git a/gcc/ada/exp_util.ads b/gcc/ada/exp_util.ads index 30a3c71..ab33e8d 100644 --- a/gcc/ada/exp_util.ads +++ b/gcc/ada/exp_util.ads @@ -240,6 +240,10 @@ package Exp_Util is -- Note that the added nodes are not analyzed. The analyze call is found in -- Exp_Ch13.Expand_N_Freeze_Entity. + function Attribute_Constrained_Static_Value (Pref : Node_Id) return Boolean; + -- Return the static value of a statically known attribute reference + -- Pref'Constrained. + procedure Build_Allocate_Deallocate_Proc (N : Node_Id; Is_Allocate : Boolean); diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index bb17e42..93e91b2 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -3569,7 +3569,8 @@ package body Freeze is Error_Msg_N ("\??use explicit size clause to set size", E); end if; - if Is_Array_Type (Typ) then + -- Declaring a too-big array in disabled ghost code is OK + if Is_Array_Type (Typ) and then not Is_Ignored_Ghost_Entity (E) then Check_Large_Modular_Array (Typ); end if; end Freeze_Object_Declaration; diff --git a/gcc/ada/frontend.adb b/gcc/ada/frontend.adb index 2b3f377..1cc143a 100644 --- a/gcc/ada/frontend.adb +++ b/gcc/ada/frontend.adb @@ -492,7 +492,9 @@ begin -- Qualify all entity names in inner packages, package bodies, etc - Exp_Dbug.Qualify_All_Entity_Names; + if not GNATprove_Mode then + Exp_Dbug.Qualify_All_Entity_Names; + end if; -- SCIL backend requirement. Check that SCIL nodes associated with -- dispatching calls reference subprogram calls. diff --git a/gcc/ada/gcc-interface/ada-tree.h b/gcc/ada/gcc-interface/ada-tree.h index 2029b7c..acea5d1 100644 --- a/gcc/ada/gcc-interface/ada-tree.h +++ b/gcc/ada/gcc-interface/ada-tree.h @@ -482,6 +482,9 @@ do { \ value of a function call or 'reference to a function call. */ #define DECL_RETURN_VALUE_P(NODE) DECL_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) +/* Nonzero in a PARM_DECL if its mechanism was forced to by-reference. */ +#define DECL_FORCED_BY_REF_P(NODE) DECL_LANG_FLAG_5 (PARM_DECL_CHECK (NODE)) + /* In a FIELD_DECL corresponding to a discriminant, contains the discriminant number. */ #define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE)) diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index 81f621b..d1082ee 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -202,7 +202,6 @@ static void prepend_one_attribute_pragma (struct attrib **, Node_Id); static void prepend_attributes (struct attrib **, Entity_Id); static tree elaborate_expression (Node_Id, Entity_Id, const char *, bool, bool, bool); -static bool type_has_variable_size (tree); static tree elaborate_expression_1 (tree, Entity_Id, const char *, bool, bool); static tree elaborate_expression_2 (tree, Entity_Id, const char *, bool, bool, unsigned int); @@ -233,6 +232,7 @@ static tree build_position_list (tree, bool, tree, tree, unsigned int, tree); static vec<subst_pair> build_subst_list (Entity_Id, Entity_Id, bool); static vec<variant_desc> build_variant_list (tree, vec<subst_pair>, vec<variant_desc>); +static tree maybe_saturate_size (tree); static tree validate_size (Uint, tree, Entity_Id, enum tree_code, bool, bool); static void set_rm_size (Uint, tree, Entity_Id); static unsigned int validate_alignment (Uint, Entity_Id, unsigned int); @@ -447,13 +447,13 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) If we are not defining it, it must be a type or an entity that is defined elsewhere or externally, otherwise we should have defined it already. */ gcc_assert (definition - || type_annotate_only || is_type || kind == E_Discriminant || kind == E_Component || kind == E_Label || (kind == E_Constant && Present (Full_View (gnat_entity))) - || Is_Public (gnat_entity)); + || Is_Public (gnat_entity) + || type_annotate_only); /* Get the name of the entity and set up the line number and filename of the original definition for use in any decl we make. Make sure we do @@ -1758,34 +1758,29 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) case E_Modular_Integer_Type: { - /* For modular types, make the unsigned type of the proper number - of bits and then set up the modulus, if required. */ - tree gnu_modulus, gnu_high = NULL_TREE; - /* Packed Array Impl. Types are supposed to be subtypes only. */ gcc_assert (!Is_Packed_Array_Impl_Type (gnat_entity)); + /* For modular types, make the unsigned type of the proper number + of bits and then set up the modulus, if required. */ gnu_type = make_unsigned_type (esize); - /* Get the modulus in this type. If it overflows, assume it is because - it is equal to 2**Esize. Note that there is no overflow checking - done on unsigned type, so we detect the overflow by looking for - a modulus of zero, which is otherwise invalid. */ - gnu_modulus = UI_To_gnu (Modulus (gnat_entity), gnu_type); + /* Get the modulus in this type. If the modulus overflows, assume + that this is because it was equal to 2**Esize. Note that there + is no overflow checking done on unsigned types, so we detect the + overflow by looking for a modulus of zero, which is invalid. */ + tree gnu_modulus = UI_To_gnu (Modulus (gnat_entity), gnu_type); + /* If the modulus is not 2**Esize, then this also means that the upper + bound of the type, i.e. modulus - 1, is not maximal, so we create an + extra subtype to carry it and set the modulus on the base type. */ if (!integer_zerop (gnu_modulus)) { + TYPE_NAME (gnu_type) = create_concat_name (gnat_entity, "UMT"); TYPE_MODULAR_P (gnu_type) = 1; SET_TYPE_MODULUS (gnu_type, gnu_modulus); - gnu_high = fold_build2 (MINUS_EXPR, gnu_type, gnu_modulus, - build_int_cst (gnu_type, 1)); - } - - /* If the upper bound is not maximal, make an extra subtype. */ - if (gnu_high - && !tree_int_cst_equal (gnu_high, TYPE_MAX_VALUE (gnu_type))) - { - TYPE_NAME (gnu_type) = create_concat_name (gnat_entity, "UMT"); + tree gnu_high = fold_build2 (MINUS_EXPR, gnu_type, gnu_modulus, + build_int_cst (gnu_type, 1)); gnu_type = create_extra_subtype (gnu_type, TYPE_MIN_VALUE (gnu_type), gnu_high); @@ -2958,10 +2953,13 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) : 0; const bool has_align = Known_Alignment (gnat_entity); const bool has_discr = Has_Discriminants (gnat_entity); - const bool has_rep = Has_Specified_Layout (gnat_entity); const bool is_extension = (Is_Tagged_Type (gnat_entity) && Nkind (record_definition) == N_Derived_Type_Definition); + const bool has_rep + = is_extension + ? Has_Record_Rep_Clause (gnat_entity) + : Has_Specified_Layout (gnat_entity); const bool is_unchecked_union = Is_Unchecked_Union (gnat_entity); bool all_rep = has_rep; @@ -2987,8 +2985,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) || Present (Record_Extension_Part (record_definition))) record_definition = Record_Extension_Part (record_definition); - gcc_assert (type_annotate_only - || Present (Parent_Subtype (gnat_entity))); + gcc_assert (Present (Parent_Subtype (gnat_entity)) + || type_annotate_only); } /* Make a node for the record. If we are not defining the record, @@ -4330,9 +4328,10 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) { tree gnu_size = TYPE_SIZE (gnu_type); - /* If the size is self-referential, annotate the maximum value. */ + /* If the size is self-referential, annotate the maximum value + after saturating it, if need be, to avoid a No_Uint value. */ if (CONTAINS_PLACEHOLDER_P (gnu_size)) - gnu_size = max_size (gnu_size, true); + gnu_size = maybe_saturate_size (max_size (gnu_size, true)); /* If we are just annotating types and the type is tagged, the tag and the parent components are not generated by the front-end so @@ -4368,7 +4367,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) gnu_size = size_binop (PLUS_EXPR, gnu_size, offset); } - gnu_size = round_up (gnu_size, align); + gnu_size = maybe_saturate_size (round_up (gnu_size, align)); Set_Esize (gnat_entity, annotate_value (gnu_size)); /* Tagged types are Strict_Alignment so RM_Size = Esize. */ @@ -5211,6 +5210,7 @@ gnat_to_gnu_param (Entity_Id gnat_param, tree gnu_param_type, bool first, bool ro_param = in_param && !Address_Taken (gnat_param); bool by_return = false, by_component_ptr = false; bool by_ref = false; + bool forced_by_ref = false; bool restricted_aliasing_p = false; location_t saved_location = input_location; tree gnu_param; @@ -5238,7 +5238,11 @@ gnat_to_gnu_param (Entity_Id gnat_param, tree gnu_param_type, bool first, /* Or else, see if a Mechanism was supplied that forced this parameter to be passed one way or another. */ else if (mech == Default || mech == By_Copy || mech == By_Reference) - ; + forced_by_ref + = (mech == By_Reference + && !foreign + && !TYPE_IS_BY_REFERENCE_P (gnu_param_type) + && !Is_Aliased (gnat_param)); /* Positive mechanism means by copy for sufficiently small parameters. */ else if (mech > 0) @@ -5371,6 +5375,7 @@ gnat_to_gnu_param (Entity_Id gnat_param, tree gnu_param_type, bool first, gnu_param = create_param_decl (gnu_param_name, gnu_param_type); TREE_READONLY (gnu_param) = ro_param || by_ref || by_component_ptr; DECL_BY_REF_P (gnu_param) = by_ref; + DECL_FORCED_BY_REF_P (gnu_param) = forced_by_ref; DECL_BY_COMPONENT_PTR_P (gnu_param) = by_component_ptr; DECL_POINTS_TO_READONLY_P (gnu_param) = (ro_param && (by_ref || by_component_ptr)); @@ -6870,11 +6875,13 @@ choices_to_gnu (tree gnu_operand, Node_Id gnat_choices) static int adjust_packed (tree field_type, tree record_type, int packed) { - /* If the field contains an item of variable size, we cannot pack it - because we cannot create temporaries of non-fixed size in case - we need to take the address of the field. See addressable_p and - the notes on the addressability issues for further details. */ - if (type_has_variable_size (field_type)) + /* If the field contains an array with self-referential size, we'd better + not pack it because this would misalign it and, therefore, cause large + temporaries to be created in case we need to take the address of the + field. See addressable_p and the notes on the addressability issues + for further details. */ + if (AGGREGATE_TYPE_P (field_type) + && aggregate_type_contains_array_p (field_type, true)) return 0; /* In the other cases, we can honor the packing. */ @@ -7279,31 +7286,6 @@ components_need_strict_alignment (Node_Id component_list) return false; } -/* Return true if TYPE is a type with variable size or a padding type with a - field of variable size or a record that has a field with such a type. */ - -static bool -type_has_variable_size (tree type) -{ - tree field; - - if (!TREE_CONSTANT (TYPE_SIZE (type))) - return true; - - if (TYPE_IS_PADDING_P (type) - && !TREE_CONSTANT (DECL_SIZE (TYPE_FIELDS (type)))) - return true; - - if (!RECORD_OR_UNION_TYPE_P (type)) - return false; - - for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) - if (type_has_variable_size (TREE_TYPE (field))) - return true; - - return false; -} - /* Return true if FIELD is an artificial field. */ static bool @@ -8403,7 +8385,7 @@ annotate_value (tree gnu_size) /* In regular mode, inline back only if symbolic annotation is requested in order to avoid memory explosion on big discriminated record types. But not in ASIS mode, as symbolic annotation is required for DDA. */ - if (List_Representation_Info == 3 || type_annotate_only) + if (List_Representation_Info >= 3 || type_annotate_only) { tree t = maybe_inline_call_in_expr (gnu_size); return t ? annotate_value (t) : No_Uint; @@ -8743,6 +8725,19 @@ build_variant_list (tree qual_union_type, vec<subst_pair> subst_list, return gnu_list; } +/* If SIZE has overflowed, return the maximum valid size, which is the upper + bound of the signed sizetype in bits; otherwise return SIZE unmodified. */ + +static tree +maybe_saturate_size (tree size) +{ + if (TREE_CODE (size) == INTEGER_CST && TREE_OVERFLOW (size)) + size = size_binop (MULT_EXPR, + fold_convert (bitsizetype, TYPE_MAX_VALUE (ssizetype)), + build_int_cst (bitsizetype, BITS_PER_UNIT)); + return size; +} + /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE corresponding to GNAT_OBJECT. If the size is valid, return an INTEGER_CST corresponding to its value. Otherwise, return NULL_TREE. KIND is set to @@ -10157,7 +10152,7 @@ concat_name (tree gnu_name, const char *suffix) return get_identifier_with_length (new_name, len); } -/* Initialize data structures of the decl.c module. */ +/* Initialize the data structures of the decl.c module. */ void init_gnat_decl (void) @@ -10169,7 +10164,7 @@ init_gnat_decl (void) dummy_to_subprog_map = hash_table<dummy_type_hasher>::create_ggc (512); } -/* Destroy data structures of the decl.c module. */ +/* Destroy the data structures of the decl.c module. */ void destroy_gnat_decl (void) diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index f7415c7..edfcbd5 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -6,7 +6,7 @@ * * * C Header File * * * - * Copyright (C) 1992-2018, Free Software Foundation, Inc. * + * Copyright (C) 1992-2019, Free Software Foundation, Inc. * * * * GNAT is free software; you can redistribute it and/or modify it under * * terms of the GNU General Public License as published by the Free Soft- * @@ -835,6 +835,11 @@ extern tree get_base_type (tree type); in bits. If we don't know anything about the alignment, return 0. */ extern unsigned int known_alignment (tree exp); +/* Return true if TYPE, an aggregate type, contains (or is) an array. + If SELF_REFERENTIAL is true, then an additional requirement on the + array is that it be self-referential. */ +extern bool aggregate_type_contains_array_p (tree type, bool self_referential); + /* Return true if VALUE is a multiple of FACTOR. FACTOR must be a power of 2. */ extern bool value_factor_p (tree value, unsigned HOST_WIDE_INT factor); @@ -1054,6 +1059,12 @@ extern void enumerate_modes (void (*f) (const char *, int, int, int, int, int, } #endif +/* Use gigi_checking_assert to test invariants in code generation mode. + It's effective only if the compiler is configured with more checking + than the release mode and can be disabled by means of -fchecking. */ +#define gigi_checking_assert(EXPR) \ + gcc_checking_assert ((EXPR) || type_annotate_only) + /* If EXP's type is a VECTOR_TYPE, return EXP converted to the associated TYPE_REPRESENTATIVE_ARRAY. */ diff --git a/gcc/ada/gcc-interface/misc.c b/gcc/ada/gcc-interface/misc.c index c5822f6..a576b7e 100644 --- a/gcc/ada/gcc-interface/misc.c +++ b/gcc/ada/gcc-interface/misc.c @@ -256,9 +256,9 @@ static bool gnat_post_options (const char **pfilename ATTRIBUTE_UNUSED) { /* Excess precision other than "fast" requires front-end support. */ - if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD) + if (flag_excess_precision == EXCESS_PRECISION_STANDARD) sorry ("%<-fexcess-precision=standard%> for Ada"); - flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; + flag_excess_precision = EXCESS_PRECISION_FAST; /* No psABI change warnings for Ada. */ warn_psabi = 0; diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index 6c696b9..fe02dc4 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -231,14 +231,13 @@ static enum gimplify_status gnat_gimplify_stmt (tree *); static void elaborate_all_entities (Node_Id); static void process_freeze_entity (Node_Id); static void process_decls (List_Id, List_Id, Node_Id, bool, bool); -static tree emit_range_check (tree, Node_Id, Node_Id); static tree emit_check (tree, tree, int, Node_Id); static tree build_unary_op_trapv (enum tree_code, tree, tree, Node_Id); static tree build_binary_op_trapv (enum tree_code, tree, tree, tree, Node_Id); -static tree convert_with_check (Entity_Id, tree, bool, bool, bool, Node_Id); +static tree convert_with_check (Entity_Id, tree, bool, bool, Node_Id); static bool addressable_p (tree, tree); static tree assoc_to_constructor (Entity_Id, Node_Id, tree); -static tree pos_to_constructor (Node_Id, tree, Entity_Id); +static tree pos_to_constructor (Node_Id, tree); static void validate_unchecked_conversion (Node_Id); static Node_Id adjust_for_implicit_deref (Node_Id); static tree maybe_implicit_deref (tree); @@ -874,12 +873,14 @@ lvalue_required_p (Node_Id gnat_node, tree gnu_type, bool constant, if (Prefix (gnat_parent) != gnat_node) return 0; - return lvalue_required_p (gnat_parent, gnu_type, constant, - address_of_constant); + return lvalue_required_p (gnat_parent, + get_unpadded_type (Etype (gnat_parent)), + constant, address_of_constant); case N_Selected_Component: - return lvalue_required_p (gnat_parent, gnu_type, constant, - address_of_constant); + return lvalue_required_p (gnat_parent, + get_unpadded_type (Etype (gnat_parent)), + constant, address_of_constant); case N_Object_Renaming_Declaration: /* We need to preserve addresses through a renaming. */ @@ -2352,6 +2353,9 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute) gnu_type = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (gnu_type))); } + /* The type must be frozen at this point. */ + gcc_assert (COMPLETE_TYPE_P (gnu_type)); + /* If we're looking for the size of a field, return the field size. */ if (TREE_CODE (gnu_prefix) == COMPONENT_REF) gnu_result = DECL_SIZE (TREE_OPERAND (gnu_prefix, 1)); @@ -5253,30 +5257,20 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, /* Do not issue warnings for CONSTRUCTORs since this is not a copy but sort of an instantiation for them. */ - if (TREE_CODE (gnu_name) == CONSTRUCTOR) + if (TREE_CODE (remove_conversions (gnu_name, true)) == CONSTRUCTOR) ; - /* If the type is passed by reference, a copy is not allowed. */ - else if (TYPE_IS_BY_REFERENCE_P (gnu_formal_type)) + /* If the formal is passed by reference, a copy is not allowed. */ + else if (TYPE_IS_BY_REFERENCE_P (gnu_formal_type) + || Is_Aliased (gnat_formal)) post_error ("misaligned actual cannot be passed by reference", gnat_actual); - /* For users of Starlet we issue a warning because the interface - apparently assumes that by-ref parameters outlive the procedure - invocation. The code still will not work as intended, but we - cannot do much better since low-level parts of the back-end - would allocate temporaries at will because of the misalignment - if we did not do so here. */ - else if (Is_Valued_Procedure (Entity (Name (gnat_node)))) - { - post_error - ("?possible violation of implicit assumption", gnat_actual); - post_error_ne - ("?made by pragma Import_Valued_Procedure on &", gnat_actual, - Entity (Name (gnat_node))); - post_error_ne ("?because of misalignment of &", gnat_actual, - gnat_formal); - } + /* If the mechanism was forced to by-ref, a copy is not allowed but + we issue only a warning because this case is not strict Ada. */ + else if (DECL_FORCED_BY_REF_P (gnu_formal)) + post_error ("misaligned actual cannot be passed by reference??", + gnat_actual); /* If the actual type of the object is already the nominal type, we have nothing to do, except if the size is self-referential @@ -5407,11 +5401,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, else gnu_actual = convert (gnu_actual_type, gnu_actual); - /* Make sure that the actual is in range of the formal's type. */ - if (Ekind (gnat_formal) != E_Out_Parameter - && Do_Range_Check (gnat_actual)) - gnu_actual - = emit_range_check (gnu_actual, gnat_formal_type, gnat_actual); + gigi_checking_assert (!Do_Range_Check (gnat_actual)); /* First see if the parameter is passed by reference. */ if (is_true_formal_parm && DECL_BY_REF_P (gnu_formal)) @@ -5655,12 +5645,15 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, conversion node and not from the inner Expression. */ if (Nkind (gnat_actual) == N_Type_Conversion) { + const Node_Id gnat_expr = Expression (gnat_actual); + + gigi_checking_assert (!Do_Range_Check (gnat_expr)); + gnu_result - = convert_with_check - (Etype (Expression (gnat_actual)), gnu_result, - Do_Overflow_Check (gnat_actual), - Do_Range_Check (Expression (gnat_actual)), - Float_Truncate (gnat_actual), gnat_actual); + = convert_with_check (Etype (gnat_expr), gnu_result, + Do_Overflow_Check (gnat_actual), + Float_Truncate (gnat_actual), + gnat_actual); if (!Is_Composite_Type (Underlying_Type (Etype (gnat_formal)))) gnu_actual = convert (TREE_TYPE (gnu_result), gnu_actual); @@ -5676,10 +5669,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, No_Truncation (gnat_actual)); else { - if (Do_Range_Check (gnat_actual)) - gnu_result - = emit_range_check (gnu_result, Etype (gnat_actual), - gnat_actual); + gigi_checking_assert (!Do_Range_Check (gnat_actual)); if (!(!TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (gnu_actual))) && TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (gnu_result))))) @@ -5736,11 +5726,7 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target, Node_Id gnat_parent = Parent (gnat_node); enum tree_code op_code; - /* If range check is needed, emit code to generate it. */ - if (Do_Range_Check (gnat_node)) - gnu_call - = emit_range_check (gnu_call, Etype (Name (gnat_parent)), - gnat_parent); + gigi_checking_assert (!Do_Range_Check (gnat_node)); /* ??? If the return type has variable size, then force the return slot optimization as we would not be able to create a temporary. @@ -7043,10 +7029,9 @@ gnat_to_gnu (Node_Id gnat_node) && (!type_annotate_only || Compile_Time_Known_Value (Expression (gnat_node)))) { + gigi_checking_assert (!Do_Range_Check (Expression (gnat_node))); + gnu_expr = gnat_to_gnu (Expression (gnat_node)); - if (Do_Range_Check (Expression (gnat_node))) - gnu_expr - = emit_range_check (gnu_expr, Etype (gnat_temp), gnat_node); if (type_annotate_only && TREE_CODE (gnu_expr) == ERROR_MARK) gnu_expr = NULL_TREE; @@ -7396,8 +7381,7 @@ gnat_to_gnu (Node_Id gnat_node) gnu_aggr_type); else if (TREE_CODE (gnu_aggr_type) == ARRAY_TYPE) gnu_result = pos_to_constructor (First (Expressions (gnat_node)), - gnu_aggr_type, - Component_Type (Etype (gnat_node))); + gnu_aggr_type); else if (TREE_CODE (gnu_aggr_type) == COMPLEX_TYPE) gnu_result = build_binary_op @@ -7436,10 +7420,11 @@ gnat_to_gnu (Node_Id gnat_node) if (kind == N_Qualified_Expression && Is_Tagged_Type (Etype (gnat_node))) used_types_insert (gnu_result_type); + gigi_checking_assert (!Do_Range_Check (Expression (gnat_node))); + gnu_result = convert_with_check (Etype (gnat_node), gnu_expr, Do_Overflow_Check (gnat_node), - Do_Range_Check (Expression (gnat_node)), kind == N_Type_Conversion && Float_Truncate (gnat_node), gnat_node); break; @@ -7749,10 +7734,9 @@ gnat_to_gnu (Node_Id gnat_node) gnat_temp = Expression (gnat_node); - /* The Expression operand can either be an N_Identifier or - Expanded_Name, which must represent a type, or a - N_Qualified_Expression, which contains both the object type and an - initial value for the object. */ + /* The expression can be either an N_Identifier or an Expanded_Name, + which must represent a type, or a N_Qualified_Expression, which + contains both the type and an initial value for the object. */ if (Nkind (gnat_temp) == N_Identifier || Nkind (gnat_temp) == N_Expanded_Name) gnu_type = gnat_to_gnu_type (Entity (gnat_temp)); @@ -7765,9 +7749,8 @@ gnat_to_gnu (Node_Id gnat_node) gnu_init = gnat_to_gnu (Expression (gnat_temp)); gnu_init = maybe_unconstrained_array (gnu_init); - if (Do_Range_Check (Expression (gnat_temp))) - gnu_init - = emit_range_check (gnu_init, gnat_desig_type, gnat_temp); + + gigi_checking_assert (!Do_Range_Check (Expression (gnat_temp))); if (Is_Elementary_Type (gnat_desig_type) || Is_Constrained (gnat_desig_type)) @@ -7873,10 +7856,7 @@ gnat_to_gnu (Node_Id gnat_node) else gnu_rhs = maybe_unconstrained_array (gnat_to_gnu (gnat_expr)); - /* If range check is needed, emit code to generate it. */ - if (Do_Range_Check (gnat_expr)) - gnu_rhs = emit_range_check (gnu_rhs, Etype (Name (gnat_node)), - gnat_node); + gigi_checking_assert (!Do_Range_Check (gnat_expr)); /* If an outer atomic access is required on the LHS, build the load- modify-store sequence. */ @@ -8737,10 +8717,16 @@ gnat_to_gnu (Node_Id gnat_node) set_gnu_expr_location_from_node (gnu_result, gnat_node); } - /* Set the location information on the result if it's not a simple name. + /* Set the location information on the result if it's not a simple name + or something that contains a simple name, for example a tag, because + we don"t want all the references to get the location of the first use. Note that we may have no result if we tried to build a CALL_EXPR node to a procedure with no side-effects and optimization is enabled. */ - else if (kind != N_Identifier && gnu_result && EXPR_P (gnu_result)) + else if (kind != N_Identifier + && !(kind == N_Selected_Component + && Chars (Selector_Name (gnat_node)) == Name_uTag) + && gnu_result + && EXPR_P (gnu_result)) set_gnu_expr_location_from_node (gnu_result, gnat_node); /* If we're supposed to return something of void_type, it means we have @@ -8804,7 +8790,7 @@ gnat_to_gnu (Node_Id gnat_node) 5. If this is a reference to an unconstrained array which is used as the prefix of an attribute reference that requires an lvalue, return the - result unmodified because we want return the original bounds. + result unmodified because we want to return the original bounds. 6. Finally, if the type of the result is already correct. */ @@ -10086,58 +10072,6 @@ build_binary_op_trapv (enum tree_code code, tree gnu_type, tree left, return emit_check (check, gnu_expr, CE_Overflow_Check_Failed, gnat_node); } -/* Emit code for a range check. GNU_EXPR is the expression to be checked, - GNAT_RANGE_TYPE the gnat type or subtype containing the bounds against - which we have to check. GNAT_NODE is the GNAT node conveying the source - location for which the error should be signaled. */ - -static tree -emit_range_check (tree gnu_expr, Entity_Id gnat_range_type, Node_Id gnat_node) -{ - tree gnu_range_type = get_unpadded_type (gnat_range_type); - tree gnu_compare_type = get_base_type (TREE_TYPE (gnu_expr)); - - /* If GNU_EXPR has GNAT_RANGE_TYPE as its base type, no check is needed. - This can for example happen when translating 'Val or 'Value. */ - if (gnu_compare_type == gnu_range_type) - return gnu_expr; - - /* Range checks can only be applied to types with ranges. */ - gcc_assert (INTEGRAL_TYPE_P (gnu_range_type) - || SCALAR_FLOAT_TYPE_P (gnu_range_type)); - - /* If GNU_EXPR has an integral type that is narrower than GNU_RANGE_TYPE, - we can't do anything since we might be truncating the bounds. No - check is needed in this case. */ - if (INTEGRAL_TYPE_P (TREE_TYPE (gnu_expr)) - && (TYPE_PRECISION (gnu_compare_type) - < TYPE_PRECISION (get_base_type (gnu_range_type)))) - return gnu_expr; - - /* Checked expressions must be evaluated only once. */ - gnu_expr = gnat_protect_expr (gnu_expr); - - /* Note that the form of the check is - (not (expr >= lo)) or (not (expr <= hi)) - the reason for this slightly convoluted form is that NaNs - are not considered to be in range in the float case. */ - return emit_check - (build_binary_op (TRUTH_ORIF_EXPR, boolean_type_node, - invert_truthvalue - (build_binary_op (GE_EXPR, boolean_type_node, - convert (gnu_compare_type, gnu_expr), - convert (gnu_compare_type, - TYPE_MIN_VALUE - (gnu_range_type)))), - invert_truthvalue - (build_binary_op (LE_EXPR, boolean_type_node, - convert (gnu_compare_type, gnu_expr), - convert (gnu_compare_type, - TYPE_MAX_VALUE - (gnu_range_type))))), - gnu_expr, CE_Range_Check_Failed, gnat_node); -} - /* GNU_COND contains the condition corresponding to an index, overflow or range check of value GNU_EXPR. Build a COND_EXPR that returns GNU_EXPR if GNU_COND is false and raises a CONSTRAINT_ERROR if GNU_COND is true. @@ -10169,14 +10103,13 @@ emit_check (tree gnu_cond, tree gnu_expr, int reason, Node_Id gnat_node) } /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing overflow - checks if OVERFLOW_P is true and range checks if RANGE_P is true. - If TRUNCATE_P true, do a float-to-integer conversion with truncation, - otherwise round. GNAT_NODE is the GNAT node conveying the source location - for which the error should be signaled. */ + checks if OVERFLOW_P is true. If TRUNCATE_P is true, do a fp-to-integer + conversion with truncation, otherwise round. GNAT_NODE is the GNAT node + conveying the source location for which the error should be signaled. */ static tree convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p, - bool range_p, bool truncate_p, Node_Id gnat_node) + bool truncate_p, Node_Id gnat_node) { tree gnu_type = get_unpadded_type (gnat_type); tree gnu_base_type = get_base_type (gnu_type); @@ -10187,8 +10120,7 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p, /* If we are not doing any checks, the output is an integral type and the input is not a floating-point type, just do the conversion. This is required for packed array types and is simpler in all cases anyway. */ - if (!range_p - && !overflow_p + if (!overflow_p && INTEGRAL_TYPE_P (gnu_base_type) && !FLOAT_TYPE_P (gnu_in_base_type)) return convert (gnu_type, gnu_expr); @@ -10221,7 +10153,13 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p, tree gnu_in_lb = TYPE_MIN_VALUE (gnu_in_base_type); tree gnu_in_ub = TYPE_MAX_VALUE (gnu_in_base_type); tree gnu_out_lb = TYPE_MIN_VALUE (gnu_base_type); - tree gnu_out_ub = TYPE_MAX_VALUE (gnu_base_type); + tree gnu_out_ub + = (TREE_CODE (gnu_base_type) == INTEGER_TYPE + && TYPE_MODULAR_P (gnu_base_type)) + ? fold_build2 (MINUS_EXPR, gnu_base_type, + TYPE_MODULUS (gnu_base_type), + build_int_cst (gnu_base_type, 1)) + : TYPE_MAX_VALUE (gnu_base_type); /* Convert the lower bounds to signed types, so we're sure we're comparing them properly. Likewise, convert the upper bounds @@ -10346,14 +10284,6 @@ convert_with_check (Entity_Id gnat_type, tree gnu_expr, bool overflow_p, else gnu_result = convert (gnu_base_type, gnu_result); - /* Finally, do the range check if requested. Note that if the result type - is a modular type, the range check is actually an overflow check. */ - if (range_p - || (overflow_p - && TREE_CODE (gnu_base_type) == INTEGER_TYPE - && TYPE_MODULAR_P (gnu_base_type))) - gnu_result = emit_range_check (gnu_result, gnat_type, gnat_node); - return convert (gnu_type, gnu_result); } @@ -10454,6 +10384,7 @@ addressable_p (tree gnu_expr, tree gnu_type) case STRING_CST: case INTEGER_CST: + case REAL_CST: /* Taking the address yields a pointer to the constant pool. */ return true; @@ -10463,6 +10394,7 @@ addressable_p (tree gnu_expr, tree gnu_type) return TREE_STATIC (gnu_expr) ? true : false; case NULL_EXPR: + case ADDR_EXPR: case SAVE_EXPR: case CALL_EXPR: case PLUS_EXPR: @@ -10682,7 +10614,8 @@ assoc_to_constructor (Entity_Id gnat_entity, Node_Id gnat_assoc, tree gnu_type) for (; Present (gnat_assoc); gnat_assoc = Next (gnat_assoc)) { - Node_Id gnat_field = First (Choices (gnat_assoc)); + const Node_Id gnat_field = First (Choices (gnat_assoc)); + const Node_Id gnat_expr = Expression (gnat_assoc); tree gnu_field = gnat_to_gnu_field_decl (Entity (gnat_field)); tree gnu_expr = gnat_to_gnu (Expression (gnat_assoc)); @@ -10702,11 +10635,9 @@ assoc_to_constructor (Entity_Id gnat_entity, Node_Id gnat_assoc, tree gnu_type) && Is_Unchecked_Union (gnat_entity)) continue; - /* Before assigning a value in an aggregate make sure range checks - are done if required. Then convert to the type of the field. */ - if (Do_Range_Check (Expression (gnat_assoc))) - gnu_expr = emit_range_check (gnu_expr, Etype (gnat_field), Empty); + gigi_checking_assert (!Do_Range_Check (gnat_expr)); + /* Convert to the type of the field. */ gnu_expr = convert (TREE_TYPE (gnu_field), gnu_expr); /* Add the field and expression to the list. */ @@ -10727,13 +10658,10 @@ assoc_to_constructor (Entity_Id gnat_entity, Node_Id gnat_assoc, tree gnu_type) /* Build a possibly nested constructor for array aggregates. GNAT_EXPR is the first element of an array aggregate. It may itself be an aggregate. - GNU_ARRAY_TYPE is the GCC type corresponding to the array aggregate. - GNAT_COMPONENT_TYPE is the type of the array component; it is needed - for range checking. */ + GNU_ARRAY_TYPE is the GCC type corresponding to the array aggregate. */ static tree -pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type, - Entity_Id gnat_component_type) +pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type) { tree gnu_index = TYPE_MIN_VALUE (TYPE_DOMAIN (gnu_array_type)); vec<constructor_elt, va_gc> *gnu_expr_vec = NULL; @@ -10749,8 +10677,7 @@ pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type, && TREE_CODE (TREE_TYPE (gnu_array_type)) == ARRAY_TYPE && TYPE_MULTI_ARRAY_P (TREE_TYPE (gnu_array_type))) gnu_expr = pos_to_constructor (First (Expressions (gnat_expr)), - TREE_TYPE (gnu_array_type), - gnat_component_type); + TREE_TYPE (gnu_array_type)); else { /* If the expression is a conversion to an unconstrained array type, @@ -10762,10 +10689,7 @@ pos_to_constructor (Node_Id gnat_expr, tree gnu_array_type, else gnu_expr = gnat_to_gnu (gnat_expr); - /* Before assigning the element to the array, make sure it is - in range. */ - if (Do_Range_Check (gnat_expr)) - gnu_expr = emit_range_check (gnu_expr, gnat_component_type, Empty); + gigi_checking_assert (!Do_Range_Check (gnat_expr)); } CONSTRUCTOR_APPEND_ELT (gnu_expr_vec, gnu_index, diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index c6942fe..8a38b34 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -1948,7 +1948,7 @@ finish_record_type (tree record_type, tree field_list, int rep_level, if (DECL_BIT_FIELD (field) && operand_equal_p (this_size, TYPE_SIZE (type), 0)) { - unsigned int align = TYPE_ALIGN (type); + const unsigned int align = TYPE_ALIGN (type); /* In the general case, type alignment is required. */ if (value_factor_p (pos, align)) @@ -2764,10 +2764,12 @@ create_var_decl (tree name, tree asm_name, tree type, tree init, return var_decl; } -/* Return true if TYPE, an aggregate type, contains (or is) an array. */ +/* Return true if TYPE, an aggregate type, contains (or is) an array. + If SELF_REFERENTIAL is true, then an additional requirement on the + array is that it be self-referential. */ -static bool -aggregate_type_contains_array_p (tree type) +bool +aggregate_type_contains_array_p (tree type, bool self_referential) { switch (TREE_CODE (type)) { @@ -2778,13 +2780,14 @@ aggregate_type_contains_array_p (tree type) tree field; for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) if (AGGREGATE_TYPE_P (TREE_TYPE (field)) - && aggregate_type_contains_array_p (TREE_TYPE (field))) + && aggregate_type_contains_array_p (TREE_TYPE (field), + self_referential)) return true; return false; } case ARRAY_TYPE: - return true; + return self_referential ? type_contains_placeholder_p (type) : true; default: gcc_unreachable (); @@ -2808,18 +2811,6 @@ create_field_decl (tree name, tree type, tree record_type, tree size, tree pos, DECL_CONTEXT (field_decl) = record_type; TREE_READONLY (field_decl) = TYPE_READONLY (type); - /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a - byte boundary since GCC cannot handle less-aligned BLKmode bitfields. - Likewise for an aggregate without specified position that contains an - array, because in this case slices of variable length of this array - must be handled by GCC and variable-sized objects need to be aligned - to at least a byte boundary. */ - if (packed && (TYPE_MODE (type) == BLKmode - || (!pos - && AGGREGATE_TYPE_P (type) - && aggregate_type_contains_array_p (type)))) - SET_DECL_ALIGN (field_decl, BITS_PER_UNIT); - /* If a size is specified, use it. Otherwise, if the record type is packed compute a size to use, which may differ from the object's natural size. We always set a size in this case to trigger the checks for bitfield @@ -2872,23 +2863,39 @@ create_field_decl (tree name, tree type, tree record_type, tree size, tree pos, DECL_PACKED (field_decl) = pos ? DECL_BIT_FIELD (field_decl) : packed; + /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a + byte boundary since GCC cannot handle less-aligned BLKmode bitfields. + Likewise for an aggregate without specified position that contains an + array, because in this case slices of variable length of this array + must be handled by GCC and variable-sized objects need to be aligned + to at least a byte boundary. */ + if (packed && (TYPE_MODE (type) == BLKmode + || (!pos + && AGGREGATE_TYPE_P (type) + && aggregate_type_contains_array_p (type, false)))) + SET_DECL_ALIGN (field_decl, BITS_PER_UNIT); + /* Bump the alignment if need be, either for bitfield/packing purposes or - to satisfy the type requirements if no such consideration applies. When + to satisfy the type requirements if no such considerations apply. When we get the alignment from the type, indicate if this is from an explicit user request, which prevents stor-layout from lowering it later on. */ - { - unsigned int bit_align - = (DECL_BIT_FIELD (field_decl) ? 1 - : packed && TYPE_MODE (type) != BLKmode ? BITS_PER_UNIT : 0); + else + { + const unsigned int field_align + = DECL_BIT_FIELD (field_decl) + ? 1 + : packed + ? BITS_PER_UNIT + : 0; - if (bit_align > DECL_ALIGN (field_decl)) - SET_DECL_ALIGN (field_decl, bit_align); - else if (!bit_align && TYPE_ALIGN (type) > DECL_ALIGN (field_decl)) - { - SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type)); - DECL_USER_ALIGN (field_decl) = TYPE_USER_ALIGN (type); - } - } + if (field_align > DECL_ALIGN (field_decl)) + SET_DECL_ALIGN (field_decl, field_align); + else if (!field_align && TYPE_ALIGN (type) > DECL_ALIGN (field_decl)) + { + SET_DECL_ALIGN (field_decl, TYPE_ALIGN (type)); + DECL_USER_ALIGN (field_decl) = TYPE_USER_ALIGN (type); + } + } if (pos) { @@ -3953,27 +3960,30 @@ build_template (tree template_type, tree array_type, tree expr) && TYPE_HAS_ACTUAL_BOUNDS_P (array_type))) bound_list = TYPE_ACTUAL_BOUNDS (array_type); - /* First make the list for a CONSTRUCTOR for the template. Go down the - field list of the template instead of the type chain because this - array might be an Ada array of arrays and we can't tell where the - nested arrays stop being the underlying object. */ - - for (field = TYPE_FIELDS (template_type); field; - (bound_list - ? (bound_list = TREE_CHAIN (bound_list)) - : (array_type = TREE_TYPE (array_type))), + /* First make the list for a CONSTRUCTOR for the template. Go down + the field list of the template instead of the type chain because + this array might be an Ada array of array and we can't tell where + the nested array stop being the underlying object. */ + for (field = TYPE_FIELDS (template_type); + field; field = DECL_CHAIN (DECL_CHAIN (field))) { tree bounds, min, max; /* If we have a bound list, get the bounds from there. Likewise for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with - DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template. - This will give us a maximum range. */ + DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the + template, but this will only give us a maximum range. */ if (bound_list) - bounds = TREE_VALUE (bound_list); + { + bounds = TREE_VALUE (bound_list); + bound_list = TREE_CHAIN (bound_list); + } else if (TREE_CODE (array_type) == ARRAY_TYPE) - bounds = TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type)); + { + bounds = TYPE_INDEX_TYPE (TYPE_DOMAIN (array_type)); + array_type = TREE_TYPE (array_type); + } else if (expr && TREE_CODE (expr) == PARM_DECL && DECL_BY_COMPONENT_PTR_P (expr)) bounds = TREE_TYPE (field); diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi index d5aa396..1f5616f 100644 --- a/gcc/ada/gnat_rm.texi +++ b/gcc/ada/gnat_rm.texi @@ -21,7 +21,7 @@ @copying @quotation -GNAT Reference Manual , Aug 01, 2019 +GNAT Reference Manual , Sep 14, 2019 AdaCore @@ -214,7 +214,6 @@ Implementation Defined Pragmas * Pragma No_Heap_Finalization:: * Pragma No_Inline:: * Pragma No_Return:: -* Pragma No_Run_Time:: * Pragma No_Strict_Aliasing:: * Pragma No_Tagged_Streams:: * Pragma Normalize_Scalars:: @@ -1292,7 +1291,6 @@ consideration, the use of these pragmas should be minimized. * Pragma No_Heap_Finalization:: * Pragma No_Inline:: * Pragma No_Return:: -* Pragma No_Run_Time:: * Pragma No_Strict_Aliasing:: * Pragma No_Tagged_Streams:: * Pragma Normalize_Scalars:: @@ -4716,7 +4714,7 @@ Ada exceptions, or used to implement run-time functions such as the Pragma @code{Interrupt_State} provides a general mechanism for overriding such uses of interrupts. It subsumes the functionality of pragma @code{Unreserve_All_Interrupts}. Pragma @code{Interrupt_State} is not -available on Windows or VMS. On all other platforms than VxWorks, +available on Windows. On all other platforms than VxWorks, it applies to signals; on VxWorks, it applies to vectored hardware interrupts and may be used to mark interrupts required by the board support package as reserved. @@ -5524,7 +5522,7 @@ in particular it is not subject to the use of option @emph{-gnatn} or @emph{-gnatN}. It is illegal to specify both pragma @code{No_Inline} and pragma @code{Inline_Always} for the same @code{NAME}. -@node Pragma No_Return,Pragma No_Run_Time,Pragma No_Inline,Implementation Defined Pragmas +@node Pragma No_Return,Pragma No_Strict_Aliasing,Pragma No_Inline,Implementation Defined Pragmas @anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{aa} @section Pragma No_Return @@ -5551,24 +5549,8 @@ Note that in Ada 2005 mode, this pragma is part of the language. It is available in all earlier versions of Ada as an implementation-defined pragma. -@node Pragma No_Run_Time,Pragma No_Strict_Aliasing,Pragma No_Return,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-no-run-time}@anchor{ab} -@section Pragma No_Run_Time - - -Syntax: - -@example -pragma No_Run_Time; -@end example - -This is an obsolete configuration pragma that historically was used to -set up a runtime library with no object code. It is now used only for -internal testing. The pragma has been superseded by the reconfigurable -runtime capability of GNAT. - -@node Pragma No_Strict_Aliasing,Pragma No_Tagged_Streams,Pragma No_Run_Time,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{ac} +@node Pragma No_Strict_Aliasing,Pragma No_Tagged_Streams,Pragma No_Return,Implementation Defined Pragmas +@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{ab} @section Pragma No_Strict_Aliasing @@ -5590,7 +5572,7 @@ in the @cite{GNAT User's Guide}. This pragma currently has no effects on access to unconstrained array types. @node Pragma No_Tagged_Streams,Pragma Normalize_Scalars,Pragma No_Strict_Aliasing,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{ad}@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{ae} +@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{ac}@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{ad} @section Pragma No_Tagged_Streams @@ -5629,7 +5611,7 @@ with empty strings. This is useful to avoid exposing entity names at binary level but has a negative impact on the debuggability of tagged types. @node Pragma Normalize_Scalars,Pragma Obsolescent,Pragma No_Tagged_Streams,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{af} +@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{ae} @section Pragma Normalize_Scalars @@ -5711,7 +5693,7 @@ will always generate an invalid value if one exists. @end table @node Pragma Obsolescent,Pragma Optimize_Alignment,Pragma Normalize_Scalars,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{b0}@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{b1} +@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{af}@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{b0} @section Pragma Obsolescent @@ -5807,7 +5789,7 @@ So if you specify @code{Entity =>} for the @code{Entity} argument, and a @code{M argument is present, it must be preceded by @code{Message =>}. @node Pragma Optimize_Alignment,Pragma Ordered,Pragma Obsolescent,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b2} +@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b1} @section Pragma Optimize_Alignment @@ -5893,7 +5875,7 @@ latter are compiled by default in pragma Optimize_Alignment (Off) mode if no pragma appears at the start of the file. @node Pragma Ordered,Pragma Overflow_Mode,Pragma Optimize_Alignment,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b3} +@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b2} @section Pragma Ordered @@ -5985,7 +5967,7 @@ For additional information please refer to the description of the @emph{-gnatw.u} switch in the GNAT User's Guide. @node Pragma Overflow_Mode,Pragma Overriding_Renamings,Pragma Ordered,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{b4} +@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{b3} @section Pragma Overflow_Mode @@ -6024,7 +6006,7 @@ The pragma @code{Unsuppress (Overflow_Check)} unsuppresses (enables) overflow checking, but does not affect the overflow mode. @node Pragma Overriding_Renamings,Pragma Partition_Elaboration_Policy,Pragma Overflow_Mode,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{b5} +@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{b4} @section Pragma Overriding_Renamings @@ -6059,7 +6041,7 @@ RM 8.3 (15) stipulates that an overridden operation is not visible within the declaration of the overriding operation. @node Pragma Partition_Elaboration_Policy,Pragma Part_Of,Pragma Overriding_Renamings,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{b6} +@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{b5} @section Pragma Partition_Elaboration_Policy @@ -6076,7 +6058,7 @@ versions of Ada as an implementation-defined pragma. See Ada 2012 Reference Manual for details. @node Pragma Part_Of,Pragma Passive,Pragma Partition_Elaboration_Policy,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{b7}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b8} +@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{b6}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b7} @section Pragma Part_Of @@ -6092,7 +6074,7 @@ For the semantics of this pragma, see the entry for aspect @code{Part_Of} in the SPARK 2014 Reference Manual, section 7.2.6. @node Pragma Passive,Pragma Persistent_BSS,Pragma Part_Of,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{b9} +@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{b8} @section Pragma Passive @@ -6116,7 +6098,7 @@ For more information on the subject of passive tasks, see the section 'Passive Task Optimization' in the GNAT Users Guide. @node Pragma Persistent_BSS,Pragma Polling,Pragma Passive,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{ba}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{bb} +@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b9}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{ba} @section Pragma Persistent_BSS @@ -6147,7 +6129,7 @@ If this pragma is used on a target where this feature is not supported, then the pragma will be ignored. See also @code{pragma Linker_Section}. @node Pragma Polling,Pragma Post,Pragma Persistent_BSS,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-polling}@anchor{bc} +@anchor{gnat_rm/implementation_defined_pragmas pragma-polling}@anchor{bb} @section Pragma Polling @@ -6189,7 +6171,7 @@ Note that polling can also be enabled by use of the @emph{-gnatP} switch. See the section on switches for gcc in the @cite{GNAT User's Guide}. @node Pragma Post,Pragma Postcondition,Pragma Polling,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{bd} +@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{bc} @section Pragma Post @@ -6214,7 +6196,7 @@ appear at the start of the declarations in a subprogram body (preceded only by other pragmas). @node Pragma Postcondition,Pragma Post_Class,Pragma Post,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{be} +@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{bd} @section Pragma Postcondition @@ -6379,7 +6361,7 @@ Ada 2012, and has been retained in its original form for compatibility purposes. @node Pragma Post_Class,Pragma Rename_Pragma,Pragma Postcondition,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{bf} +@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{be} @section Pragma Post_Class @@ -6414,7 +6396,7 @@ policy that controls this pragma is @code{Post'Class}, not @code{Post_Class}. @node Pragma Rename_Pragma,Pragma Pre,Pragma Post_Class,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{c0} +@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{bf} @section Pragma Rename_Pragma @@ -6453,7 +6435,7 @@ Pragma Inline_Only will not necessarily mean the same thing as the other Ada compiler; it's up to you to make sure the semantics are close enough. @node Pragma Pre,Pragma Precondition,Pragma Rename_Pragma,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{c1} +@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{c0} @section Pragma Pre @@ -6478,7 +6460,7 @@ appear at the start of the declarations in a subprogram body (preceded only by other pragmas). @node Pragma Precondition,Pragma Predicate,Pragma Pre,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{c2} +@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{c1} @section Pragma Precondition @@ -6537,7 +6519,7 @@ Ada 2012, and has been retained in its original form for compatibility purposes. @node Pragma Predicate,Pragma Predicate_Failure,Pragma Precondition,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c3}@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{c4} +@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c2}@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{c3} @section Pragma Predicate @@ -6591,7 +6573,7 @@ defined for subtype B). When following this approach, the use of predicates should be avoided. @node Pragma Predicate_Failure,Pragma Preelaborable_Initialization,Pragma Predicate,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c5} +@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c4} @section Pragma Predicate_Failure @@ -6608,7 +6590,7 @@ the language-defined @code{Predicate_Failure} aspect, and shares its restrictions and semantics. @node Pragma Preelaborable_Initialization,Pragma Prefix_Exception_Messages,Pragma Predicate_Failure,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{c6} +@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{c5} @section Pragma Preelaborable_Initialization @@ -6623,7 +6605,7 @@ versions of Ada as an implementation-defined pragma. See Ada 2012 Reference Manual for details. @node Pragma Prefix_Exception_Messages,Pragma Pre_Class,Pragma Preelaborable_Initialization,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{c7} +@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{c6} @section Pragma Prefix_Exception_Messages @@ -6654,7 +6636,7 @@ prefixing in this case, you can always call @code{GNAT.Source_Info.Enclosing_Entity} and prepend the string manually. @node Pragma Pre_Class,Pragma Priority_Specific_Dispatching,Pragma Prefix_Exception_Messages,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{c8} +@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{c7} @section Pragma Pre_Class @@ -6689,7 +6671,7 @@ policy that controls this pragma is @code{Pre'Class}, not @code{Pre_Class}. @node Pragma Priority_Specific_Dispatching,Pragma Profile,Pragma Pre_Class,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{c9} +@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{c8} @section Pragma Priority_Specific_Dispatching @@ -6713,7 +6695,7 @@ versions of Ada as an implementation-defined pragma. See Ada 2012 Reference Manual for details. @node Pragma Profile,Pragma Profile_Warnings,Pragma Priority_Specific_Dispatching,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{ca} +@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{c9} @section Pragma Profile @@ -6987,7 +6969,7 @@ conforming Ada constructs. The profile enables the following three pragmas: @end itemize @node Pragma Profile_Warnings,Pragma Propagate_Exceptions,Pragma Profile,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{cb} +@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{ca} @section Pragma Profile_Warnings @@ -7005,7 +6987,7 @@ violations of the profile generate warning messages instead of error messages. @node Pragma Propagate_Exceptions,Pragma Provide_Shift_Operators,Pragma Profile_Warnings,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{cc} +@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{cb} @section Pragma Propagate_Exceptions @@ -7024,7 +7006,7 @@ purposes. It used to be used in connection with optimization of a now-obsolete mechanism for implementation of exceptions. @node Pragma Provide_Shift_Operators,Pragma Psect_Object,Pragma Propagate_Exceptions,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{cd} +@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{cc} @section Pragma Provide_Shift_Operators @@ -7044,7 +7026,7 @@ including the function declarations for these five operators, together with the pragma Import (Intrinsic, ...) statements. @node Pragma Psect_Object,Pragma Pure_Function,Pragma Provide_Shift_Operators,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{ce} +@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{cd} @section Pragma Psect_Object @@ -7064,7 +7046,7 @@ EXTERNAL_SYMBOL ::= This pragma is identical in effect to pragma @code{Common_Object}. @node Pragma Pure_Function,Pragma Rational,Pragma Psect_Object,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{d0} +@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{ce}@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{cf} @section Pragma Pure_Function @@ -7126,7 +7108,7 @@ unit is not a Pure unit in the categorization sense. So for example, a function thus marked is free to @code{with} non-pure units. @node Pragma Rational,Pragma Ravenscar,Pragma Pure_Function,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{d1} +@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{d0} @section Pragma Rational @@ -7144,7 +7126,7 @@ pragma Profile (Rational); @end example @node Pragma Ravenscar,Pragma Refined_Depends,Pragma Rational,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{d2} +@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{d1} @section Pragma Ravenscar @@ -7164,7 +7146,7 @@ pragma Profile (Ravenscar); which is the preferred method of setting the @code{Ravenscar} profile. @node Pragma Refined_Depends,Pragma Refined_Global,Pragma Ravenscar,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{d4} +@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d2}@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{d3} @section Pragma Refined_Depends @@ -7197,7 +7179,7 @@ For the semantics of this pragma, see the entry for aspect @code{Refined_Depends the SPARK 2014 Reference Manual, section 6.1.5. @node Pragma Refined_Global,Pragma Refined_Post,Pragma Refined_Depends,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{d6} +@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d4}@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{d5} @section Pragma Refined_Global @@ -7222,7 +7204,7 @@ For the semantics of this pragma, see the entry for aspect @code{Refined_Global} the SPARK 2014 Reference Manual, section 6.1.4. @node Pragma Refined_Post,Pragma Refined_State,Pragma Refined_Global,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d7}@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d8} +@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d6}@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d7} @section Pragma Refined_Post @@ -7236,7 +7218,7 @@ For the semantics of this pragma, see the entry for aspect @code{Refined_Post} i the SPARK 2014 Reference Manual, section 7.2.7. @node Pragma Refined_State,Pragma Relative_Deadline,Pragma Refined_Post,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d9}@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{da} +@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d8}@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d9} @section Pragma Refined_State @@ -7262,7 +7244,7 @@ For the semantics of this pragma, see the entry for aspect @code{Refined_State} the SPARK 2014 Reference Manual, section 7.2.2. @node Pragma Relative_Deadline,Pragma Remote_Access_Type,Pragma Refined_State,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{db} +@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{da} @section Pragma Relative_Deadline @@ -7277,7 +7259,7 @@ versions of Ada as an implementation-defined pragma. See Ada 2012 Reference Manual for details. @node Pragma Remote_Access_Type,Pragma Restricted_Run_Time,Pragma Relative_Deadline,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{dc}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{dd} +@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{db}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{dc} @section Pragma Remote_Access_Type @@ -7303,7 +7285,7 @@ pertaining to remote access to class-wide types. At instantiation, the actual type must be a remote access to class-wide type. @node Pragma Restricted_Run_Time,Pragma Restriction_Warnings,Pragma Remote_Access_Type,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{de} +@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{dd} @section Pragma Restricted_Run_Time @@ -7324,7 +7306,7 @@ which is the preferred method of setting the restricted run time profile. @node Pragma Restriction_Warnings,Pragma Reviewable,Pragma Restricted_Run_Time,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{df} +@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{de} @section Pragma Restriction_Warnings @@ -7362,7 +7344,7 @@ generating a warning, but any other use of implementation defined pragmas will cause a warning to be generated. @node Pragma Reviewable,Pragma Secondary_Stack_Size,Pragma Restriction_Warnings,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{e0} +@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{df} @section Pragma Reviewable @@ -7466,7 +7448,7 @@ comprehensive messages identifying possible problems based on this information. @node Pragma Secondary_Stack_Size,Pragma Share_Generic,Pragma Reviewable,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{e1}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{e2} +@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{e0}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{e1} @section Pragma Secondary_Stack_Size @@ -7502,7 +7484,7 @@ Note the pragma cannot appear when the restriction @code{No_Secondary_Stack} is in effect. @node Pragma Share_Generic,Pragma Shared,Pragma Secondary_Stack_Size,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{e3} +@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{e2} @section Pragma Share_Generic @@ -7520,7 +7502,7 @@ than to check that the given names are all names of generic units or generic instances. @node Pragma Shared,Pragma Short_Circuit_And_Or,Pragma Share_Generic,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{e4}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{e5} +@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{e3}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{e4} @section Pragma Shared @@ -7528,7 +7510,7 @@ This pragma is provided for compatibility with Ada 83. The syntax and semantics are identical to pragma Atomic. @node Pragma Short_Circuit_And_Or,Pragma Short_Descriptors,Pragma Shared,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{e6} +@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{e5} @section Pragma Short_Circuit_And_Or @@ -7547,7 +7529,7 @@ within the file being compiled, it applies only to the file being compiled. There is no requirement that all units in a partition use this option. @node Pragma Short_Descriptors,Pragma Simple_Storage_Pool_Type,Pragma Short_Circuit_And_Or,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e7} +@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e6} @section Pragma Short_Descriptors @@ -7561,7 +7543,7 @@ This pragma is provided for compatibility with other Ada implementations. It is recognized but ignored by all current versions of GNAT. @node Pragma Simple_Storage_Pool_Type,Pragma Source_File_Name,Pragma Short_Descriptors,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e8}@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e9} +@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e7}@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e8} @section Pragma Simple_Storage_Pool_Type @@ -7615,7 +7597,7 @@ storage-management discipline). An object of a simple storage pool type can be associated with an access type by specifying the attribute -@ref{ea,,Simple_Storage_Pool}. For example: +@ref{e9,,Simple_Storage_Pool}. For example: @example My_Pool : My_Simple_Storage_Pool_Type; @@ -7625,11 +7607,11 @@ type Acc is access My_Data_Type; for Acc'Simple_Storage_Pool use My_Pool; @end example -See attribute @ref{ea,,Simple_Storage_Pool} +See attribute @ref{e9,,Simple_Storage_Pool} for further details. @node Pragma Source_File_Name,Pragma Source_File_Name_Project,Pragma Simple_Storage_Pool_Type,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{eb}@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{ec} +@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{eb} @section Pragma Source_File_Name @@ -7721,19 +7703,19 @@ aware of these pragmas, and so other tools that use the projet file would not be aware of the intended naming conventions. If you are using project files, file naming is controlled by Source_File_Name_Project pragmas, which are usually supplied automatically by the project manager. A pragma -Source_File_Name cannot appear after a @ref{ed,,Pragma Source_File_Name_Project}. +Source_File_Name cannot appear after a @ref{ec,,Pragma Source_File_Name_Project}. For more details on the use of the @code{Source_File_Name} pragma, see the sections on @code{Using Other File Names} and @cite{Alternative File Naming Schemes' in the :title:`GNAT User's Guide}. @node Pragma Source_File_Name_Project,Pragma Source_Reference,Pragma Source_File_Name,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{ed}@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{ee} +@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{ec}@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{ed} @section Pragma Source_File_Name_Project This pragma has the same syntax and semantics as pragma Source_File_Name. It is only allowed as a stand-alone configuration pragma. -It cannot appear after a @ref{eb,,Pragma Source_File_Name}, and +It cannot appear after a @ref{ea,,Pragma Source_File_Name}, and most importantly, once pragma Source_File_Name_Project appears, no further Source_File_Name pragmas are allowed. @@ -7745,7 +7727,7 @@ Source_File_Name or Source_File_Name_Project pragmas (which would not be known to the project manager). @node Pragma Source_Reference,Pragma SPARK_Mode,Pragma Source_File_Name_Project,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{ef} +@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{ee} @section Pragma Source_Reference @@ -7769,7 +7751,7 @@ string expression other than a string literal. This is because its value is needed for error messages issued by all phases of the compiler. @node Pragma SPARK_Mode,Pragma Static_Elaboration_Desired,Pragma Source_Reference,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{f0}@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{f1} +@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{ef}@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{f0} @section Pragma SPARK_Mode @@ -7851,7 +7833,7 @@ SPARK_Mode (@code{Off}), then that pragma will need to be repeated in the package body. @node Pragma Static_Elaboration_Desired,Pragma Stream_Convert,Pragma SPARK_Mode,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{f2} +@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{f1} @section Pragma Static_Elaboration_Desired @@ -7875,7 +7857,7 @@ construction of larger aggregates with static components that include an others choice.) @node Pragma Stream_Convert,Pragma Style_Checks,Pragma Static_Elaboration_Desired,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{f3} +@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{f2} @section Pragma Stream_Convert @@ -7952,7 +7934,7 @@ the pragma is silently ignored, and the default implementation of the stream attributes is used instead. @node Pragma Style_Checks,Pragma Subtitle,Pragma Stream_Convert,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{f4} +@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{f3} @section Pragma Style_Checks @@ -8025,7 +8007,7 @@ Rf2 : Integer := ARG; -- OK, no error @end example @node Pragma Subtitle,Pragma Suppress,Pragma Style_Checks,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{f5} +@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{f4} @section Pragma Subtitle @@ -8039,7 +8021,7 @@ This pragma is recognized for compatibility with other Ada compilers but is ignored by GNAT. @node Pragma Suppress,Pragma Suppress_All,Pragma Subtitle,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{f6} +@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{f5} @section Pragma Suppress @@ -8112,7 +8094,7 @@ Of course, run-time checks are omitted whenever the compiler can prove that they will not fail, whether or not checks are suppressed. @node Pragma Suppress_All,Pragma Suppress_Debug_Info,Pragma Suppress,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{f7} +@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{f6} @section Pragma Suppress_All @@ -8131,7 +8113,7 @@ The use of the standard Ada pragma @code{Suppress (All_Checks)} as a normal configuration pragma is the preferred usage in GNAT. @node Pragma Suppress_Debug_Info,Pragma Suppress_Exception_Locations,Pragma Suppress_All,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f8}@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{f9} +@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f7}@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{f8} @section Pragma Suppress_Debug_Info @@ -8146,7 +8128,7 @@ for the specified entity. It is intended primarily for use in debugging the debugger, and navigating around debugger problems. @node Pragma Suppress_Exception_Locations,Pragma Suppress_Initialization,Pragma Suppress_Debug_Info,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{fa} +@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{f9} @section Pragma Suppress_Exception_Locations @@ -8169,7 +8151,7 @@ a partition, so it is fine to have some units within a partition compiled with this pragma and others compiled in normal mode without it. @node Pragma Suppress_Initialization,Pragma Task_Name,Pragma Suppress_Exception_Locations,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{fb}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{fc} +@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{fa}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{fb} @section Pragma Suppress_Initialization @@ -8214,7 +8196,7 @@ is suppressed, just as though its subtype had been given in a pragma Suppress_Initialization, as described above. @node Pragma Task_Name,Pragma Task_Storage,Pragma Suppress_Initialization,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{fd} +@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{fc} @section Pragma Task_Name @@ -8270,7 +8252,7 @@ end; @end example @node Pragma Task_Storage,Pragma Test_Case,Pragma Task_Name,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{fe} +@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{fd} @section Pragma Task_Storage @@ -8290,7 +8272,7 @@ created, depending on the target. This pragma can appear anywhere a type. @node Pragma Test_Case,Pragma Thread_Local_Storage,Pragma Task_Storage,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{ff}@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{100} +@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{fe}@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{ff} @section Pragma Test_Case @@ -8346,7 +8328,7 @@ postcondition. Mode @code{Robustness} indicates that the precondition and postcondition of the subprogram should be ignored for this test case. @node Pragma Thread_Local_Storage,Pragma Time_Slice,Pragma Test_Case,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{101}@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{102} +@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{100}@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{101} @section Pragma Thread_Local_Storage @@ -8384,7 +8366,7 @@ If this pragma is used on a system where @code{TLS} is not supported, then an error message will be generated and the program will be rejected. @node Pragma Time_Slice,Pragma Title,Pragma Thread_Local_Storage,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{103} +@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{102} @section Pragma Time_Slice @@ -8400,7 +8382,7 @@ It is ignored if it is used in a system that does not allow this control, or if it appears in other than the main program unit. @node Pragma Title,Pragma Type_Invariant,Pragma Time_Slice,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{104} +@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{103} @section Pragma Title @@ -8425,7 +8407,7 @@ notation is used, and named and positional notation can be mixed following the normal rules for procedure calls in Ada. @node Pragma Type_Invariant,Pragma Type_Invariant_Class,Pragma Title,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{105} +@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{104} @section Pragma Type_Invariant @@ -8446,7 +8428,7 @@ controlled by the assertion identifier @code{Type_Invariant} rather than @code{Invariant}. @node Pragma Type_Invariant_Class,Pragma Unchecked_Union,Pragma Type_Invariant,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{106}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{107} +@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{106} @section Pragma Type_Invariant_Class @@ -8473,7 +8455,7 @@ policy that controls this pragma is @code{Type_Invariant'Class}, not @code{Type_Invariant_Class}. @node Pragma Unchecked_Union,Pragma Unevaluated_Use_Of_Old,Pragma Type_Invariant_Class,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{108} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{107} @section Pragma Unchecked_Union @@ -8493,7 +8475,7 @@ version in all language modes (Ada 83, Ada 95, and Ada 2005). For full details, consult the Ada 2012 Reference Manual, section B.3.3. @node Pragma Unevaluated_Use_Of_Old,Pragma Unimplemented_Unit,Pragma Unchecked_Union,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{109} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{108} @section Pragma Unevaluated_Use_Of_Old @@ -8548,7 +8530,7 @@ uses up to the end of the corresponding statement sequence or sequence of package declarations. @node Pragma Unimplemented_Unit,Pragma Universal_Aliasing,Pragma Unevaluated_Use_Of_Old,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{10a} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{109} @section Pragma Unimplemented_Unit @@ -8568,7 +8550,7 @@ The abort only happens if code is being generated. Thus you can use specs of unimplemented packages in syntax or semantic checking mode. @node Pragma Universal_Aliasing,Pragma Universal_Data,Pragma Unimplemented_Unit,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{10c} +@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{10a}@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{10b} @section Pragma Universal_Aliasing @@ -8587,7 +8569,7 @@ situations in which it must be suppressed, see the section on @code{Optimization and Strict Aliasing} in the @cite{GNAT User's Guide}. @node Pragma Universal_Data,Pragma Unmodified,Pragma Universal_Aliasing,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-data}@anchor{10d}@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{10e} +@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-data}@anchor{10c}@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{10d} @section Pragma Universal_Data @@ -8611,7 +8593,7 @@ of this pragma is also available by applying the -univ switch on the compilations of units where universal addressing of the data is desired. @node Pragma Unmodified,Pragma Unreferenced,Pragma Universal_Data,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{10f}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{110} +@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{10e}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{10f} @section Pragma Unmodified @@ -8645,7 +8627,7 @@ Thus it is never necessary to use @code{pragma Unmodified} for such variables, though it is harmless to do so. @node Pragma Unreferenced,Pragma Unreferenced_Objects,Pragma Unmodified,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{111}@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{112} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{110}@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{111} @section Pragma Unreferenced @@ -8689,7 +8671,7 @@ Note that if a warning is desired for all calls to a given subprogram, regardless of whether they occur in the same unit as the subprogram declaration, then this pragma should not be used (calls from another unit would not be flagged); pragma Obsolescent can be used instead -for this purpose, see @ref{b0,,Pragma Obsolescent}. +for this purpose, see @ref{af,,Pragma Obsolescent}. The second form of pragma @code{Unreferenced} is used within a context clause. In this case the arguments must be unit names of units previously @@ -8705,7 +8687,7 @@ Thus it is never necessary to use @code{pragma Unreferenced} for such variables, though it is harmless to do so. @node Pragma Unreferenced_Objects,Pragma Unreserve_All_Interrupts,Pragma Unreferenced,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{113}@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{114} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{112}@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{113} @section Pragma Unreferenced_Objects @@ -8730,7 +8712,7 @@ compiler will automatically suppress unwanted warnings about these variables not being referenced. @node Pragma Unreserve_All_Interrupts,Pragma Unsuppress,Pragma Unreferenced_Objects,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{115} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{114} @section Pragma Unreserve_All_Interrupts @@ -8766,7 +8748,7 @@ handled, see pragma @code{Interrupt_State}, which subsumes the functionality of the @code{Unreserve_All_Interrupts} pragma. @node Pragma Unsuppress,Pragma Use_VADS_Size,Pragma Unreserve_All_Interrupts,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{116} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{115} @section Pragma Unsuppress @@ -8802,7 +8784,7 @@ number of implementation-defined check names. See the description of pragma @code{Suppress} for full details. @node Pragma Use_VADS_Size,Pragma Unused,Pragma Unsuppress,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{117} +@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{116} @section Pragma Use_VADS_Size @@ -8826,7 +8808,7 @@ as implemented in the VADS compiler. See description of the VADS_Size attribute for further details. @node Pragma Unused,Pragma Validity_Checks,Pragma Use_VADS_Size,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{118}@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{119} +@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{117}@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{118} @section Pragma Unused @@ -8860,7 +8842,7 @@ Thus it is never necessary to use @code{pragma Unmodified} for such variables, though it is harmless to do so. @node Pragma Validity_Checks,Pragma Volatile,Pragma Unused,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{11a} +@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{119} @section Pragma Validity_Checks @@ -8916,7 +8898,7 @@ A := C; -- C will be validity checked @end example @node Pragma Volatile,Pragma Volatile_Full_Access,Pragma Validity_Checks,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{11c} +@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{11a}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{11b} @section Pragma Volatile @@ -8934,7 +8916,7 @@ implementation of pragma Volatile is upwards compatible with the implementation in DEC Ada 83. @node Pragma Volatile_Full_Access,Pragma Volatile_Function,Pragma Volatile,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{11d}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{11e} +@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{11c}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{11d} @section Pragma Volatile_Full_Access @@ -8966,7 +8948,7 @@ It is not permissible to specify @code{Volatile_Full_Access} for a composite (record or array) type or object that has at least one @code{Aliased} component. @node Pragma Volatile_Function,Pragma Warning_As_Error,Pragma Volatile_Full_Access,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11f}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{120} +@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11e}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{11f} @section Pragma Volatile_Function @@ -8980,7 +8962,7 @@ For the semantics of this pragma, see the entry for aspect @code{Volatile_Functi in the SPARK 2014 Reference Manual, section 7.1.2. @node Pragma Warning_As_Error,Pragma Warnings,Pragma Volatile_Function,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{121} +@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{120} @section Pragma Warning_As_Error @@ -9012,13 +8994,15 @@ message string (it is not necessary to put an asterisk at the start and the end of the message, since this is implied). Another possibility for the static_string_EXPRESSION which works whether -or not error tags are enabled (@emph{-gnatw.d}) is to use the +or not error tags are enabled (@emph{-gnatw.d}) is to use a single @emph{-gnatw} tag string, enclosed in brackets, -as shown in the example below, to treat a class of warnings as errors. +as shown in the example below, to treat one category of warnings as errors. +Note that if you want to treat multiple categories of warnings as errors, +you can use multiple pragma Warning_As_Error. The above use of patterns to match the message applies only to warning messages generated by the front end. This pragma can also be applied to -warnings provided by the back end and mentioned in @ref{122,,Pragma Warnings}. +warnings provided by the back end and mentioned in @ref{121,,Pragma Warnings}. By using a single full @emph{-Wxxx} switch in the pragma, such warnings can also be treated as errors. @@ -9068,7 +9052,7 @@ the tag is changed from "warning:" to "error:" and the string "[warning-as-error]" is appended to the end of the message. @node Pragma Warnings,Pragma Weak_External,Pragma Warning_As_Error,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{123}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{122} +@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{122}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{121} @section Pragma Warnings @@ -9205,7 +9189,7 @@ asterisks is similar in effect to specifying @code{pragma Warnings (Off)} except @code{pragma Warnings (On, "***")} will be required. This can be helpful in avoiding forgetting to turn warnings back on. -Note: the debug flag @code{-gnatd.i} (@code{/NOWARNINGS_PRAGMAS} in VMS) can be +Note: the debug flag @code{-gnatd.i} can be used to cause the compiler to entirely ignore all WARNINGS pragmas. This can be useful in checking whether obsolete pragmas in existing programs are hiding real problems. @@ -9224,7 +9208,7 @@ selectively for each tool, and as a consequence to detect useless pragma Warnings with switch @code{-gnatw.w}. @node Pragma Weak_External,Pragma Wide_Character_Encoding,Pragma Warnings,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{124} +@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{123} @section Pragma Weak_External @@ -9275,7 +9259,7 @@ end External_Module; @end example @node Pragma Wide_Character_Encoding,,Pragma Weak_External,Implementation Defined Pragmas -@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{125} +@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{124} @section Pragma Wide_Character_Encoding @@ -9306,7 +9290,7 @@ encoding within that file, and does not affect withed units, specs, or subunits. @node Implementation Defined Aspects,Implementation Defined Attributes,Implementation Defined Pragmas,Top -@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{126}@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{127}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{128} +@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{125}@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{126}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{127} @chapter Implementation Defined Aspects @@ -9425,7 +9409,7 @@ or attribute definition clause. @end menu @node Aspect Abstract_State,Aspect Annotate,,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{129} +@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{128} @section Aspect Abstract_State @@ -9434,7 +9418,7 @@ or attribute definition clause. This aspect is equivalent to @ref{1c,,pragma Abstract_State}. @node Aspect Annotate,Aspect Async_Readers,Aspect Abstract_State,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{12a} +@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{129} @section Aspect Annotate @@ -9461,7 +9445,7 @@ Equivalent to @code{pragma Annotate (ID, ID @{, ARG@}, Entity => Name);} @end table @node Aspect Async_Readers,Aspect Async_Writers,Aspect Annotate,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{12b} +@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{12a} @section Aspect Async_Readers @@ -9470,7 +9454,7 @@ Equivalent to @code{pragma Annotate (ID, ID @{, ARG@}, Entity => Name);} This boolean aspect is equivalent to @ref{31,,pragma Async_Readers}. @node Aspect Async_Writers,Aspect Constant_After_Elaboration,Aspect Async_Readers,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{12c} +@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{12b} @section Aspect Async_Writers @@ -9479,7 +9463,7 @@ This boolean aspect is equivalent to @ref{31,,pragma Async_Readers}. This boolean aspect is equivalent to @ref{34,,pragma Async_Writers}. @node Aspect Constant_After_Elaboration,Aspect Contract_Cases,Aspect Async_Writers,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{12d} +@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{12c} @section Aspect Constant_After_Elaboration @@ -9488,7 +9472,7 @@ This boolean aspect is equivalent to @ref{34,,pragma Async_Writers}. This aspect is equivalent to @ref{45,,pragma Constant_After_Elaboration}. @node Aspect Contract_Cases,Aspect Depends,Aspect Constant_After_Elaboration,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{12e} +@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{12d} @section Aspect Contract_Cases @@ -9499,7 +9483,7 @@ of clauses being enclosed in parentheses so that syntactically it is an aggregate. @node Aspect Depends,Aspect Default_Initial_Condition,Aspect Contract_Cases,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{12f} +@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{12e} @section Aspect Depends @@ -9508,7 +9492,7 @@ aggregate. This aspect is equivalent to @ref{56,,pragma Depends}. @node Aspect Default_Initial_Condition,Aspect Dimension,Aspect Depends,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{130} +@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{12f} @section Aspect Default_Initial_Condition @@ -9517,7 +9501,7 @@ This aspect is equivalent to @ref{56,,pragma Depends}. This aspect is equivalent to @ref{51,,pragma Default_Initial_Condition}. @node Aspect Dimension,Aspect Dimension_System,Aspect Default_Initial_Condition,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{131} +@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{130} @section Aspect Dimension @@ -9553,7 +9537,7 @@ Note that when the dimensioned type is an integer type, then any dimension value must be an integer literal. @node Aspect Dimension_System,Aspect Disable_Controlled,Aspect Dimension,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{132} +@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{131} @section Aspect Dimension_System @@ -9613,7 +9597,7 @@ See section 'Performing Dimensionality Analysis in GNAT' in the GNAT Users Guide for detailed examples of use of the dimension system. @node Aspect Disable_Controlled,Aspect Effective_Reads,Aspect Dimension_System,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{133} +@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{132} @section Aspect Disable_Controlled @@ -9626,7 +9610,7 @@ where for example you might want a record to be controlled or not depending on whether some run-time check is enabled or suppressed. @node Aspect Effective_Reads,Aspect Effective_Writes,Aspect Disable_Controlled,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{134} +@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{133} @section Aspect Effective_Reads @@ -9635,7 +9619,7 @@ whether some run-time check is enabled or suppressed. This aspect is equivalent to @ref{5c,,pragma Effective_Reads}. @node Aspect Effective_Writes,Aspect Extensions_Visible,Aspect Effective_Reads,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{135} +@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{134} @section Aspect Effective_Writes @@ -9644,7 +9628,7 @@ This aspect is equivalent to @ref{5c,,pragma Effective_Reads}. This aspect is equivalent to @ref{5e,,pragma Effective_Writes}. @node Aspect Extensions_Visible,Aspect Favor_Top_Level,Aspect Effective_Writes,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{136} +@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{135} @section Aspect Extensions_Visible @@ -9653,7 +9637,7 @@ This aspect is equivalent to @ref{5e,,pragma Effective_Writes}. This aspect is equivalent to @ref{6a,,pragma Extensions_Visible}. @node Aspect Favor_Top_Level,Aspect Ghost,Aspect Extensions_Visible,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{137} +@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{136} @section Aspect Favor_Top_Level @@ -9662,7 +9646,7 @@ This aspect is equivalent to @ref{6a,,pragma Extensions_Visible}. This boolean aspect is equivalent to @ref{6f,,pragma Favor_Top_Level}. @node Aspect Ghost,Aspect Global,Aspect Favor_Top_Level,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{138} +@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{137} @section Aspect Ghost @@ -9671,7 +9655,7 @@ This boolean aspect is equivalent to @ref{6f,,pragma Favor_Top_Level}. This aspect is equivalent to @ref{72,,pragma Ghost}. @node Aspect Global,Aspect Initial_Condition,Aspect Ghost,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{139} +@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{138} @section Aspect Global @@ -9680,7 +9664,7 @@ This aspect is equivalent to @ref{72,,pragma Ghost}. This aspect is equivalent to @ref{74,,pragma Global}. @node Aspect Initial_Condition,Aspect Initializes,Aspect Global,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{13a} +@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{139} @section Aspect Initial_Condition @@ -9689,7 +9673,7 @@ This aspect is equivalent to @ref{74,,pragma Global}. This aspect is equivalent to @ref{82,,pragma Initial_Condition}. @node Aspect Initializes,Aspect Inline_Always,Aspect Initial_Condition,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{13b} +@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{13a} @section Aspect Initializes @@ -9698,7 +9682,7 @@ This aspect is equivalent to @ref{82,,pragma Initial_Condition}. This aspect is equivalent to @ref{84,,pragma Initializes}. @node Aspect Inline_Always,Aspect Invariant,Aspect Initializes,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{13c} +@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{13b} @section Aspect Inline_Always @@ -9707,7 +9691,7 @@ This aspect is equivalent to @ref{84,,pragma Initializes}. This boolean aspect is equivalent to @ref{87,,pragma Inline_Always}. @node Aspect Invariant,Aspect Invariant'Class,Aspect Inline_Always,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{13d} +@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{13c} @section Aspect Invariant @@ -9718,18 +9702,18 @@ synonym for the language defined aspect @code{Type_Invariant} except that it is separately controllable using pragma @code{Assertion_Policy}. @node Aspect Invariant'Class,Aspect Iterable,Aspect Invariant,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{13e} +@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{13d} @section Aspect Invariant'Class @geindex Invariant'Class -This aspect is equivalent to @ref{107,,pragma Type_Invariant_Class}. It is a +This aspect is equivalent to @ref{106,,pragma Type_Invariant_Class}. It is a synonym for the language defined aspect @code{Type_Invariant'Class} except that it is separately controllable using pragma @code{Assertion_Policy}. @node Aspect Iterable,Aspect Linker_Section,Aspect Invariant'Class,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{13f} +@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{13e} @section Aspect Iterable @@ -9809,7 +9793,7 @@ function Get_Element (Cont : Container; Position : Cursor) return Element_Type; This aspect is used in the GNAT-defined formal container packages. @node Aspect Linker_Section,Aspect Lock_Free,Aspect Iterable,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{140} +@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{13f} @section Aspect Linker_Section @@ -9818,7 +9802,7 @@ This aspect is used in the GNAT-defined formal container packages. This aspect is equivalent to @ref{96,,pragma Linker_Section}. @node Aspect Lock_Free,Aspect Max_Queue_Length,Aspect Linker_Section,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{141} +@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{140} @section Aspect Lock_Free @@ -9827,7 +9811,7 @@ This aspect is equivalent to @ref{96,,pragma Linker_Section}. This boolean aspect is equivalent to @ref{98,,pragma Lock_Free}. @node Aspect Max_Queue_Length,Aspect No_Caching,Aspect Lock_Free,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{142} +@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{141} @section Aspect Max_Queue_Length @@ -9836,7 +9820,7 @@ This boolean aspect is equivalent to @ref{98,,pragma Lock_Free}. This aspect is equivalent to @ref{a0,,pragma Max_Queue_Length}. @node Aspect No_Caching,Aspect No_Elaboration_Code_All,Aspect Max_Queue_Length,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{143} +@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{142} @section Aspect No_Caching @@ -9845,7 +9829,7 @@ This aspect is equivalent to @ref{a0,,pragma Max_Queue_Length}. This boolean aspect is equivalent to @ref{a2,,pragma No_Caching}. @node Aspect No_Elaboration_Code_All,Aspect No_Inline,Aspect No_Caching,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{144} +@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{143} @section Aspect No_Elaboration_Code_All @@ -9855,7 +9839,7 @@ This aspect is equivalent to @ref{a6,,pragma No_Elaboration_Code_All} for a program unit. @node Aspect No_Inline,Aspect No_Tagged_Streams,Aspect No_Elaboration_Code_All,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{145} +@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{144} @section Aspect No_Inline @@ -9864,62 +9848,62 @@ for a program unit. This boolean aspect is equivalent to @ref{a9,,pragma No_Inline}. @node Aspect No_Tagged_Streams,Aspect Object_Size,Aspect No_Inline,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{146} +@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{145} @section Aspect No_Tagged_Streams @geindex No_Tagged_Streams -This aspect is equivalent to @ref{ad,,pragma No_Tagged_Streams} with an +This aspect is equivalent to @ref{ac,,pragma No_Tagged_Streams} with an argument specifying a root tagged type (thus this aspect can only be applied to such a type). @node Aspect Object_Size,Aspect Obsolescent,Aspect No_Tagged_Streams,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{147} +@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{146} @section Aspect Object_Size @geindex Object_Size -This aspect is equivalent to @ref{148,,attribute Object_Size}. +This aspect is equivalent to @ref{147,,attribute Object_Size}. @node Aspect Obsolescent,Aspect Part_Of,Aspect Object_Size,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{149} +@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{148} @section Aspect Obsolescent @geindex Obsolsecent -This aspect is equivalent to @ref{b0,,pragma Obsolescent}. Note that the +This aspect is equivalent to @ref{af,,pragma Obsolescent}. Note that the evaluation of this aspect happens at the point of occurrence, it is not delayed until the freeze point. @node Aspect Part_Of,Aspect Persistent_BSS,Aspect Obsolescent,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{14a} +@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{149} @section Aspect Part_Of @geindex Part_Of -This aspect is equivalent to @ref{b8,,pragma Part_Of}. +This aspect is equivalent to @ref{b7,,pragma Part_Of}. @node Aspect Persistent_BSS,Aspect Predicate,Aspect Part_Of,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{14b} +@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{14a} @section Aspect Persistent_BSS @geindex Persistent_BSS -This boolean aspect is equivalent to @ref{bb,,pragma Persistent_BSS}. +This boolean aspect is equivalent to @ref{ba,,pragma Persistent_BSS}. @node Aspect Predicate,Aspect Pure_Function,Aspect Persistent_BSS,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{14c} +@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{14b} @section Aspect Predicate @geindex Predicate -This aspect is equivalent to @ref{c3,,pragma Predicate}. It is thus +This aspect is equivalent to @ref{c2,,pragma Predicate}. It is thus similar to the language defined aspects @code{Dynamic_Predicate} and @code{Static_Predicate} except that whether the resulting predicate is static or dynamic is controlled by the form of the @@ -9927,239 +9911,239 @@ expression. It is also separately controllable using pragma @code{Assertion_Policy}. @node Aspect Pure_Function,Aspect Refined_Depends,Aspect Predicate,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{14d} +@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{14c} @section Aspect Pure_Function @geindex Pure_Function -This boolean aspect is equivalent to @ref{cf,,pragma Pure_Function}. +This boolean aspect is equivalent to @ref{ce,,pragma Pure_Function}. @node Aspect Refined_Depends,Aspect Refined_Global,Aspect Pure_Function,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{14e} +@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{14d} @section Aspect Refined_Depends @geindex Refined_Depends -This aspect is equivalent to @ref{d3,,pragma Refined_Depends}. +This aspect is equivalent to @ref{d2,,pragma Refined_Depends}. @node Aspect Refined_Global,Aspect Refined_Post,Aspect Refined_Depends,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{14f} +@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{14e} @section Aspect Refined_Global @geindex Refined_Global -This aspect is equivalent to @ref{d5,,pragma Refined_Global}. +This aspect is equivalent to @ref{d4,,pragma Refined_Global}. @node Aspect Refined_Post,Aspect Refined_State,Aspect Refined_Global,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{150} +@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{14f} @section Aspect Refined_Post @geindex Refined_Post -This aspect is equivalent to @ref{d7,,pragma Refined_Post}. +This aspect is equivalent to @ref{d6,,pragma Refined_Post}. @node Aspect Refined_State,Aspect Remote_Access_Type,Aspect Refined_Post,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{151} +@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{150} @section Aspect Refined_State @geindex Refined_State -This aspect is equivalent to @ref{d9,,pragma Refined_State}. +This aspect is equivalent to @ref{d8,,pragma Refined_State}. @node Aspect Remote_Access_Type,Aspect Secondary_Stack_Size,Aspect Refined_State,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{152} +@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{151} @section Aspect Remote_Access_Type @geindex Remote_Access_Type -This aspect is equivalent to @ref{dd,,pragma Remote_Access_Type}. +This aspect is equivalent to @ref{dc,,pragma Remote_Access_Type}. @node Aspect Secondary_Stack_Size,Aspect Scalar_Storage_Order,Aspect Remote_Access_Type,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{153} +@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{152} @section Aspect Secondary_Stack_Size @geindex Secondary_Stack_Size -This aspect is equivalent to @ref{e2,,pragma Secondary_Stack_Size}. +This aspect is equivalent to @ref{e1,,pragma Secondary_Stack_Size}. @node Aspect Scalar_Storage_Order,Aspect Shared,Aspect Secondary_Stack_Size,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{154} +@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{153} @section Aspect Scalar_Storage_Order @geindex Scalar_Storage_Order -This aspect is equivalent to a @ref{155,,attribute Scalar_Storage_Order}. +This aspect is equivalent to a @ref{154,,attribute Scalar_Storage_Order}. @node Aspect Shared,Aspect Simple_Storage_Pool,Aspect Scalar_Storage_Order,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{156} +@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{155} @section Aspect Shared @geindex Shared -This boolean aspect is equivalent to @ref{e5,,pragma Shared} +This boolean aspect is equivalent to @ref{e4,,pragma Shared} and is thus a synonym for aspect @code{Atomic}. @node Aspect Simple_Storage_Pool,Aspect Simple_Storage_Pool_Type,Aspect Shared,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{157} +@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{156} @section Aspect Simple_Storage_Pool @geindex Simple_Storage_Pool -This aspect is equivalent to @ref{ea,,attribute Simple_Storage_Pool}. +This aspect is equivalent to @ref{e9,,attribute Simple_Storage_Pool}. @node Aspect Simple_Storage_Pool_Type,Aspect SPARK_Mode,Aspect Simple_Storage_Pool,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{158} +@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{157} @section Aspect Simple_Storage_Pool_Type @geindex Simple_Storage_Pool_Type -This boolean aspect is equivalent to @ref{e8,,pragma Simple_Storage_Pool_Type}. +This boolean aspect is equivalent to @ref{e7,,pragma Simple_Storage_Pool_Type}. @node Aspect SPARK_Mode,Aspect Suppress_Debug_Info,Aspect Simple_Storage_Pool_Type,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{159} +@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{158} @section Aspect SPARK_Mode @geindex SPARK_Mode -This aspect is equivalent to @ref{f0,,pragma SPARK_Mode} and +This aspect is equivalent to @ref{ef,,pragma SPARK_Mode} and may be specified for either or both of the specification and body of a subprogram or package. @node Aspect Suppress_Debug_Info,Aspect Suppress_Initialization,Aspect SPARK_Mode,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{15a} +@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{159} @section Aspect Suppress_Debug_Info @geindex Suppress_Debug_Info -This boolean aspect is equivalent to @ref{f8,,pragma Suppress_Debug_Info}. +This boolean aspect is equivalent to @ref{f7,,pragma Suppress_Debug_Info}. @node Aspect Suppress_Initialization,Aspect Test_Case,Aspect Suppress_Debug_Info,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{15b} +@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{15a} @section Aspect Suppress_Initialization @geindex Suppress_Initialization -This boolean aspect is equivalent to @ref{fc,,pragma Suppress_Initialization}. +This boolean aspect is equivalent to @ref{fb,,pragma Suppress_Initialization}. @node Aspect Test_Case,Aspect Thread_Local_Storage,Aspect Suppress_Initialization,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{15c} +@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{15b} @section Aspect Test_Case @geindex Test_Case -This aspect is equivalent to @ref{ff,,pragma Test_Case}. +This aspect is equivalent to @ref{fe,,pragma Test_Case}. @node Aspect Thread_Local_Storage,Aspect Universal_Aliasing,Aspect Test_Case,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{15d} +@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{15c} @section Aspect Thread_Local_Storage @geindex Thread_Local_Storage -This boolean aspect is equivalent to @ref{101,,pragma Thread_Local_Storage}. +This boolean aspect is equivalent to @ref{100,,pragma Thread_Local_Storage}. @node Aspect Universal_Aliasing,Aspect Universal_Data,Aspect Thread_Local_Storage,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{15e} +@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{15d} @section Aspect Universal_Aliasing @geindex Universal_Aliasing -This boolean aspect is equivalent to @ref{10b,,pragma Universal_Aliasing}. +This boolean aspect is equivalent to @ref{10a,,pragma Universal_Aliasing}. @node Aspect Universal_Data,Aspect Unmodified,Aspect Universal_Aliasing,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-universal-data}@anchor{15f} +@anchor{gnat_rm/implementation_defined_aspects aspect-universal-data}@anchor{15e} @section Aspect Universal_Data @geindex Universal_Data -This aspect is equivalent to @ref{10d,,pragma Universal_Data}. +This aspect is equivalent to @ref{10c,,pragma Universal_Data}. @node Aspect Unmodified,Aspect Unreferenced,Aspect Universal_Data,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{160} +@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{15f} @section Aspect Unmodified @geindex Unmodified -This boolean aspect is equivalent to @ref{110,,pragma Unmodified}. +This boolean aspect is equivalent to @ref{10f,,pragma Unmodified}. @node Aspect Unreferenced,Aspect Unreferenced_Objects,Aspect Unmodified,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{161} +@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{160} @section Aspect Unreferenced @geindex Unreferenced -This boolean aspect is equivalent to @ref{111,,pragma Unreferenced}. Note that +This boolean aspect is equivalent to @ref{110,,pragma Unreferenced}. Note that in the case of formal parameters, it is not permitted to have aspects for a formal parameter, so in this case the pragma form must be used. @node Aspect Unreferenced_Objects,Aspect Value_Size,Aspect Unreferenced,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{162} +@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{161} @section Aspect Unreferenced_Objects @geindex Unreferenced_Objects -This boolean aspect is equivalent to @ref{113,,pragma Unreferenced_Objects}. +This boolean aspect is equivalent to @ref{112,,pragma Unreferenced_Objects}. @node Aspect Value_Size,Aspect Volatile_Full_Access,Aspect Unreferenced_Objects,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{163} +@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{162} @section Aspect Value_Size @geindex Value_Size -This aspect is equivalent to @ref{164,,attribute Value_Size}. +This aspect is equivalent to @ref{163,,attribute Value_Size}. @node Aspect Volatile_Full_Access,Aspect Volatile_Function,Aspect Value_Size,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{165} +@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{164} @section Aspect Volatile_Full_Access @geindex Volatile_Full_Access -This boolean aspect is equivalent to @ref{11e,,pragma Volatile_Full_Access}. +This boolean aspect is equivalent to @ref{11d,,pragma Volatile_Full_Access}. @node Aspect Volatile_Function,Aspect Warnings,Aspect Volatile_Full_Access,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{166} +@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{165} @section Aspect Volatile_Function @geindex Volatile_Function -This boolean aspect is equivalent to @ref{120,,pragma Volatile_Function}. +This boolean aspect is equivalent to @ref{11f,,pragma Volatile_Function}. @node Aspect Warnings,,Aspect Volatile_Function,Implementation Defined Aspects -@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{167} +@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{166} @section Aspect Warnings @geindex Warnings -This aspect is equivalent to the two argument form of @ref{122,,pragma Warnings}, +This aspect is equivalent to the two argument form of @ref{121,,pragma Warnings}, where the first argument is @code{ON} or @code{OFF} and the second argument is the entity. @node Implementation Defined Attributes,Standard and Implementation Defined Restrictions,Implementation Defined Aspects,Top -@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{168}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{169} +@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{167}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{168} @chapter Implementation Defined Attributes @@ -10260,7 +10244,7 @@ consideration, you should minimize the use of these attributes. @end menu @node Attribute Abort_Signal,Attribute Address_Size,,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{16a} +@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{169} @section Attribute Abort_Signal @@ -10274,7 +10258,7 @@ completely outside the normal semantics of Ada, for a user program to intercept the abort exception). @node Attribute Address_Size,Attribute Asm_Input,Attribute Abort_Signal,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{16b} +@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{16a} @section Attribute Address_Size @@ -10290,7 +10274,7 @@ reference to System.Address'Size is nonstatic because Address is a private type. @node Attribute Asm_Input,Attribute Asm_Output,Attribute Address_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{16c} +@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{16b} @section Attribute Asm_Input @@ -10304,10 +10288,10 @@ to be a static expression, and is the constraint for the parameter, value to be used as the input argument. The possible values for the constant are the same as those used in the RTL, and are dependent on the configuration file used to built the GCC back end. -@ref{16d,,Machine Code Insertions} +@ref{16c,,Machine Code Insertions} @node Attribute Asm_Output,Attribute Atomic_Always_Lock_Free,Attribute Asm_Input,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{16e} +@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{16d} @section Attribute Asm_Output @@ -10323,10 +10307,10 @@ result. The possible values for constraint are the same as those used in the RTL, and are dependent on the configuration file used to build the GCC back end. If there are no output operands, then this argument may either be omitted, or explicitly given as @code{No_Output_Operands}. -@ref{16d,,Machine Code Insertions} +@ref{16c,,Machine Code Insertions} @node Attribute Atomic_Always_Lock_Free,Attribute Bit,Attribute Asm_Output,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{16f} +@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{16e} @section Attribute Atomic_Always_Lock_Free @@ -10338,7 +10322,7 @@ and False otherwise. The result indicate whether atomic operations are supported by the target for the given type. @node Attribute Bit,Attribute Bit_Position,Attribute Atomic_Always_Lock_Free,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{170} +@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{16f} @section Attribute Bit @@ -10369,7 +10353,7 @@ This attribute is designed to be compatible with the DEC Ada 83 definition and implementation of the @code{Bit} attribute. @node Attribute Bit_Position,Attribute Code_Address,Attribute Bit,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{171} +@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{170} @section Attribute Bit_Position @@ -10384,7 +10368,7 @@ type @emph{universal_integer}. The value depends only on the field the containing record @code{R}. @node Attribute Code_Address,Attribute Compiler_Version,Attribute Bit_Position,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{172} +@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{171} @section Attribute Code_Address @@ -10427,7 +10411,7 @@ the same value as is returned by the corresponding @code{'Address} attribute. @node Attribute Compiler_Version,Attribute Constrained,Attribute Code_Address,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{173} +@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{172} @section Attribute Compiler_Version @@ -10438,7 +10422,7 @@ prefix) yields a static string identifying the version of the compiler being used to compile the unit containing the attribute reference. @node Attribute Constrained,Attribute Default_Bit_Order,Attribute Compiler_Version,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{174} +@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{173} @section Attribute Constrained @@ -10453,7 +10437,7 @@ record type without discriminants is always @code{True}. This usage is compatible with older Ada compilers, including notably DEC Ada. @node Attribute Default_Bit_Order,Attribute Default_Scalar_Storage_Order,Attribute Constrained,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{175} +@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{174} @section Attribute Default_Bit_Order @@ -10470,7 +10454,7 @@ as a @code{Pos} value (0 for @code{High_Order_First}, 1 for @code{Default_Bit_Order} in package @code{System}. @node Attribute Default_Scalar_Storage_Order,Attribute Deref,Attribute Default_Bit_Order,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{176} +@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{175} @section Attribute Default_Scalar_Storage_Order @@ -10487,7 +10471,7 @@ equal to @code{Default_Bit_Order} if unspecified) as a @code{System.Bit_Order} value. This is a static attribute. @node Attribute Deref,Attribute Descriptor_Size,Attribute Default_Scalar_Storage_Order,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{177} +@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{176} @section Attribute Deref @@ -10500,7 +10484,7 @@ a named access-to-@cite{typ} type, except that it yields a variable, so it can b used on the left side of an assignment. @node Attribute Descriptor_Size,Attribute Elaborated,Attribute Deref,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{178} +@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{177} @section Attribute Descriptor_Size @@ -10527,7 +10511,7 @@ In the example above, the descriptor contains two values of type a size of 31 bits and an alignment of 4, the descriptor size is @code{2 * Positive'Size + 2} or 64 bits. @node Attribute Elaborated,Attribute Elab_Body,Attribute Descriptor_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{179} +@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{178} @section Attribute Elaborated @@ -10542,7 +10526,7 @@ units has been completed. An exception is for units which need no elaboration, the value is always False for such units. @node Attribute Elab_Body,Attribute Elab_Spec,Attribute Elaborated,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{17a} +@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{179} @section Attribute Elab_Body @@ -10558,7 +10542,7 @@ e.g., if it is necessary to do selective re-elaboration to fix some error. @node Attribute Elab_Spec,Attribute Elab_Subp_Body,Attribute Elab_Body,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{17b} +@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{17a} @section Attribute Elab_Spec @@ -10574,7 +10558,7 @@ Ada code, e.g., if it is necessary to do selective re-elaboration to fix some error. @node Attribute Elab_Subp_Body,Attribute Emax,Attribute Elab_Spec,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{17c} +@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{17b} @section Attribute Elab_Subp_Body @@ -10588,7 +10572,7 @@ elaboration procedure by the binder in CodePeer mode only and is unrecognized otherwise. @node Attribute Emax,Attribute Enabled,Attribute Elab_Subp_Body,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{17d} +@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{17c} @section Attribute Emax @@ -10601,7 +10585,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Enabled,Attribute Enum_Rep,Attribute Emax,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{17e} +@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{17d} @section Attribute Enabled @@ -10625,7 +10609,7 @@ a @code{pragma Suppress} or @code{pragma Unsuppress} before instantiating the package or subprogram, controlling whether the check will be present. @node Attribute Enum_Rep,Attribute Enum_Val,Attribute Enabled,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{17f} +@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{17e} @section Attribute Enum_Rep @@ -10662,7 +10646,7 @@ integer calculation is done at run time, then the call to @code{Enum_Rep} may raise @code{Constraint_Error}. @node Attribute Enum_Val,Attribute Epsilon,Attribute Enum_Rep,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{180} +@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{17f} @section Attribute Enum_Val @@ -10685,7 +10669,7 @@ absence of an enumeration representation clause. This is a static attribute (i.e., the result is static if the argument is static). @node Attribute Epsilon,Attribute Fast_Math,Attribute Enum_Val,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{181} +@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{180} @section Attribute Epsilon @@ -10698,7 +10682,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Fast_Math,Attribute Finalization_Size,Attribute Epsilon,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{182} +@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{181} @section Attribute Fast_Math @@ -10709,7 +10693,7 @@ prefix) yields a static Boolean value that is True if pragma @code{Fast_Math} is active, and False otherwise. @node Attribute Finalization_Size,Attribute Fixed_Value,Attribute Fast_Math,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{183} +@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{182} @section Attribute Finalization_Size @@ -10727,7 +10711,7 @@ class-wide type whose tag denotes a type with no controlled parts. Note that only heap-allocated objects contain finalization data. @node Attribute Fixed_Value,Attribute From_Any,Attribute Finalization_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{184} +@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{183} @section Attribute Fixed_Value @@ -10754,7 +10738,7 @@ This attribute is primarily intended for use in implementation of the input-output functions for fixed-point values. @node Attribute From_Any,Attribute Has_Access_Values,Attribute Fixed_Value,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{185} +@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{184} @section Attribute From_Any @@ -10764,7 +10748,7 @@ This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex. @node Attribute Has_Access_Values,Attribute Has_Discriminants,Attribute From_Any,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{186} +@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{185} @section Attribute Has_Access_Values @@ -10782,7 +10766,7 @@ definitions. If the attribute is applied to a generic private type, it indicates whether or not the corresponding actual type has access values. @node Attribute Has_Discriminants,Attribute Img,Attribute Has_Access_Values,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{187} +@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{186} @section Attribute Has_Discriminants @@ -10798,7 +10782,7 @@ definitions. If the attribute is applied to a generic private type, it indicates whether or not the corresponding actual type has discriminants. @node Attribute Img,Attribute Integer_Value,Attribute Has_Discriminants,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{188} +@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{187} @section Attribute Img @@ -10828,7 +10812,7 @@ that returns the appropriate string when called. This means that in an instantiation as a function parameter. @node Attribute Integer_Value,Attribute Invalid_Value,Attribute Img,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{189} +@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{188} @section Attribute Integer_Value @@ -10856,7 +10840,7 @@ This attribute is primarily intended for use in implementation of the standard input-output functions for fixed-point values. @node Attribute Invalid_Value,Attribute Iterable,Attribute Integer_Value,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{18a} +@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{189} @section Attribute Invalid_Value @@ -10870,7 +10854,7 @@ including the ability to modify the value with the binder -Sxx flag and relevant environment variables at run time. @node Attribute Iterable,Attribute Large,Attribute Invalid_Value,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{18b} +@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{18a} @section Attribute Iterable @@ -10879,7 +10863,7 @@ relevant environment variables at run time. Equivalent to Aspect Iterable. @node Attribute Large,Attribute Library_Level,Attribute Iterable,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{18c} +@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{18b} @section Attribute Large @@ -10892,7 +10876,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Library_Level,Attribute Lock_Free,Attribute Large,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{18d} +@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{18c} @section Attribute Library_Level @@ -10918,7 +10902,7 @@ end Gen; @end example @node Attribute Lock_Free,Attribute Loop_Entry,Attribute Library_Level,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-lock-free}@anchor{18e} +@anchor{gnat_rm/implementation_defined_attributes attribute-lock-free}@anchor{18d} @section Attribute Lock_Free @@ -10928,7 +10912,7 @@ end Gen; pragma @code{Lock_Free} applies to P. @node Attribute Loop_Entry,Attribute Machine_Size,Attribute Lock_Free,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{18f} +@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{18e} @section Attribute Loop_Entry @@ -10958,7 +10942,7 @@ entry. This copy is not performed if the loop is not entered, or if the corresponding pragmas are ignored or disabled. @node Attribute Machine_Size,Attribute Mantissa,Attribute Loop_Entry,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{190} +@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{18f} @section Attribute Machine_Size @@ -10968,7 +10952,7 @@ This attribute is identical to the @code{Object_Size} attribute. It is provided for compatibility with the DEC Ada 83 attribute of this name. @node Attribute Mantissa,Attribute Maximum_Alignment,Attribute Machine_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{191} +@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{190} @section Attribute Mantissa @@ -10981,7 +10965,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Maximum_Alignment,Attribute Mechanism_Code,Attribute Mantissa,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{192}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{193} +@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{191}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{192} @section Attribute Maximum_Alignment @@ -10997,7 +10981,7 @@ for an object, guaranteeing that it is properly aligned in all cases. @node Attribute Mechanism_Code,Attribute Null_Parameter,Attribute Maximum_Alignment,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{194} +@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{193} @section Attribute Mechanism_Code @@ -11028,7 +11012,7 @@ by reference @end table @node Attribute Null_Parameter,Attribute Object_Size,Attribute Mechanism_Code,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{195} +@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{194} @section Attribute Null_Parameter @@ -11053,7 +11037,7 @@ There is no way of indicating this without the @code{Null_Parameter} attribute. @node Attribute Object_Size,Attribute Old,Attribute Null_Parameter,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{148}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{196} +@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{147}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{195} @section Attribute Object_Size @@ -11123,7 +11107,7 @@ Similar additional checks are performed in other contexts requiring statically matching subtypes. @node Attribute Old,Attribute Passed_By_Reference,Attribute Object_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{197} +@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{196} @section Attribute Old @@ -11138,7 +11122,7 @@ definition are allowed under control of implementation defined pragma @code{Unevaluated_Use_Of_Old}. @node Attribute Passed_By_Reference,Attribute Pool_Address,Attribute Old,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{198} +@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{197} @section Attribute Passed_By_Reference @@ -11154,7 +11138,7 @@ passed by copy in calls. For scalar types, the result is always @code{False} and is static. For non-scalar types, the result is nonstatic. @node Attribute Pool_Address,Attribute Range_Length,Attribute Passed_By_Reference,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{199} +@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{198} @section Attribute Pool_Address @@ -11179,7 +11163,7 @@ For an object created by @code{new}, @code{Ptr.all'Pool_Address} is what is passed to @code{Allocate} and returned from @code{Deallocate}. @node Attribute Range_Length,Attribute Restriction_Set,Attribute Pool_Address,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{19a} +@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{199} @section Attribute Range_Length @@ -11192,7 +11176,7 @@ applied to the index subtype of a one dimensional array always gives the same result as @code{Length} applied to the array itself. @node Attribute Restriction_Set,Attribute Result,Attribute Range_Length,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{19b} +@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{19a} @section Attribute Restriction_Set @@ -11262,7 +11246,7 @@ Restrictions pragma, they are not analyzed semantically, so they do not have a type. @node Attribute Result,Attribute Safe_Emax,Attribute Restriction_Set,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{19c} +@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{19b} @section Attribute Result @@ -11275,7 +11259,7 @@ For a further discussion of the use of this attribute and examples of its use, see the description of pragma Postcondition. @node Attribute Safe_Emax,Attribute Safe_Large,Attribute Result,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{19d} +@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{19c} @section Attribute Safe_Emax @@ -11288,7 +11272,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Safe_Large,Attribute Safe_Small,Attribute Safe_Emax,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{19e} +@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{19d} @section Attribute Safe_Large @@ -11301,7 +11285,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Safe_Small,Attribute Scalar_Storage_Order,Attribute Safe_Large,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{19f} +@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{19e} @section Attribute Safe_Small @@ -11314,7 +11298,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute. @node Attribute Scalar_Storage_Order,Attribute Simple_Storage_Pool,Attribute Safe_Small,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{1a0}@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{155} +@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{19f}@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{154} @section Attribute Scalar_Storage_Order @@ -11437,7 +11421,7 @@ Note that debuggers may be unable to display the correct value of scalar components of a type for which the opposite storage order is specified. @node Attribute Simple_Storage_Pool,Attribute Small,Attribute Scalar_Storage_Order,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{ea}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1a1} +@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{e9}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1a0} @section Attribute Simple_Storage_Pool @@ -11500,7 +11484,7 @@ as defined in section 13.11.2 of the Ada Reference Manual, except that the term @emph{simple storage pool} is substituted for @emph{storage pool}. @node Attribute Small,Attribute Storage_Unit,Attribute Simple_Storage_Pool,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1a2} +@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1a1} @section Attribute Small @@ -11516,7 +11500,7 @@ the Ada 83 reference manual for an exact description of the semantics of this attribute when applied to floating-point types. @node Attribute Storage_Unit,Attribute Stub_Type,Attribute Small,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1a3} +@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1a2} @section Attribute Storage_Unit @@ -11526,7 +11510,7 @@ this attribute when applied to floating-point types. prefix) provides the same value as @code{System.Storage_Unit}. @node Attribute Stub_Type,Attribute System_Allocator_Alignment,Attribute Storage_Unit,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1a4} +@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1a3} @section Attribute Stub_Type @@ -11550,7 +11534,7 @@ unit @code{System.Partition_Interface}. Use of this attribute will create an implicit dependency on this unit. @node Attribute System_Allocator_Alignment,Attribute Target_Name,Attribute Stub_Type,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1a5} +@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1a4} @section Attribute System_Allocator_Alignment @@ -11567,7 +11551,7 @@ with alignment too large or to enable a realignment circuitry if the alignment request is larger than this value. @node Attribute Target_Name,Attribute To_Address,Attribute System_Allocator_Alignment,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1a6} +@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1a5} @section Attribute Target_Name @@ -11580,7 +11564,7 @@ standard gcc target name without the terminating slash (for example, GNAT 5.0 on windows yields "i586-pc-mingw32msv"). @node Attribute To_Address,Attribute To_Any,Attribute Target_Name,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1a7} +@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1a6} @section Attribute To_Address @@ -11603,7 +11587,7 @@ modular manner (e.g., -1 means the same as 16#FFFF_FFFF# on a 32 bits machine). @node Attribute To_Any,Attribute Type_Class,Attribute To_Address,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1a8} +@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1a7} @section Attribute To_Any @@ -11613,7 +11597,7 @@ This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex. @node Attribute Type_Class,Attribute Type_Key,Attribute To_Any,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1a9} +@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1a8} @section Attribute Type_Class @@ -11643,7 +11627,7 @@ applies to all concurrent types. This attribute is designed to be compatible with the DEC Ada 83 attribute of the same name. @node Attribute Type_Key,Attribute TypeCode,Attribute Type_Class,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1aa} +@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1a9} @section Attribute Type_Key @@ -11655,7 +11639,7 @@ about the type or subtype. This provides improved compatibility with other implementations that support this attribute. @node Attribute TypeCode,Attribute Unconstrained_Array,Attribute Type_Key,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1ab} +@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1aa} @section Attribute TypeCode @@ -11665,7 +11649,7 @@ This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex. @node Attribute Unconstrained_Array,Attribute Universal_Literal_String,Attribute TypeCode,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1ac} +@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1ab} @section Attribute Unconstrained_Array @@ -11679,7 +11663,7 @@ still static, and yields the result of applying this test to the generic actual. @node Attribute Universal_Literal_String,Attribute Unrestricted_Access,Attribute Unconstrained_Array,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1ad} +@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1ac} @section Attribute Universal_Literal_String @@ -11707,7 +11691,7 @@ end; @end example @node Attribute Unrestricted_Access,Attribute Update,Attribute Universal_Literal_String,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1ae} +@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1ad} @section Attribute Unrestricted_Access @@ -11894,7 +11878,7 @@ In general this is a risky approach. It may appear to "work" but such uses of of GNAT to another, so are best avoided if possible. @node Attribute Update,Attribute Valid_Scalars,Attribute Unrestricted_Access,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1af} +@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1ae} @section Attribute Update @@ -11975,7 +11959,7 @@ A := A'Update ((1, 2) => 20, (3, 4) => 30); which changes element (1,2) to 20 and (3,4) to 30. @node Attribute Valid_Scalars,Attribute VADS_Size,Attribute Update,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1b0} +@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1af} @section Attribute Valid_Scalars @@ -12009,7 +11993,7 @@ write a function with a single use of the attribute, and then call that function from multiple places. @node Attribute VADS_Size,Attribute Value_Size,Attribute Valid_Scalars,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1b1} +@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1b0} @section Attribute VADS_Size @@ -12029,7 +12013,7 @@ gives the result that would be obtained by applying the attribute to the corresponding type. @node Attribute Value_Size,Attribute Wchar_T_Size,Attribute VADS_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b2}@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{164} +@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b1}@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{163} @section Attribute Value_Size @@ -12043,7 +12027,7 @@ a value of the given subtype. It is the same as @code{type'Size}, but, unlike @code{Size}, may be set for non-first subtypes. @node Attribute Wchar_T_Size,Attribute Word_Size,Attribute Value_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1b3} +@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1b2} @section Attribute Wchar_T_Size @@ -12055,7 +12039,7 @@ primarily for constructing the definition of this type in package @code{Interfaces.C}. The result is a static constant. @node Attribute Word_Size,,Attribute Wchar_T_Size,Implementation Defined Attributes -@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1b4} +@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1b3} @section Attribute Word_Size @@ -12066,7 +12050,7 @@ prefix) provides the value @code{System.Word_Size}. The result is a static constant. @node Standard and Implementation Defined Restrictions,Implementation Advice,Implementation Defined Attributes,Top -@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1b5}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b6} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1b4}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b5} @chapter Standard and Implementation Defined Restrictions @@ -12095,7 +12079,7 @@ language defined or GNAT-specific, are listed in the following. @end menu @node Partition-Wide Restrictions,Program Unit Level Restrictions,,Standard and Implementation Defined Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b7}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1b8} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b6}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1b7} @section Partition-Wide Restrictions @@ -12184,7 +12168,7 @@ then all compilation units in the partition must obey the restriction). @end menu @node Immediate_Reclamation,Max_Asynchronous_Select_Nesting,,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1b9} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1b8} @subsection Immediate_Reclamation @@ -12196,7 +12180,7 @@ deallocation, any storage reserved at run time for an object is immediately reclaimed when the object no longer exists. @node Max_Asynchronous_Select_Nesting,Max_Entry_Queue_Length,Immediate_Reclamation,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1ba} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1b9} @subsection Max_Asynchronous_Select_Nesting @@ -12208,7 +12192,7 @@ detected at compile time. Violations of this restriction with values other than zero cause Storage_Error to be raised. @node Max_Entry_Queue_Length,Max_Protected_Entries,Max_Asynchronous_Select_Nesting,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1bb} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1ba} @subsection Max_Entry_Queue_Length @@ -12229,7 +12213,7 @@ compatibility purposes (and a warning will be generated for its use if warnings on obsolescent features are activated). @node Max_Protected_Entries,Max_Select_Alternatives,Max_Entry_Queue_Length,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1bc} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1bb} @subsection Max_Protected_Entries @@ -12240,7 +12224,7 @@ bounds of every entry family of a protected unit shall be static, or shall be defined by a discriminant of a subtype whose corresponding bound is static. @node Max_Select_Alternatives,Max_Storage_At_Blocking,Max_Protected_Entries,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1bd} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1bc} @subsection Max_Select_Alternatives @@ -12249,7 +12233,7 @@ defined by a discriminant of a subtype whose corresponding bound is static. [RM D.7] Specifies the maximum number of alternatives in a selective accept. @node Max_Storage_At_Blocking,Max_Task_Entries,Max_Select_Alternatives,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1be} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1bd} @subsection Max_Storage_At_Blocking @@ -12260,7 +12244,7 @@ Storage_Size that can be retained by a blocked task. A violation of this restriction causes Storage_Error to be raised. @node Max_Task_Entries,Max_Tasks,Max_Storage_At_Blocking,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1bf} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1be} @subsection Max_Task_Entries @@ -12273,7 +12257,7 @@ defined by a discriminant of a subtype whose corresponding bound is static. @node Max_Tasks,No_Abort_Statements,Max_Task_Entries,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1c0} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1bf} @subsection Max_Tasks @@ -12286,7 +12270,7 @@ time. Violations of this restriction with values other than zero cause Storage_Error to be raised. @node No_Abort_Statements,No_Access_Parameter_Allocators,Max_Tasks,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1c1} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1c0} @subsection No_Abort_Statements @@ -12296,7 +12280,7 @@ Storage_Error to be raised. no calls to Task_Identification.Abort_Task. @node No_Access_Parameter_Allocators,No_Access_Subprograms,No_Abort_Statements,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1c2} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1c1} @subsection No_Access_Parameter_Allocators @@ -12307,7 +12291,7 @@ occurrences of an allocator as the actual parameter to an access parameter. @node No_Access_Subprograms,No_Allocators,No_Access_Parameter_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1c3} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1c2} @subsection No_Access_Subprograms @@ -12317,7 +12301,7 @@ parameter. declarations of access-to-subprogram types. @node No_Allocators,No_Anonymous_Allocators,No_Access_Subprograms,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1c4} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1c3} @subsection No_Allocators @@ -12327,7 +12311,7 @@ declarations of access-to-subprogram types. occurrences of an allocator. @node No_Anonymous_Allocators,No_Asynchronous_Control,No_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1c5} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1c4} @subsection No_Anonymous_Allocators @@ -12337,7 +12321,7 @@ occurrences of an allocator. occurrences of an allocator of anonymous access type. @node No_Asynchronous_Control,No_Calendar,No_Anonymous_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1c6} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1c5} @subsection No_Asynchronous_Control @@ -12347,7 +12331,7 @@ occurrences of an allocator of anonymous access type. dependences on the predefined package Asynchronous_Task_Control. @node No_Calendar,No_Coextensions,No_Asynchronous_Control,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1c7} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1c6} @subsection No_Calendar @@ -12357,7 +12341,7 @@ dependences on the predefined package Asynchronous_Task_Control. dependences on package Calendar. @node No_Coextensions,No_Default_Initialization,No_Calendar,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1c8} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1c7} @subsection No_Coextensions @@ -12367,7 +12351,7 @@ dependences on package Calendar. coextensions. See 3.10.2. @node No_Default_Initialization,No_Delay,No_Coextensions,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1c9} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1c8} @subsection No_Default_Initialization @@ -12384,7 +12368,7 @@ is to prohibit all cases of variables declared without a specific initializer (including the case of OUT scalar parameters). @node No_Delay,No_Dependence,No_Default_Initialization,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1ca} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1c9} @subsection No_Delay @@ -12394,7 +12378,7 @@ initializer (including the case of OUT scalar parameters). delay statements and no semantic dependences on package Calendar. @node No_Dependence,No_Direct_Boolean_Operators,No_Delay,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1cb} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1ca} @subsection No_Dependence @@ -12404,7 +12388,7 @@ delay statements and no semantic dependences on package Calendar. dependences on a library unit. @node No_Direct_Boolean_Operators,No_Dispatch,No_Dependence,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1cc} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1cb} @subsection No_Direct_Boolean_Operators @@ -12417,7 +12401,7 @@ protocol requires the use of short-circuit (and then, or else) forms for all composite boolean operations. @node No_Dispatch,No_Dispatching_Calls,No_Direct_Boolean_Operators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1cd} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1cc} @subsection No_Dispatch @@ -12427,7 +12411,7 @@ composite boolean operations. occurrences of @code{T'Class}, for any (tagged) subtype @code{T}. @node No_Dispatching_Calls,No_Dynamic_Attachment,No_Dispatch,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1ce} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1cd} @subsection No_Dispatching_Calls @@ -12488,7 +12472,7 @@ end Example; @end example @node No_Dynamic_Attachment,No_Dynamic_Priorities,No_Dispatching_Calls,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1cf} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1ce} @subsection No_Dynamic_Attachment @@ -12507,7 +12491,7 @@ compatibility purposes (and a warning will be generated for its use if warnings on obsolescent features are activated). @node No_Dynamic_Priorities,No_Entry_Calls_In_Elaboration_Code,No_Dynamic_Attachment,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1d0} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1cf} @subsection No_Dynamic_Priorities @@ -12516,7 +12500,7 @@ warnings on obsolescent features are activated). [RM D.7] There are no semantic dependencies on the package Dynamic_Priorities. @node No_Entry_Calls_In_Elaboration_Code,No_Enumeration_Maps,No_Dynamic_Priorities,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1d1} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1d0} @subsection No_Entry_Calls_In_Elaboration_Code @@ -12528,7 +12512,7 @@ restriction, the compiler can assume that no code past an accept statement in a task can be executed at elaboration time. @node No_Enumeration_Maps,No_Exception_Handlers,No_Entry_Calls_In_Elaboration_Code,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1d2} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1d1} @subsection No_Enumeration_Maps @@ -12539,7 +12523,7 @@ enumeration maps are used (that is Image and Value attributes applied to enumeration types). @node No_Exception_Handlers,No_Exception_Propagation,No_Enumeration_Maps,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1d3} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1d2} @subsection No_Exception_Handlers @@ -12564,7 +12548,7 @@ statement generated by the compiler). The Line parameter when nonzero represents the line number in the source program where the raise occurs. @node No_Exception_Propagation,No_Exception_Registration,No_Exception_Handlers,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1d4} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1d3} @subsection No_Exception_Propagation @@ -12581,7 +12565,7 @@ the package GNAT.Current_Exception is not permitted, and reraise statements (raise with no operand) are not permitted. @node No_Exception_Registration,No_Exceptions,No_Exception_Propagation,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1d5} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1d4} @subsection No_Exception_Registration @@ -12595,7 +12579,7 @@ code is simplified by omitting the otherwise-required global registration of exceptions when they are declared. @node No_Exceptions,No_Finalization,No_Exception_Registration,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1d6} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1d5} @subsection No_Exceptions @@ -12606,7 +12590,7 @@ raise statements and no exception handlers and also suppresses the generation of language-defined run-time checks. @node No_Finalization,No_Fixed_Point,No_Exceptions,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1d7} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1d6} @subsection No_Finalization @@ -12647,7 +12631,7 @@ object or a nested component, either declared on the stack or on the heap. The deallocation of a controlled object no longer finalizes its contents. @node No_Fixed_Point,No_Floating_Point,No_Finalization,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1d8} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1d7} @subsection No_Fixed_Point @@ -12657,7 +12641,7 @@ deallocation of a controlled object no longer finalizes its contents. occurrences of fixed point types and operations. @node No_Floating_Point,No_Implicit_Conditionals,No_Fixed_Point,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1d9} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1d8} @subsection No_Floating_Point @@ -12667,7 +12651,7 @@ occurrences of fixed point types and operations. occurrences of floating point types and operations. @node No_Implicit_Conditionals,No_Implicit_Dynamic_Code,No_Floating_Point,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1da} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1d9} @subsection No_Implicit_Conditionals @@ -12683,7 +12667,7 @@ normal manner. Constructs generating implicit conditionals include comparisons of composite objects and the Max/Min attributes. @node No_Implicit_Dynamic_Code,No_Implicit_Heap_Allocations,No_Implicit_Conditionals,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1db} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1da} @subsection No_Implicit_Dynamic_Code @@ -12713,7 +12697,7 @@ foreign-language convention; primitive operations of nested tagged types. @node No_Implicit_Heap_Allocations,No_Implicit_Protected_Object_Allocations,No_Implicit_Dynamic_Code,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1dc} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1db} @subsection No_Implicit_Heap_Allocations @@ -12722,7 +12706,7 @@ types. [RM D.7] No constructs are allowed to cause implicit heap allocation. @node No_Implicit_Protected_Object_Allocations,No_Implicit_Task_Allocations,No_Implicit_Heap_Allocations,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1dd} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1dc} @subsection No_Implicit_Protected_Object_Allocations @@ -12732,7 +12716,7 @@ types. protected object. @node No_Implicit_Task_Allocations,No_Initialize_Scalars,No_Implicit_Protected_Object_Allocations,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1de} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1dd} @subsection No_Implicit_Task_Allocations @@ -12741,7 +12725,7 @@ protected object. [GNAT] No constructs are allowed to cause implicit heap allocation of a task. @node No_Initialize_Scalars,No_IO,No_Implicit_Task_Allocations,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1df} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1de} @subsection No_Initialize_Scalars @@ -12753,7 +12737,7 @@ code, and in particular eliminates dummy null initialization routines that are otherwise generated for some record and array types. @node No_IO,No_Local_Allocators,No_Initialize_Scalars,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1e0} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1df} @subsection No_IO @@ -12764,7 +12748,7 @@ dependences on any of the library units Sequential_IO, Direct_IO, Text_IO, Wide_Text_IO, Wide_Wide_Text_IO, or Stream_IO. @node No_Local_Allocators,No_Local_Protected_Objects,No_IO,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1e1} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1e0} @subsection No_Local_Allocators @@ -12775,7 +12759,7 @@ occurrences of an allocator in subprograms, generic subprograms, tasks, and entry bodies. @node No_Local_Protected_Objects,No_Local_Timing_Events,No_Local_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1e2} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1e1} @subsection No_Local_Protected_Objects @@ -12785,7 +12769,7 @@ and entry bodies. only declared at the library level. @node No_Local_Timing_Events,No_Long_Long_Integers,No_Local_Protected_Objects,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1e3} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1e2} @subsection No_Local_Timing_Events @@ -12795,7 +12779,7 @@ only declared at the library level. declared at the library level. @node No_Long_Long_Integers,No_Multiple_Elaboration,No_Local_Timing_Events,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1e4} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1e3} @subsection No_Long_Long_Integers @@ -12807,7 +12791,7 @@ implicit base type is Long_Long_Integer, and modular types whose size exceeds Long_Integer'Size. @node No_Multiple_Elaboration,No_Nested_Finalization,No_Long_Long_Integers,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1e5} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1e4} @subsection No_Multiple_Elaboration @@ -12823,7 +12807,7 @@ possible, including non-Ada main programs and Stand Alone libraries, are not permitted and will be diagnosed by the binder. @node No_Nested_Finalization,No_Protected_Type_Allocators,No_Multiple_Elaboration,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{1e6} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{1e5} @subsection No_Nested_Finalization @@ -12832,7 +12816,7 @@ permitted and will be diagnosed by the binder. [RM D.7] All objects requiring finalization are declared at the library level. @node No_Protected_Type_Allocators,No_Protected_Types,No_Nested_Finalization,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{1e7} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{1e6} @subsection No_Protected_Type_Allocators @@ -12842,7 +12826,7 @@ permitted and will be diagnosed by the binder. expressions that attempt to allocate protected objects. @node No_Protected_Types,No_Recursion,No_Protected_Type_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{1e8} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{1e7} @subsection No_Protected_Types @@ -12852,7 +12836,7 @@ expressions that attempt to allocate protected objects. declarations of protected types or protected objects. @node No_Recursion,No_Reentrancy,No_Protected_Types,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{1e9} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{1e8} @subsection No_Recursion @@ -12862,7 +12846,7 @@ declarations of protected types or protected objects. part of its execution. @node No_Reentrancy,No_Relative_Delay,No_Recursion,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{1ea} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{1e9} @subsection No_Reentrancy @@ -12872,7 +12856,7 @@ part of its execution. two tasks at the same time. @node No_Relative_Delay,No_Requeue_Statements,No_Reentrancy,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{1eb} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{1ea} @subsection No_Relative_Delay @@ -12883,7 +12867,7 @@ relative statements and prevents expressions such as @code{delay 1.23;} from appearing in source code. @node No_Requeue_Statements,No_Secondary_Stack,No_Relative_Delay,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{1ec} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{1eb} @subsection No_Requeue_Statements @@ -12901,7 +12885,7 @@ compatibility purposes (and a warning will be generated for its use if warnings on oNobsolescent features are activated). @node No_Secondary_Stack,No_Select_Statements,No_Requeue_Statements,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{1ed} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{1ec} @subsection No_Secondary_Stack @@ -12914,7 +12898,7 @@ stack is used to implement functions returning unconstrained objects secondary stacks for tasks (excluding the environment task) at run time. @node No_Select_Statements,No_Specific_Termination_Handlers,No_Secondary_Stack,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{1ee} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{1ed} @subsection No_Select_Statements @@ -12924,7 +12908,7 @@ secondary stacks for tasks (excluding the environment task) at run time. kind are permitted, that is the keyword @code{select} may not appear. @node No_Specific_Termination_Handlers,No_Specification_of_Aspect,No_Select_Statements,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{1ef} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{1ee} @subsection No_Specific_Termination_Handlers @@ -12934,7 +12918,7 @@ kind are permitted, that is the keyword @code{select} may not appear. or to Ada.Task_Termination.Specific_Handler. @node No_Specification_of_Aspect,No_Standard_Allocators_After_Elaboration,No_Specific_Termination_Handlers,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{1f0} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{1ef} @subsection No_Specification_of_Aspect @@ -12945,7 +12929,7 @@ specification, attribute definition clause, or pragma is given for a given aspect. @node No_Standard_Allocators_After_Elaboration,No_Standard_Storage_Pools,No_Specification_of_Aspect,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{1f1} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{1f0} @subsection No_Standard_Allocators_After_Elaboration @@ -12957,7 +12941,7 @@ library items of the partition has completed. Otherwise, Storage_Error is raised. @node No_Standard_Storage_Pools,No_Stream_Optimizations,No_Standard_Allocators_After_Elaboration,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{1f2} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{1f1} @subsection No_Standard_Storage_Pools @@ -12969,7 +12953,7 @@ have an explicit Storage_Pool attribute defined specifying a user-defined storage pool. @node No_Stream_Optimizations,No_Streams,No_Standard_Storage_Pools,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{1f3} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{1f2} @subsection No_Stream_Optimizations @@ -12982,7 +12966,7 @@ due to their superior performance. When this restriction is in effect, the compiler performs all IO operations on a per-character basis. @node No_Streams,No_Task_Allocators,No_Stream_Optimizations,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{1f4} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{1f3} @subsection No_Streams @@ -13003,7 +12987,7 @@ unit declaring a tagged type should be compiled with the restriction, though this is not required. @node No_Task_Allocators,No_Task_At_Interrupt_Priority,No_Streams,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{1f5} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{1f4} @subsection No_Task_Allocators @@ -13013,7 +12997,7 @@ though this is not required. or types containing task subcomponents. @node No_Task_At_Interrupt_Priority,No_Task_Attributes_Package,No_Task_Allocators,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{1f6} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{1f5} @subsection No_Task_At_Interrupt_Priority @@ -13025,7 +13009,7 @@ a consequence, the tasks are always created with a priority below that an interrupt priority. @node No_Task_Attributes_Package,No_Task_Hierarchy,No_Task_At_Interrupt_Priority,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{1f7} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{1f6} @subsection No_Task_Attributes_Package @@ -13042,7 +13026,7 @@ compatibility purposes (and a warning will be generated for its use if warnings on obsolescent features are activated). @node No_Task_Hierarchy,No_Task_Termination,No_Task_Attributes_Package,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{1f8} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{1f7} @subsection No_Task_Hierarchy @@ -13052,7 +13036,7 @@ warnings on obsolescent features are activated). directly on the environment task of the partition. @node No_Task_Termination,No_Tasking,No_Task_Hierarchy,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{1f9} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{1f8} @subsection No_Task_Termination @@ -13061,7 +13045,7 @@ directly on the environment task of the partition. [RM D.7] Tasks that terminate are erroneous. @node No_Tasking,No_Terminate_Alternatives,No_Task_Termination,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{1fa} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{1f9} @subsection No_Tasking @@ -13074,7 +13058,7 @@ and cause an error message to be output either by the compiler or binder. @node No_Terminate_Alternatives,No_Unchecked_Access,No_Tasking,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{1fb} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{1fa} @subsection No_Terminate_Alternatives @@ -13083,7 +13067,7 @@ binder. [RM D.7] There are no selective accepts with terminate alternatives. @node No_Unchecked_Access,No_Unchecked_Conversion,No_Terminate_Alternatives,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{1fc} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{1fb} @subsection No_Unchecked_Access @@ -13093,7 +13077,7 @@ binder. occurrences of the Unchecked_Access attribute. @node No_Unchecked_Conversion,No_Unchecked_Deallocation,No_Unchecked_Access,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{1fd} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{1fc} @subsection No_Unchecked_Conversion @@ -13103,7 +13087,7 @@ occurrences of the Unchecked_Access attribute. dependences on the predefined generic function Unchecked_Conversion. @node No_Unchecked_Deallocation,No_Use_Of_Entity,No_Unchecked_Conversion,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{1fe} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{1fd} @subsection No_Unchecked_Deallocation @@ -13113,7 +13097,7 @@ dependences on the predefined generic function Unchecked_Conversion. dependences on the predefined generic procedure Unchecked_Deallocation. @node No_Use_Of_Entity,Pure_Barriers,No_Unchecked_Deallocation,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{1ff} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{1fe} @subsection No_Use_Of_Entity @@ -13133,7 +13117,7 @@ No_Use_Of_Entity => Ada.Text_IO.Put_Line @end example @node Pure_Barriers,Simple_Barriers,No_Use_Of_Entity,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{200} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{1ff} @subsection Pure_Barriers @@ -13184,7 +13168,7 @@ but still ensures absence of side effects, exceptions, and recursion during the evaluation of the barriers. @node Simple_Barriers,Static_Priorities,Pure_Barriers,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{201} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{200} @subsection Simple_Barriers @@ -13203,7 +13187,7 @@ compatibility purposes (and a warning will be generated for its use if warnings on obsolescent features are activated). @node Static_Priorities,Static_Storage_Size,Simple_Barriers,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{202} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{201} @subsection Static_Priorities @@ -13214,7 +13198,7 @@ are static, and that there are no dependences on the package @code{Ada.Dynamic_Priorities}. @node Static_Storage_Size,,Static_Priorities,Partition-Wide Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{203} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{202} @subsection Static_Storage_Size @@ -13224,7 +13208,7 @@ are static, and that there are no dependences on the package in a Storage_Size pragma or attribute definition clause is static. @node Program Unit Level Restrictions,,Partition-Wide Restrictions,Standard and Implementation Defined Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{204}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{205} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{203}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{204} @section Program Unit Level Restrictions @@ -13254,7 +13238,7 @@ other compilation units in the partition. @end menu @node No_Elaboration_Code,No_Dynamic_Sized_Objects,,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{206} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{205} @subsection No_Elaboration_Code @@ -13310,7 +13294,7 @@ associated with the unit. This counter is typically used to check for access before elaboration and to control multiple elaboration attempts. @node No_Dynamic_Sized_Objects,No_Entry_Queue,No_Elaboration_Code,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{207} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{206} @subsection No_Dynamic_Sized_Objects @@ -13328,7 +13312,7 @@ access discriminants. It is often a good idea to combine this restriction with No_Secondary_Stack. @node No_Entry_Queue,No_Implementation_Aspect_Specifications,No_Dynamic_Sized_Objects,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{208} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{207} @subsection No_Entry_Queue @@ -13341,7 +13325,7 @@ checked at compile time. A program execution is erroneous if an attempt is made to queue a second task on such an entry. @node No_Implementation_Aspect_Specifications,No_Implementation_Attributes,No_Entry_Queue,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{209} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{208} @subsection No_Implementation_Aspect_Specifications @@ -13352,7 +13336,7 @@ GNAT-defined aspects are present. With this restriction, the only aspects that can be used are those defined in the Ada Reference Manual. @node No_Implementation_Attributes,No_Implementation_Identifiers,No_Implementation_Aspect_Specifications,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{20a} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{209} @subsection No_Implementation_Attributes @@ -13364,7 +13348,7 @@ attributes that can be used are those defined in the Ada Reference Manual. @node No_Implementation_Identifiers,No_Implementation_Pragmas,No_Implementation_Attributes,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{20b} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{20a} @subsection No_Implementation_Identifiers @@ -13375,7 +13359,7 @@ implementation-defined identifiers (marked with pragma Implementation_Defined) occur within language-defined packages. @node No_Implementation_Pragmas,No_Implementation_Restrictions,No_Implementation_Identifiers,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{20c} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{20b} @subsection No_Implementation_Pragmas @@ -13386,7 +13370,7 @@ GNAT-defined pragmas are present. With this restriction, the only pragmas that can be used are those defined in the Ada Reference Manual. @node No_Implementation_Restrictions,No_Implementation_Units,No_Implementation_Pragmas,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{20d} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{20c} @subsection No_Implementation_Restrictions @@ -13398,7 +13382,7 @@ are present. With this restriction, the only other restriction identifiers that can be used are those defined in the Ada Reference Manual. @node No_Implementation_Units,No_Implicit_Aliasing,No_Implementation_Restrictions,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{20e} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{20d} @subsection No_Implementation_Units @@ -13409,7 +13393,7 @@ mention in the context clause of any implementation-defined descendants of packages Ada, Interfaces, or System. @node No_Implicit_Aliasing,No_Implicit_Loops,No_Implementation_Units,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{20f} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{20e} @subsection No_Implicit_Aliasing @@ -13424,7 +13408,7 @@ to be aliased, and in such cases, it can always be replaced by the standard attribute Unchecked_Access which is preferable. @node No_Implicit_Loops,No_Obsolescent_Features,No_Implicit_Aliasing,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{210} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{20f} @subsection No_Implicit_Loops @@ -13441,7 +13425,7 @@ arrays larger than about 5000 scalar components. Note that if this restriction is set in the spec of a package, it will not apply to its body. @node No_Obsolescent_Features,No_Wide_Characters,No_Implicit_Loops,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{211} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{210} @subsection No_Obsolescent_Features @@ -13451,7 +13435,7 @@ is set in the spec of a package, it will not apply to its body. features are used, as defined in Annex J of the Ada Reference Manual. @node No_Wide_Characters,Static_Dispatch_Tables,No_Obsolescent_Features,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{212} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{211} @subsection No_Wide_Characters @@ -13465,7 +13449,7 @@ appear in the program (that is literals representing characters not in type @code{Character}). @node Static_Dispatch_Tables,SPARK_05,No_Wide_Characters,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{213} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{212} @subsection Static_Dispatch_Tables @@ -13475,7 +13459,7 @@ type @code{Character}). associated with dispatch tables can be placed in read-only memory. @node SPARK_05,,Static_Dispatch_Tables,Program Unit Level Restrictions -@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{214} +@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{213} @subsection SPARK_05 @@ -13849,7 +13833,7 @@ violations will be reported for constructs forbidden in SPARK 95, instead of SPARK 2005. @node Implementation Advice,Implementation Defined Characteristics,Standard and Implementation Defined Restrictions,Top -@anchor{gnat_rm/implementation_advice doc}@anchor{215}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}@anchor{gnat_rm/implementation_advice id1}@anchor{216} +@anchor{gnat_rm/implementation_advice doc}@anchor{214}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}@anchor{gnat_rm/implementation_advice id1}@anchor{215} @chapter Implementation Advice @@ -13946,7 +13930,7 @@ case the text describes what GNAT does and why. @end menu @node RM 1 1 3 20 Error Detection,RM 1 1 3 31 Child Units,,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{217} +@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{216} @section RM 1.1.3(20): Error Detection @@ -13963,7 +13947,7 @@ or diagnosed at compile time. @geindex Child Units @node RM 1 1 3 31 Child Units,RM 1 1 5 12 Bounded Errors,RM 1 1 3 20 Error Detection,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{218} +@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{217} @section RM 1.1.3(31): Child Units @@ -13979,7 +13963,7 @@ Followed. @geindex Bounded errors @node RM 1 1 5 12 Bounded Errors,RM 2 8 16 Pragmas,RM 1 1 3 31 Child Units,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{219} +@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{218} @section RM 1.1.5(12): Bounded Errors @@ -13996,7 +13980,7 @@ runtime. @geindex Pragmas @node RM 2 8 16 Pragmas,RM 2 8 17-19 Pragmas,RM 1 1 5 12 Bounded Errors,Implementation Advice -@anchor{gnat_rm/implementation_advice id2}@anchor{21a}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{21b} +@anchor{gnat_rm/implementation_advice id2}@anchor{219}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{21a} @section RM 2.8(16): Pragmas @@ -14109,7 +14093,7 @@ that this advice not be followed. For details see @ref{7,,Implementation Defined Pragmas}. @node RM 2 8 17-19 Pragmas,RM 3 5 2 5 Alternative Character Sets,RM 2 8 16 Pragmas,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{21c} +@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{21b} @section RM 2.8(17-19): Pragmas @@ -14130,14 +14114,14 @@ replacing @code{library_items}." @end itemize @end quotation -See @ref{21b,,RM 2.8(16); Pragmas}. +See @ref{21a,,RM 2.8(16); Pragmas}. @geindex Character Sets @geindex Alternative Character Sets @node RM 3 5 2 5 Alternative Character Sets,RM 3 5 4 28 Integer Types,RM 2 8 17-19 Pragmas,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{21d} +@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{21c} @section RM 3.5.2(5): Alternative Character Sets @@ -14165,7 +14149,7 @@ there is no such restriction. @geindex Integer types @node RM 3 5 4 28 Integer Types,RM 3 5 4 29 Integer Types,RM 3 5 2 5 Alternative Character Sets,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{21e} +@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{21d} @section RM 3.5.4(28): Integer Types @@ -14184,7 +14168,7 @@ are supported for convenient interface to C, and so that all hardware types of the machine are easily available. @node RM 3 5 4 29 Integer Types,RM 3 5 5 8 Enumeration Values,RM 3 5 4 28 Integer Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{21f} +@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{21e} @section RM 3.5.4(29): Integer Types @@ -14200,7 +14184,7 @@ Followed. @geindex Enumeration values @node RM 3 5 5 8 Enumeration Values,RM 3 5 7 17 Float Types,RM 3 5 4 29 Integer Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{220} +@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{21f} @section RM 3.5.5(8): Enumeration Values @@ -14220,7 +14204,7 @@ Followed. @geindex Float types @node RM 3 5 7 17 Float Types,RM 3 6 2 11 Multidimensional Arrays,RM 3 5 5 8 Enumeration Values,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{221} +@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{220} @section RM 3.5.7(17): Float Types @@ -14250,7 +14234,7 @@ since this is a software rather than a hardware format. @geindex multidimensional @node RM 3 6 2 11 Multidimensional Arrays,RM 9 6 30-31 Duration'Small,RM 3 5 7 17 Float Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{222} +@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{221} @section RM 3.6.2(11): Multidimensional Arrays @@ -14268,7 +14252,7 @@ Followed. @geindex Duration'Small @node RM 9 6 30-31 Duration'Small,RM 10 2 1 12 Consistent Representation,RM 3 6 2 11 Multidimensional Arrays,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{223} +@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{222} @section RM 9.6(30-31): Duration'Small @@ -14289,7 +14273,7 @@ it need not be the same time base as used for @code{Calendar.Clock}." Followed. @node RM 10 2 1 12 Consistent Representation,RM 11 4 1 19 Exception Information,RM 9 6 30-31 Duration'Small,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{224} +@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{223} @section RM 10.2.1(12): Consistent Representation @@ -14311,7 +14295,7 @@ advice without severely impacting efficiency of execution. @geindex Exception information @node RM 11 4 1 19 Exception Information,RM 11 5 28 Suppression of Checks,RM 10 2 1 12 Consistent Representation,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{225} +@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{224} @section RM 11.4.1(19): Exception Information @@ -14342,7 +14326,7 @@ Pragma @code{Discard_Names}. @geindex suppression of @node RM 11 5 28 Suppression of Checks,RM 13 1 21-24 Representation Clauses,RM 11 4 1 19 Exception Information,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{226} +@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{225} @section RM 11.5(28): Suppression of Checks @@ -14357,7 +14341,7 @@ Followed. @geindex Representation clauses @node RM 13 1 21-24 Representation Clauses,RM 13 2 6-8 Packed Types,RM 11 5 28 Suppression of Checks,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{227} +@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{226} @section RM 13.1 (21-24): Representation Clauses @@ -14406,7 +14390,7 @@ Followed. @geindex Packed types @node RM 13 2 6-8 Packed Types,RM 13 3 14-19 Address Clauses,RM 13 1 21-24 Representation Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{228} +@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{227} @section RM 13.2(6-8): Packed Types @@ -14445,7 +14429,7 @@ Followed. @geindex Address clauses @node RM 13 3 14-19 Address Clauses,RM 13 3 29-35 Alignment Clauses,RM 13 2 6-8 Packed Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{229} +@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{228} @section RM 13.3(14-19): Address Clauses @@ -14498,7 +14482,7 @@ Followed. @geindex Alignment clauses @node RM 13 3 29-35 Alignment Clauses,RM 13 3 42-43 Size Clauses,RM 13 3 14-19 Address Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{22a} +@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{229} @section RM 13.3(29-35): Alignment Clauses @@ -14555,7 +14539,7 @@ Followed. @geindex Size clauses @node RM 13 3 42-43 Size Clauses,RM 13 3 50-56 Size Clauses,RM 13 3 29-35 Alignment Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{22b} +@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{22a} @section RM 13.3(42-43): Size Clauses @@ -14573,7 +14557,7 @@ object's @code{Alignment} (if the @code{Alignment} is nonzero)." Followed. @node RM 13 3 50-56 Size Clauses,RM 13 3 71-73 Component Size Clauses,RM 13 3 42-43 Size Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{22c} +@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{22b} @section RM 13.3(50-56): Size Clauses @@ -14624,7 +14608,7 @@ Followed. @geindex Component_Size clauses @node RM 13 3 71-73 Component Size Clauses,RM 13 4 9-10 Enumeration Representation Clauses,RM 13 3 50-56 Size Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{22d} +@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{22c} @section RM 13.3(71-73): Component Size Clauses @@ -14658,7 +14642,7 @@ Followed. @geindex enumeration @node RM 13 4 9-10 Enumeration Representation Clauses,RM 13 5 1 17-22 Record Representation Clauses,RM 13 3 71-73 Component Size Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{22e} +@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{22d} @section RM 13.4(9-10): Enumeration Representation Clauses @@ -14680,7 +14664,7 @@ Followed. @geindex records @node RM 13 5 1 17-22 Record Representation Clauses,RM 13 5 2 5 Storage Place Attributes,RM 13 4 9-10 Enumeration Representation Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{22f} +@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{22e} @section RM 13.5.1(17-22): Record Representation Clauses @@ -14740,7 +14724,7 @@ and all mentioned features are implemented. @geindex Storage place attributes @node RM 13 5 2 5 Storage Place Attributes,RM 13 5 3 7-8 Bit Ordering,RM 13 5 1 17-22 Record Representation Clauses,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{230} +@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{22f} @section RM 13.5.2(5): Storage Place Attributes @@ -14760,7 +14744,7 @@ Followed. There are no such components in GNAT. @geindex Bit ordering @node RM 13 5 3 7-8 Bit Ordering,RM 13 7 37 Address as Private,RM 13 5 2 5 Storage Place Attributes,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{231} +@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{230} @section RM 13.5.3(7-8): Bit Ordering @@ -14780,7 +14764,7 @@ Thus non-default bit ordering is not supported. @geindex as private type @node RM 13 7 37 Address as Private,RM 13 7 1 16 Address Operations,RM 13 5 3 7-8 Bit Ordering,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{232} +@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{231} @section RM 13.7(37): Address as Private @@ -14798,7 +14782,7 @@ Followed. @geindex operations of @node RM 13 7 1 16 Address Operations,RM 13 9 14-17 Unchecked Conversion,RM 13 7 37 Address as Private,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{233} +@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{232} @section RM 13.7.1(16): Address Operations @@ -14816,7 +14800,7 @@ operation raises @code{Program_Error}, since all operations make sense. @geindex Unchecked conversion @node RM 13 9 14-17 Unchecked Conversion,RM 13 11 23-25 Implicit Heap Usage,RM 13 7 1 16 Address Operations,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{234} +@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{233} @section RM 13.9(14-17): Unchecked Conversion @@ -14860,7 +14844,7 @@ Followed. @geindex implicit @node RM 13 11 23-25 Implicit Heap Usage,RM 13 11 2 17 Unchecked Deallocation,RM 13 9 14-17 Unchecked Conversion,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{235} +@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{234} @section RM 13.11(23-25): Implicit Heap Usage @@ -14911,7 +14895,7 @@ Followed. @geindex Unchecked deallocation @node RM 13 11 2 17 Unchecked Deallocation,RM 13 13 2 1 6 Stream Oriented Attributes,RM 13 11 23-25 Implicit Heap Usage,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{236} +@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{235} @section RM 13.11.2(17): Unchecked Deallocation @@ -14926,7 +14910,7 @@ Followed. @geindex Stream oriented attributes @node RM 13 13 2 1 6 Stream Oriented Attributes,RM A 1 52 Names of Predefined Numeric Types,RM 13 11 2 17 Unchecked Deallocation,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{237} +@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{236} @section RM 13.13.2(1.6): Stream Oriented Attributes @@ -14981,7 +14965,7 @@ the @emph{GNAT and Libraries} section of the @cite{GNAT User's Guide}. @end itemize @node RM A 1 52 Names of Predefined Numeric Types,RM A 3 2 49 Ada Characters Handling,RM 13 13 2 1 6 Stream Oriented Attributes,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{238} +@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{237} @section RM A.1(52): Names of Predefined Numeric Types @@ -14999,7 +14983,7 @@ Followed. @geindex Ada.Characters.Handling @node RM A 3 2 49 Ada Characters Handling,RM A 4 4 106 Bounded-Length String Handling,RM A 1 52 Names of Predefined Numeric Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{239} +@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{238} @section RM A.3.2(49): @code{Ada.Characters.Handling} @@ -15016,7 +15000,7 @@ Followed. GNAT provides no such localized definitions. @geindex Bounded-length strings @node RM A 4 4 106 Bounded-Length String Handling,RM A 5 2 46-47 Random Number Generation,RM A 3 2 49 Ada Characters Handling,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{23a} +@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{239} @section RM A.4.4(106): Bounded-Length String Handling @@ -15031,7 +15015,7 @@ Followed. No implicit pointers or dynamic allocation are used. @geindex Random number generation @node RM A 5 2 46-47 Random Number Generation,RM A 10 7 23 Get_Immediate,RM A 4 4 106 Bounded-Length String Handling,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{23b} +@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{23a} @section RM A.5.2(46-47): Random Number Generation @@ -15060,7 +15044,7 @@ condition here to hold true. @geindex Get_Immediate @node RM A 10 7 23 Get_Immediate,RM B 1 39-41 Pragma Export,RM A 5 2 46-47 Random Number Generation,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{23c} +@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{23b} @section RM A.10.7(23): @code{Get_Immediate} @@ -15084,7 +15068,7 @@ this functionality. @geindex Export @node RM B 1 39-41 Pragma Export,RM B 2 12-13 Package Interfaces,RM A 10 7 23 Get_Immediate,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{23d} +@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{23c} @section RM B.1(39-41): Pragma @code{Export} @@ -15132,7 +15116,7 @@ Followed. @geindex Interfaces @node RM B 2 12-13 Package Interfaces,RM B 3 63-71 Interfacing with C,RM B 1 39-41 Pragma Export,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{23e} +@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{23d} @section RM B.2(12-13): Package @code{Interfaces} @@ -15162,7 +15146,7 @@ Followed. GNAT provides all the packages described in this section. @geindex interfacing with @node RM B 3 63-71 Interfacing with C,RM B 4 95-98 Interfacing with COBOL,RM B 2 12-13 Package Interfaces,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{23f} +@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{23e} @section RM B.3(63-71): Interfacing with C @@ -15250,7 +15234,7 @@ Followed. @geindex interfacing with @node RM B 4 95-98 Interfacing with COBOL,RM B 5 22-26 Interfacing with Fortran,RM B 3 63-71 Interfacing with C,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{240} +@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{23f} @section RM B.4(95-98): Interfacing with COBOL @@ -15291,7 +15275,7 @@ Followed. @geindex interfacing with @node RM B 5 22-26 Interfacing with Fortran,RM C 1 3-5 Access to Machine Operations,RM B 4 95-98 Interfacing with COBOL,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{241} +@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{240} @section RM B.5(22-26): Interfacing with Fortran @@ -15342,7 +15326,7 @@ Followed. @geindex Machine operations @node RM C 1 3-5 Access to Machine Operations,RM C 1 10-16 Access to Machine Operations,RM B 5 22-26 Interfacing with Fortran,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{242} +@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{241} @section RM C.1(3-5): Access to Machine Operations @@ -15377,7 +15361,7 @@ object that is specified as exported." Followed. @node RM C 1 10-16 Access to Machine Operations,RM C 3 28 Interrupt Support,RM C 1 3-5 Access to Machine Operations,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{243} +@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{242} @section RM C.1(10-16): Access to Machine Operations @@ -15438,7 +15422,7 @@ Followed on any target supporting such operations. @geindex Interrupt support @node RM C 3 28 Interrupt Support,RM C 3 1 20-21 Protected Procedure Handlers,RM C 1 10-16 Access to Machine Operations,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{244} +@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{243} @section RM C.3(28): Interrupt Support @@ -15456,7 +15440,7 @@ of interrupt blocking. @geindex Protected procedure handlers @node RM C 3 1 20-21 Protected Procedure Handlers,RM C 3 2 25 Package Interrupts,RM C 3 28 Interrupt Support,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{245} +@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{244} @section RM C.3.1(20-21): Protected Procedure Handlers @@ -15482,7 +15466,7 @@ Followed. Compile time warnings are given when possible. @geindex Interrupts @node RM C 3 2 25 Package Interrupts,RM C 4 14 Pre-elaboration Requirements,RM C 3 1 20-21 Protected Procedure Handlers,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{246} +@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{245} @section RM C.3.2(25): Package @code{Interrupts} @@ -15500,7 +15484,7 @@ Followed. @geindex Pre-elaboration requirements @node RM C 4 14 Pre-elaboration Requirements,RM C 5 8 Pragma Discard_Names,RM C 3 2 25 Package Interrupts,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{247} +@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{246} @section RM C.4(14): Pre-elaboration Requirements @@ -15516,7 +15500,7 @@ Followed. Executable code is generated in some cases, e.g., loops to initialize large arrays. @node RM C 5 8 Pragma Discard_Names,RM C 7 2 30 The Package Task_Attributes,RM C 4 14 Pre-elaboration Requirements,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{248} +@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{247} @section RM C.5(8): Pragma @code{Discard_Names} @@ -15534,7 +15518,7 @@ Followed. @geindex Task_Attributes @node RM C 7 2 30 The Package Task_Attributes,RM D 3 17 Locking Policies,RM C 5 8 Pragma Discard_Names,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{249} +@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{248} @section RM C.7.2(30): The Package Task_Attributes @@ -15555,7 +15539,7 @@ Not followed. This implementation is not targeted to such a domain. @geindex Locking Policies @node RM D 3 17 Locking Policies,RM D 4 16 Entry Queuing Policies,RM C 7 2 30 The Package Task_Attributes,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{24a} +@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{249} @section RM D.3(17): Locking Policies @@ -15572,7 +15556,7 @@ whose names (@code{Inheritance_Locking} and @geindex Entry queuing policies @node RM D 4 16 Entry Queuing Policies,RM D 6 9-10 Preemptive Abort,RM D 3 17 Locking Policies,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{24b} +@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{24a} @section RM D.4(16): Entry Queuing Policies @@ -15587,7 +15571,7 @@ Followed. No such implementation-defined queuing policies exist. @geindex Preemptive abort @node RM D 6 9-10 Preemptive Abort,RM D 7 21 Tasking Restrictions,RM D 4 16 Entry Queuing Policies,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{24c} +@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{24b} @section RM D.6(9-10): Preemptive Abort @@ -15613,7 +15597,7 @@ Followed. @geindex Tasking restrictions @node RM D 7 21 Tasking Restrictions,RM D 8 47-49 Monotonic Time,RM D 6 9-10 Preemptive Abort,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{24d} +@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{24c} @section RM D.7(21): Tasking Restrictions @@ -15632,7 +15616,7 @@ pragma @code{Profile (Restricted)} for more details. @geindex monotonic @node RM D 8 47-49 Monotonic Time,RM E 5 28-29 Partition Communication Subsystem,RM D 7 21 Tasking Restrictions,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{24e} +@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{24d} @section RM D.8(47-49): Monotonic Time @@ -15667,7 +15651,7 @@ Followed. @geindex PCS @node RM E 5 28-29 Partition Communication Subsystem,RM F 7 COBOL Support,RM D 8 47-49 Monotonic Time,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{24f} +@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{24e} @section RM E.5(28-29): Partition Communication Subsystem @@ -15695,7 +15679,7 @@ GNAT. @geindex COBOL support @node RM F 7 COBOL Support,RM F 1 2 Decimal Radix Support,RM E 5 28-29 Partition Communication Subsystem,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{250} +@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{24f} @section RM F(7): COBOL Support @@ -15715,7 +15699,7 @@ Followed. @geindex Decimal radix support @node RM F 1 2 Decimal Radix Support,RM G Numerics,RM F 7 COBOL Support,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{251} +@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{250} @section RM F.1(2): Decimal Radix Support @@ -15731,7 +15715,7 @@ representations. @geindex Numerics @node RM G Numerics,RM G 1 1 56-58 Complex Types,RM F 1 2 Decimal Radix Support,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{252} +@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{251} @section RM G: Numerics @@ -15751,7 +15735,7 @@ Followed. @geindex Complex types @node RM G 1 1 56-58 Complex Types,RM G 1 2 49 Complex Elementary Functions,RM G Numerics,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{253} +@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{252} @section RM G.1.1(56-58): Complex Types @@ -15813,7 +15797,7 @@ Followed. @geindex Complex elementary functions @node RM G 1 2 49 Complex Elementary Functions,RM G 2 4 19 Accuracy Requirements,RM G 1 1 56-58 Complex Types,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{254} +@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{253} @section RM G.1.2(49): Complex Elementary Functions @@ -15835,7 +15819,7 @@ Followed. @geindex Accuracy requirements @node RM G 2 4 19 Accuracy Requirements,RM G 2 6 15 Complex Arithmetic Accuracy,RM G 1 2 49 Complex Elementary Functions,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{255} +@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{254} @section RM G.2.4(19): Accuracy Requirements @@ -15859,7 +15843,7 @@ Followed. @geindex complex arithmetic @node RM G 2 6 15 Complex Arithmetic Accuracy,RM H 6 15/2 Pragma Partition_Elaboration_Policy,RM G 2 4 19 Accuracy Requirements,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{256} +@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{255} @section RM G.2.6(15): Complex Arithmetic Accuracy @@ -15877,7 +15861,7 @@ Followed. @geindex Sequential elaboration policy @node RM H 6 15/2 Pragma Partition_Elaboration_Policy,,RM G 2 6 15 Complex Arithmetic Accuracy,Implementation Advice -@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{257} +@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{256} @section RM H.6(15/2): Pragma Partition_Elaboration_Policy @@ -15892,7 +15876,7 @@ immediately terminated." Not followed. @node Implementation Defined Characteristics,Intrinsic Subprograms,Implementation Advice,Top -@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{258}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{259} +@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{257}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{258} @chapter Implementation Defined Characteristics @@ -17088,7 +17072,7 @@ When the @code{Pattern} parameter is not the null string, it is interpreted according to the syntax of regular expressions as defined in the @code{GNAT.Regexp} package. -See @ref{25a,,GNAT.Regexp (g-regexp.ads)}. +See @ref{259,,GNAT.Regexp (g-regexp.ads)}. @itemize * @@ -17267,9 +17251,8 @@ pragma @code{Import} specifies convention @code{stubbed} then no body need be present at all. This convention is useful during development for the inclusion of subprograms whose body has not yet been written. In addition, all otherwise unrecognized convention names are also -treated as being synonymous with convention C. In all implementations -except for VMS, use of such other names results in a warning. In VMS -implementations, these names are accepted silently. +treated as being synonymous with convention C. In all implementations, +use of such other names results in a warning. @end multitable @@ -18137,7 +18120,7 @@ H.4(27)." There are no restrictions on pragma @code{Restrictions}. @node Intrinsic Subprograms,Representation Clauses and Pragmas,Implementation Defined Characteristics,Top -@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{25b}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{25c} +@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{25a}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{25b} @chapter Intrinsic Subprograms @@ -18175,7 +18158,7 @@ Ada standard does not require Ada compilers to implement this feature. @end menu @node Intrinsic Operators,Compilation_ISO_Date,,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{25d}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{25e} +@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{25c}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{25d} @section Intrinsic Operators @@ -18206,7 +18189,7 @@ It is also possible to specify such operators for private types, if the full views are appropriate arithmetic types. @node Compilation_ISO_Date,Compilation_Date,Intrinsic Operators,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{25f}@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{260} +@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{25e}@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{25f} @section Compilation_ISO_Date @@ -18220,7 +18203,7 @@ application program should simply call the function the current compilation (in local time format YYYY-MM-DD). @node Compilation_Date,Compilation_Time,Compilation_ISO_Date,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{261}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{262} +@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{260}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{261} @section Compilation_Date @@ -18230,7 +18213,7 @@ Same as Compilation_ISO_Date, except the string is in the form MMM DD YYYY. @node Compilation_Time,Enclosing_Entity,Compilation_Date,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{263}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{264} +@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{262}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{263} @section Compilation_Time @@ -18244,7 +18227,7 @@ application program should simply call the function the current compilation (in local time format HH:MM:SS). @node Enclosing_Entity,Exception_Information,Compilation_Time,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{265}@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{266} +@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{264}@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{265} @section Enclosing_Entity @@ -18258,7 +18241,7 @@ application program should simply call the function the current subprogram, package, task, entry, or protected subprogram. @node Exception_Information,Exception_Message,Enclosing_Entity,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{267}@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{268} +@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{266}@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{267} @section Exception_Information @@ -18272,7 +18255,7 @@ so an application program should simply call the function the exception information associated with the current exception. @node Exception_Message,Exception_Name,Exception_Information,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{269}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{26a} +@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{268}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{269} @section Exception_Message @@ -18286,7 +18269,7 @@ so an application program should simply call the function the message associated with the current exception. @node Exception_Name,File,Exception_Message,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{26b}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{26c} +@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{26a}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{26b} @section Exception_Name @@ -18300,7 +18283,7 @@ so an application program should simply call the function the name of the current exception. @node File,Line,Exception_Name,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms file}@anchor{26e} +@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{26c}@anchor{gnat_rm/intrinsic_subprograms file}@anchor{26d} @section File @@ -18314,7 +18297,7 @@ application program should simply call the function file. @node Line,Shifts and Rotates,File,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{26f}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{270} +@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{26e}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{26f} @section Line @@ -18328,7 +18311,7 @@ application program should simply call the function source line. @node Shifts and Rotates,Source_Location,Line,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{271}@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{272} +@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{270}@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{271} @section Shifts and Rotates @@ -18367,7 +18350,7 @@ the Provide_Shift_Operators pragma, which provides the function declarations and corresponding pragma Import's for all five shift functions. @node Source_Location,,Shifts and Rotates,Intrinsic Subprograms -@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{273}@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{274} +@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{272}@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{273} @section Source_Location @@ -18381,7 +18364,7 @@ application program should simply call the function source file location. @node Representation Clauses and Pragmas,Standard Library Routines,Intrinsic Subprograms,Top -@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{275}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{276} +@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{274}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{275} @chapter Representation Clauses and Pragmas @@ -18427,7 +18410,7 @@ and this section describes the additional capabilities provided. @end menu @node Alignment Clauses,Size Clauses,,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{277}@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{278} +@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{276}@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{277} @section Alignment Clauses @@ -18449,7 +18432,7 @@ For elementary types, the alignment is the minimum of the actual size of objects of the type divided by @code{Storage_Unit}, and the maximum alignment supported by the target. (This maximum alignment is given by the GNAT-specific attribute -@code{Standard'Maximum_Alignment}; see @ref{192,,Attribute Maximum_Alignment}.) +@code{Standard'Maximum_Alignment}; see @ref{191,,Attribute Maximum_Alignment}.) @geindex Maximum_Alignment attribute @@ -18558,7 +18541,7 @@ assumption is non-portable, and other compilers may choose different alignments for the subtype @code{RS}. @node Size Clauses,Storage_Size Clauses,Alignment Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{279}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{27a} +@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{278}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{279} @section Size Clauses @@ -18635,7 +18618,7 @@ if it is known that a Size value can be accommodated in an object of type Integer. @node Storage_Size Clauses,Size of Variant Record Objects,Size Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{27b}@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{27c} +@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{27a}@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{27b} @section Storage_Size Clauses @@ -18708,7 +18691,7 @@ Of course in practice, there will not be any explicit allocators in the case of such an access declaration. @node Size of Variant Record Objects,Biased Representation,Storage_Size Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{27d}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{27e} +@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{27c}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{27d} @section Size of Variant Record Objects @@ -18818,7 +18801,7 @@ the maximum size, regardless of the current variant value, the variant value. @node Biased Representation,Value_Size and Object_Size Clauses,Size of Variant Record Objects,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{27f}@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{280} +@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{27e}@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{27f} @section Biased Representation @@ -18856,7 +18839,7 @@ biased representation can be used for all discrete types except for enumeration types for which a representation clause is given. @node Value_Size and Object_Size Clauses,Component_Size Clauses,Biased Representation,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{281}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{282} +@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{280}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{281} @section Value_Size and Object_Size Clauses @@ -19172,7 +19155,7 @@ definition clause forces biased representation. This warning can be turned off using @code{-gnatw.B}. @node Component_Size Clauses,Bit_Order Clauses,Value_Size and Object_Size Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{283}@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{284} +@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{282}@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{283} @section Component_Size Clauses @@ -19219,7 +19202,7 @@ and a pragma Pack for the same array type. if such duplicate clauses are given, the pragma Pack will be ignored. @node Bit_Order Clauses,Effect of Bit_Order on Byte Ordering,Component_Size Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{285}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{286} +@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{284}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{285} @section Bit_Order Clauses @@ -19325,7 +19308,7 @@ if desired. The following section contains additional details regarding the issue of byte ordering. @node Effect of Bit_Order on Byte Ordering,Pragma Pack for Arrays,Bit_Order Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{287}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{288} +@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{286}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{287} @section Effect of Bit_Order on Byte Ordering @@ -19582,7 +19565,7 @@ to set the boolean constant @code{Master_Byte_First} in an appropriate manner. @node Pragma Pack for Arrays,Pragma Pack for Records,Effect of Bit_Order on Byte Ordering,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{289}@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{28a} +@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{288}@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{289} @section Pragma Pack for Arrays @@ -19699,7 +19682,7 @@ Here 31-bit packing is achieved as required, and no warning is generated, since in this case the programmer intention is clear. @node Pragma Pack for Records,Record Representation Clauses,Pragma Pack for Arrays,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{28b}@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{28c} +@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{28a}@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{28b} @section Pragma Pack for Records @@ -19784,7 +19767,7 @@ the @code{L6} field is aligned to the next byte boundary, and takes an integral number of bytes, i.e., 72 bits. @node Record Representation Clauses,Handling of Records with Holes,Pragma Pack for Records,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{28d}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{28e} +@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{28c}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{28d} @section Record Representation Clauses @@ -19862,7 +19845,7 @@ end record; @end example @node Handling of Records with Holes,Enumeration Clauses,Record Representation Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{28f}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{290} +@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{28e}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{28f} @section Handling of Records with Holes @@ -19939,7 +19922,7 @@ for Hrec'Size use 64; @end example @node Enumeration Clauses,Address Clauses,Handling of Records with Holes,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{291}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{292} +@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{290}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{291} @section Enumeration Clauses @@ -19982,7 +19965,7 @@ the overhead of converting representation values to the corresponding positional values, (i.e., the value delivered by the @code{Pos} attribute). @node Address Clauses,Use of Address Clauses for Memory-Mapped I/O,Enumeration Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{293}@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{294} +@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{292}@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{293} @section Address Clauses @@ -20311,7 +20294,7 @@ then the program compiles without the warning and when run will generate the output @code{X was not clobbered}. @node Use of Address Clauses for Memory-Mapped I/O,Effect of Convention on Representation,Address Clauses,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{295}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{296} +@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{294}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{295} @section Use of Address Clauses for Memory-Mapped I/O @@ -20369,7 +20352,7 @@ provides the pragma @code{Volatile_Full_Access} which can be used in lieu of pragma @code{Atomic} and will give the additional guarantee. @node Effect of Convention on Representation,Conventions and Anonymous Access Types,Use of Address Clauses for Memory-Mapped I/O,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{297}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{298} +@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{296}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{297} @section Effect of Convention on Representation @@ -20447,7 +20430,7 @@ when one of these values is read, any nonzero value is treated as True. @end itemize @node Conventions and Anonymous Access Types,Determining the Representations chosen by GNAT,Effect of Convention on Representation,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{299}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{29a} +@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{298}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{299} @section Conventions and Anonymous Access Types @@ -20523,7 +20506,7 @@ package ConvComp is @end example @node Determining the Representations chosen by GNAT,,Conventions and Anonymous Access Types,Representation Clauses and Pragmas -@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{29b}@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{29c} +@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{29a}@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{29b} @section Determining the Representations chosen by GNAT @@ -20675,7 +20658,7 @@ generated by the compiler into the original source to fix and guarantee the actual representation to be used. @node Standard Library Routines,The Implementation of Standard I/O,Representation Clauses and Pragmas,Top -@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}@anchor{gnat_rm/standard_library_routines doc}@anchor{29d}@anchor{gnat_rm/standard_library_routines id1}@anchor{29e} +@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}@anchor{gnat_rm/standard_library_routines doc}@anchor{29c}@anchor{gnat_rm/standard_library_routines id1}@anchor{29d} @chapter Standard Library Routines @@ -21499,7 +21482,7 @@ For packages in Interfaces and System, all the RM defined packages are available in GNAT, see the Ada 2012 RM for full details. @node The Implementation of Standard I/O,The GNAT Library,Standard Library Routines,Top -@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{29f}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2a0} +@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{29e}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{29f} @chapter The Implementation of Standard I/O @@ -21551,7 +21534,7 @@ these additional facilities are also described in this chapter. @end menu @node Standard I/O Packages,FORM Strings,,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a1}@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2a2} +@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a0}@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2a1} @section Standard I/O Packages @@ -21622,7 +21605,7 @@ flush the common I/O streams and in particular Standard_Output before elaborating the Ada code. @node FORM Strings,Direct_IO,Standard I/O Packages,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2a3}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2a4} +@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2a2}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2a3} @section FORM Strings @@ -21648,7 +21631,7 @@ unrecognized keyword appears in a form string, it is silently ignored and not considered invalid. @node Direct_IO,Sequential_IO,FORM Strings,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2a5}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2a6} +@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2a4}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2a5} @section Direct_IO @@ -21668,7 +21651,7 @@ There is no limit on the size of Direct_IO files, they are expanded as necessary to accommodate whatever records are written to the file. @node Sequential_IO,Text_IO,Direct_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2a7}@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2a8} +@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2a6}@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2a7} @section Sequential_IO @@ -21715,7 +21698,7 @@ using Stream_IO, and this is the preferred mechanism. In particular, the above program fragment rewritten to use Stream_IO will work correctly. @node Text_IO,Wide_Text_IO,Sequential_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2a9}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2aa} +@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2a8}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2a9} @section Text_IO @@ -21798,7 +21781,7 @@ the file. @end menu @node Stream Pointer Positioning,Reading and Writing Non-Regular Files,,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2ab}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2ac} +@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2aa}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2ab} @subsection Stream Pointer Positioning @@ -21834,7 +21817,7 @@ between two Ada files, then the difference may be observable in some situations. @node Reading and Writing Non-Regular Files,Get_Immediate,Stream Pointer Positioning,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2ad}@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2ae} +@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2ac}@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2ad} @subsection Reading and Writing Non-Regular Files @@ -21885,7 +21868,7 @@ to read data past that end of file indication, until another end of file indication is entered. @node Get_Immediate,Treating Text_IO Files as Streams,Reading and Writing Non-Regular Files,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2af}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2b0} +@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2ae}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2af} @subsection Get_Immediate @@ -21903,7 +21886,7 @@ possible), it is undefined whether the FF character will be treated as a page mark. @node Treating Text_IO Files as Streams,Text_IO Extensions,Get_Immediate,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2b1}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2b2} +@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2b0}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2b1} @subsection Treating Text_IO Files as Streams @@ -21919,7 +21902,7 @@ skipped and the effect is similar to that described above for @code{Get_Immediate}. @node Text_IO Extensions,Text_IO Facilities for Unbounded Strings,Treating Text_IO Files as Streams,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2b3}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2b4} +@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2b2}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2b3} @subsection Text_IO Extensions @@ -21947,7 +21930,7 @@ the string is to be read. @end itemize @node Text_IO Facilities for Unbounded Strings,,Text_IO Extensions,Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2b5}@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2b6} +@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2b4}@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2b5} @subsection Text_IO Facilities for Unbounded Strings @@ -21995,7 +21978,7 @@ files @code{a-szuzti.ads} and @code{a-szuzti.adb} provides similar extended @code{Wide_Wide_Text_IO} functionality for unbounded wide wide strings. @node Wide_Text_IO,Wide_Wide_Text_IO,Text_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2b7}@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2b8} +@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2b6}@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2b7} @section Wide_Text_IO @@ -22242,12 +22225,12 @@ input also causes Constraint_Error to be raised. @end menu @node Stream Pointer Positioning<2>,Reading and Writing Non-Regular Files<2>,,Wide_Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2b9}@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2ba} +@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2b8}@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2b9} @subsection Stream Pointer Positioning @code{Ada.Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling -of stream pointer positioning (@ref{2aa,,Text_IO}). There is one additional +of stream pointer positioning (@ref{2a9,,Text_IO}). There is one additional case: If @code{Ada.Wide_Text_IO.Look_Ahead} reads a character outside the @@ -22266,7 +22249,7 @@ to a normal program using @code{Wide_Text_IO}. However, this discrepancy can be observed if the wide text file shares a stream with another file. @node Reading and Writing Non-Regular Files<2>,,Stream Pointer Positioning<2>,Wide_Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2bb}@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2bc} +@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2ba}@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2bb} @subsection Reading and Writing Non-Regular Files @@ -22277,7 +22260,7 @@ treated as data characters), and @code{End_Of_Page} always returns it is possible to read beyond an end of file. @node Wide_Wide_Text_IO,Stream_IO,Wide_Text_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2bd}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2be} +@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2bc}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2bd} @section Wide_Wide_Text_IO @@ -22446,12 +22429,12 @@ input also causes Constraint_Error to be raised. @end menu @node Stream Pointer Positioning<3>,Reading and Writing Non-Regular Files<3>,,Wide_Wide_Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2c0} +@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2be}@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2bf} @subsection Stream Pointer Positioning @code{Ada.Wide_Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling -of stream pointer positioning (@ref{2aa,,Text_IO}). There is one additional +of stream pointer positioning (@ref{2a9,,Text_IO}). There is one additional case: If @code{Ada.Wide_Wide_Text_IO.Look_Ahead} reads a character outside the @@ -22470,7 +22453,7 @@ to a normal program using @code{Wide_Wide_Text_IO}. However, this discrepancy can be observed if the wide text file shares a stream with another file. @node Reading and Writing Non-Regular Files<3>,,Stream Pointer Positioning<3>,Wide_Wide_Text_IO -@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2c1}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2c2} +@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2c0}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2c1} @subsection Reading and Writing Non-Regular Files @@ -22481,7 +22464,7 @@ treated as data characters), and @code{End_Of_Page} always returns it is possible to read beyond an end of file. @node Stream_IO,Text Translation,Wide_Wide_Text_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2c3}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2c4} +@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2c2}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2c3} @section Stream_IO @@ -22503,7 +22486,7 @@ manner described for stream attributes. @end itemize @node Text Translation,Shared Files,Stream_IO,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2c5}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2c6} +@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2c4}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2c5} @section Text Translation @@ -22537,7 +22520,7 @@ mode. (corresponds to_O_U16TEXT). @end itemize @node Shared Files,Filenames encoding,Text Translation,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2c7}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2c8} +@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2c6}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2c7} @section Shared Files @@ -22600,7 +22583,7 @@ heterogeneous input-output. Although this approach will work in GNAT if for this purpose (using the stream attributes) @node Filenames encoding,File content encoding,Shared Files,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2c9}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2ca} +@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2c8}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2c9} @section Filenames encoding @@ -22640,7 +22623,7 @@ platform. On the other Operating Systems the run-time is supporting UTF-8 natively. @node File content encoding,Open Modes,Filenames encoding,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2cb}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2cc} +@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2ca}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2cb} @section File content encoding @@ -22673,7 +22656,7 @@ Unicode 8-bit encoding This encoding is only supported on the Windows platform. @node Open Modes,Operations on C Streams,File content encoding,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2ce} +@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2cc}@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2cd} @section Open Modes @@ -22776,7 +22759,7 @@ subsequently requires switching from reading to writing or vice-versa, then the file is reopened in @code{r+} mode to permit the required operation. @node Operations on C Streams,Interfacing to C Streams,Open Modes,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2d0} +@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2ce}@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2cf} @section Operations on C Streams @@ -22936,7 +22919,7 @@ end Interfaces.C_Streams; @end example @node Interfacing to C Streams,,Operations on C Streams,The Implementation of Standard I/O -@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2d2} +@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d0}@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2d1} @section Interfacing to C Streams @@ -23029,7 +23012,7 @@ imported from a C program, allowing an Ada file to operate on an existing C file. @node The GNAT Library,Interfacing to Other Languages,The Implementation of Standard I/O,Top -@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}@anchor{gnat_rm/the_gnat_library doc}@anchor{2d3}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d4} +@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}@anchor{gnat_rm/the_gnat_library doc}@anchor{2d2}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d3} @chapter The GNAT Library @@ -23222,7 +23205,7 @@ of GNAT, and will generate a warning message. @end menu @node Ada Characters Latin_9 a-chlat9 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,,The GNAT Library -@anchor{gnat_rm/the_gnat_library id2}@anchor{2d5}@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2d6} +@anchor{gnat_rm/the_gnat_library id2}@anchor{2d4}@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2d5} @section @code{Ada.Characters.Latin_9} (@code{a-chlat9.ads}) @@ -23239,7 +23222,7 @@ is specifically authorized by the Ada Reference Manual (RM A.3.3(27)). @node Ada Characters Wide_Latin_1 a-cwila1 ads,Ada Characters Wide_Latin_9 a-cwila1 ads,Ada Characters Latin_9 a-chlat9 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2d7}@anchor{gnat_rm/the_gnat_library id3}@anchor{2d8} +@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2d6}@anchor{gnat_rm/the_gnat_library id3}@anchor{2d7} @section @code{Ada.Characters.Wide_Latin_1} (@code{a-cwila1.ads}) @@ -23256,7 +23239,7 @@ is specifically authorized by the Ada Reference Manual (RM A.3.3(27)). @node Ada Characters Wide_Latin_9 a-cwila1 ads,Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id4}@anchor{2d9}@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila1-ads}@anchor{2da} +@anchor{gnat_rm/the_gnat_library id4}@anchor{2d8}@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila1-ads}@anchor{2d9} @section @code{Ada.Characters.Wide_Latin_9} (@code{a-cwila1.ads}) @@ -23273,7 +23256,7 @@ is specifically authorized by the Ada Reference Manual (RM A.3.3(27)). @node Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,Ada Characters Wide_Latin_9 a-cwila1 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2db}@anchor{gnat_rm/the_gnat_library id5}@anchor{2dc} +@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2da}@anchor{gnat_rm/the_gnat_library id5}@anchor{2db} @section @code{Ada.Characters.Wide_Wide_Latin_1} (@code{a-chzla1.ads}) @@ -23290,7 +23273,7 @@ is specifically authorized by the Ada Reference Manual (RM A.3.3(27)). @node Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads,Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2dd}@anchor{gnat_rm/the_gnat_library id6}@anchor{2de} +@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2dc}@anchor{gnat_rm/the_gnat_library id6}@anchor{2dd} @section @code{Ada.Characters.Wide_Wide_Latin_9} (@code{a-chzla9.ads}) @@ -23307,7 +23290,7 @@ is specifically authorized by the Ada Reference Manual (RM A.3.3(27)). @node Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads,Ada Containers Formal_Hashed_Maps a-cfhama ads,Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id7}@anchor{2df}@anchor{gnat_rm/the_gnat_library ada-containers-formal-doubly-linked-lists-a-cfdlli-ads}@anchor{2e0} +@anchor{gnat_rm/the_gnat_library id7}@anchor{2de}@anchor{gnat_rm/the_gnat_library ada-containers-formal-doubly-linked-lists-a-cfdlli-ads}@anchor{2df} @section @code{Ada.Containers.Formal_Doubly_Linked_Lists} (@code{a-cfdlli.ads}) @@ -23326,7 +23309,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Hashed_Maps a-cfhama ads,Ada Containers Formal_Hashed_Sets a-cfhase ads,Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id8}@anchor{2e1}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-maps-a-cfhama-ads}@anchor{2e2} +@anchor{gnat_rm/the_gnat_library id8}@anchor{2e0}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-maps-a-cfhama-ads}@anchor{2e1} @section @code{Ada.Containers.Formal_Hashed_Maps} (@code{a-cfhama.ads}) @@ -23345,7 +23328,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Hashed_Sets a-cfhase ads,Ada Containers Formal_Ordered_Maps a-cforma ads,Ada Containers Formal_Hashed_Maps a-cfhama ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id9}@anchor{2e3}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-sets-a-cfhase-ads}@anchor{2e4} +@anchor{gnat_rm/the_gnat_library id9}@anchor{2e2}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-sets-a-cfhase-ads}@anchor{2e3} @section @code{Ada.Containers.Formal_Hashed_Sets} (@code{a-cfhase.ads}) @@ -23364,7 +23347,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Ordered_Maps a-cforma ads,Ada Containers Formal_Ordered_Sets a-cforse ads,Ada Containers Formal_Hashed_Sets a-cfhase ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id10}@anchor{2e5}@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-maps-a-cforma-ads}@anchor{2e6} +@anchor{gnat_rm/the_gnat_library id10}@anchor{2e4}@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-maps-a-cforma-ads}@anchor{2e5} @section @code{Ada.Containers.Formal_Ordered_Maps} (@code{a-cforma.ads}) @@ -23383,7 +23366,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Ordered_Sets a-cforse ads,Ada Containers Formal_Vectors a-cofove ads,Ada Containers Formal_Ordered_Maps a-cforma ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-sets-a-cforse-ads}@anchor{2e7}@anchor{gnat_rm/the_gnat_library id11}@anchor{2e8} +@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-sets-a-cforse-ads}@anchor{2e6}@anchor{gnat_rm/the_gnat_library id11}@anchor{2e7} @section @code{Ada.Containers.Formal_Ordered_Sets} (@code{a-cforse.ads}) @@ -23402,7 +23385,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Vectors a-cofove ads,Ada Containers Formal_Indefinite_Vectors a-cfinve ads,Ada Containers Formal_Ordered_Sets a-cforse ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id12}@anchor{2e9}@anchor{gnat_rm/the_gnat_library ada-containers-formal-vectors-a-cofove-ads}@anchor{2ea} +@anchor{gnat_rm/the_gnat_library id12}@anchor{2e8}@anchor{gnat_rm/the_gnat_library ada-containers-formal-vectors-a-cofove-ads}@anchor{2e9} @section @code{Ada.Containers.Formal_Vectors} (@code{a-cofove.ads}) @@ -23421,7 +23404,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Formal_Indefinite_Vectors a-cfinve ads,Ada Containers Functional_Vectors a-cofuve ads,Ada Containers Formal_Vectors a-cofove ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id13}@anchor{2eb}@anchor{gnat_rm/the_gnat_library ada-containers-formal-indefinite-vectors-a-cfinve-ads}@anchor{2ec} +@anchor{gnat_rm/the_gnat_library id13}@anchor{2ea}@anchor{gnat_rm/the_gnat_library ada-containers-formal-indefinite-vectors-a-cfinve-ads}@anchor{2eb} @section @code{Ada.Containers.Formal_Indefinite_Vectors} (@code{a-cfinve.ads}) @@ -23440,7 +23423,7 @@ efficient version than the one defined in the standard. In particular it does not have the complex overhead required to detect cursor tampering. @node Ada Containers Functional_Vectors a-cofuve ads,Ada Containers Functional_Sets a-cofuse ads,Ada Containers Formal_Indefinite_Vectors a-cfinve ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id14}@anchor{2ed}@anchor{gnat_rm/the_gnat_library ada-containers-functional-vectors-a-cofuve-ads}@anchor{2ee} +@anchor{gnat_rm/the_gnat_library id14}@anchor{2ec}@anchor{gnat_rm/the_gnat_library ada-containers-functional-vectors-a-cofuve-ads}@anchor{2ed} @section @code{Ada.Containers.Functional_Vectors} (@code{a-cofuve.ads}) @@ -23462,7 +23445,7 @@ and annotations, so that they can be removed from the final executable. The specification of this unit is compatible with SPARK 2014. @node Ada Containers Functional_Sets a-cofuse ads,Ada Containers Functional_Maps a-cofuma ads,Ada Containers Functional_Vectors a-cofuve ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-containers-functional-sets-a-cofuse-ads}@anchor{2ef}@anchor{gnat_rm/the_gnat_library id15}@anchor{2f0} +@anchor{gnat_rm/the_gnat_library ada-containers-functional-sets-a-cofuse-ads}@anchor{2ee}@anchor{gnat_rm/the_gnat_library id15}@anchor{2ef} @section @code{Ada.Containers.Functional_Sets} (@code{a-cofuse.ads}) @@ -23484,7 +23467,7 @@ and annotations, so that they can be removed from the final executable. The specification of this unit is compatible with SPARK 2014. @node Ada Containers Functional_Maps a-cofuma ads,Ada Containers Bounded_Holders a-coboho ads,Ada Containers Functional_Sets a-cofuse ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id16}@anchor{2f1}@anchor{gnat_rm/the_gnat_library ada-containers-functional-maps-a-cofuma-ads}@anchor{2f2} +@anchor{gnat_rm/the_gnat_library id16}@anchor{2f0}@anchor{gnat_rm/the_gnat_library ada-containers-functional-maps-a-cofuma-ads}@anchor{2f1} @section @code{Ada.Containers.Functional_Maps} (@code{a-cofuma.ads}) @@ -23506,7 +23489,7 @@ and annotations, so that they can be removed from the final executable. The specification of this unit is compatible with SPARK 2014. @node Ada Containers Bounded_Holders a-coboho ads,Ada Command_Line Environment a-colien ads,Ada Containers Functional_Maps a-cofuma ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2f3}@anchor{gnat_rm/the_gnat_library id17}@anchor{2f4} +@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2f2}@anchor{gnat_rm/the_gnat_library id17}@anchor{2f3} @section @code{Ada.Containers.Bounded_Holders} (@code{a-coboho.ads}) @@ -23518,7 +23501,7 @@ This child of @code{Ada.Containers} defines a modified version of Indefinite_Holders that avoids heap allocation. @node Ada Command_Line Environment a-colien ads,Ada Command_Line Remove a-colire ads,Ada Containers Bounded_Holders a-coboho ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{2f5}@anchor{gnat_rm/the_gnat_library id18}@anchor{2f6} +@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{2f4}@anchor{gnat_rm/the_gnat_library id18}@anchor{2f5} @section @code{Ada.Command_Line.Environment} (@code{a-colien.ads}) @@ -23531,7 +23514,7 @@ provides a mechanism for obtaining environment values on systems where this concept makes sense. @node Ada Command_Line Remove a-colire ads,Ada Command_Line Response_File a-clrefi ads,Ada Command_Line Environment a-colien ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id19}@anchor{2f7}@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f8} +@anchor{gnat_rm/the_gnat_library id19}@anchor{2f6}@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f7} @section @code{Ada.Command_Line.Remove} (@code{a-colire.ads}) @@ -23549,7 +23532,7 @@ to further calls on the subprograms in @code{Ada.Command_Line} will not see the removed argument. @node Ada Command_Line Response_File a-clrefi ads,Ada Direct_IO C_Streams a-diocst ads,Ada Command_Line Remove a-colire ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id20}@anchor{2f9}@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2fa} +@anchor{gnat_rm/the_gnat_library id20}@anchor{2f8}@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2f9} @section @code{Ada.Command_Line.Response_File} (@code{a-clrefi.ads}) @@ -23569,7 +23552,7 @@ Using a response file allow passing a set of arguments to an executable longer than the maximum allowed by the system on the command line. @node Ada Direct_IO C_Streams a-diocst ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Command_Line Response_File a-clrefi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id21}@anchor{2fb}@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2fc} +@anchor{gnat_rm/the_gnat_library id21}@anchor{2fa}@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2fb} @section @code{Ada.Direct_IO.C_Streams} (@code{a-diocst.ads}) @@ -23584,7 +23567,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Direct_IO C_Streams a-diocst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id22}@anchor{2fd}@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2fe} +@anchor{gnat_rm/the_gnat_library id22}@anchor{2fc}@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2fd} @section @code{Ada.Exceptions.Is_Null_Occurrence} (@code{a-einuoc.ads}) @@ -23598,7 +23581,7 @@ exception occurrence (@code{Null_Occurrence}) without raising an exception. @node Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Exceptions Traceback a-exctra ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id23}@anchor{2ff}@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{300} +@anchor{gnat_rm/the_gnat_library id23}@anchor{2fe}@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{2ff} @section @code{Ada.Exceptions.Last_Chance_Handler} (@code{a-elchha.ads}) @@ -23612,7 +23595,7 @@ exceptions (hence the name last chance), and perform clean ups before terminating the program. Note that this subprogram never returns. @node Ada Exceptions Traceback a-exctra ads,Ada Sequential_IO C_Streams a-siocst ads,Ada Exceptions Last_Chance_Handler a-elchha ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{301}@anchor{gnat_rm/the_gnat_library id24}@anchor{302} +@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{300}@anchor{gnat_rm/the_gnat_library id24}@anchor{301} @section @code{Ada.Exceptions.Traceback} (@code{a-exctra.ads}) @@ -23625,7 +23608,7 @@ give a traceback array of addresses based on an exception occurrence. @node Ada Sequential_IO C_Streams a-siocst ads,Ada Streams Stream_IO C_Streams a-ssicst ads,Ada Exceptions Traceback a-exctra ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{303}@anchor{gnat_rm/the_gnat_library id25}@anchor{304} +@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{302}@anchor{gnat_rm/the_gnat_library id25}@anchor{303} @section @code{Ada.Sequential_IO.C_Streams} (@code{a-siocst.ads}) @@ -23640,7 +23623,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Streams Stream_IO C_Streams a-ssicst ads,Ada Strings Unbounded Text_IO a-suteio ads,Ada Sequential_IO C_Streams a-siocst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id26}@anchor{305}@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{306} +@anchor{gnat_rm/the_gnat_library id26}@anchor{304}@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{305} @section @code{Ada.Streams.Stream_IO.C_Streams} (@code{a-ssicst.ads}) @@ -23655,7 +23638,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Strings Unbounded Text_IO a-suteio ads,Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,Ada Streams Stream_IO C_Streams a-ssicst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{307}@anchor{gnat_rm/the_gnat_library id27}@anchor{308} +@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{306}@anchor{gnat_rm/the_gnat_library id27}@anchor{307} @section @code{Ada.Strings.Unbounded.Text_IO} (@code{a-suteio.ads}) @@ -23672,7 +23655,7 @@ strings, avoiding the necessity for an intermediate operation with ordinary strings. @node Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Strings Unbounded Text_IO a-suteio ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id28}@anchor{309}@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{30a} +@anchor{gnat_rm/the_gnat_library id28}@anchor{308}@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{309} @section @code{Ada.Strings.Wide_Unbounded.Wide_Text_IO} (@code{a-swuwti.ads}) @@ -23689,7 +23672,7 @@ wide strings, avoiding the necessity for an intermediate operation with ordinary wide strings. @node Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Text_IO C_Streams a-tiocst ads,Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id29}@anchor{30b}@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{30c} +@anchor{gnat_rm/the_gnat_library id29}@anchor{30a}@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{30b} @section @code{Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO} (@code{a-szuzti.ads}) @@ -23706,7 +23689,7 @@ wide wide strings, avoiding the necessity for an intermediate operation with ordinary wide wide strings. @node Ada Text_IO C_Streams a-tiocst ads,Ada Text_IO Reset_Standard_Files a-tirsfi ads,Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{30d}@anchor{gnat_rm/the_gnat_library id30}@anchor{30e} +@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{30c}@anchor{gnat_rm/the_gnat_library id30}@anchor{30d} @section @code{Ada.Text_IO.C_Streams} (@code{a-tiocst.ads}) @@ -23721,7 +23704,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Text_IO Reset_Standard_Files a-tirsfi ads,Ada Wide_Characters Unicode a-wichun ads,Ada Text_IO C_Streams a-tiocst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{30f}@anchor{gnat_rm/the_gnat_library id31}@anchor{310} +@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{30e}@anchor{gnat_rm/the_gnat_library id31}@anchor{30f} @section @code{Ada.Text_IO.Reset_Standard_Files} (@code{a-tirsfi.ads}) @@ -23736,7 +23719,7 @@ execution (for example a standard input file may be redefined to be interactive). @node Ada Wide_Characters Unicode a-wichun ads,Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Text_IO Reset_Standard_Files a-tirsfi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id32}@anchor{311}@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{312} +@anchor{gnat_rm/the_gnat_library id32}@anchor{310}@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{311} @section @code{Ada.Wide_Characters.Unicode} (@code{a-wichun.ads}) @@ -23749,7 +23732,7 @@ This package provides subprograms that allow categorization of Wide_Character values according to Unicode categories. @node Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,Ada Wide_Characters Unicode a-wichun ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{313}@anchor{gnat_rm/the_gnat_library id33}@anchor{314} +@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{312}@anchor{gnat_rm/the_gnat_library id33}@anchor{313} @section @code{Ada.Wide_Text_IO.C_Streams} (@code{a-wtcstr.ads}) @@ -23764,7 +23747,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,Ada Wide_Wide_Characters Unicode a-zchuni ads,Ada Wide_Text_IO C_Streams a-wtcstr ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{315}@anchor{gnat_rm/the_gnat_library id34}@anchor{316} +@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{314}@anchor{gnat_rm/the_gnat_library id34}@anchor{315} @section @code{Ada.Wide_Text_IO.Reset_Standard_Files} (@code{a-wrstfi.ads}) @@ -23779,7 +23762,7 @@ execution (for example a standard input file may be redefined to be interactive). @node Ada Wide_Wide_Characters Unicode a-zchuni ads,Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id35}@anchor{317}@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{318} +@anchor{gnat_rm/the_gnat_library id35}@anchor{316}@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{317} @section @code{Ada.Wide_Wide_Characters.Unicode} (@code{a-zchuni.ads}) @@ -23792,7 +23775,7 @@ This package provides subprograms that allow categorization of Wide_Wide_Character values according to Unicode categories. @node Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,Ada Wide_Wide_Characters Unicode a-zchuni ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id36}@anchor{319}@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{31a} +@anchor{gnat_rm/the_gnat_library id36}@anchor{318}@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{319} @section @code{Ada.Wide_Wide_Text_IO.C_Streams} (@code{a-ztcstr.ads}) @@ -23807,7 +23790,7 @@ extracted from a file opened on the Ada side, and an Ada file can be constructed from a stream opened on the C side. @node Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,GNAT Altivec g-altive ads,Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id37}@anchor{31b}@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{31c} +@anchor{gnat_rm/the_gnat_library id37}@anchor{31a}@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{31b} @section @code{Ada.Wide_Wide_Text_IO.Reset_Standard_Files} (@code{a-zrstfi.ads}) @@ -23822,7 +23805,7 @@ change during execution (for example a standard input file may be redefined to be interactive). @node GNAT Altivec g-altive ads,GNAT Altivec Conversions g-altcon ads,Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{31d}@anchor{gnat_rm/the_gnat_library id38}@anchor{31e} +@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{31c}@anchor{gnat_rm/the_gnat_library id38}@anchor{31d} @section @code{GNAT.Altivec} (@code{g-altive.ads}) @@ -23835,7 +23818,7 @@ definitions of constants and types common to all the versions of the binding. @node GNAT Altivec Conversions g-altcon ads,GNAT Altivec Vector_Operations g-alveop ads,GNAT Altivec g-altive ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{31f}@anchor{gnat_rm/the_gnat_library id39}@anchor{320} +@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{31e}@anchor{gnat_rm/the_gnat_library id39}@anchor{31f} @section @code{GNAT.Altivec.Conversions} (@code{g-altcon.ads}) @@ -23846,7 +23829,7 @@ binding. This package provides the Vector/View conversion routines. @node GNAT Altivec Vector_Operations g-alveop ads,GNAT Altivec Vector_Types g-alvety ads,GNAT Altivec Conversions g-altcon ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{321}@anchor{gnat_rm/the_gnat_library id40}@anchor{322} +@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{320}@anchor{gnat_rm/the_gnat_library id40}@anchor{321} @section @code{GNAT.Altivec.Vector_Operations} (@code{g-alveop.ads}) @@ -23860,7 +23843,7 @@ library. The hard binding is provided as a separate package. This unit is common to both bindings. @node GNAT Altivec Vector_Types g-alvety ads,GNAT Altivec Vector_Views g-alvevi ads,GNAT Altivec Vector_Operations g-alveop ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{323}@anchor{gnat_rm/the_gnat_library id41}@anchor{324} +@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{322}@anchor{gnat_rm/the_gnat_library id41}@anchor{323} @section @code{GNAT.Altivec.Vector_Types} (@code{g-alvety.ads}) @@ -23872,7 +23855,7 @@ This package exposes the various vector types part of the Ada binding to AltiVec facilities. @node GNAT Altivec Vector_Views g-alvevi ads,GNAT Array_Split g-arrspl ads,GNAT Altivec Vector_Types g-alvety ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{325}@anchor{gnat_rm/the_gnat_library id42}@anchor{326} +@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{324}@anchor{gnat_rm/the_gnat_library id42}@anchor{325} @section @code{GNAT.Altivec.Vector_Views} (@code{g-alvevi.ads}) @@ -23887,7 +23870,7 @@ vector elements and provides a simple way to initialize vector objects. @node GNAT Array_Split g-arrspl ads,GNAT AWK g-awk ads,GNAT Altivec Vector_Views g-alvevi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{327}@anchor{gnat_rm/the_gnat_library id43}@anchor{328} +@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{326}@anchor{gnat_rm/the_gnat_library id43}@anchor{327} @section @code{GNAT.Array_Split} (@code{g-arrspl.ads}) @@ -23900,7 +23883,7 @@ an array wherever the separators appear, and provide direct access to the resulting slices. @node GNAT AWK g-awk ads,GNAT Bind_Environment g-binenv ads,GNAT Array_Split g-arrspl ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id44}@anchor{329}@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{32a} +@anchor{gnat_rm/the_gnat_library id44}@anchor{328}@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{329} @section @code{GNAT.AWK} (@code{g-awk.ads}) @@ -23915,7 +23898,7 @@ or more files containing formatted data. The file is viewed as a database where each record is a line and a field is a data element in this line. @node GNAT Bind_Environment g-binenv ads,GNAT Branch_Prediction g-brapre ads,GNAT AWK g-awk ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{32b}@anchor{gnat_rm/the_gnat_library id45}@anchor{32c} +@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{32a}@anchor{gnat_rm/the_gnat_library id45}@anchor{32b} @section @code{GNAT.Bind_Environment} (@code{g-binenv.ads}) @@ -23928,7 +23911,7 @@ These associations can be specified using the @code{-V} binder command line switch. @node GNAT Branch_Prediction g-brapre ads,GNAT Bounded_Buffers g-boubuf ads,GNAT Bind_Environment g-binenv ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id46}@anchor{32d}@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{32e} +@anchor{gnat_rm/the_gnat_library id46}@anchor{32c}@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{32d} @section @code{GNAT.Branch_Prediction} (@code{g-brapre.ads}) @@ -23939,7 +23922,7 @@ line switch. Provides routines giving hints to the branch predictor of the code generator. @node GNAT Bounded_Buffers g-boubuf ads,GNAT Bounded_Mailboxes g-boumai ads,GNAT Branch_Prediction g-brapre ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id47}@anchor{32f}@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{330} +@anchor{gnat_rm/the_gnat_library id47}@anchor{32e}@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{32f} @section @code{GNAT.Bounded_Buffers} (@code{g-boubuf.ads}) @@ -23954,7 +23937,7 @@ useful directly or as parts of the implementations of other abstractions, such as mailboxes. @node GNAT Bounded_Mailboxes g-boumai ads,GNAT Bubble_Sort g-bubsor ads,GNAT Bounded_Buffers g-boubuf ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{331}@anchor{gnat_rm/the_gnat_library id48}@anchor{332} +@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{330}@anchor{gnat_rm/the_gnat_library id48}@anchor{331} @section @code{GNAT.Bounded_Mailboxes} (@code{g-boumai.ads}) @@ -23967,7 +23950,7 @@ such as mailboxes. Provides a thread-safe asynchronous intertask mailbox communication facility. @node GNAT Bubble_Sort g-bubsor ads,GNAT Bubble_Sort_A g-busora ads,GNAT Bounded_Mailboxes g-boumai ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{333}@anchor{gnat_rm/the_gnat_library id49}@anchor{334} +@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{332}@anchor{gnat_rm/the_gnat_library id49}@anchor{333} @section @code{GNAT.Bubble_Sort} (@code{g-bubsor.ads}) @@ -23982,7 +23965,7 @@ data items. Exchange and comparison procedures are provided by passing access-to-procedure values. @node GNAT Bubble_Sort_A g-busora ads,GNAT Bubble_Sort_G g-busorg ads,GNAT Bubble_Sort g-bubsor ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id50}@anchor{335}@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{336} +@anchor{gnat_rm/the_gnat_library id50}@anchor{334}@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{335} @section @code{GNAT.Bubble_Sort_A} (@code{g-busora.ads}) @@ -23998,7 +23981,7 @@ access-to-procedure values. This is an older version, retained for compatibility. Usually @code{GNAT.Bubble_Sort} will be preferable. @node GNAT Bubble_Sort_G g-busorg ads,GNAT Byte_Order_Mark g-byorma ads,GNAT Bubble_Sort_A g-busora ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{337}@anchor{gnat_rm/the_gnat_library id51}@anchor{338} +@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{336}@anchor{gnat_rm/the_gnat_library id51}@anchor{337} @section @code{GNAT.Bubble_Sort_G} (@code{g-busorg.ads}) @@ -24014,7 +23997,7 @@ if the procedures can be inlined, at the expense of duplicating code for multiple instantiations. @node GNAT Byte_Order_Mark g-byorma ads,GNAT Byte_Swapping g-bytswa ads,GNAT Bubble_Sort_G g-busorg ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{339}@anchor{gnat_rm/the_gnat_library id52}@anchor{33a} +@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{338}@anchor{gnat_rm/the_gnat_library id52}@anchor{339} @section @code{GNAT.Byte_Order_Mark} (@code{g-byorma.ads}) @@ -24030,7 +24013,7 @@ the encoding of the string. The routine includes detection of special XML sequences for various UCS input formats. @node GNAT Byte_Swapping g-bytswa ads,GNAT Calendar g-calend ads,GNAT Byte_Order_Mark g-byorma ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{33b}@anchor{gnat_rm/the_gnat_library id53}@anchor{33c} +@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{33a}@anchor{gnat_rm/the_gnat_library id53}@anchor{33b} @section @code{GNAT.Byte_Swapping} (@code{g-bytswa.ads}) @@ -24044,7 +24027,7 @@ General routines for swapping the bytes in 2-, 4-, and 8-byte quantities. Machine-specific implementations are available in some cases. @node GNAT Calendar g-calend ads,GNAT Calendar Time_IO g-catiio ads,GNAT Byte_Swapping g-bytswa ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id54}@anchor{33d}@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{33e} +@anchor{gnat_rm/the_gnat_library id54}@anchor{33c}@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{33d} @section @code{GNAT.Calendar} (@code{g-calend.ads}) @@ -24058,7 +24041,7 @@ Also provides conversion of @code{Ada.Calendar.Time} values to and from the C @code{timeval} format. @node GNAT Calendar Time_IO g-catiio ads,GNAT CRC32 g-crc32 ads,GNAT Calendar g-calend ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id55}@anchor{33f}@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{340} +@anchor{gnat_rm/the_gnat_library id55}@anchor{33e}@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{33f} @section @code{GNAT.Calendar.Time_IO} (@code{g-catiio.ads}) @@ -24069,7 +24052,7 @@ C @code{timeval} format. @geindex GNAT.Calendar.Time_IO (g-catiio.ads) @node GNAT CRC32 g-crc32 ads,GNAT Case_Util g-casuti ads,GNAT Calendar Time_IO g-catiio ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id56}@anchor{341}@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{342} +@anchor{gnat_rm/the_gnat_library id56}@anchor{340}@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{341} @section @code{GNAT.CRC32} (@code{g-crc32.ads}) @@ -24086,7 +24069,7 @@ of this algorithm see Aug. 1988. Sarwate, D.V. @node GNAT Case_Util g-casuti ads,GNAT CGI g-cgi ads,GNAT CRC32 g-crc32 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id57}@anchor{343}@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{344} +@anchor{gnat_rm/the_gnat_library id57}@anchor{342}@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{343} @section @code{GNAT.Case_Util} (@code{g-casuti.ads}) @@ -24101,7 +24084,7 @@ without the overhead of the full casing tables in @code{Ada.Characters.Handling}. @node GNAT CGI g-cgi ads,GNAT CGI Cookie g-cgicoo ads,GNAT Case_Util g-casuti ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id58}@anchor{345}@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{346} +@anchor{gnat_rm/the_gnat_library id58}@anchor{344}@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{345} @section @code{GNAT.CGI} (@code{g-cgi.ads}) @@ -24116,7 +24099,7 @@ builds a table whose index is the key and provides some services to deal with this table. @node GNAT CGI Cookie g-cgicoo ads,GNAT CGI Debug g-cgideb ads,GNAT CGI g-cgi ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{347}@anchor{gnat_rm/the_gnat_library id59}@anchor{348} +@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{346}@anchor{gnat_rm/the_gnat_library id59}@anchor{347} @section @code{GNAT.CGI.Cookie} (@code{g-cgicoo.ads}) @@ -24131,7 +24114,7 @@ Common Gateway Interface (CGI). It exports services to deal with Web cookies (piece of information kept in the Web client software). @node GNAT CGI Debug g-cgideb ads,GNAT Command_Line g-comlin ads,GNAT CGI Cookie g-cgicoo ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{349}@anchor{gnat_rm/the_gnat_library id60}@anchor{34a} +@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{348}@anchor{gnat_rm/the_gnat_library id60}@anchor{349} @section @code{GNAT.CGI.Debug} (@code{g-cgideb.ads}) @@ -24143,7 +24126,7 @@ This is a package to help debugging CGI (Common Gateway Interface) programs written in Ada. @node GNAT Command_Line g-comlin ads,GNAT Compiler_Version g-comver ads,GNAT CGI Debug g-cgideb ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id61}@anchor{34b}@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{34c} +@anchor{gnat_rm/the_gnat_library id61}@anchor{34a}@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{34b} @section @code{GNAT.Command_Line} (@code{g-comlin.ads}) @@ -24156,7 +24139,7 @@ including the ability to scan for named switches with optional parameters and expand file names using wildcard notations. @node GNAT Compiler_Version g-comver ads,GNAT Ctrl_C g-ctrl_c ads,GNAT Command_Line g-comlin ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{34d}@anchor{gnat_rm/the_gnat_library id62}@anchor{34e} +@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{34c}@anchor{gnat_rm/the_gnat_library id62}@anchor{34d} @section @code{GNAT.Compiler_Version} (@code{g-comver.ads}) @@ -24174,7 +24157,7 @@ of the compiler if a consistent tool set is used to compile all units of a partition). @node GNAT Ctrl_C g-ctrl_c ads,GNAT Current_Exception g-curexc ads,GNAT Compiler_Version g-comver ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{34f}@anchor{gnat_rm/the_gnat_library id63}@anchor{350} +@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{34e}@anchor{gnat_rm/the_gnat_library id63}@anchor{34f} @section @code{GNAT.Ctrl_C} (@code{g-ctrl_c.ads}) @@ -24185,7 +24168,7 @@ of a partition). Provides a simple interface to handle Ctrl-C keyboard events. @node GNAT Current_Exception g-curexc ads,GNAT Debug_Pools g-debpoo ads,GNAT Ctrl_C g-ctrl_c ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id64}@anchor{351}@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{352} +@anchor{gnat_rm/the_gnat_library id64}@anchor{350}@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{351} @section @code{GNAT.Current_Exception} (@code{g-curexc.ads}) @@ -24202,7 +24185,7 @@ This is particularly useful in simulating typical facilities for obtaining information about exceptions provided by Ada 83 compilers. @node GNAT Debug_Pools g-debpoo ads,GNAT Debug_Utilities g-debuti ads,GNAT Current_Exception g-curexc ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{353}@anchor{gnat_rm/the_gnat_library id65}@anchor{354} +@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{352}@anchor{gnat_rm/the_gnat_library id65}@anchor{353} @section @code{GNAT.Debug_Pools} (@code{g-debpoo.ads}) @@ -24219,7 +24202,7 @@ problems. See @code{The GNAT Debug_Pool Facility} section in the @cite{GNAT User's Guide}. @node GNAT Debug_Utilities g-debuti ads,GNAT Decode_String g-decstr ads,GNAT Debug_Pools g-debpoo ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{355}@anchor{gnat_rm/the_gnat_library id66}@anchor{356} +@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{354}@anchor{gnat_rm/the_gnat_library id66}@anchor{355} @section @code{GNAT.Debug_Utilities} (@code{g-debuti.ads}) @@ -24232,7 +24215,7 @@ to and from string images of address values. Supports both C and Ada formats for hexadecimal literals. @node GNAT Decode_String g-decstr ads,GNAT Decode_UTF8_String g-deutst ads,GNAT Debug_Utilities g-debuti ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id67}@anchor{357}@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{358} +@anchor{gnat_rm/the_gnat_library id67}@anchor{356}@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{357} @section @code{GNAT.Decode_String} (@code{g-decstr.ads}) @@ -24256,7 +24239,7 @@ Useful in conjunction with Unicode character coding. Note there is a preinstantiation for UTF-8. See next entry. @node GNAT Decode_UTF8_String g-deutst ads,GNAT Directory_Operations g-dirope ads,GNAT Decode_String g-decstr ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{359}@anchor{gnat_rm/the_gnat_library id68}@anchor{35a} +@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{358}@anchor{gnat_rm/the_gnat_library id68}@anchor{359} @section @code{GNAT.Decode_UTF8_String} (@code{g-deutst.ads}) @@ -24277,7 +24260,7 @@ preinstantiation for UTF-8. See next entry. A preinstantiation of GNAT.Decode_Strings for UTF-8 encoding. @node GNAT Directory_Operations g-dirope ads,GNAT Directory_Operations Iteration g-diopit ads,GNAT Decode_UTF8_String g-deutst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id69}@anchor{35b}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{35c} +@anchor{gnat_rm/the_gnat_library id69}@anchor{35a}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{35b} @section @code{GNAT.Directory_Operations} (@code{g-dirope.ads}) @@ -24290,7 +24273,7 @@ the current directory, making new directories, and scanning the files in a directory. @node GNAT Directory_Operations Iteration g-diopit ads,GNAT Dynamic_HTables g-dynhta ads,GNAT Directory_Operations g-dirope ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id70}@anchor{35d}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{35e} +@anchor{gnat_rm/the_gnat_library id70}@anchor{35c}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{35d} @section @code{GNAT.Directory_Operations.Iteration} (@code{g-diopit.ads}) @@ -24302,7 +24285,7 @@ A child unit of GNAT.Directory_Operations providing additional operations for iterating through directories. @node GNAT Dynamic_HTables g-dynhta ads,GNAT Dynamic_Tables g-dyntab ads,GNAT Directory_Operations Iteration g-diopit ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id71}@anchor{35f}@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{360} +@anchor{gnat_rm/the_gnat_library id71}@anchor{35e}@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{35f} @section @code{GNAT.Dynamic_HTables} (@code{g-dynhta.ads}) @@ -24320,7 +24303,7 @@ dynamic instances of the hash table, while an instantiation of @code{GNAT.HTable} creates a single instance of the hash table. @node GNAT Dynamic_Tables g-dyntab ads,GNAT Encode_String g-encstr ads,GNAT Dynamic_HTables g-dynhta ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{361}@anchor{gnat_rm/the_gnat_library id72}@anchor{362} +@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{360}@anchor{gnat_rm/the_gnat_library id72}@anchor{361} @section @code{GNAT.Dynamic_Tables} (@code{g-dyntab.ads}) @@ -24340,7 +24323,7 @@ dynamic instances of the table, while an instantiation of @code{GNAT.Table} creates a single instance of the table type. @node GNAT Encode_String g-encstr ads,GNAT Encode_UTF8_String g-enutst ads,GNAT Dynamic_Tables g-dyntab ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id73}@anchor{363}@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{364} +@anchor{gnat_rm/the_gnat_library id73}@anchor{362}@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{363} @section @code{GNAT.Encode_String} (@code{g-encstr.ads}) @@ -24362,7 +24345,7 @@ encoding method. Useful in conjunction with Unicode character coding. Note there is a preinstantiation for UTF-8. See next entry. @node GNAT Encode_UTF8_String g-enutst ads,GNAT Exception_Actions g-excact ads,GNAT Encode_String g-encstr ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{365}@anchor{gnat_rm/the_gnat_library id74}@anchor{366} +@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{364}@anchor{gnat_rm/the_gnat_library id74}@anchor{365} @section @code{GNAT.Encode_UTF8_String} (@code{g-enutst.ads}) @@ -24383,7 +24366,7 @@ Note there is a preinstantiation for UTF-8. See next entry. A preinstantiation of GNAT.Encode_Strings for UTF-8 encoding. @node GNAT Exception_Actions g-excact ads,GNAT Exception_Traces g-exctra ads,GNAT Encode_UTF8_String g-enutst ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{367}@anchor{gnat_rm/the_gnat_library id75}@anchor{368} +@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{366}@anchor{gnat_rm/the_gnat_library id75}@anchor{367} @section @code{GNAT.Exception_Actions} (@code{g-excact.ads}) @@ -24396,7 +24379,7 @@ for specific exceptions, or when any exception is raised. This can be used for instance to force a core dump to ease debugging. @node GNAT Exception_Traces g-exctra ads,GNAT Exceptions g-except ads,GNAT Exception_Actions g-excact ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{369}@anchor{gnat_rm/the_gnat_library id76}@anchor{36a} +@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{368}@anchor{gnat_rm/the_gnat_library id76}@anchor{369} @section @code{GNAT.Exception_Traces} (@code{g-exctra.ads}) @@ -24410,7 +24393,7 @@ Provides an interface allowing to control automatic output upon exception occurrences. @node GNAT Exceptions g-except ads,GNAT Expect g-expect ads,GNAT Exception_Traces g-exctra ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id77}@anchor{36b}@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{36c} +@anchor{gnat_rm/the_gnat_library id77}@anchor{36a}@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{36b} @section @code{GNAT.Exceptions} (@code{g-except.ads}) @@ -24431,7 +24414,7 @@ predefined exceptions, and for example allow raising @code{Constraint_Error} with a message from a pure subprogram. @node GNAT Expect g-expect ads,GNAT Expect TTY g-exptty ads,GNAT Exceptions g-except ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id78}@anchor{36d}@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{36e} +@anchor{gnat_rm/the_gnat_library id78}@anchor{36c}@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{36d} @section @code{GNAT.Expect} (@code{g-expect.ads}) @@ -24447,7 +24430,7 @@ It is not implemented for cross ports, and in particular is not implemented for VxWorks or LynxOS. @node GNAT Expect TTY g-exptty ads,GNAT Float_Control g-flocon ads,GNAT Expect g-expect ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id79}@anchor{36f}@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{370} +@anchor{gnat_rm/the_gnat_library id79}@anchor{36e}@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{36f} @section @code{GNAT.Expect.TTY} (@code{g-exptty.ads}) @@ -24459,7 +24442,7 @@ ports. It is not implemented for cross ports, and in particular is not implemented for VxWorks or LynxOS. @node GNAT Float_Control g-flocon ads,GNAT Formatted_String g-forstr ads,GNAT Expect TTY g-exptty ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id80}@anchor{371}@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{372} +@anchor{gnat_rm/the_gnat_library id80}@anchor{370}@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{371} @section @code{GNAT.Float_Control} (@code{g-flocon.ads}) @@ -24473,7 +24456,7 @@ library calls may cause this mode to be modified, and the Reset procedure in this package can be used to reestablish the required mode. @node GNAT Formatted_String g-forstr ads,GNAT Heap_Sort g-heasor ads,GNAT Float_Control g-flocon ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id81}@anchor{373}@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{374} +@anchor{gnat_rm/the_gnat_library id81}@anchor{372}@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{373} @section @code{GNAT.Formatted_String} (@code{g-forstr.ads}) @@ -24488,7 +24471,7 @@ derived from Integer, Float or enumerations as values for the formatted string. @node GNAT Heap_Sort g-heasor ads,GNAT Heap_Sort_A g-hesora ads,GNAT Formatted_String g-forstr ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{375}@anchor{gnat_rm/the_gnat_library id82}@anchor{376} +@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{374}@anchor{gnat_rm/the_gnat_library id82}@anchor{375} @section @code{GNAT.Heap_Sort} (@code{g-heasor.ads}) @@ -24502,7 +24485,7 @@ access-to-procedure values. The algorithm used is a modified heap sort that performs approximately N*log(N) comparisons in the worst case. @node GNAT Heap_Sort_A g-hesora ads,GNAT Heap_Sort_G g-hesorg ads,GNAT Heap_Sort g-heasor ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id83}@anchor{377}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{378} +@anchor{gnat_rm/the_gnat_library id83}@anchor{376}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{377} @section @code{GNAT.Heap_Sort_A} (@code{g-hesora.ads}) @@ -24518,7 +24501,7 @@ This differs from @code{GNAT.Heap_Sort} in having a less convenient interface, but may be slightly more efficient. @node GNAT Heap_Sort_G g-hesorg ads,GNAT HTable g-htable ads,GNAT Heap_Sort_A g-hesora ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id84}@anchor{379}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{37a} +@anchor{gnat_rm/the_gnat_library id84}@anchor{378}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{379} @section @code{GNAT.Heap_Sort_G} (@code{g-hesorg.ads}) @@ -24532,7 +24515,7 @@ if the procedures can be inlined, at the expense of duplicating code for multiple instantiations. @node GNAT HTable g-htable ads,GNAT IO g-io ads,GNAT Heap_Sort_G g-hesorg ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id85}@anchor{37b}@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37c} +@anchor{gnat_rm/the_gnat_library id85}@anchor{37a}@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37b} @section @code{GNAT.HTable} (@code{g-htable.ads}) @@ -24545,7 +24528,7 @@ data. Provides two approaches, one a simple static approach, and the other allowing arbitrary dynamic hash tables. @node GNAT IO g-io ads,GNAT IO_Aux g-io_aux ads,GNAT HTable g-htable ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id86}@anchor{37d}@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{37e} +@anchor{gnat_rm/the_gnat_library id86}@anchor{37c}@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{37d} @section @code{GNAT.IO} (@code{g-io.ads}) @@ -24561,7 +24544,7 @@ Standard_Input, and writing characters, strings and integers to either Standard_Output or Standard_Error. @node GNAT IO_Aux g-io_aux ads,GNAT Lock_Files g-locfil ads,GNAT IO g-io ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id87}@anchor{37f}@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{380} +@anchor{gnat_rm/the_gnat_library id87}@anchor{37e}@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{37f} @section @code{GNAT.IO_Aux} (@code{g-io_aux.ads}) @@ -24575,7 +24558,7 @@ Provides some auxiliary functions for use with Text_IO, including a test for whether a file exists, and functions for reading a line of text. @node GNAT Lock_Files g-locfil ads,GNAT MBBS_Discrete_Random g-mbdira ads,GNAT IO_Aux g-io_aux ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id88}@anchor{381}@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{382} +@anchor{gnat_rm/the_gnat_library id88}@anchor{380}@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{381} @section @code{GNAT.Lock_Files} (@code{g-locfil.ads}) @@ -24589,7 +24572,7 @@ Provides a general interface for using files as locks. Can be used for providing program level synchronization. @node GNAT MBBS_Discrete_Random g-mbdira ads,GNAT MBBS_Float_Random g-mbflra ads,GNAT Lock_Files g-locfil ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id89}@anchor{383}@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{384} +@anchor{gnat_rm/the_gnat_library id89}@anchor{382}@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{383} @section @code{GNAT.MBBS_Discrete_Random} (@code{g-mbdira.ads}) @@ -24601,7 +24584,7 @@ The original implementation of @code{Ada.Numerics.Discrete_Random}. Uses a modified version of the Blum-Blum-Shub generator. @node GNAT MBBS_Float_Random g-mbflra ads,GNAT MD5 g-md5 ads,GNAT MBBS_Discrete_Random g-mbdira ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id90}@anchor{385}@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{386} +@anchor{gnat_rm/the_gnat_library id90}@anchor{384}@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{385} @section @code{GNAT.MBBS_Float_Random} (@code{g-mbflra.ads}) @@ -24613,7 +24596,7 @@ The original implementation of @code{Ada.Numerics.Float_Random}. Uses a modified version of the Blum-Blum-Shub generator. @node GNAT MD5 g-md5 ads,GNAT Memory_Dump g-memdum ads,GNAT MBBS_Float_Random g-mbflra ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id91}@anchor{387}@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{388} +@anchor{gnat_rm/the_gnat_library id91}@anchor{386}@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{387} @section @code{GNAT.MD5} (@code{g-md5.ads}) @@ -24626,7 +24609,7 @@ the HMAC-MD5 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT Memory_Dump g-memdum ads,GNAT Most_Recent_Exception g-moreex ads,GNAT MD5 g-md5 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id92}@anchor{389}@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{38a} +@anchor{gnat_rm/the_gnat_library id92}@anchor{388}@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{389} @section @code{GNAT.Memory_Dump} (@code{g-memdum.ads}) @@ -24639,7 +24622,7 @@ standard output or standard error files. Uses GNAT.IO for actual output. @node GNAT Most_Recent_Exception g-moreex ads,GNAT OS_Lib g-os_lib ads,GNAT Memory_Dump g-memdum ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{38b}@anchor{gnat_rm/the_gnat_library id93}@anchor{38c} +@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{38a}@anchor{gnat_rm/the_gnat_library id93}@anchor{38b} @section @code{GNAT.Most_Recent_Exception} (@code{g-moreex.ads}) @@ -24653,7 +24636,7 @@ various logging purposes, including duplicating functionality of some Ada 83 implementation dependent extensions. @node GNAT OS_Lib g-os_lib ads,GNAT Perfect_Hash_Generators g-pehage ads,GNAT Most_Recent_Exception g-moreex ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{38d}@anchor{gnat_rm/the_gnat_library id94}@anchor{38e} +@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{38c}@anchor{gnat_rm/the_gnat_library id94}@anchor{38d} @section @code{GNAT.OS_Lib} (@code{g-os_lib.ads}) @@ -24669,7 +24652,7 @@ including a portable spawn procedure, and access to environment variables and error return codes. @node GNAT Perfect_Hash_Generators g-pehage ads,GNAT Random_Numbers g-rannum ads,GNAT OS_Lib g-os_lib ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{38f}@anchor{gnat_rm/the_gnat_library id95}@anchor{390} +@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{38e}@anchor{gnat_rm/the_gnat_library id95}@anchor{38f} @section @code{GNAT.Perfect_Hash_Generators} (@code{g-pehage.ads}) @@ -24687,7 +24670,7 @@ hashcode are in the same order. These hashing functions are very convenient for use with realtime applications. @node GNAT Random_Numbers g-rannum ads,GNAT Regexp g-regexp ads,GNAT Perfect_Hash_Generators g-pehage ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{391}@anchor{gnat_rm/the_gnat_library id96}@anchor{392} +@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{390}@anchor{gnat_rm/the_gnat_library id96}@anchor{391} @section @code{GNAT.Random_Numbers} (@code{g-rannum.ads}) @@ -24699,7 +24682,7 @@ Provides random number capabilities which extend those available in the standard Ada library and are more convenient to use. @node GNAT Regexp g-regexp ads,GNAT Registry g-regist ads,GNAT Random_Numbers g-rannum ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{25a}@anchor{gnat_rm/the_gnat_library id97}@anchor{393} +@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{259}@anchor{gnat_rm/the_gnat_library id97}@anchor{392} @section @code{GNAT.Regexp} (@code{g-regexp.ads}) @@ -24715,7 +24698,7 @@ simplest of the three pattern matching packages provided, and is particularly suitable for 'file globbing' applications. @node GNAT Registry g-regist ads,GNAT Regpat g-regpat ads,GNAT Regexp g-regexp ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id98}@anchor{394}@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{395} +@anchor{gnat_rm/the_gnat_library id98}@anchor{393}@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{394} @section @code{GNAT.Registry} (@code{g-regist.ads}) @@ -24729,7 +24712,7 @@ registry API, but at a lower level of abstraction, refer to the Win32.Winreg package provided with the Win32Ada binding @node GNAT Regpat g-regpat ads,GNAT Rewrite_Data g-rewdat ads,GNAT Registry g-regist ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id99}@anchor{396}@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{397} +@anchor{gnat_rm/the_gnat_library id99}@anchor{395}@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{396} @section @code{GNAT.Regpat} (@code{g-regpat.ads}) @@ -24744,7 +24727,7 @@ from the original V7 style regular expression library written in C by Henry Spencer (and binary compatible with this C library). @node GNAT Rewrite_Data g-rewdat ads,GNAT Secondary_Stack_Info g-sestin ads,GNAT Regpat g-regpat ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id100}@anchor{398}@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{399} +@anchor{gnat_rm/the_gnat_library id100}@anchor{397}@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{398} @section @code{GNAT.Rewrite_Data} (@code{g-rewdat.ads}) @@ -24758,7 +24741,7 @@ full content to be processed is not loaded into memory all at once. This makes this interface usable for large files or socket streams. @node GNAT Secondary_Stack_Info g-sestin ads,GNAT Semaphores g-semaph ads,GNAT Rewrite_Data g-rewdat ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id101}@anchor{39a}@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{39b} +@anchor{gnat_rm/the_gnat_library id101}@anchor{399}@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{39a} @section @code{GNAT.Secondary_Stack_Info} (@code{g-sestin.ads}) @@ -24770,7 +24753,7 @@ Provide the capability to query the high water mark of the current task's secondary stack. @node GNAT Semaphores g-semaph ads,GNAT Serial_Communications g-sercom ads,GNAT Secondary_Stack_Info g-sestin ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id102}@anchor{39c}@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39d} +@anchor{gnat_rm/the_gnat_library id102}@anchor{39b}@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39c} @section @code{GNAT.Semaphores} (@code{g-semaph.ads}) @@ -24781,7 +24764,7 @@ secondary stack. Provides classic counting and binary semaphores using protected types. @node GNAT Serial_Communications g-sercom ads,GNAT SHA1 g-sha1 ads,GNAT Semaphores g-semaph ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{39e}@anchor{gnat_rm/the_gnat_library id103}@anchor{39f} +@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{39d}@anchor{gnat_rm/the_gnat_library id103}@anchor{39e} @section @code{GNAT.Serial_Communications} (@code{g-sercom.ads}) @@ -24793,7 +24776,7 @@ Provides a simple interface to send and receive data over a serial port. This is only supported on GNU/Linux and Windows. @node GNAT SHA1 g-sha1 ads,GNAT SHA224 g-sha224 ads,GNAT Serial_Communications g-sercom ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{3a0}@anchor{gnat_rm/the_gnat_library id104}@anchor{3a1} +@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{39f}@anchor{gnat_rm/the_gnat_library id104}@anchor{3a0} @section @code{GNAT.SHA1} (@code{g-sha1.ads}) @@ -24806,7 +24789,7 @@ and RFC 3174, and the HMAC-SHA1 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT SHA224 g-sha224 ads,GNAT SHA256 g-sha256 ads,GNAT SHA1 g-sha1 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{3a2}@anchor{gnat_rm/the_gnat_library id105}@anchor{3a3} +@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{3a1}@anchor{gnat_rm/the_gnat_library id105}@anchor{3a2} @section @code{GNAT.SHA224} (@code{g-sha224.ads}) @@ -24819,7 +24802,7 @@ and the HMAC-SHA224 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT SHA256 g-sha256 ads,GNAT SHA384 g-sha384 ads,GNAT SHA224 g-sha224 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{3a4}@anchor{gnat_rm/the_gnat_library id106}@anchor{3a5} +@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{3a3}@anchor{gnat_rm/the_gnat_library id106}@anchor{3a4} @section @code{GNAT.SHA256} (@code{g-sha256.ads}) @@ -24832,7 +24815,7 @@ and the HMAC-SHA256 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT SHA384 g-sha384 ads,GNAT SHA512 g-sha512 ads,GNAT SHA256 g-sha256 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a6}@anchor{gnat_rm/the_gnat_library id107}@anchor{3a7} +@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a5}@anchor{gnat_rm/the_gnat_library id107}@anchor{3a6} @section @code{GNAT.SHA384} (@code{g-sha384.ads}) @@ -24845,7 +24828,7 @@ and the HMAC-SHA384 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT SHA512 g-sha512 ads,GNAT Signals g-signal ads,GNAT SHA384 g-sha384 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id108}@anchor{3a8}@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3a9} +@anchor{gnat_rm/the_gnat_library id108}@anchor{3a7}@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3a8} @section @code{GNAT.SHA512} (@code{g-sha512.ads}) @@ -24858,7 +24841,7 @@ and the HMAC-SHA512 message authentication function as described in RFC 2104 and FIPS PUB 198. @node GNAT Signals g-signal ads,GNAT Sockets g-socket ads,GNAT SHA512 g-sha512 ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id109}@anchor{3aa}@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3ab} +@anchor{gnat_rm/the_gnat_library id109}@anchor{3a9}@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3aa} @section @code{GNAT.Signals} (@code{g-signal.ads}) @@ -24870,7 +24853,7 @@ Provides the ability to manipulate the blocked status of signals on supported targets. @node GNAT Sockets g-socket ads,GNAT Source_Info g-souinf ads,GNAT Signals g-signal ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3ac}@anchor{gnat_rm/the_gnat_library id110}@anchor{3ad} +@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3ab}@anchor{gnat_rm/the_gnat_library id110}@anchor{3ac} @section @code{GNAT.Sockets} (@code{g-socket.ads}) @@ -24885,7 +24868,7 @@ on all native GNAT ports and on VxWorks cross prots. It is not implemented for the LynxOS cross port. @node GNAT Source_Info g-souinf ads,GNAT Spelling_Checker g-speche ads,GNAT Sockets g-socket ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3ae}@anchor{gnat_rm/the_gnat_library id111}@anchor{3af} +@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3ad}@anchor{gnat_rm/the_gnat_library id111}@anchor{3ae} @section @code{GNAT.Source_Info} (@code{g-souinf.ads}) @@ -24899,7 +24882,7 @@ subprograms yielding the date and time of the current compilation (like the C macros @code{__DATE__} and @code{__TIME__}) @node GNAT Spelling_Checker g-speche ads,GNAT Spelling_Checker_Generic g-spchge ads,GNAT Source_Info g-souinf ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id112}@anchor{3b0}@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3b1} +@anchor{gnat_rm/the_gnat_library id112}@anchor{3af}@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3b0} @section @code{GNAT.Spelling_Checker} (@code{g-speche.ads}) @@ -24911,7 +24894,7 @@ Provides a function for determining whether one string is a plausible near misspelling of another string. @node GNAT Spelling_Checker_Generic g-spchge ads,GNAT Spitbol Patterns g-spipat ads,GNAT Spelling_Checker g-speche ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3b2}@anchor{gnat_rm/the_gnat_library id113}@anchor{3b3} +@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3b1}@anchor{gnat_rm/the_gnat_library id113}@anchor{3b2} @section @code{GNAT.Spelling_Checker_Generic} (@code{g-spchge.ads}) @@ -24924,7 +24907,7 @@ determining whether one string is a plausible near misspelling of another string. @node GNAT Spitbol Patterns g-spipat ads,GNAT Spitbol g-spitbo ads,GNAT Spelling_Checker_Generic g-spchge ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3b4}@anchor{gnat_rm/the_gnat_library id114}@anchor{3b5} +@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3b3}@anchor{gnat_rm/the_gnat_library id114}@anchor{3b4} @section @code{GNAT.Spitbol.Patterns} (@code{g-spipat.ads}) @@ -24940,7 +24923,7 @@ the SNOBOL4 dynamic pattern construction and matching capabilities, using the efficient algorithm developed by Robert Dewar for the SPITBOL system. @node GNAT Spitbol g-spitbo ads,GNAT Spitbol Table_Boolean g-sptabo ads,GNAT Spitbol Patterns g-spipat ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b6}@anchor{gnat_rm/the_gnat_library id115}@anchor{3b7} +@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b5}@anchor{gnat_rm/the_gnat_library id115}@anchor{3b6} @section @code{GNAT.Spitbol} (@code{g-spitbo.ads}) @@ -24955,7 +24938,7 @@ useful for constructing arbitrary mappings from strings in the style of the SNOBOL4 TABLE function. @node GNAT Spitbol Table_Boolean g-sptabo ads,GNAT Spitbol Table_Integer g-sptain ads,GNAT Spitbol g-spitbo ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id116}@anchor{3b8}@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3b9} +@anchor{gnat_rm/the_gnat_library id116}@anchor{3b7}@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3b8} @section @code{GNAT.Spitbol.Table_Boolean} (@code{g-sptabo.ads}) @@ -24970,7 +24953,7 @@ for type @code{Standard.Boolean}, giving an implementation of sets of string values. @node GNAT Spitbol Table_Integer g-sptain ads,GNAT Spitbol Table_VString g-sptavs ads,GNAT Spitbol Table_Boolean g-sptabo ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3ba}@anchor{gnat_rm/the_gnat_library id117}@anchor{3bb} +@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3b9}@anchor{gnat_rm/the_gnat_library id117}@anchor{3ba} @section @code{GNAT.Spitbol.Table_Integer} (@code{g-sptain.ads}) @@ -24987,7 +24970,7 @@ for type @code{Standard.Integer}, giving an implementation of maps from string to integer values. @node GNAT Spitbol Table_VString g-sptavs ads,GNAT SSE g-sse ads,GNAT Spitbol Table_Integer g-sptain ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id118}@anchor{3bc}@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3bd} +@anchor{gnat_rm/the_gnat_library id118}@anchor{3bb}@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3bc} @section @code{GNAT.Spitbol.Table_VString} (@code{g-sptavs.ads}) @@ -25004,7 +24987,7 @@ a variable length string type, giving an implementation of general maps from strings to strings. @node GNAT SSE g-sse ads,GNAT SSE Vector_Types g-ssvety ads,GNAT Spitbol Table_VString g-sptavs ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id119}@anchor{3be}@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3bf} +@anchor{gnat_rm/the_gnat_library id119}@anchor{3bd}@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3be} @section @code{GNAT.SSE} (@code{g-sse.ads}) @@ -25016,7 +24999,7 @@ targets. It exposes vector component types together with a general introduction to the binding contents and use. @node GNAT SSE Vector_Types g-ssvety ads,GNAT String_Hash g-strhas ads,GNAT SSE g-sse ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3c0}@anchor{gnat_rm/the_gnat_library id120}@anchor{3c1} +@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3bf}@anchor{gnat_rm/the_gnat_library id120}@anchor{3c0} @section @code{GNAT.SSE.Vector_Types} (@code{g-ssvety.ads}) @@ -25025,7 +25008,7 @@ introduction to the binding contents and use. SSE vector types for use with SSE related intrinsics. @node GNAT String_Hash g-strhas ads,GNAT Strings g-string ads,GNAT SSE Vector_Types g-ssvety ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3c2}@anchor{gnat_rm/the_gnat_library id121}@anchor{3c3} +@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3c1}@anchor{gnat_rm/the_gnat_library id121}@anchor{3c2} @section @code{GNAT.String_Hash} (@code{g-strhas.ads}) @@ -25037,7 +25020,7 @@ Provides a generic hash function working on arrays of scalars. Both the scalar type and the hash result type are parameters. @node GNAT Strings g-string ads,GNAT String_Split g-strspl ads,GNAT String_Hash g-strhas ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c4}@anchor{gnat_rm/the_gnat_library id122}@anchor{3c5} +@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c3}@anchor{gnat_rm/the_gnat_library id122}@anchor{3c4} @section @code{GNAT.Strings} (@code{g-string.ads}) @@ -25047,7 +25030,7 @@ Common String access types and related subprograms. Basically it defines a string access and an array of string access types. @node GNAT String_Split g-strspl ads,GNAT Table g-table ads,GNAT Strings g-string ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3c6}@anchor{gnat_rm/the_gnat_library id123}@anchor{3c7} +@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3c5}@anchor{gnat_rm/the_gnat_library id123}@anchor{3c6} @section @code{GNAT.String_Split} (@code{g-strspl.ads}) @@ -25061,7 +25044,7 @@ to the resulting slices. This package is instantiated from @code{GNAT.Array_Split}. @node GNAT Table g-table ads,GNAT Task_Lock g-tasloc ads,GNAT String_Split g-strspl ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id124}@anchor{3c8}@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3c9} +@anchor{gnat_rm/the_gnat_library id124}@anchor{3c7}@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3c8} @section @code{GNAT.Table} (@code{g-table.ads}) @@ -25081,7 +25064,7 @@ while an instantiation of @code{GNAT.Dynamic_Tables} creates a type that can be used to define dynamic instances of the table. @node GNAT Task_Lock g-tasloc ads,GNAT Time_Stamp g-timsta ads,GNAT Table g-table ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id125}@anchor{3ca}@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3cb} +@anchor{gnat_rm/the_gnat_library id125}@anchor{3c9}@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3ca} @section @code{GNAT.Task_Lock} (@code{g-tasloc.ads}) @@ -25098,7 +25081,7 @@ single global task lock. Appropriate for use in situations where contention between tasks is very rarely expected. @node GNAT Time_Stamp g-timsta ads,GNAT Threads g-thread ads,GNAT Task_Lock g-tasloc ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id126}@anchor{3cc}@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3cd} +@anchor{gnat_rm/the_gnat_library id126}@anchor{3cb}@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3cc} @section @code{GNAT.Time_Stamp} (@code{g-timsta.ads}) @@ -25113,7 +25096,7 @@ represents the current date and time in ISO 8601 format. This is a very simple routine with minimal code and there are no dependencies on any other unit. @node GNAT Threads g-thread ads,GNAT Traceback g-traceb ads,GNAT Time_Stamp g-timsta ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id127}@anchor{3ce}@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3cf} +@anchor{gnat_rm/the_gnat_library id127}@anchor{3cd}@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3ce} @section @code{GNAT.Threads} (@code{g-thread.ads}) @@ -25130,7 +25113,7 @@ further details if your program has threads that are created by a non-Ada environment which then accesses Ada code. @node GNAT Traceback g-traceb ads,GNAT Traceback Symbolic g-trasym ads,GNAT Threads g-thread ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id128}@anchor{3d0}@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d1} +@anchor{gnat_rm/the_gnat_library id128}@anchor{3cf}@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d0} @section @code{GNAT.Traceback} (@code{g-traceb.ads}) @@ -25142,7 +25125,7 @@ Provides a facility for obtaining non-symbolic traceback information, useful in various debugging situations. @node GNAT Traceback Symbolic g-trasym ads,GNAT UTF_32 g-table ads,GNAT Traceback g-traceb ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d2}@anchor{gnat_rm/the_gnat_library id129}@anchor{3d3} +@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d1}@anchor{gnat_rm/the_gnat_library id129}@anchor{3d2} @section @code{GNAT.Traceback.Symbolic} (@code{g-trasym.ads}) @@ -25151,7 +25134,7 @@ in various debugging situations. @geindex Trace back facilities @node GNAT UTF_32 g-table ads,GNAT Wide_Spelling_Checker g-u3spch ads,GNAT Traceback Symbolic g-trasym ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id130}@anchor{3d4}@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-table-ads}@anchor{3d5} +@anchor{gnat_rm/the_gnat_library id130}@anchor{3d3}@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-table-ads}@anchor{3d4} @section @code{GNAT.UTF_32} (@code{g-table.ads}) @@ -25170,7 +25153,7 @@ lower case to upper case fold routine corresponding to the Ada 2005 rules for identifier equivalence. @node GNAT Wide_Spelling_Checker g-u3spch ads,GNAT Wide_Spelling_Checker g-wispch ads,GNAT UTF_32 g-table ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-u3spch-ads}@anchor{3d6}@anchor{gnat_rm/the_gnat_library id131}@anchor{3d7} +@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-u3spch-ads}@anchor{3d5}@anchor{gnat_rm/the_gnat_library id131}@anchor{3d6} @section @code{GNAT.Wide_Spelling_Checker} (@code{g-u3spch.ads}) @@ -25183,7 +25166,7 @@ near misspelling of another wide wide string, where the strings are represented using the UTF_32_String type defined in System.Wch_Cnv. @node GNAT Wide_Spelling_Checker g-wispch ads,GNAT Wide_String_Split g-wistsp ads,GNAT Wide_Spelling_Checker g-u3spch ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3d8}@anchor{gnat_rm/the_gnat_library id132}@anchor{3d9} +@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3d7}@anchor{gnat_rm/the_gnat_library id132}@anchor{3d8} @section @code{GNAT.Wide_Spelling_Checker} (@code{g-wispch.ads}) @@ -25195,7 +25178,7 @@ Provides a function for determining whether one wide string is a plausible near misspelling of another wide string. @node GNAT Wide_String_Split g-wistsp ads,GNAT Wide_Wide_Spelling_Checker g-zspche ads,GNAT Wide_Spelling_Checker g-wispch ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id133}@anchor{3da}@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3db} +@anchor{gnat_rm/the_gnat_library id133}@anchor{3d9}@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3da} @section @code{GNAT.Wide_String_Split} (@code{g-wistsp.ads}) @@ -25209,7 +25192,7 @@ to the resulting slices. This package is instantiated from @code{GNAT.Array_Split}. @node GNAT Wide_Wide_Spelling_Checker g-zspche ads,GNAT Wide_Wide_String_Split g-zistsp ads,GNAT Wide_String_Split g-wistsp ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3dc}@anchor{gnat_rm/the_gnat_library id134}@anchor{3dd} +@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3db}@anchor{gnat_rm/the_gnat_library id134}@anchor{3dc} @section @code{GNAT.Wide_Wide_Spelling_Checker} (@code{g-zspche.ads}) @@ -25221,7 +25204,7 @@ Provides a function for determining whether one wide wide string is a plausible near misspelling of another wide wide string. @node GNAT Wide_Wide_String_Split g-zistsp ads,Interfaces C Extensions i-cexten ads,GNAT Wide_Wide_Spelling_Checker g-zspche ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3de}@anchor{gnat_rm/the_gnat_library id135}@anchor{3df} +@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3dd}@anchor{gnat_rm/the_gnat_library id135}@anchor{3de} @section @code{GNAT.Wide_Wide_String_Split} (@code{g-zistsp.ads}) @@ -25235,7 +25218,7 @@ to the resulting slices. This package is instantiated from @code{GNAT.Array_Split}. @node Interfaces C Extensions i-cexten ads,Interfaces C Streams i-cstrea ads,GNAT Wide_Wide_String_Split g-zistsp ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3e0}@anchor{gnat_rm/the_gnat_library id136}@anchor{3e1} +@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3df}@anchor{gnat_rm/the_gnat_library id136}@anchor{3e0} @section @code{Interfaces.C.Extensions} (@code{i-cexten.ads}) @@ -25246,7 +25229,7 @@ for use with either manually or automatically generated bindings to C libraries. @node Interfaces C Streams i-cstrea ads,Interfaces Packed_Decimal i-pacdec ads,Interfaces C Extensions i-cexten ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3e2}@anchor{gnat_rm/the_gnat_library id137}@anchor{3e3} +@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3e1}@anchor{gnat_rm/the_gnat_library id137}@anchor{3e2} @section @code{Interfaces.C.Streams} (@code{i-cstrea.ads}) @@ -25259,7 +25242,7 @@ This package is a binding for the most commonly used operations on C streams. @node Interfaces Packed_Decimal i-pacdec ads,Interfaces VxWorks i-vxwork ads,Interfaces C Streams i-cstrea ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id138}@anchor{3e4}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e5} +@anchor{gnat_rm/the_gnat_library id138}@anchor{3e3}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e4} @section @code{Interfaces.Packed_Decimal} (@code{i-pacdec.ads}) @@ -25274,7 +25257,7 @@ from a packed decimal format compatible with that used on IBM mainframes. @node Interfaces VxWorks i-vxwork ads,Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces Packed_Decimal i-pacdec ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id139}@anchor{3e6}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3e7} +@anchor{gnat_rm/the_gnat_library id139}@anchor{3e5}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3e6} @section @code{Interfaces.VxWorks} (@code{i-vxwork.ads}) @@ -25290,7 +25273,7 @@ In particular, it interfaces with the VxWorks hardware interrupt facilities. @node Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces VxWorks IO i-vxwoio ads,Interfaces VxWorks i-vxwork ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3e8}@anchor{gnat_rm/the_gnat_library id140}@anchor{3e9} +@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3e7}@anchor{gnat_rm/the_gnat_library id140}@anchor{3e8} @section @code{Interfaces.VxWorks.Int_Connection} (@code{i-vxinco.ads}) @@ -25306,7 +25289,7 @@ intConnect() with a custom routine for installing interrupt handlers. @node Interfaces VxWorks IO i-vxwoio ads,System Address_Image s-addima ads,Interfaces VxWorks Int_Connection i-vxinco ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3ea}@anchor{gnat_rm/the_gnat_library id141}@anchor{3eb} +@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3e9}@anchor{gnat_rm/the_gnat_library id141}@anchor{3ea} @section @code{Interfaces.VxWorks.IO} (@code{i-vxwoio.ads}) @@ -25329,7 +25312,7 @@ function codes. A particular use of this package is to enable the use of Get_Immediate under VxWorks. @node System Address_Image s-addima ads,System Assertions s-assert ads,Interfaces VxWorks IO i-vxwoio ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3ec}@anchor{gnat_rm/the_gnat_library id142}@anchor{3ed} +@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3eb}@anchor{gnat_rm/the_gnat_library id142}@anchor{3ec} @section @code{System.Address_Image} (@code{s-addima.ads}) @@ -25345,7 +25328,7 @@ function that gives an (implementation dependent) string which identifies an address. @node System Assertions s-assert ads,System Atomic_Counters s-atocou ads,System Address_Image s-addima ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3ee}@anchor{gnat_rm/the_gnat_library id143}@anchor{3ef} +@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3ed}@anchor{gnat_rm/the_gnat_library id143}@anchor{3ee} @section @code{System.Assertions} (@code{s-assert.ads}) @@ -25361,7 +25344,7 @@ by an run-time assertion failure, as well as the routine that is used internally to raise this assertion. @node System Atomic_Counters s-atocou ads,System Memory s-memory ads,System Assertions s-assert ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id144}@anchor{3f0}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3f1} +@anchor{gnat_rm/the_gnat_library id144}@anchor{3ef}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3f0} @section @code{System.Atomic_Counters} (@code{s-atocou.ads}) @@ -25375,7 +25358,7 @@ on most targets, including all Alpha, ia64, PowerPC, SPARC V9, x86, and x86_64 platforms. @node System Memory s-memory ads,System Multiprocessors s-multip ads,System Atomic_Counters s-atocou ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f2}@anchor{gnat_rm/the_gnat_library id145}@anchor{3f3} +@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f1}@anchor{gnat_rm/the_gnat_library id145}@anchor{3f2} @section @code{System.Memory} (@code{s-memory.ads}) @@ -25393,7 +25376,7 @@ calls to this unit may be made for low level allocation uses (for example see the body of @code{GNAT.Tables}). @node System Multiprocessors s-multip ads,System Multiprocessors Dispatching_Domains s-mudido ads,System Memory s-memory ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id146}@anchor{3f4}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3f5} +@anchor{gnat_rm/the_gnat_library id146}@anchor{3f3}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3f4} @section @code{System.Multiprocessors} (@code{s-multip.ads}) @@ -25406,7 +25389,7 @@ in GNAT we also make it available in Ada 95 and Ada 2005 (where it is technically an implementation-defined addition). @node System Multiprocessors Dispatching_Domains s-mudido ads,System Partition_Interface s-parint ads,System Multiprocessors s-multip ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3f6}@anchor{gnat_rm/the_gnat_library id147}@anchor{3f7} +@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3f5}@anchor{gnat_rm/the_gnat_library id147}@anchor{3f6} @section @code{System.Multiprocessors.Dispatching_Domains} (@code{s-mudido.ads}) @@ -25419,7 +25402,7 @@ in GNAT we also make it available in Ada 95 and Ada 2005 (where it is technically an implementation-defined addition). @node System Partition_Interface s-parint ads,System Pool_Global s-pooglo ads,System Multiprocessors Dispatching_Domains s-mudido ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id148}@anchor{3f8}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3f9} +@anchor{gnat_rm/the_gnat_library id148}@anchor{3f7}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3f8} @section @code{System.Partition_Interface} (@code{s-parint.ads}) @@ -25432,7 +25415,7 @@ is used primarily in a distribution context when using Annex E with @code{GLADE}. @node System Pool_Global s-pooglo ads,System Pool_Local s-pooloc ads,System Partition_Interface s-parint ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id149}@anchor{3fa}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3fb} +@anchor{gnat_rm/the_gnat_library id149}@anchor{3f9}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3fa} @section @code{System.Pool_Global} (@code{s-pooglo.ads}) @@ -25449,7 +25432,7 @@ declared. It uses malloc/free to allocate/free and does not attempt to do any automatic reclamation. @node System Pool_Local s-pooloc ads,System Restrictions s-restri ads,System Pool_Global s-pooglo ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3fc}@anchor{gnat_rm/the_gnat_library id150}@anchor{3fd} +@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3fb}@anchor{gnat_rm/the_gnat_library id150}@anchor{3fc} @section @code{System.Pool_Local} (@code{s-pooloc.ads}) @@ -25466,7 +25449,7 @@ a list of allocated blocks, so that all storage allocated for the pool can be freed automatically when the pool is finalized. @node System Restrictions s-restri ads,System Rident s-rident ads,System Pool_Local s-pooloc ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{3fe}@anchor{gnat_rm/the_gnat_library id151}@anchor{3ff} +@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{3fd}@anchor{gnat_rm/the_gnat_library id151}@anchor{3fe} @section @code{System.Restrictions} (@code{s-restri.ads}) @@ -25482,7 +25465,7 @@ compiler determined information on which restrictions are violated by one or more packages in the partition. @node System Rident s-rident ads,System Strings Stream_Ops s-ststop ads,System Restrictions s-restri ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{400}@anchor{gnat_rm/the_gnat_library id152}@anchor{401} +@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{3ff}@anchor{gnat_rm/the_gnat_library id152}@anchor{400} @section @code{System.Rident} (@code{s-rident.ads}) @@ -25498,7 +25481,7 @@ since the necessary instantiation is included in package System.Restrictions. @node System Strings Stream_Ops s-ststop ads,System Unsigned_Types s-unstyp ads,System Rident s-rident ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id153}@anchor{402}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{403} +@anchor{gnat_rm/the_gnat_library id153}@anchor{401}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{402} @section @code{System.Strings.Stream_Ops} (@code{s-ststop.ads}) @@ -25514,7 +25497,7 @@ stream attributes are applied to string types, but the subprograms in this package can be used directly by application programs. @node System Unsigned_Types s-unstyp ads,System Wch_Cnv s-wchcnv ads,System Strings Stream_Ops s-ststop ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{404}@anchor{gnat_rm/the_gnat_library id154}@anchor{405} +@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{403}@anchor{gnat_rm/the_gnat_library id154}@anchor{404} @section @code{System.Unsigned_Types} (@code{s-unstyp.ads}) @@ -25527,7 +25510,7 @@ also contains some related definitions for other specialized types used by the compiler in connection with packed array types. @node System Wch_Cnv s-wchcnv ads,System Wch_Con s-wchcon ads,System Unsigned_Types s-unstyp ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{406}@anchor{gnat_rm/the_gnat_library id155}@anchor{407} +@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{405}@anchor{gnat_rm/the_gnat_library id155}@anchor{406} @section @code{System.Wch_Cnv} (@code{s-wchcnv.ads}) @@ -25548,7 +25531,7 @@ encoding method. It uses definitions in package @code{System.Wch_Con}. @node System Wch_Con s-wchcon ads,,System Wch_Cnv s-wchcnv ads,The GNAT Library -@anchor{gnat_rm/the_gnat_library id156}@anchor{408}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{409} +@anchor{gnat_rm/the_gnat_library id156}@anchor{407}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{408} @section @code{System.Wch_Con} (@code{s-wchcon.ads}) @@ -25560,7 +25543,7 @@ in ordinary strings. These definitions are used by the package @code{System.Wch_Cnv}. @node Interfacing to Other Languages,Specialized Needs Annexes,The GNAT Library,Top -@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{40a}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40b} +@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{409}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40a} @chapter Interfacing to Other Languages @@ -25578,7 +25561,7 @@ provided. @end menu @node Interfacing to C,Interfacing to C++,,Interfacing to Other Languages -@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{40c}@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40d} +@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{40b}@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40c} @section Interfacing to C @@ -25718,7 +25701,7 @@ of the length corresponding to the @code{type'Size} value in Ada. @end itemize @node Interfacing to C++,Interfacing to COBOL,Interfacing to C,Interfacing to Other Languages -@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{40e}@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{4a} +@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{40d}@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{4a} @section Interfacing to C++ @@ -25775,7 +25758,7 @@ The @code{External_Name} is the name of the C++ RTTI symbol. You can then cover a specific C++ exception in an exception handler. @node Interfacing to COBOL,Interfacing to Fortran,Interfacing to C++,Interfacing to Other Languages -@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{40f}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{410} +@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{40e}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{40f} @section Interfacing to COBOL @@ -25783,7 +25766,7 @@ Interfacing to COBOL is achieved as described in section B.4 of the Ada Reference Manual. @node Interfacing to Fortran,Interfacing to non-GNAT Ada code,Interfacing to COBOL,Interfacing to Other Languages -@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{411}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{412} +@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{410}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{411} @section Interfacing to Fortran @@ -25793,7 +25776,7 @@ multi-dimensional array causes the array to be stored in column-major order as required for convenient interface to Fortran. @node Interfacing to non-GNAT Ada code,,Interfacing to Fortran,Interfacing to Other Languages -@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{413}@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{414} +@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{412}@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{413} @section Interfacing to non-GNAT Ada code @@ -25817,7 +25800,7 @@ values or simple record types without variants, or simple array types with fixed bounds. @node Specialized Needs Annexes,Implementation of Specific Ada Features,Interfacing to Other Languages,Top -@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{415}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{416} +@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{414}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{415} @chapter Specialized Needs Annexes @@ -25858,7 +25841,7 @@ in Ada 2005) is fully implemented. @end table @node Implementation of Specific Ada Features,Implementation of Ada 2012 Features,Specialized Needs Annexes,Top -@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{417}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{418} +@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{416}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{417} @chapter Implementation of Specific Ada Features @@ -25876,7 +25859,7 @@ facilities. @end menu @node Machine Code Insertions,GNAT Implementation of Tasking,,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{16d}@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{419} +@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{16c}@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{418} @section Machine Code Insertions @@ -26044,7 +26027,7 @@ according to normal visibility rules. In particular if there is no qualification is required. @node GNAT Implementation of Tasking,GNAT Implementation of Shared Passive Packages,Machine Code Insertions,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{41a}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41b} +@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{419}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41a} @section GNAT Implementation of Tasking @@ -26060,7 +26043,7 @@ to compliance with the Real-Time Systems Annex. @end menu @node Mapping Ada Tasks onto the Underlying Kernel Threads,Ensuring Compliance with the Real-Time Annex,,GNAT Implementation of Tasking -@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{41c}@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41d} +@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{41b}@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41c} @subsection Mapping Ada Tasks onto the Underlying Kernel Threads @@ -26129,7 +26112,7 @@ support this functionality when the parent contains more than one task. @geindex Forking a new process @node Ensuring Compliance with the Real-Time Annex,Support for Locking Policies,Mapping Ada Tasks onto the Underlying Kernel Threads,GNAT Implementation of Tasking -@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{41e}@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{41f} +@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{41d}@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{41e} @subsection Ensuring Compliance with the Real-Time Annex @@ -26180,7 +26163,7 @@ placed at the end. @c Support_for_Locking_Policies @node Support for Locking Policies,,Ensuring Compliance with the Real-Time Annex,GNAT Implementation of Tasking -@anchor{gnat_rm/implementation_of_specific_ada_features support-for-locking-policies}@anchor{420} +@anchor{gnat_rm/implementation_of_specific_ada_features support-for-locking-policies}@anchor{41f} @subsection Support for Locking Policies @@ -26214,7 +26197,7 @@ then ceiling locking is used. Otherwise, the @code{Ceiling_Locking} policy is ignored. @node GNAT Implementation of Shared Passive Packages,Code Generation for Array Aggregates,GNAT Implementation of Tasking,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{421}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{422} +@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{420}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{421} @section GNAT Implementation of Shared Passive Packages @@ -26311,11 +26294,8 @@ is created in the shared memory directory. This is used to provide the required locking semantics for proper protected object synchronization. -GNAT supports shared passive packages on all platforms -except for OpenVMS. - @node Code Generation for Array Aggregates,The Size of Discriminated Records with Default Discriminants,GNAT Implementation of Shared Passive Packages,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features code-generation-for-array-aggregates}@anchor{423}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{424} +@anchor{gnat_rm/implementation_of_specific_ada_features code-generation-for-array-aggregates}@anchor{422}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{423} @section Code Generation for Array Aggregates @@ -26346,7 +26326,7 @@ component values and static subtypes also lead to simpler code. @end menu @node Static constant aggregates with static bounds,Constant aggregates with unconstrained nominal types,,Code Generation for Array Aggregates -@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{425}@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{426} +@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{424}@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{425} @subsection Static constant aggregates with static bounds @@ -26393,7 +26373,7 @@ Zero2: constant two_dim := (others => (others => 0)); @end example @node Constant aggregates with unconstrained nominal types,Aggregates with static bounds,Static constant aggregates with static bounds,Code Generation for Array Aggregates -@anchor{gnat_rm/implementation_of_specific_ada_features constant-aggregates-with-unconstrained-nominal-types}@anchor{427}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{428} +@anchor{gnat_rm/implementation_of_specific_ada_features constant-aggregates-with-unconstrained-nominal-types}@anchor{426}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{427} @subsection Constant aggregates with unconstrained nominal types @@ -26408,7 +26388,7 @@ Cr_Unc : constant One_Unc := (12,24,36); @end example @node Aggregates with static bounds,Aggregates with nonstatic bounds,Constant aggregates with unconstrained nominal types,Code Generation for Array Aggregates -@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{429}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{42a} +@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{428}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{429} @subsection Aggregates with static bounds @@ -26436,7 +26416,7 @@ end loop; @end example @node Aggregates with nonstatic bounds,Aggregates in assignment statements,Aggregates with static bounds,Code Generation for Array Aggregates -@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42b}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42c} +@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42a}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42b} @subsection Aggregates with nonstatic bounds @@ -26447,7 +26427,7 @@ have to be applied to sub-arrays individually, if they do not have statically compatible subtypes. @node Aggregates in assignment statements,,Aggregates with nonstatic bounds,Code Generation for Array Aggregates -@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{42d}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{42e} +@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{42c}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{42d} @subsection Aggregates in assignment statements @@ -26489,7 +26469,7 @@ a temporary (created either by the front-end or the code generator) and then that temporary will be copied onto the target. @node The Size of Discriminated Records with Default Discriminants,Strict Conformance to the Ada Reference Manual,Code Generation for Array Aggregates,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features id13}@anchor{42f}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{430} +@anchor{gnat_rm/implementation_of_specific_ada_features id13}@anchor{42e}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{42f} @section The Size of Discriminated Records with Default Discriminants @@ -26569,7 +26549,7 @@ say) must be consistent, so it is imperative that the object, once created, remain invariant. @node Strict Conformance to the Ada Reference Manual,,The Size of Discriminated Records with Default Discriminants,Implementation of Specific Ada Features -@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{431}@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{432} +@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{430}@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{431} @section Strict Conformance to the Ada Reference Manual @@ -26596,7 +26576,7 @@ behavior (although at the cost of a significant performance penalty), so infinite and NaN values are properly generated. @node Implementation of Ada 2012 Features,Obsolescent Features,Implementation of Specific Ada Features,Top -@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{433}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{434} +@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{432}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{433} @chapter Implementation of Ada 2012 Features @@ -28762,7 +28742,7 @@ RM References: H.04 (8/1) @end itemize @node Obsolescent Features,Compatibility and Porting Guide,Implementation of Ada 2012 Features,Top -@anchor{gnat_rm/obsolescent_features id1}@anchor{435}@anchor{gnat_rm/obsolescent_features doc}@anchor{436}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{15} +@anchor{gnat_rm/obsolescent_features id1}@anchor{434}@anchor{gnat_rm/obsolescent_features doc}@anchor{435}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{15} @chapter Obsolescent Features @@ -28781,7 +28761,7 @@ compatibility purposes. @end menu @node pragma No_Run_Time,pragma Ravenscar,,Obsolescent Features -@anchor{gnat_rm/obsolescent_features id2}@anchor{437}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{438} +@anchor{gnat_rm/obsolescent_features id2}@anchor{436}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{437} @section pragma No_Run_Time @@ -28794,7 +28774,7 @@ preferred usage is to use an appropriately configured run-time that includes just those features that are to be made accessible. @node pragma Ravenscar,pragma Restricted_Run_Time,pragma No_Run_Time,Obsolescent Features -@anchor{gnat_rm/obsolescent_features id3}@anchor{439}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{43a} +@anchor{gnat_rm/obsolescent_features id3}@anchor{438}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{439} @section pragma Ravenscar @@ -28803,7 +28783,7 @@ The pragma @code{Ravenscar} has exactly the same effect as pragma is part of the new Ada 2005 standard. @node pragma Restricted_Run_Time,pragma Task_Info,pragma Ravenscar,Obsolescent Features -@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{43b}@anchor{gnat_rm/obsolescent_features id4}@anchor{43c} +@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{43a}@anchor{gnat_rm/obsolescent_features id4}@anchor{43b} @section pragma Restricted_Run_Time @@ -28813,7 +28793,7 @@ preferred since the Ada 2005 pragma @code{Profile} is intended for this kind of implementation dependent addition. @node pragma Task_Info,package System Task_Info s-tasinf ads,pragma Restricted_Run_Time,Obsolescent Features -@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{43d}@anchor{gnat_rm/obsolescent_features id5}@anchor{43e} +@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{43c}@anchor{gnat_rm/obsolescent_features id5}@anchor{43d} @section pragma Task_Info @@ -28839,7 +28819,7 @@ in the spec of package System.Task_Info in the runtime library. @node package System Task_Info s-tasinf ads,,pragma Task_Info,Obsolescent Features -@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{43f}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{440} +@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{43e}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{43f} @section package System.Task_Info (@code{s-tasinf.ads}) @@ -28849,7 +28829,7 @@ to support the @code{Task_Info} pragma. The predefined Ada package standard replacement for GNAT's @code{Task_Info} functionality. @node Compatibility and Porting Guide,GNU Free Documentation License,Obsolescent Features,Top -@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{16}@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{441}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{442} +@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{16}@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{440}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{441} @chapter Compatibility and Porting Guide @@ -28871,7 +28851,7 @@ applications developed in other Ada environments. @end menu @node Writing Portable Fixed-Point Declarations,Compatibility with Ada 83,,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{443}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{444} +@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{442}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{443} @section Writing Portable Fixed-Point Declarations @@ -28993,7 +28973,7 @@ If you follow this scheme you will be guaranteed that your fixed-point types will be portable. @node Compatibility with Ada 83,Compatibility between Ada 95 and Ada 2005,Writing Portable Fixed-Point Declarations,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{445}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{446} +@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{444}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{445} @section Compatibility with Ada 83 @@ -29021,7 +29001,7 @@ following subsections treat the most likely issues to be encountered. @end menu @node Legal Ada 83 programs that are illegal in Ada 95,More deterministic semantics,,Compatibility with Ada 83 -@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{447}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{448} +@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{446}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{447} @subsection Legal Ada 83 programs that are illegal in Ada 95 @@ -29121,7 +29101,7 @@ the fix is usually simply to add the @code{(<>)} to the generic declaration. @end itemize @node More deterministic semantics,Changed semantics,Legal Ada 83 programs that are illegal in Ada 95,Compatibility with Ada 83 -@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{449}@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{44a} +@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{448}@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{449} @subsection More deterministic semantics @@ -29149,7 +29129,7 @@ which open select branches are executed. @end itemize @node Changed semantics,Other language compatibility issues,More deterministic semantics,Compatibility with Ada 83 -@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{44b}@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{44c} +@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{44a}@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{44b} @subsection Changed semantics @@ -29191,7 +29171,7 @@ covers only the restricted range. @end itemize @node Other language compatibility issues,,Changed semantics,Compatibility with Ada 83 -@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{44d}@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{44e} +@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{44c}@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{44d} @subsection Other language compatibility issues @@ -29224,7 +29204,7 @@ include @code{pragma Interface} and the floating point type attributes @end itemize @node Compatibility between Ada 95 and Ada 2005,Implementation-dependent characteristics,Compatibility with Ada 83,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{44f}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{450} +@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{44e}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{44f} @section Compatibility between Ada 95 and Ada 2005 @@ -29296,7 +29276,7 @@ can declare a function returning a value from an anonymous access type. @end itemize @node Implementation-dependent characteristics,Compatibility with Other Ada Systems,Compatibility between Ada 95 and Ada 2005,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{451}@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{452} +@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{450}@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{451} @section Implementation-dependent characteristics @@ -29319,7 +29299,7 @@ transition from certain Ada 83 compilers. @end menu @node Implementation-defined pragmas,Implementation-defined attributes,,Implementation-dependent characteristics -@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{453}@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{454} +@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{452}@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{453} @subsection Implementation-defined pragmas @@ -29341,7 +29321,7 @@ avoiding compiler rejection of units that contain such pragmas; they are not relevant in a GNAT context and hence are not otherwise implemented. @node Implementation-defined attributes,Libraries,Implementation-defined pragmas,Implementation-dependent characteristics -@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{455}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{456} +@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{454}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{455} @subsection Implementation-defined attributes @@ -29355,7 +29335,7 @@ Ada 83, GNAT supplies the attributes @code{Bit}, @code{Machine_Size} and @code{Type_Class}. @node Libraries,Elaboration order,Implementation-defined attributes,Implementation-dependent characteristics -@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{457}@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{458} +@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{456}@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{457} @subsection Libraries @@ -29384,7 +29364,7 @@ be preferable to retrofit the application using modular types. @end itemize @node Elaboration order,Target-specific aspects,Libraries,Implementation-dependent characteristics -@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{459}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{45a} +@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{458}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{459} @subsection Elaboration order @@ -29420,7 +29400,7 @@ pragmas either globally (as an effect of the @emph{-gnatE} switch) or locally @end itemize @node Target-specific aspects,,Elaboration order,Implementation-dependent characteristics -@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{45b}@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{45c} +@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{45a}@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{45b} @subsection Target-specific aspects @@ -29433,10 +29413,10 @@ on the robustness of the original design. Moreover, Ada 95 (and thus Ada 2005 and Ada 2012) are sometimes incompatible with typical Ada 83 compiler practices regarding implicit packing, the meaning of the Size attribute, and the size of access values. -GNAT's approach to these issues is described in @ref{45d,,Representation Clauses}. +GNAT's approach to these issues is described in @ref{45c,,Representation Clauses}. @node Compatibility with Other Ada Systems,Representation Clauses,Implementation-dependent characteristics,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{45e}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{45f} +@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{45e} @section Compatibility with Other Ada Systems @@ -29479,7 +29459,7 @@ far beyond this minimal set, as described in the next section. @end itemize @node Representation Clauses,Compatibility with HP Ada 83,Compatibility with Other Ada Systems,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{460} +@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{45c}@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{45f} @section Representation Clauses @@ -29572,7 +29552,7 @@ with thin pointers. @end itemize @node Compatibility with HP Ada 83,,Representation Clauses,Compatibility and Porting Guide -@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{461}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{462} +@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{460}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{461} @section Compatibility with HP Ada 83 @@ -29602,7 +29582,7 @@ extension of package System. @end itemize @node GNU Free Documentation License,Index,Compatibility and Porting Guide,Top -@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{463}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{464} +@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{462}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{463} @chapter GNU Free Documentation License diff --git a/gcc/ada/gnat_ugn.texi b/gcc/ada/gnat_ugn.texi index c2dd053..5db9c76 100644 --- a/gcc/ada/gnat_ugn.texi +++ b/gcc/ada/gnat_ugn.texi @@ -21,7 +21,7 @@ @copying @quotation -GNAT User's Guide for Native Platforms , Aug 01, 2019 +GNAT User's Guide for Native Platforms , Sep 14, 2019 AdaCore @@ -13661,7 +13661,7 @@ in the source text. The set of style check switches is set to match that used by the GNAT sources. This may be useful when developing code that is eventually intended to be -incorporated into GNAT. Currently this is equivalent to @code{-gnatwydISux}) +incorporated into GNAT. Currently this is equivalent to @code{-gnatyydISux}) but additional style switches may be added to this set in the future without advance notice. @end table @@ -23321,8 +23321,11 @@ $ gnatbind -u0 file @end example @end quotation -With this option, at each task termination, its stack usage is output on +With this option, at each task termination, its stack usage is output on @code{stderr}. +Note that this switch is not compatible with tools like +Valgrind and DrMemory; they will report errors. + It is not always convenient to output the stack usage when the program is still running. Hence, it is possible to delay this output until program termination. for a given number of tasks specified as the argument of the diff --git a/gcc/ada/gsocket.h b/gcc/ada/gsocket.h index c44e134..91a06b8 100644 --- a/gcc/ada/gsocket.h +++ b/gcc/ada/gsocket.h @@ -208,6 +208,7 @@ */ #if !(defined (VMS) || defined (__MINGW32__)) #include <sys/socket.h> +#include <sys/un.h> #include <netinet/in.h> #include <netinet/tcp.h> #include <sys/ioctl.h> diff --git a/gcc/ada/inline.adb b/gcc/ada/inline.adb index e5ecb55..6e345d6 100644 --- a/gcc/ada/inline.adb +++ b/gcc/ada/inline.adb @@ -1681,6 +1681,12 @@ package body Inline is elsif not In_Extended_Main_Code_Unit (Id) then return False; + -- Do not inline dispatching operations, as only their static calls + -- can be analyzed in context, and not their dispatching calls. + + elsif Is_Dispatching_Operation (Id) then + return False; + -- Do not inline subprograms marked No_Return, possibly used for -- signaling errors, which GNATprove handles specially. diff --git a/gcc/ada/libgnarl/s-interr.adb b/gcc/ada/libgnarl/s-interr.adb index 7106c57..bb5defd 100644 --- a/gcc/ada/libgnarl/s-interr.adb +++ b/gcc/ada/libgnarl/s-interr.adb @@ -545,9 +545,11 @@ package body System.Interrupts is function Is_Registered (Handler : Parameterless_Handler) return Boolean is + type Acc_Proc is access procedure; + type Fat_Ptr is record Object_Addr : System.Address; - Handler_Addr : System.Address; + Handler_Addr : Acc_Proc; end record; function To_Fat_Ptr is new Ada.Unchecked_Conversion @@ -565,7 +567,7 @@ package body System.Interrupts is Ptr := Registered_Handler_Head; while Ptr /= null loop - if Ptr.H = Fat.Handler_Addr then + if Ptr.H = Fat.Handler_Addr.all'Address then return True; end if; diff --git a/gcc/ada/libgnarl/s-interr__hwint.adb b/gcc/ada/libgnarl/s-interr__hwint.adb index 50e2ec2..ff7fe05 100644 --- a/gcc/ada/libgnarl/s-interr__hwint.adb +++ b/gcc/ada/libgnarl/s-interr__hwint.adb @@ -561,9 +561,12 @@ package body System.Interrupts is ------------------- function Is_Registered (Handler : Parameterless_Handler) return Boolean is + + type Acc_Proc is access procedure; + type Fat_Ptr is record Object_Addr : System.Address; - Handler_Addr : System.Address; + Handler_Addr : Acc_Proc; end record; function To_Fat_Ptr is new Ada.Unchecked_Conversion @@ -581,7 +584,7 @@ package body System.Interrupts is Ptr := Registered_Handler_Head; while Ptr /= null loop - if Ptr.H = Fat.Handler_Addr then + if Ptr.H = Fat.Handler_Addr.all'Address then return True; end if; diff --git a/gcc/ada/libgnarl/s-interr__sigaction.adb b/gcc/ada/libgnarl/s-interr__sigaction.adb index d9ffe0c..d8fb7ba 100644 --- a/gcc/ada/libgnarl/s-interr__sigaction.adb +++ b/gcc/ada/libgnarl/s-interr__sigaction.adb @@ -487,9 +487,11 @@ package body System.Interrupts is function Is_Registered (Handler : Parameterless_Handler) return Boolean is Ptr : R_Link := Registered_Handlers; + type Acc_Proc is access procedure; + type Fat_Ptr is record Object_Addr : System.Address; - Handler_Addr : System.Address; + Handler_Addr : Acc_Proc; end record; function To_Fat_Ptr is new Ada.Unchecked_Conversion @@ -505,7 +507,7 @@ package body System.Interrupts is Fat := To_Fat_Ptr (Handler); while Ptr /= null loop - if Ptr.H = Fat.Handler_Addr then + if Ptr.H = Fat.Handler_Addr.all'Address then return True; end if; diff --git a/gcc/ada/libgnarl/s-interr__vxworks.adb b/gcc/ada/libgnarl/s-interr__vxworks.adb index b2c4eee..16d22a6 100644 --- a/gcc/ada/libgnarl/s-interr__vxworks.adb +++ b/gcc/ada/libgnarl/s-interr__vxworks.adb @@ -578,9 +578,12 @@ package body System.Interrupts is ------------------- function Is_Registered (Handler : Parameterless_Handler) return Boolean is + + type Acc_Proc is access procedure; + type Fat_Ptr is record Object_Addr : System.Address; - Handler_Addr : System.Address; + Handler_Addr : Acc_Proc; end record; function To_Fat_Ptr is new Ada.Unchecked_Conversion @@ -598,7 +601,7 @@ package body System.Interrupts is Ptr := Registered_Handler_Head; while Ptr /= null loop - if Ptr.H = Fat.Handler_Addr then + if Ptr.H = Fat.Handler_Addr.all'Address then return True; end if; diff --git a/gcc/ada/libgnat/a-cbhama.adb b/gcc/ada/libgnat/a-cbhama.adb index 68e3602..74e3d95 100644 --- a/gcc/ada/libgnat/a-cbhama.adb +++ b/gcc/ada/libgnat/a-cbhama.adb @@ -262,18 +262,14 @@ package body Ada.Containers.Bounded_Hashed_Maps is Capacity : Count_Type := 0; Modulus : Hash_Type := 0) return Map is - C : Count_Type; + C : constant Count_Type := + (if Capacity = 0 then Source.Length + else Capacity); M : Hash_Type; begin - if Capacity = 0 then - C := Source.Length; - - elsif Capacity >= Source.Length then - C := Capacity; - - elsif Checks then - raise Capacity_Error with "Capacity value too small"; + if Checks and then C < Source.Length then + raise Capacity_Error with "Capacity too small"; end if; if Modulus = 0 then diff --git a/gcc/ada/libgnat/a-cbhase.adb b/gcc/ada/libgnat/a-cbhase.adb index 796cb97..390e82b 100644 --- a/gcc/ada/libgnat/a-cbhase.adb +++ b/gcc/ada/libgnat/a-cbhase.adb @@ -254,16 +254,14 @@ package body Ada.Containers.Bounded_Hashed_Sets is Capacity : Count_Type := 0; Modulus : Hash_Type := 0) return Set is - C : Count_Type; + C : constant Count_Type := + (if Capacity = 0 then Source.Length + else Capacity); M : Hash_Type; begin - if Capacity = 0 then - C := Source.Length; - elsif Capacity >= Source.Length then - C := Capacity; - elsif Checks then - raise Capacity_Error with "Capacity value too small"; + if Checks and then C < Source.Length then + raise Capacity_Error with "Capacity too small"; end if; if Modulus = 0 then diff --git a/gcc/ada/libgnat/a-cbmutr.adb b/gcc/ada/libgnat/a-cbmutr.adb index fb8585a..4c0f8fe 100644 --- a/gcc/ada/libgnat/a-cbmutr.adb +++ b/gcc/ada/libgnat/a-cbmutr.adb @@ -625,15 +625,12 @@ package body Ada.Containers.Bounded_Multiway_Trees is (Source : Tree; Capacity : Count_Type := 0) return Tree is - C : Count_Type; - + C : constant Count_Type := + (if Capacity = 0 then Source.Count + else Capacity); begin - if Capacity = 0 then - C := Source.Count; - elsif Capacity >= Source.Count then - C := Capacity; - elsif Checks then - raise Capacity_Error with "Capacity value too small"; + if Checks and then C < Source.Count then + raise Capacity_Error with "Capacity too small"; end if; return Target : Tree (Capacity => C) do diff --git a/gcc/ada/libgnat/a-cborma.adb b/gcc/ada/libgnat/a-cborma.adb index 55be7ad..e4e4b57 100644 --- a/gcc/ada/libgnat/a-cborma.adb +++ b/gcc/ada/libgnat/a-cborma.adb @@ -464,17 +464,12 @@ package body Ada.Containers.Bounded_Ordered_Maps is ---------- function Copy (Source : Map; Capacity : Count_Type := 0) return Map is - C : Count_Type; - + C : constant Count_Type := + (if Capacity = 0 then Source.Length + else Capacity); begin - if Capacity = 0 then - C := Source.Length; - - elsif Capacity >= Source.Length then - C := Capacity; - - elsif Checks then - raise Capacity_Error with "Capacity value too small"; + if Checks and then C < Source.Length then + raise Capacity_Error with "Capacity too small"; end if; return Target : Map (Capacity => C) do diff --git a/gcc/ada/libgnat/a-cborse.adb b/gcc/ada/libgnat/a-cborse.adb index 9fdba26..7b98378 100644 --- a/gcc/ada/libgnat/a-cborse.adb +++ b/gcc/ada/libgnat/a-cborse.adb @@ -442,15 +442,12 @@ package body Ada.Containers.Bounded_Ordered_Sets is ---------- function Copy (Source : Set; Capacity : Count_Type := 0) return Set is - C : Count_Type; - + C : constant Count_Type := + (if Capacity = 0 then Source.Length + else Capacity); begin - if Capacity = 0 then - C := Source.Length; - elsif Capacity >= Source.Length then - C := Capacity; - elsif Checks then - raise Capacity_Error with "Capacity value too small"; + if Checks and then C < Source.Length then + raise Capacity_Error with "Capacity too small"; end if; return Target : Set (Capacity => C) do diff --git a/gcc/ada/libgnat/a-cobove.adb b/gcc/ada/libgnat/a-cobove.adb index 8d80fb7..3e48bc6 100644 --- a/gcc/ada/libgnat/a-cobove.adb +++ b/gcc/ada/libgnat/a-cobove.adb @@ -451,18 +451,12 @@ package body Ada.Containers.Bounded_Vectors is (Source : Vector; Capacity : Count_Type := 0) return Vector is - C : Count_Type; - + C : constant Count_Type := + (if Capacity = 0 then Source.Length + else Capacity); begin - if Capacity = 0 then - C := Source.Length; - - elsif Capacity >= Source.Length then - C := Capacity; - - elsif Checks then - raise Capacity_Error - with "Requested capacity is less than Source length"; + if Checks and then C < Source.Length then + raise Capacity_Error with "Capacity too small"; end if; return Target : Vector (C) do diff --git a/gcc/ada/libgnat/a-cofuma.adb b/gcc/ada/libgnat/a-cofuma.adb index 1652efe..e8da187 100644 --- a/gcc/ada/libgnat/a-cofuma.adb +++ b/gcc/ada/libgnat/a-cofuma.adb @@ -88,15 +88,15 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is New_Key : Key_Type) return Boolean is begin - for I in 1 .. Length (Left.Keys) loop + for J in 1 .. Length (Left.Keys) loop declare - K : constant Key_Type := Get (Left.Keys, I); + K : constant Key_Type := Get (Left.Keys, J); begin if not Equivalent_Keys (K, New_Key) and then (Find (Right.Keys, K) = 0 or else Get (Right.Elements, Find (Right.Keys, K)) /= - Get (Left.Elements, I)) + Get (Left.Elements, J)) then return False; end if; @@ -112,16 +112,16 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is Y : Key_Type) return Boolean is begin - for I in 1 .. Length (Left.Keys) loop + for J in 1 .. Length (Left.Keys) loop declare - K : constant Key_Type := Get (Left.Keys, I); + K : constant Key_Type := Get (Left.Keys, J); begin if not Equivalent_Keys (K, X) and then not Equivalent_Keys (K, Y) and then (Find (Right.Keys, K) = 0 or else Get (Right.Elements, Find (Right.Keys, K)) /= - Get (Left.Elements, I)) + Get (Left.Elements, J)) then return False; end if; @@ -173,9 +173,9 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is function Keys_Included (Left : Map; Right : Map) return Boolean is begin - for I in 1 .. Length (Left.Keys) loop + for J in 1 .. Length (Left.Keys) loop declare - K : constant Key_Type := Get (Left.Keys, I); + K : constant Key_Type := Get (Left.Keys, J); begin if Find (Right.Keys, K) = 0 then return False; @@ -196,9 +196,9 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is New_Key : Key_Type) return Boolean is begin - for I in 1 .. Length (Left.Keys) loop + for J in 1 .. Length (Left.Keys) loop declare - K : constant Key_Type := Get (Left.Keys, I); + K : constant Key_Type := Get (Left.Keys, J); begin if not Equivalent_Keys (K, New_Key) and then Find (Right.Keys, K) = 0 @@ -218,9 +218,9 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is Y : Key_Type) return Boolean is begin - for I in 1 .. Length (Left.Keys) loop + for J in 1 .. Length (Left.Keys) loop declare - K : constant Key_Type := Get (Left.Keys, I); + K : constant Key_Type := Get (Left.Keys, J); begin if not Equivalent_Keys (K, X) and then not Equivalent_Keys (K, Y) @@ -243,6 +243,18 @@ package body Ada.Containers.Functional_Maps with SPARK_Mode => Off is return Length (Container.Elements); end Length; + ------------ + -- Remove -- + ------------ + + function Remove (Container : Map; Key : Key_Type) return Map is + J : constant Extended_Index := Find (Container.Keys, Key); + begin + return + (Keys => Remove (Container.Keys, J), + Elements => Remove (Container.Elements, J)); + end Remove; + --------------- -- Same_Keys -- --------------- diff --git a/gcc/ada/libgnat/a-cofuma.ads b/gcc/ada/libgnat/a-cofuma.ads index bf6e5a8..e458b06 100644 --- a/gcc/ada/libgnat/a-cofuma.ads +++ b/gcc/ada/libgnat/a-cofuma.ads @@ -243,6 +243,20 @@ package Ada.Containers.Functional_Maps with SPARK_Mode is and Container <= Add'Result and Keys_Included_Except (Add'Result, Container, New_Key); + function Remove + (Container : Map; + Key : Key_Type) return Map + -- Returns Container without any mapping for Key + + with + Global => null, + Pre => Has_Key (Container, Key), + Post => + Length (Container) = Length (Remove'Result) + 1 + and not Has_Key (Remove'Result, Key) + and Remove'Result <= Container + and Keys_Included_Except (Container, Remove'Result, Key); + function Set (Container : Map; Key : Key_Type; diff --git a/gcc/ada/libgnat/g-expect.adb b/gcc/ada/libgnat/g-expect.adb index 21c7913..4efd98d 100644 --- a/gcc/ada/libgnat/g-expect.adb +++ b/gcc/ada/libgnat/g-expect.adb @@ -222,15 +222,17 @@ package body GNAT.Expect is Next_Filter : Filter_List; begin - if Descriptor.Input_Fd /= Invalid_FD then - Close (Descriptor.Input_Fd); - end if; + Close_Input (Descriptor); - if Descriptor.Error_Fd /= Descriptor.Output_Fd then + if Descriptor.Error_Fd /= Descriptor.Output_Fd + and then Descriptor.Error_Fd /= Invalid_FD + then Close (Descriptor.Error_Fd); end if; - Close (Descriptor.Output_Fd); + if Descriptor.Output_Fd /= Invalid_FD then + Close (Descriptor.Output_Fd); + end if; -- ??? Should have timeouts for different signals @@ -267,6 +269,27 @@ package body GNAT.Expect is Close (Descriptor, Status); end Close; + ----------------- + -- Close_Input -- + ----------------- + + procedure Close_Input (Pid : in out Process_Descriptor) is + begin + if Pid.Input_Fd /= Invalid_FD then + Close (Pid.Input_Fd); + end if; + + if Pid.Output_Fd = Pid.Input_Fd then + Pid.Output_Fd := Invalid_FD; + end if; + + if Pid.Error_Fd = Pid.Input_Fd then + Pid.Error_Fd := Invalid_FD; + end if; + + Pid.Input_Fd := Invalid_FD; + end Close_Input; + ------------ -- Expect -- ------------ @@ -630,7 +653,9 @@ package body GNAT.Expect is begin for J in Descriptors'Range loop - if Descriptors (J) /= null then + if Descriptors (J) /= null + and then Descriptors (J).Output_Fd /= Invalid_FD + then Fds (Fds'First + Fds_Count) := Descriptors (J).Output_Fd; Fds_To_Descriptor (Fds'First + Fds_Count) := J; Fds_Count := Fds_Count + 1; @@ -644,6 +669,14 @@ package body GNAT.Expect is end if; end loop; + if Fds_Count = 0 then + -- There are no descriptors to monitor, it means that process died. + + Result := Expect_Process_Died; + + return; + end if; + declare Buffer : aliased String (1 .. Buffer_Size); -- Buffer used for input. This is allocated only once, not for @@ -656,8 +689,17 @@ package body GNAT.Expect is -- Loop until we match or we have a timeout loop - Num_Descriptors := - Poll (Fds'Address, Fds_Count, Timeout, D'Access, Is_Set'Address); + -- Poll may be interrupted on Linux by a signal and need to be + -- repeated. We don't want to check for errno = EINTER, so just + -- attempt to call Poll a few times. + + for J in 1 .. 3 loop + Num_Descriptors := + Poll + (Fds'Address, Fds_Count, Timeout, D'Access, Is_Set'Address); + + exit when Num_Descriptors /= -1; + end loop; case Num_Descriptors is @@ -667,8 +709,7 @@ package body GNAT.Expect is Result := Expect_Internal_Error; if D /= 0 then - Close (Descriptors (D).Input_Fd); - Descriptors (D).Input_Fd := Invalid_FD; + Close_Input (Descriptors (D).all); end if; return; @@ -707,9 +748,9 @@ package body GNAT.Expect is -- Error or End of file if N <= 0 then - Close (Descriptors (D).Input_Fd); - Descriptors (D).Input_Fd := Invalid_FD; + Close_Input (Descriptors (D).all); Result := Expect_Process_Died; + return; else @@ -931,8 +972,7 @@ package body GNAT.Expect is Send (Process, Input); end if; - Close (Process.Input_Fd); - Process.Input_Fd := Invalid_FD; + Close_Input (Process); declare Result : Expect_Match; diff --git a/gcc/ada/libgnat/g-expect.ads b/gcc/ada/libgnat/g-expect.ads index ae84f84..77bb579 100644 --- a/gcc/ada/libgnat/g-expect.ads +++ b/gcc/ada/libgnat/g-expect.ads @@ -613,6 +613,10 @@ private -- spawns the child process (based on Cmd). On systems that support fork, -- this procedure is executed inside the newly created process. + procedure Close_Input (Pid : in out Process_Descriptor); + -- Closes input file descriptor. Set Input_Fd to Invalid_Fd as well as + -- Output_Fd and Error_Fd when they share same file descriptor. + type Process_Descriptor is tagged record Pid : aliased Process_Id := Invalid_Pid; Input_Fd : GNAT.OS_Lib.File_Descriptor := GNAT.OS_Lib.Invalid_FD; diff --git a/gcc/ada/libgnat/g-exptty.adb b/gcc/ada/libgnat/g-exptty.adb index 728c5c6..b193448 100644 --- a/gcc/ada/libgnat/g-exptty.adb +++ b/gcc/ada/libgnat/g-exptty.adb @@ -74,9 +74,6 @@ package body GNAT.Expect.TTY is procedure Free_Process (Process : System.Address); pragma Import (C, Free_Process, "__gnat_free_process"); - procedure Close_TTY (Process : System.Address); - pragma Import (C, Close_TTY, "__gnat_close_tty"); - begin -- If we haven't already closed the process @@ -93,9 +90,7 @@ package body GNAT.Expect.TTY is -- signal, so this needs to be done while the file descriptors are -- still open (it used to be after the closes and that was wrong). - if Descriptor.Input_Fd /= Invalid_FD then - Close (Descriptor.Input_Fd); - end if; + Close_Input (Descriptor); if Descriptor.Error_Fd /= Descriptor.Output_Fd and then Descriptor.Error_Fd /= Invalid_FD @@ -125,10 +120,6 @@ package body GNAT.Expect.TTY is Status := Descriptor.Exit_Status; end if; - if not On_Windows then - Close_TTY (Descriptor.Process); - end if; - Free_Process (Descriptor.Process'Address); Descriptor.Process := System.Null_Address; @@ -143,6 +134,47 @@ package body GNAT.Expect.TTY is Close (Descriptor, Status); end Close; + ----------------- + -- Close_Input -- + ----------------- + + overriding procedure Close_Input + (Descriptor : in out TTY_Process_Descriptor) + is + function TTY_FD + (Handle : System.Address) return GNAT.OS_Lib.File_Descriptor; + pragma Import (C, TTY_FD, "__gnat_tty_fd"); + + procedure Close_TTY (Process : System.Address); + pragma Import (C, Close_TTY, "__gnat_close_tty"); + + begin + if not On_Windows and then Descriptor.Process /= System.Null_Address then + -- Check whether input/output/error streams use master descriptor and + -- reset corresponding members. + + if Descriptor.Input_Fd = TTY_FD (Descriptor.Process) then + Descriptor.Input_Fd := Invalid_FD; + end if; + + if Descriptor.Output_Fd = TTY_FD (Descriptor.Process) then + Descriptor.Output_Fd := Invalid_FD; + end if; + + if Descriptor.Error_Fd = TTY_FD (Descriptor.Process) then + Descriptor.Error_Fd := Invalid_FD; + end if; + + -- Close master descriptor. + + Close_TTY (Descriptor.Process); + end if; + + -- Call parent's implementation to close all remaining descriptors. + + Process_Descriptor (Descriptor).Close_Input; + end Close_Input; + ----------------------------- -- Close_Pseudo_Descriptor -- ----------------------------- diff --git a/gcc/ada/libgnat/g-exptty.ads b/gcc/ada/libgnat/g-exptty.ads index 57aa8d7..81068a6 100644 --- a/gcc/ada/libgnat/g-exptty.ads +++ b/gcc/ada/libgnat/g-exptty.ads @@ -134,6 +134,8 @@ private Cmd : String; Args : System.Address); + procedure Close_Input (Descriptor : in out TTY_Process_Descriptor); + Still_Active : constant Integer := -1; type TTY_Process_Descriptor is new Process_Descriptor with record diff --git a/gcc/ada/libgnat/g-socket.adb b/gcc/ada/libgnat/g-socket.adb index 51817ea..8565ccf 100644 --- a/gcc/ada/libgnat/g-socket.adb +++ b/gcc/ada/libgnat/g-socket.adb @@ -128,14 +128,12 @@ package body GNAT.Sockets is Socket_Error_Id : constant Exception_Id := Socket_Error'Identity; Host_Error_Id : constant Exception_Id := Host_Error'Identity; - type In_Addr_Union (Family : Family_Type) is record + type In_Addr_Union (Family : Family_Inet_4_6) is record case Family is when Family_Inet => In4 : In_Addr; when Family_Inet6 => In6 : In6_Addr; - when Family_Unspec => - null; end case; end record with Unchecked_Union; @@ -291,7 +289,7 @@ package body GNAT.Sockets is -- or the null selector. function Create_Address - (Family : Family_Type; Bytes : Inet_Addr_Bytes) return Inet_Addr_Type + (Family : Family_Inet_4_6; Bytes : Inet_Addr_Bytes) return Inet_Addr_Type with Inline; -- Creates address from family and Inet_Addr_Bytes array. @@ -354,7 +352,7 @@ package body GNAT.Sockets is end if; Socket := Socket_Type (Res); - Address := Get_Address (Sin); + Address := Get_Address (Sin, Len); end Accept_Socket; ------------------- @@ -465,12 +463,12 @@ package body GNAT.Sockets is is Res : C.int; Sin : aliased Sockaddr; + Len : C.int; begin - Set_Address (Sin'Unchecked_Access, Address); + Set_Address (Sin'Unchecked_Access, Address, Len); - Res := C_Bind - (C.int (Socket), Sin'Address, C.int (Lengths (Address.Family))); + Res := C_Bind (C.int (Socket), Sin'Address, Len); if Res = Failure then Raise_Socket_Error (Socket_Errno); @@ -670,11 +668,11 @@ package body GNAT.Sockets is Server : Sock_Addr_Type) return C.int is Sin : aliased Sockaddr; + Len : C.int; begin - Set_Address (Sin'Unchecked_Access, Server); + Set_Address (Sin'Unchecked_Access, Server, Len); - return C_Connect - (C.int (Socket), Sin'Address, C.int (Lengths (Server.Family))); + return C_Connect (C.int (Socket), Sin'Address, Len); end Connect_Socket; procedure Connect_Socket @@ -1039,10 +1037,17 @@ package body GNAT.Sockets is for J in Result'Range loop Look_For_Supported : loop if Iter = null then + pragma Warnings + (Off, "may be referenced before it has a value"); + return Result (1 .. J - 1); + + pragma Warnings + (On, "may be referenced before it has a value"); end if; - Result (J).Addr := Get_Address (Iter.ai_addr.all); + Result (J).Addr := + Get_Address (Iter.ai_addr.all, C.int (Iter.ai_addrlen)); if Result (J).Addr.Family = Family_Unspec then Unsupported; @@ -1071,10 +1076,6 @@ package body GNAT.Sockets is end if; Iter := Iter.ai_next; - - if Iter = null then - return Result (1 .. J - 1); - end if; end loop Look_For_Supported; Iter := Iter.ai_next; @@ -1149,15 +1150,16 @@ package body GNAT.Sockets is Numeric_Host : Boolean := False; Numeric_Serv : Boolean := False) return Host_Service is - SA : aliased Sockaddr; - H : aliased C.char_array := (1 .. SOSC.NI_MAXHOST => C.nul); - S : aliased C.char_array := (1 .. SOSC.NI_MAXSERV => C.nul); - RC : C.int; + SA : aliased Sockaddr; + H : aliased C.char_array := (1 .. SOSC.NI_MAXHOST => C.nul); + S : aliased C.char_array := (1 .. SOSC.NI_MAXSERV => C.nul); + RC : C.int; + Len : C.int; begin - Set_Address (SA'Unchecked_Access, Addr); + Set_Address (SA'Unchecked_Access, Addr, Len); RC := C_Getnameinfo - (SA'Unchecked_Access, socklen_t (Lengths (Addr.Family)), + (SA'Unchecked_Access, socklen_t (Len), H'Unchecked_Access, H'Length, S'Unchecked_Access, S'Length, (if Numeric_Host then SOSC.NI_NUMERICHOST else 0) + @@ -1197,9 +1199,6 @@ package body GNAT.Sockets is HA.In4 := To_In_Addr (Address); when Family_Inet6 => HA.In6 := To_In6_Addr (Address); - when Family_Unspec => - return (0, 0, (1, " "), (1 .. 0 => (1, " ")), - (1 .. 0 => No_Inet_Addr)); end case; Netdb_Lock; @@ -1208,8 +1207,7 @@ package body GNAT.Sockets is (HA'Address, (case Address.Family is when Family_Inet => HA.In4'Size, - when Family_Inet6 => HA.In6'Size, - when Family_Unspec => 0) / 8, + when Family_Inet6 => HA.In6'Size) / 8, Families (Address.Family), Res'Access, Buf'Address, Buflen, Err'Access) /= 0 then @@ -1280,7 +1278,7 @@ package body GNAT.Sockets is Raise_Socket_Error (Socket_Errno); end if; - return Get_Address (Sin); + return Get_Address (Sin, Len); end Get_Peer_Name; ------------------------- @@ -1364,7 +1362,7 @@ package body GNAT.Sockets is return No_Sock_Addr; end if; - return Get_Address (Sin); + return Get_Address (Sin, Len); end Get_Socket_Name; ----------------------- @@ -1572,9 +1570,8 @@ package body GNAT.Sockets is Size : constant socklen_t := (case Value.Family is when Family_Inet => 4 * Value.Sin_V4'Length, - when Family_Inet6 => 6 * 5 + 4 * 4, + when Family_Inet6 => 6 * 5 + 4 * 4); -- 1234:1234:1234:1234:1234:1234:123.123.123.123 - when Family_Unspec => 0); Dst : aliased C.char_array := (1 .. C.size_t (Size) => C.nul); Ia : aliased In_Addr_Union (Value.Family); begin @@ -1583,8 +1580,6 @@ package body GNAT.Sockets is Ia.In6 := To_In6_Addr (Value); when Family_Inet => Ia.In4 := To_In_Addr (Value); - when Family_Unspec => - return ""; end case; if Inet_Ntop @@ -1602,11 +1597,30 @@ package body GNAT.Sockets is ----------- function Image (Value : Sock_Addr_Type) return String is - Port : constant String := Value.Port'Img; function Ipv6_Brackets (S : String) return String is (if Value.Family = Family_Inet6 then "[" & S & "]" else S); begin - return Ipv6_Brackets (Image (Value.Addr)) & ':' & Port (2 .. Port'Last); + case Value.Family is + when Family_Unix => + if ASU.Length (Value.Name) > 0 + and then ASU.Element (Value.Name, 1) = ASCII.NUL + then + return '@' & ASU.Slice (Value.Name, 2, ASU.Length (Value.Name)); + else + return ASU.To_String (Value.Name); + end if; + + when Family_Inet_4_6 => + declare + Port : constant String := Value.Port'Img; + begin + return Ipv6_Brackets (Image (Value.Addr)) & ':' + & Port (2 .. Port'Last); + end; + + when Family_Unspec => + return ""; + end case; end Image; ----------- @@ -1924,6 +1938,19 @@ package body GNAT.Sockets is end if; end Netdb_Unlock; + ---------------------------- + -- Network_Socket_Address -- + ---------------------------- + + function Network_Socket_Address + (Addr : Inet_Addr_Type; Port : Port_Type) return Sock_Addr_Type is + begin + return Result : Sock_Addr_Type (Addr.Family) do + Result.Addr := Addr; + Result.Port := Port; + end return; + end Network_Socket_Address; + -------------------------------- -- Normalize_Empty_Socket_Set -- -------------------------------- @@ -2139,7 +2166,7 @@ package body GNAT.Sockets is Last := Last_Index (First => Item'First, Count => size_t (Res)); - From := Get_Address (Sin); + From := Get_Address (Sin, Len); end Receive_Socket; -------------------- @@ -2404,9 +2431,8 @@ package body GNAT.Sockets is begin if To /= null then - Set_Address (Sin'Unchecked_Access, To.all); + Set_Address (Sin'Unchecked_Access, To.all, Len); C_To := Sin'Address; - Len := C.int (Thin_Common.Lengths (To.Family)); else C_To := System.Null_Address; @@ -3055,12 +3081,11 @@ package body GNAT.Sockets is -------------------- function Create_Address - (Family : Family_Type; Bytes : Inet_Addr_Bytes) return Inet_Addr_Type + (Family : Family_Inet_4_6; Bytes : Inet_Addr_Bytes) return Inet_Addr_Type is (case Family is when Family_Inet => (Family_Inet, Bytes), - when Family_Inet6 => (Family_Inet6, Bytes), - when Family_Unspec => (Family => Family_Unspec)); + when Family_Inet6 => (Family_Inet6, Bytes)); --------------- -- Get_Bytes -- @@ -3069,15 +3094,14 @@ package body GNAT.Sockets is function Get_Bytes (Addr : Inet_Addr_Type) return Inet_Addr_Bytes is (case Addr.Family is when Family_Inet => Addr.Sin_V4, - when Family_Inet6 => Addr.Sin_V6, - when Family_Unspec => (1 .. 0 => 0)); + when Family_Inet6 => Addr.Sin_V6); ---------- -- Mask -- ---------- function Mask - (Family : Family_Type; + (Family : Family_Inet_4_6; Length : Natural; Host : Boolean := False) return Inet_Addr_Type is @@ -3109,6 +3133,15 @@ package body GNAT.Sockets is end; end Mask; + ------------------------- + -- Unix_Socket_Address -- + ------------------------- + + function Unix_Socket_Address (Addr : String) return Sock_Addr_Type is + begin + return Sock_Addr_Type'(Family_Unix, ASU.To_Unbounded_String (Addr)); + end Unix_Socket_Address; + ----------- -- "and" -- ----------- diff --git a/gcc/ada/libgnat/g-socket.ads b/gcc/ada/libgnat/g-socket.ads index acd72f1..38d1078 100644 --- a/gcc/ada/libgnat/g-socket.ads +++ b/gcc/ada/libgnat/g-socket.ads @@ -45,6 +45,7 @@ with Ada.Exceptions; with Ada.Streams; +with Ada.Strings.Unbounded; with Ada.Unchecked_Deallocation; with Interfaces.C; @@ -469,12 +470,14 @@ package GNAT.Sockets is -- Return a file descriptor to be used by external subprograms. This is -- useful for C functions that are not yet interfaced in this package. - type Family_Type is (Family_Inet, Family_Inet6, Family_Unspec); + type Family_Type is (Family_Inet, Family_Inet6, Family_Unix, Family_Unspec); -- Address family (or protocol family) identifies the communication domain -- and groups protocols with similar address formats. -- The order of the enumeration elements should not be changed unilaterally -- because the IPv6_TCP_Preferred routine rely on it. + subtype Family_Inet_4_6 is Family_Type range Family_Inet .. Family_Inet6; + type Mode_Type is (Socket_Stream, Socket_Datagram, Socket_Raw); -- Stream sockets provide connection-oriented byte streams. Datagram -- sockets support unreliable connectionless message-based communication. @@ -502,8 +505,8 @@ package GNAT.Sockets is type Inet_Addr_Comp_Type is mod 2 ** 8; -- Octet for Internet address - Inet_Addr_Bytes_Length : constant array (Family_Type) of Natural := - (Family_Inet => 4, Family_Inet6 => 16, Family_Unspec => 0); + Inet_Addr_Bytes_Length : constant array (Family_Inet_4_6) of Natural := + (Family_Inet => 4, Family_Inet6 => 16); type Inet_Addr_Bytes is array (Natural range <>) of Inet_Addr_Comp_Type; @@ -515,7 +518,7 @@ package GNAT.Sockets is subtype Inet_Addr_VN_Type is Inet_Addr_Bytes; -- For backwards compatibility - type Inet_Addr_Type (Family : Family_Type := Family_Inet) is record + type Inet_Addr_Type (Family : Family_Inet_4_6 := Family_Inet) is record case Family is when Family_Inet => Sin_V4 : Inet_Addr_V4_Type := (others => 0); @@ -523,9 +526,6 @@ package GNAT.Sockets is when Family_Inet6 => Sin_V6 : Inet_Addr_V6_Type := (others => 0); - when Family_Unspec => - null; - end case; end record; @@ -541,10 +541,6 @@ package GNAT.Sockets is No_Inet_Addr : constant Inet_Addr_Type; -- Uninitialized inet address - Unspecified_Addr : constant Inet_Addr_Type; - -- Unspecified address. Unlike of No_Inet_Addr the constraint is - -- Family_Unspec for this constant. - Broadcast_Inet_Addr : constant Inet_Addr_Type; -- Broadcast destination address in the current network @@ -581,7 +577,7 @@ package GNAT.Sockets is -- Functions to handle masks and prefixes function Mask - (Family : Family_Type; + (Family : Family_Inet_4_6; Length : Natural; Host : Boolean := False) return Inet_Addr_Type; -- Return an address mask of the given family with the given prefix length. @@ -596,8 +592,15 @@ package GNAT.Sockets is -- same address family). type Sock_Addr_Type (Family : Family_Type := Family_Inet) is record - Addr : Inet_Addr_Type (Family); - Port : Port_Type; + case Family is + when Family_Unix => + Name : Ada.Strings.Unbounded.Unbounded_String; + when Family_Inet_4_6 => + Addr : Inet_Addr_Type (Family); + Port : Port_Type; + when Family_Unspec => + null; + end case; end record; pragma No_Component_Reordering (Sock_Addr_Type); -- Socket addresses fully define a socket connection with protocol family, @@ -619,12 +622,20 @@ package GNAT.Sockets is -- 8 hextets in hexadecimal format separated by colons. function Image (Value : Sock_Addr_Type) return String; - -- Return inet address image and port image separated by a colon + -- Return socket address image. Network socket address image will be with + -- a port image separated by a colon. function Inet_Addr (Image : String) return Inet_Addr_Type; -- Convert address image from numbers-dots-and-colons notation into an -- inet address. + function Unix_Socket_Address (Addr : String) return Sock_Addr_Type; + -- Convert unix local socket name to Sock_Addr_Type + + function Network_Socket_Address + (Addr : Inet_Addr_Type; Port : Port_Type) return Sock_Addr_Type; + -- Create network socket address + -- Host entries provide complete information on a given host: the official -- name, an array of alternative names or aliases and array of network -- addresses. @@ -1439,6 +1450,8 @@ package GNAT.Sockets is private + package ASU renames Ada.Strings.Unbounded; + type Socket_Type is new Integer; No_Socket : constant Socket_Type := -1; @@ -1493,8 +1506,6 @@ private (Family_Inet6, (others => 0)); No_Inet_Addr : constant Inet_Addr_Type := (Family_Inet, (others => 0)); - Unspecified_Addr : constant Inet_Addr_Type := - (Family => Family_Unspec); Broadcast_Inet_Addr : constant Inet_Addr_Type := (Family_Inet, (others => 255)); Loopback_Inet_Addr : constant Inet_Addr_Type := diff --git a/gcc/ada/libgnat/g-sothco.adb b/gcc/ada/libgnat/g-sothco.adb index eb15ac2..9794d8b 100644 --- a/gcc/ada/libgnat/g-sothco.adb +++ b/gcc/ada/libgnat/g-sothco.adb @@ -37,18 +37,59 @@ package body GNAT.Sockets.Thin_Common is procedure Set_Address (Sin : Sockaddr_Access; - Address : Sock_Addr_Type) + Address : Sock_Addr_Type; + Length : out C.int) is + use type C.char; + + function Network_Port return C.unsigned_short is + (Short_To_Network (C.unsigned_short (Address.Port))) with Inline; + begin Set_Family (Sin.Sin_Family, Address.Family); - Sin.Sin_Port := Short_To_Network (C.unsigned_short (Address.Port)); + + Length := C.int (Lengths (Address.Family)); case Address.Family is when Family_Inet => + Sin.Sin_Port := Network_Port; Sin.Sin_Addr := To_In_Addr (Address.Addr); + when Family_Inet6 => + Sin.Sin6_Port := Network_Port; Sin.Sin6_Addr := To_In6_Addr (Address.Addr); Sin.Sin6_Scope_Id := 0; + + when Family_Unix => + declare + use type C.size_t; + Name_Len : constant C.size_t := + C.size_t (ASU.Length (Address.Name)); + begin + Length := Sockaddr_Length_And_Family'Size / System.Storage_Unit + + C.int (Name_Len); + + if Name_Len > Sin.Sun_Path'Length then + raise Constraint_Error with + "Too big address length for UNIX local communication"; + end if; + + if Name_Len = 0 then + Sin.Sun_Path (1) := C.nul; + + else + Sin.Sun_Path (1 .. Name_Len) := + C.To_C (ASU.To_String (Address.Name), Append_Nul => False); + + if Sin.Sun_Path (1) /= C.nul + and then Name_Len < Sin.Sun_Path'Length + then + Sin.Sun_Path (Name_Len + 1) := C.nul; + Length := Length + 1; + end if; + end if; + end; + when Family_Unspec => null; end case; @@ -58,26 +99,39 @@ package body GNAT.Sockets.Thin_Common is -- Get_Address -- ----------------- - function Get_Address (Sin : Sockaddr) return Sock_Addr_Type is - use type C.unsigned_short; + function Get_Address + (Sin : Sockaddr; Length : C.int) return Sock_Addr_Type + is + use type C.unsigned_short, C.size_t, C.char, SOSC.OS_Type; Family : constant C.unsigned_short := (if SOSC.Has_Sockaddr_Len = 0 then Sin.Sin_Family.Short_Family else C.unsigned_short (Sin.Sin_Family.Char_Family)); - AF_INET6_Defined : constant Boolean := SOSC.AF_INET6 > 0; Result : Sock_Addr_Type - (if AF_INET6_Defined and then SOSC.AF_INET6 = Family then Family_Inet6 + (if SOSC.AF_INET6 > 0 and then SOSC.AF_INET6 = Family then Family_Inet6 + elsif SOSC.AF_UNIX > 0 and then SOSC.AF_UNIX = Family then Family_Unix elsif SOSC.AF_INET = Family then Family_Inet else Family_Unspec); begin - Result.Port := Port_Type (Network_To_Short (Sin.Sin_Port)); - case Result.Family is when Family_Inet => + Result.Port := Port_Type (Network_To_Short (Sin.Sin_Port)); To_Inet_Addr (Sin.Sin_Addr, Result.Addr); when Family_Inet6 => + Result.Port := Port_Type (Network_To_Short (Sin.Sin6_Port)); To_Inet_Addr (Sin.Sin6_Addr, Result.Addr); + when Family_Unix => + if Length > Sin.Sin_Family'Size / System.Storage_Unit then + Result.Name := ASU.To_Unbounded_String + (C.To_Ada + (Sin.Sun_Path + (1 .. C.size_t (Length) + - Sin.Sin_Family'Size / System.Storage_Unit), + Trim_Nul => Sin.Sun_Path (1) /= C.nul + or else SOSC.Target_OS = SOSC.Windows)); + end if; + when Family_Unspec => - Result.Addr := (Family => Family_Unspec); + null; end case; return Result; diff --git a/gcc/ada/libgnat/g-sothco.ads b/gcc/ada/libgnat/g-sothco.ads index c62161d..a68019c 100644 --- a/gcc/ada/libgnat/g-sothco.ads +++ b/gcc/ada/libgnat/g-sothco.ads @@ -75,11 +75,13 @@ package GNAT.Sockets.Thin_Common is Families : constant array (Family_Type) of C.int := (Family_Unspec => SOSC.AF_UNSPEC, + Family_Unix => SOSC.AF_UNIX, Family_Inet => SOSC.AF_INET, Family_Inet6 => SOSC.AF_INET6); Lengths : constant array (Family_Type) of C.unsigned_char := (Family_Unspec => 0, + Family_Unix => SOSC.SIZEOF_sockaddr_un, Family_Inet => SOSC.SIZEOF_sockaddr_in, Family_Inet6 => SOSC.SIZEOF_sockaddr_in6); @@ -106,9 +108,7 @@ package GNAT.Sockets.Thin_Common is when False => Short_Family : C.unsigned_short; end case; - end record; - pragma Unchecked_Union (Sockaddr_Length_And_Family); - pragma Convention (C, Sockaddr_Length_And_Family); + end record with Unchecked_Union, Convention => C; procedure Set_Family (Length_And_Family : out Sockaddr_Length_And_Family; @@ -122,9 +122,7 @@ package GNAT.Sockets.Thin_Common is type In_Addr is record S_B1, S_B2, S_B3, S_B4 : C.unsigned_char; - end record; - for In_Addr'Alignment use C.int'Alignment; - pragma Convention (C, In_Addr); + end record with Convention => C, Alignment => C.int'Alignment; -- IPv4 address, represented as a network-order C.int. Note that the -- underlying operating system may assume that values of this type have -- C.int alignment, so we need to provide a suitable alignment clause here. @@ -138,9 +136,10 @@ package GNAT.Sockets.Thin_Common is Result : out Inet_Addr_Type); -- Conversion functions - type In6_Addr is array (1 .. 16) of C.unsigned_char; - for In6_Addr'Alignment use C.int'Alignment; - pragma Convention (C, In6_Addr); + type In6_Addr is array (1 .. 16) of C.unsigned_char with Convention => C; + + Unix_Name_Length : constant := 108; + -- Maximum length for local unix socket name function To_In6_Addr (Addr : Inet_Addr_Type) return In6_Addr; procedure To_Inet_Addr @@ -149,14 +148,14 @@ package GNAT.Sockets.Thin_Common is -- Conversion functions type Sockaddr (Family : Family_Type := Family_Inet) is record - Sin_Family : Sockaddr_Length_And_Family; - -- Address family (and address length on some platforms) - - Sin_Port : C.unsigned_short; - -- Port in network byte order - case Family is when Family_Inet => + Sin_Family : Sockaddr_Length_And_Family; + -- Address family (and address length on some platforms) + + Sin_Port : C.unsigned_short; + -- Port in network byte order + Sin_Addr : In_Addr := (others => 0); -- IPv4 address @@ -165,16 +164,28 @@ package GNAT.Sockets.Thin_Common is -- -- Note that some platforms require that all unused (reserved) bytes -- in addresses be initialized to 0 (e.g. VxWorks). + when Family_Inet6 => + Sin6_Family : Sockaddr_Length_And_Family; + -- Address family (and address length on some platforms) + + Sin6_Port : C.unsigned_short; + -- Port in network byte order + Sin6_FlowInfo : Interfaces.Unsigned_32 := 0; Sin6_Addr : In6_Addr := (others => 0); Sin6_Scope_Id : Interfaces.Unsigned_32 := 0; + + when Family_Unix => + Sun_Family : Sockaddr_Length_And_Family; + -- Address family (and address length on some platforms) + + Sun_Path : C.char_array (1 .. Unix_Name_Length); + when Family_Unspec => null; end case; - end record; - pragma Unchecked_Union (Sockaddr); - pragma Convention (C, Sockaddr); + end record with Convention => C, Unchecked_Union; -- Internet socket address type Sockaddr_Access is access all Sockaddr; @@ -183,13 +194,15 @@ package GNAT.Sockets.Thin_Common is procedure Set_Address (Sin : Sockaddr_Access; - Address : Sock_Addr_Type); + Address : Sock_Addr_Type; + Length : out C.int); -- Initialise all necessary fields in Sin from Address. -- Set appropriate Family, Port, and either Sin.Sin_Addr or Sin.Sin6_Addr -- depend on family. + -- Set the Length out parameter to the valuable Sockaddr data length. - function Get_Address (Sin : Sockaddr) return Sock_Addr_Type; - -- Get Sock_Addr_Type from Sockaddr + function Get_Address (Sin : Sockaddr; Length : C.int) return Sock_Addr_Type; + -- Get Sock_Addr_Type from Sockaddr and its valuable data Length ------------------ -- Host entries -- diff --git a/gcc/ada/libgnat/s-arit64.adb b/gcc/ada/libgnat/s-arit64.adb index 3a65ec0..ede7562 100644 --- a/gcc/ada/libgnat/s-arit64.adb +++ b/gcc/ada/libgnat/s-arit64.adb @@ -147,13 +147,31 @@ package body System.Arith_64 is Raise_Error; end if; + -- Set final signs (RM 4.5.5(27-30)) + + Den_Pos := (Y < 0) = (Z < 0); + -- Compute Y * Z. Note that if the result overflows 64 bits unsigned, - -- then the rounded result is clearly zero (since the dividend is at - -- most 2**63 - 1, the extra bit of precision is nice here). + -- then the rounded result is zero, except for the very special case + -- where X = -2**63 and abs(Y*Z) = 2**64, when Round is True. if Yhi /= 0 then if Zhi /= 0 then - Q := 0; + + -- Handle the special case when Round is True + + if Yhi = 1 + and then Zhi = 1 + and then Ylo = 0 + and then Zlo = 0 + and then X = Int64'First + and then Round + then + Q := (if Den_Pos then -1 else 1); + else + Q := 0; + end if; + R := X; return; else @@ -161,25 +179,34 @@ package body System.Arith_64 is end if; else - T2 := (if Zhi /= 0 then Ylo * Zhi else 0); + T2 := Ylo * Zhi; end if; T1 := Ylo * Zlo; T2 := T2 + Hi (T1); if Hi (T2) /= 0 then - Q := 0; + + -- Handle the special case when Round is True + + if Hi (T2) = 1 + and then Lo (T2) = 0 + and then Lo (T1) = 0 + and then X = Int64'First + and then Round + then + Q := (if Den_Pos then -1 else 1); + else + Q := 0; + end if; + R := X; return; end if; Du := Lo (T2) & Lo (T1); - -- Set final signs (RM 4.5.5(27-30)) - - Den_Pos := (Y < 0) = (Z < 0); - - -- Check overflow case of largest negative number divided by 1 + -- Check overflow case of largest negative number divided by -1 if X = Int64'First and then Du = 1 and then not Den_Pos then Raise_Error; @@ -204,9 +231,13 @@ package body System.Arith_64 is -- Case of dividend (X) sign negative + -- We perform the unary minus operation on the unsigned value + -- before conversion to signed, to avoid a possible overflow for + -- value -2**63, both for computing R and Q. + else - R := -To_Int (Ru); - Q := (if Den_Pos then -To_Int (Qu) else To_Int (Qu)); + R := To_Int (-Ru); + Q := (if Den_Pos then To_Int (-Qu) else To_Int (Qu)); end if; end Double_Divide; @@ -400,15 +431,16 @@ package body System.Arith_64 is Ru := T2 rem Zlo; end if; - -- If divisor is double digit and too large, raise error + -- If divisor is double digit and dividend is too large, raise error elsif (D (1) & D (2)) >= Zu then Raise_Error; -- This is the complex case where we definitely have a double digit -- divisor and a dividend of at least three digits. We use the classical - -- multiple division algorithm (see section (4.3.1) of Knuth's "The Art - -- of Computer Programming", Vol. 2 for a description (algorithm D). + -- multiple-precision division algorithm (see section (4.3.1) of Knuth's + -- "The Art of Computer Programming", Vol. 2 for a description + -- (algorithm D). else -- First normalize the divisor so that it has the leading bit on. @@ -446,7 +478,7 @@ package body System.Arith_64 is -- Note that when we scale up the dividend, it still fits in four -- digits, since we already tested for overflow, and scaling does - -- not change the invariant that (D (1) & D (2)) >= Zu. + -- not change the invariant that (D (1) & D (2)) < Zu. T1 := Shift_Left (D (1) & D (2), Scale); D (1) := Hi (T1); @@ -481,6 +513,19 @@ package body System.Arith_64 is -- Adjust quotient digit if it was too high + -- We use the version of the algorithm in the 2nd Edition of + -- "The Art of Computer Programming". This had a bug not + -- discovered till 1995, see Vol 2 errata: + -- http://www-cs-faculty.stanford.edu/~uno/err2-2e.ps.gz. + -- Under rare circumstances the expression in the test could + -- overflow. This version was further corrected in 2005, see + -- Vol 2 errata: + -- http://www-cs-faculty.stanford.edu/~uno/all2-pre.ps.gz. + -- This implementation is not impacted by these bugs, due to the + -- use of a word-size comparison done in function Le3 instead of + -- a comparison on two-word integer quantities in the original + -- algorithm. + loop exit when Le3 (S1, S2, S3, D (J + 1), D (J + 2), D (J + 3)); Qd (J + 1) := Qd (J + 1) - 1; @@ -507,6 +552,14 @@ package body System.Arith_64 is -- Deal with rounding case if Round and then Ru > (Zu - Uns64'(1)) / Uns64'(2) then + + -- Protect against wrapping around when rounding, by signaling + -- an overflow when the quotient is too large. + + if Qu = Uns64'Last then + Raise_Error; + end if; + Qu := Qu + Uns64 (1); end if; diff --git a/gcc/ada/libgnat/s-bitfie.ads b/gcc/ada/libgnat/s-bitfie.ads index 1b62b9d..a90605b 100644 --- a/gcc/ada/libgnat/s-bitfie.ads +++ b/gcc/ada/libgnat/s-bitfie.ads @@ -36,9 +36,13 @@ package System.Bitfields is -- Instances of the generic package in System.Bitfield_Utils. So far -- we have just one, which defaults to the natural endianness of the -- machine. We might someday want to support Scalar_Storage_Order. + -- Note: we use Long_Long_Integer'Size / 2 instead of 32 to support + -- specifying a target configuration file where the largest integer is + -- 32 bits instead of 64. + + Val_Bits : constant := Long_Long_Integer'Size / 2; + Val_Bytes : constant := Val_Bits / System.Storage_Unit; - Val_Bytes : constant := 4; - Val_Bits : constant := Val_Bytes * System.Storage_Unit; type Val_2 is mod 2**(Val_Bits * 2) with Alignment => Val_Bytes; pragma Provide_Shift_Operators (Val_2); type Val is mod 2**Val_Bits with Alignment => Val_Bytes; diff --git a/gcc/ada/libgnat/s-bituti.adb b/gcc/ada/libgnat/s-bituti.adb index 78e391b..b425e9f 100644 --- a/gcc/ada/libgnat/s-bituti.adb +++ b/gcc/ada/libgnat/s-bituti.adb @@ -43,6 +43,31 @@ package body System.Bitfield_Utils is Val_Bytes : constant Address := Address (Val'Size / Storage_Unit); + -- A Val_2 can cross a memory page boundary (e.g. an 8-byte Val_2 that + -- starts 4 bytes before the end of a page). If the bit field also + -- crosses that boundary, then the second page is known to exist, and we + -- can safely load or store the Val_2. On the other hand, if the bit + -- field is entirely within the first half of the Val_2, then it is + -- possible (albeit highly unlikely) that the second page does not + -- exist, so we must load or store only the first half of the Val_2. + -- Get_Val_2 and Set_Val_2 take care of all this. + + function Get_Val_2 + (Src_Address : Address; + Src_Offset : Bit_Offset; + Size : Small_Size) + return Val_2; + -- Get the Val_2, taking care to only load the first half when + -- necessary. + + procedure Set_Val_2 + (Dest_Address : Address; + Dest_Offset : Bit_Offset; + V : Val_2; + Size : Small_Size); + -- Set the Val_2, taking care to only store the first half when + -- necessary. + -- Get_Bitfield and Set_Bitfield are helper functions that get/set small -- bit fields -- the value fits in Val, and the bit field is placed -- starting at some offset within the first half of a Val_2. @@ -56,11 +81,6 @@ package body System.Bitfield_Utils is -- Returns the bit field in Src starting at Src_Offset, of the given -- Size. If Size < Small_Size'Last, then high order bits are zero. - function Get_Full_Bitfield - (Src : Val_2; Src_Offset : Bit_Offset) return Val; - -- Same as Get_Bitfield, except the Size is hardwired to the maximum - -- allowed. - function Set_Bitfield (Src_Value : Val; Dest : Val_2; @@ -71,6 +91,99 @@ package body System.Bitfield_Utils is -- set to Src_Value. Src_Value must have high order bits (Size and -- above) zero. The result is returned as the function result. + procedure Set_Bitfield + (Src_Value : Val; + Dest_Address : Address; + Dest_Offset : Bit_Offset; + Size : Small_Size); + -- This version takes the bit address and size of the destination. + + procedure Copy_Small_Bitfield + (Src_Address : Address; + Src_Offset : Bit_Offset; + Dest_Address : Address; + Dest_Offset : Bit_Offset; + Size : Small_Size); + -- Copy_Bitfield in the case where Size <= Val'Size. + -- The Address values must be aligned as for Val and Val_2. + -- This works for overlapping bit fields. + + procedure Copy_Large_Bitfield + (Src_Address : Address; + Src_Offset : Bit_Offset; + Dest_Address : Address; + Dest_Offset : Bit_Offset; + Size : Bit_Size); + -- Copy_Bitfield in the case where Size > Val'Size. + -- The Address values must be aligned as for Val and Val_2. + -- This works for overlapping bit fields only if the source + -- bit address is greater than or equal to the destination + -- bit address, because it copies forward (from lower to higher + -- bit addresses). + + function Get_Val_2 + (Src_Address : Address; + Src_Offset : Bit_Offset; + Size : Small_Size) + return Val_2 is + begin + pragma Assert (Src_Address mod Val'Alignment = 0); + + -- Bit field fits in first half; fetch just one Val. On little + -- endian, we want that in the low half, but on big endian, we + -- want it in the high half. + + if Src_Offset + Size <= Val'Size then + declare + Result : aliased constant Val with + Import, Address => Src_Address; + begin + return (case Endian is + when Little => Val_2 (Result), + when Big => Shift_Left (Val_2 (Result), Val'Size)); + end; + + -- Bit field crosses into the second half, so it's safe to fetch the + -- whole Val_2. + + else + declare + Result : aliased constant Val_2 with + Import, Address => Src_Address; + begin + return Result; + end; + end if; + end Get_Val_2; + + procedure Set_Val_2 + (Dest_Address : Address; + Dest_Offset : Bit_Offset; + V : Val_2; + Size : Small_Size) is + begin + pragma Assert (Dest_Address mod Val'Alignment = 0); + + -- Comments in Get_Val_2 apply, except we're storing instead of + -- fetching. + + if Dest_Offset + Size <= Val'Size then + declare + Dest : aliased Val with Import, Address => Dest_Address; + begin + Dest := (case Endian is + when Little => Val'Mod (V), + when Big => Val (Shift_Right (V, Val'Size))); + end; + else + declare + Dest : aliased Val_2 with Import, Address => Dest_Address; + begin + Dest := V; + end; + end if; + end Set_Val_2; + function Get_Bitfield (Src : Val_2; Src_Offset : Bit_Offset; Size : Small_Size) return Val @@ -87,12 +200,6 @@ package body System.Bitfield_Utils is return Val (Temp2); end Get_Bitfield; - function Get_Full_Bitfield - (Src : Val_2; Src_Offset : Bit_Offset) return Val is - begin - return Get_Bitfield (Src, Src_Offset, Size => Val'Size); - end Get_Full_Bitfield; - function Set_Bitfield (Src_Value : Val; Dest : Val_2; @@ -115,28 +222,19 @@ package body System.Bitfield_Utils is return Result; end Set_Bitfield; - procedure Copy_Small_Bitfield - (Src_Address : Address; - Src_Offset : Bit_Offset; - Dest_Address : Address; - Dest_Offset : Bit_Offset; - Size : Small_Size); - -- Copy_Bitfield in the case where Size <= Val'Size. - -- The Address values must be aligned as for Val and Val_2. - -- This works for overlapping bit fields. - - procedure Copy_Large_Bitfield - (Src_Address : Address; - Src_Offset : Bit_Offset; + procedure Set_Bitfield + (Src_Value : Val; Dest_Address : Address; - Dest_Offset : Bit_Offset; - Size : Bit_Size); - -- Copy_Bitfield in the case where Size > Val'Size. - -- The Address values must be aligned as for Val and Val_2. - -- This works for overlapping bit fields only if the source - -- bit address is greater than or equal to the destination - -- bit address, because it copies forward (from lower to higher - -- bit addresses). + Dest_Offset : Bit_Offset; + Size : Small_Size) + is + Old_Dest : constant Val_2 := + Get_Val_2 (Dest_Address, Dest_Offset, Size); + New_Dest : constant Val_2 := + Set_Bitfield (Src_Value, Old_Dest, Dest_Offset, Size); + begin + Set_Val_2 (Dest_Address, Dest_Offset, New_Dest, Size); + end Set_Bitfield; procedure Copy_Small_Bitfield (Src_Address : Address; @@ -145,11 +243,10 @@ package body System.Bitfield_Utils is Dest_Offset : Bit_Offset; Size : Small_Size) is - Src : constant Val_2 with Import, Address => Src_Address; + Src : constant Val_2 := Get_Val_2 (Src_Address, Src_Offset, Size); V : constant Val := Get_Bitfield (Src, Src_Offset, Size); - Dest : Val_2 with Import, Address => Dest_Address; begin - Dest := Set_Bitfield (V, Dest, Dest_Offset, Size); + Set_Bitfield (V, Dest_Address, Dest_Offset, Size); end Copy_Small_Bitfield; -- Copy_Large_Bitfield does the main work. Copying aligned Vals is more @@ -168,9 +265,9 @@ package body System.Bitfield_Utils is -- Address). Get_Bitfield and Set_Bitfield are used here. -- -- Step 2: - -- Loop, copying Vals. Get_Full_Bitfield is used to fetch a - -- Val-sized bit field, but Set_Bitfield is not needed -- we can set - -- the aligned Val with an array indexing. + -- Loop, copying Vals. Get_Bitfield is used to fetch a Val-sized + -- bit field, but Set_Bitfield is not needed -- we can set the + -- aligned Val with an array indexing. -- -- Step 3: -- Copy remaining smaller-than-Val bits, if any @@ -216,13 +313,13 @@ package body System.Bitfield_Utils is declare Initial_Size : constant Small_Size := Val'Size - D_Off; - Initial_Val_2 : constant Val_2 with Import, Address => S_Addr; + Initial_Val_2 : constant Val_2 := + Get_Val_2 (S_Addr, S_Off, Initial_Size); Initial_Val : constant Val := Get_Bitfield (Initial_Val_2, S_Off, Initial_Size); - Initial_Dest : Val_2 with Import, Address => D_Addr; begin - Initial_Dest := Set_Bitfield - (Initial_Val, Initial_Dest, D_Off, Initial_Size); + Set_Bitfield + (Initial_Val, D_Addr, D_Off, Initial_Size); Sz := Sz - Initial_Size; declare @@ -253,8 +350,10 @@ package body System.Bitfield_Utils is pragma Assert (Dest_Comp in Val); pragma Warnings (On); pragma Assert (Dest_Comp'Valid); - Src_V_2 : constant Val_2 with Import, Address => S_Addr; - Full_V : constant Val := Get_Full_Bitfield (Src_V_2, S_Off); + Src_V_2 : constant Val_2 := + Get_Val_2 (S_Addr, S_Off, Val'Size); + Full_V : constant Val := + Get_Bitfield (Src_V_2, S_Off, Val'Size); begin Dest_Comp := Full_V; S_Addr := S_Addr + Val_Bytes; @@ -262,18 +361,18 @@ package body System.Bitfield_Utils is end; end loop; - if Sz mod Val'Size /= 0 then + Sz := Sz mod Val'Size; + if Sz /= 0 then -- Step 3: declare - Final_Val_2 : constant Val_2 with Import, Address => S_Addr; + Final_Val_2 : constant Val_2 := + Get_Val_2 (S_Addr, S_Off, Sz); Final_Val : constant Val := - Get_Bitfield (Final_Val_2, S_Off, Sz mod Val'Size); - Final_Dest : Val_2 with Import, - Address => D_Addr + Dest_Arr'Length * Val_Bytes; + Get_Bitfield (Final_Val_2, S_Off, Sz); begin - Final_Dest := Set_Bitfield - (Final_Val, Final_Dest, 0, Sz mod Val'Size); + Set_Bitfield + (Final_Val, D_Addr + Dest_Arr'Length * Val_Bytes, 0, Sz); end; end if; end; diff --git a/gcc/ada/libgnat/s-stausa.adb b/gcc/ada/libgnat/s-stausa.adb index f93d1d9..597634a 100644 --- a/gcc/ada/libgnat/s-stausa.adb +++ b/gcc/ada/libgnat/s-stausa.adb @@ -42,7 +42,7 @@ package body System.Stack_Usage is -- Stack_Slots -- ----------------- - -- Stackl_Slots is an internal data type to represent a sequence of real + -- Stack_Slots is an internal data type to represent a sequence of real -- stack slots initialized with a provided pattern, with operations to -- abstract away the target call stack growth direction. diff --git a/gcc/ada/libgnat/s-stausa.ads b/gcc/ada/libgnat/s-stausa.ads index 03bc760..2dfa735 100644 --- a/gcc/ada/libgnat/s-stausa.ads +++ b/gcc/ada/libgnat/s-stausa.ads @@ -67,6 +67,11 @@ package System.Stack_Usage is -- Type of the stack analyzer tool. It is used to fill a portion of the -- stack with Pattern, and to compute the stack used after some execution. + -- Note that Fill_Stack writes data past the current top of the stack + -- (i.e. at addresses less than the stack pointer register, assuming the + -- stack grows downward). Therefore, this package is incompatible with + -- tools like Valgrind and DrMemory. + -- Usage: -- A typical use of the package is something like: diff --git a/gcc/ada/libgnat/s-valrea.adb b/gcc/ada/libgnat/s-valrea.adb index 99c7360..519e369 100644 --- a/gcc/ada/libgnat/s-valrea.adb +++ b/gcc/ada/libgnat/s-valrea.adb @@ -29,346 +29,469 @@ -- -- ------------------------------------------------------------------------------ -with System.Powten_Table; use System.Powten_Table; with System.Val_Util; use System.Val_Util; with System.Float_Control; package body System.Val_Real is - --------------- - -- Scan_Real -- - --------------- + procedure Scan_Integral_Digits + (Str : String; + Index : in out Integer; + Max : Integer; + Value : out Long_Long_Integer; + Scale : out Integer; + Base_Violation : in out Boolean; + Base : Long_Long_Integer := 10; + Base_Specified : Boolean := False); + -- Scan the integral part of a real (i.e: before decimal separator) + -- + -- The string parsed is Str (Index .. Max), and after the call Index will + -- point to the first non parsed character. + -- + -- For each digit parsed either value := value * base + digit, or scale + -- is incremented by 1. + -- + -- Base_Violation will be set to True a digit found is not part of the Base + + procedure Scan_Decimal_Digits + (Str : String; + Index : in out Integer; + Max : Integer; + Value : in out Long_Long_Integer; + Scale : in out Integer; + Base_Violation : in out Boolean; + Base : Long_Long_Integer := 10; + Base_Specified : Boolean := False); + -- Scan the decimal part of a real (i.e: after decimal separator) + -- + -- The string parsed is Str (Index .. Max), and after the call Index will + -- point to the first non parsed character. + -- + -- For each digit parsed value = value * base + digit and scale is + -- decremented by 1. If precision limit is reached remaining digits are + -- still parsed but ignored. + -- + -- Base_Violation will be set to True a digit found is not part of the Base + + subtype Char_As_Digit is Long_Long_Integer range -2 .. 15; + subtype Valid_Digit is Char_As_Digit range 0 .. Char_As_Digit'Last; + Underscore : constant Char_As_Digit := -2; + E_Digit : constant Char_As_Digit := 14; + + function As_Digit (C : Character) return Char_As_Digit; + -- Given a character return the digit it represent. If the character is + -- not a digit then a negative value is returned, -2 for underscore and + -- -1 for any other character. + + Precision_Limit : constant Long_Long_Integer := + 2 ** (Long_Long_Float'Machine_Mantissa - 1) - 1; + -- This is an upper bound for the number of bits used to represent the + -- mantissa. Beyond that number, any digits parsed are useless. + + -------------- + -- As_Digit -- + -------------- + + function As_Digit (C : Character) return Char_As_Digit + is + begin + case C is + when '0' .. '9' => + return Character'Pos (C) - Character'Pos ('0'); + when 'a' .. 'f' => + return Character'Pos (C) - (Character'Pos ('a') - 10); + when 'A' .. 'F' => + return Character'Pos (C) - (Character'Pos ('A') - 10); + when '_' => + return Underscore; + when others => + return -1; + end case; + end As_Digit; + + ------------------------- + -- Scan_Decimal_Digits -- + ------------------------- + + procedure Scan_Decimal_Digits + (Str : String; + Index : in out Integer; + Max : Integer; + Value : in out Long_Long_Integer; + Scale : in out Integer; + Base_Violation : in out Boolean; + Base : Long_Long_Integer := 10; + Base_Specified : Boolean := False) - function Scan_Real - (Str : String; - Ptr : not null access Integer; - Max : Integer) return Long_Long_Float is - P : Integer; - -- Local copy of string pointer + Precision_Limit_Reached : Boolean := False; + -- Set to True if addition of a digit will cause Value to be superior + -- to Precision_Limit. - Base : Long_Long_Float; - -- Base value + Digit : Char_As_Digit; + -- The current digit. - Uval : Long_Long_Float; - -- Accumulated float result + Trailing_Zeros : Natural := 0; + -- Number of trailing zeros at a given point. + begin - subtype Digs is Character range '0' .. '9'; - -- Used to check for decimal digit + -- If initial Scale is not 0 then it means that Precision_Limit was + -- reached during integral part scanning. + if Scale > 0 then + Precision_Limit_Reached := True; + end if; - Scale : Integer := 0; - -- Power of Base to multiply result by + -- The function precondition is that the first character is a valid + -- digit. + Digit := As_Digit (Str (Index)); + + loop + -- Check if base is correct. If the base is not specified the digit + -- E or e cannot be considered as a base violation as it can be used + -- for exponentiation. + if Digit >= Base then + if Base_Specified then + Base_Violation := True; + elsif Digit = E_Digit then + return; + else + Base_Violation := True; + end if; + end if; - Start : Positive; - -- Position of starting non-blank character + -- If precision limit has been reached just ignore any remaining + -- digits for the computation of Value and Scale. The scanning + -- should continue only to assess the validity of the string + if not Precision_Limit_Reached then + if Digit = 0 then + -- Trailing '0' digits are ignored unless a non-zero digit is + -- found. + Trailing_Zeros := Trailing_Zeros + 1; + else - Minus : Boolean; - -- Set to True if minus sign is present, otherwise to False + -- Handle accumulated zeros. + for J in 1 .. Trailing_Zeros loop + if Value > Precision_Limit / Base then + Precision_Limit_Reached := True; + exit; + else + Value := Value * Base; + Scale := Scale - 1; + end if; + end loop; - Bad_Base : Boolean := False; - -- Set True if Base out of range or if out of range digit - - After_Point : Natural := 0; - -- Set to 1 after the point - - Precision_Limit : constant Long_Long_Float := - 2.0 ** (Long_Long_Float'Machine_Mantissa - 1); - -- This is an upper bound for the number of bits used to represent the - -- mantissa. Beyond that number, any digits parsed by Scanf are useless. - -- Thus, only the scale should be updated. This ensures that infinity is - -- not reached by the temporary Uval, which could lead to erroneous - -- rounding (for example: 0.4444444... or 1<n zero>E-n). - - procedure Scanf; - -- Scans integer literal value starting at current character position. - -- For each digit encountered, Uval is multiplied by 10.0, and the new - -- digit value is incremented. In addition Scale is decremented for each - -- digit encountered if we are after the point (After_Point = 1). The - -- longest possible syntactically valid numeral is scanned out, and on - -- return P points past the last character. On entry, the current - -- character is known to be a digit, so a numeral is definitely present. - - ----------- - -- Scanf -- - ----------- - - procedure Scanf is - Digit : Natural; - Uval_Tmp : Long_Long_Float; - Precision_Limit_Reached : Boolean := False; - begin - loop - Digit := Character'Pos (Str (P)) - Character'Pos ('0'); - - if not Precision_Limit_Reached then - -- Compute potential new value - Uval_Tmp := Uval * 10.0 + Long_Long_Float (Digit); - - if Uval_Tmp > Precision_Limit then + -- Reset trailing zero counter + Trailing_Zeros := 0; + + -- Handle current non zero digit + if Value > (Precision_Limit - Digit) / Base then Precision_Limit_Reached := True; + else + Value := Value * Base + Digit; + Scale := Scale - 1; end if; end if; + end if; - if Precision_Limit_Reached then - -- If beyond the precision of the mantissa then just ignore the - -- digit, to avoid rounding issues. - if After_Point = 0 then - Scale := Scale + 1; - end if; - else - Uval := Uval_Tmp; - Scale := Scale - After_Point; - end if; + -- Check next character + Index := Index + 1; - -- Check next character - P := P + 1; + if Index > Max then + return; + end if; - if P > Max then - -- Done if end of input field - return; + Digit := As_Digit (Str (Index)); - elsif Str (P) not in Digs then - -- If next character is not a digit, check if this is an - -- underscore. If this is not the case, then return. - if Str (P) = '_' then - Scan_Underscore (Str, P, Ptr, Max, False); + if Digit < 0 then + if Digit = Underscore and Index + 1 <= Max then + -- Underscore is only alllowed if followed by a digit + Digit := As_Digit (Str (Index + 1)); + if Digit in Valid_Digit then + Index := Index + 1; else return; end if; + else + -- Neither a valid underscore nor a digit. + return; end if; + end if; + end loop; + + end Scan_Decimal_Digits; + + -------------------------- + -- Scan_Integral_Digits -- + -------------------------- + + procedure Scan_Integral_Digits + (Str : String; + Index : in out Integer; + Max : Integer; + Value : out Long_Long_Integer; + Scale : out Integer; + Base_Violation : in out Boolean; + Base : Long_Long_Integer := 10; + Base_Specified : Boolean := False) + is + Precision_Limit_Reached : Boolean := False; + -- Set to True if addition of a digit will cause Value to be superior + -- to Precision_Limit. - end loop; - end Scanf; - - -- Start of processing for System.Scan_Real - + Digit : Char_As_Digit; + -- The current digit begin - -- We do not tolerate strings with Str'Last = Positive'Last - if Str'Last = Positive'Last then - raise Program_Error with - "string upper bound is Positive'Last, not supported"; - end if; - - -- We call the floating-point processor reset routine so that we can - -- be sure the floating-point processor is properly set for conversion - -- calls. This is notably need on Windows, where calls to the operating - -- system randomly reset the processor into 64-bit mode. - - System.Float_Control.Reset; - - Scan_Sign (Str, Ptr, Max, Minus, Start); - P := Ptr.all; - Ptr.all := Start; - - -- If digit, scan numeral before point - - if Str (P) in Digs then - Uval := 0.0; - Scanf; - - -- Initial point, allowed only if followed by digit (RM 3.5(47)) - - elsif Str (P) = '.' - and then P < Max - and then Str (P + 1) in Digs - then - Uval := 0.0; - - -- Any other initial character is an error - - else - Bad_Value (Str); - end if; - - -- Deal with based case. We reognize either the standard '#' or the - -- allowed alternative replacement ':' (see RM J.2(3)). - - if P < Max and then (Str (P) = '#' or else Str (P) = ':') then - declare - Base_Char : constant Character := Str (P); - Digit : Natural; - Fdigit : Long_Long_Float; - Uval_Tmp : Long_Long_Float; - Precision_Limit_Reached : Boolean := False; - begin - -- Set bad base if out of range, and use safe base of 16.0, - -- to guard against division by zero in the loop below. - - if Uval < 2.0 or else Uval > 16.0 then - Bad_Base := True; - Uval := 16.0; + -- Initialize Scale and Value + Value := 0; + Scale := 0; + + -- The function precondition is that the first character is a valid + -- digit. + Digit := As_Digit (Str (Index)); + + loop + -- Check if base is correct. If the base is not specified the digit + -- E or e cannot be considered as a base violation as it can be used + -- for exponentiation. + if Digit >= Base then + if Base_Specified then + Base_Violation := True; + elsif Digit = E_Digit then + return; + else + Base_Violation := True; end if; + end if; - Base := Uval; - Uval := 0.0; - P := P + 1; - - -- Special check to allow initial point (RM 3.5(49)) - - if Str (P) = '.' then - After_Point := 1; - P := P + 1; + if Precision_Limit_Reached then + -- Precision limit has been reached so just update the exponent + Scale := Scale + 1; + else + if Value > (Precision_Limit - Digit) / Base then + -- Updating Value will overflow so ignore this digit and any + -- following ones. Only update the scale + Precision_Limit_Reached := True; + Scale := Scale + 1; + else + Value := Value * Base + Digit; end if; + end if; - -- Loop to scan digits of based number. On entry to the loop we - -- must have a valid digit. If we don't, then we have an illegal - -- floating-point value, and we raise Constraint_Error, note that - -- Ptr at this stage was reset to the proper (Start) value. - - loop - if P > Max then - Bad_Value (Str); - - elsif Str (P) in Digs then - Digit := Character'Pos (Str (P)) - Character'Pos ('0'); - - elsif Str (P) in 'A' .. 'F' then - Digit := - Character'Pos (Str (P)) - (Character'Pos ('A') - 10); + -- Look for the next character + Index := Index + 1; + if Index > Max then + return; + end if; - elsif Str (P) in 'a' .. 'f' then - Digit := - Character'Pos (Str (P)) - (Character'Pos ('a') - 10); + Digit := As_Digit (Str (Index)); + if Digit not in Valid_Digit then + -- Next character is not a digit. In that case stop scanning + -- unless the next chracter is an underscore followed by a digit. + if Digit = Underscore and Index + 1 <= Max then + Digit := As_Digit (Str (Index + 1)); + if Digit in Valid_Digit then + Index := Index + 1; else - Bad_Value (Str); + return; end if; + else + return; + end if; + end if; + end loop; - if not Precision_Limit_Reached then - -- Compute potential new value - Uval_Tmp := Uval * Base + Long_Long_Float (Digit); + end Scan_Integral_Digits; - if Uval_Tmp > Precision_Limit then - Precision_Limit_Reached := True; - end if; - end if; + --------------- + -- Scan_Real -- + --------------- - if Precision_Limit_Reached then - -- If beyond precision of the mantissa then just update - -- the scale and discard remaining digits. + function Scan_Real + (Str : String; + Ptr : not null access Integer; + Max : Integer) + return Long_Long_Float - if After_Point = 0 then - Scale := Scale + 1; - end if; + is + Start : Positive; + -- Position of starting non-blank character - else - -- Now accumulate the new digit + Minus : Boolean; + -- Set to True if minus sign is present, otherwise to False - Fdigit := Long_Long_Float (Digit); + Index : Integer; + -- Local copy of string pointer - if Fdigit >= Base then - Bad_Base := True; - else - Scale := Scale - After_Point; - Uval := Uval_Tmp; - end if; - end if; + Int_Value : Long_Long_Integer := -1; + -- Mantissa as an Integer - P := P + 1; + Int_Scale : Integer := 0; + -- Exponent value - if P > Max then - Bad_Value (Str); + Base_Violation : Boolean := False; + -- If True some digits where not in the base. The float is still scan + -- till the end even if an error will be raised. - elsif Str (P) = '_' then - Scan_Underscore (Str, P, Ptr, Max, True); + Uval : Long_Long_Float := 0.0; + -- Contain the final value at the end of the function - else - -- Skip past period after digit. Note that the processing - -- here will permit either a digit after the period, or the - -- terminating base character, as allowed in (RM 3.5(48)) + After_Point : Boolean := False; + -- True if a decimal should be parsed - if Str (P) = '.' and then After_Point = 0 then - P := P + 1; - After_Point := 1; + Base : Long_Long_Integer := 10; + -- Current base (default: 10) - if P > Max then - Bad_Value (Str); - end if; - end if; + Base_Char : Character := ASCII.NUL; + -- Character used to set the base. If Nul this means that default + -- base is used. - exit when Str (P) = Base_Char; - end if; - end loop; + begin + -- We do not tolerate strings with Str'Last = Positive'Last + + if Str'Last = Positive'Last then + raise Program_Error with + "string upper bound is Positive'Last, not supported"; + end if; - -- Based number successfully scanned out (point was found) + -- We call the floating-point processor reset routine so that we can + -- be sure the floating-point processor is properly set for conversion + -- calls. This is notably need on Windows, where calls to the operating + -- system randomly reset the processor into 64-bit mode. - Ptr.all := P + 1; - end; + System.Float_Control.Reset; - -- Non-based case, check for being at decimal point now. Note that - -- in Ada 95, we do not insist on a decimal point being present + -- Scan the optional sign + Scan_Sign (Str, Ptr, Max, Minus, Start); + Index := Ptr.all; + Ptr.all := Start; + -- First character can be either a decimal digit or a dot. + if Str (Index) in '0' .. '9' then + -- If this is a digit it can indicates either the float decimal + -- part or the base to use + Scan_Integral_Digits + (Str, + Index, + Max => Max, + Value => Int_Value, + Scale => Int_Scale, + Base_Violation => Base_Violation, + Base => 10); + elsif Str (Index) = '.' and then + -- A dot is only allowed if followed by a digit. + Index < Max and then + Str (Index + 1) in '0' .. '9' + then + -- Initial point, allowed only if followed by digit (RM 3.5(47)) + After_Point := True; + Index := Index + 1; + Int_Value := 0; else - Base := 10.0; - After_Point := 1; + Bad_Value (Str); + end if; - if P <= Max and then Str (P) = '.' then - P := P + 1; + -- Check if the first number encountered is a base + if Index < Max and then + (Str (Index) = '#' or else Str (Index) = ':') + then + Base_Char := Str (Index); + Base := Int_Value; + + -- Reset Int_Value to indicate that parsing of integral value should + -- be done + Int_Value := -1; + if Base < 2 or else Base > 16 then + Base_Violation := True; + Base := 16; + end if; - -- Scan digits after point if any are present (RM 3.5(46)) + Index := Index + 1; - if P <= Max and then Str (P) in Digs then - Scanf; - end if; + if Str (Index) = '.' and then + Index < Max and then + As_Digit (Str (Index + 1)) in Valid_Digit + then + After_Point := True; + Index := Index + 1; + Int_Value := 0; end if; - - Ptr.all := P; end if; - -- At this point, we have Uval containing the digits of the value as - -- an integer, and Scale indicates the negative of the number of digits - -- after the point. Base contains the base value (an integral value in - -- the range 2.0 .. 16.0). Test for exponent, must be at least one - -- character after the E for the exponent to be valid. - - Scale := Scale + Scan_Exponent (Str, Ptr, Max, Real => True); + -- Does scanning of integral part needed + if Int_Value < 0 then + if Index > Max or else As_Digit (Str (Index)) not in Valid_Digit then + Bad_Value (Str); + end if; - -- At this point the exponent has been scanned if one is present and - -- Scale is adjusted to include the exponent value. Uval contains the - -- the integral value which is to be multiplied by Base ** Scale. + Scan_Integral_Digits + (Str, + Index, + Max => Max, + Value => Int_Value, + Scale => Int_Scale, + Base_Violation => Base_Violation, + Base => Base, + Base_Specified => Base_Char /= ASCII.NUL); + end if; - -- If base is not 10, use exponentiation for scaling + -- Do we have a dot ? + if not After_Point and then + Index <= Max and then + Str (Index) = '.' + then + -- At this stage if After_Point was not set, this means that an + -- integral part has been found. Thus the dot is valid even if not + -- followed by a digit. + if Index < Max and then As_Digit (Str (Index + 1)) in Valid_Digit then + After_Point := True; + end if; - if Base /= 10.0 then - Uval := Uval * Base ** Scale; + Index := Index + 1; + end if; - -- For base 10, use power of ten table, repeatedly if necessary + if After_Point then + -- Parse decimal part + Scan_Decimal_Digits + (Str, + Index, + Max => Max, + Value => Int_Value, + Scale => Int_Scale, + Base_Violation => Base_Violation, + Base => Base, + Base_Specified => Base_Char /= ASCII.NUL); + end if; - elsif Scale > 0 then - while Scale > Maxpow and then Uval'Valid loop - Uval := Uval * Powten (Maxpow); - Scale := Scale - Maxpow; - end loop; + -- If an explicit base was specified ensure that the delimiter is found + if Base_Char /= ASCII.NUL then + if Index > Max or else Str (Index) /= Base_Char then + Bad_Value (Str); + else + Index := Index + 1; + end if; + end if; - -- Note that we still know that Scale > 0, since the loop - -- above leaves Scale in the range 1 .. Maxpow. + -- Compute the final value + Uval := Long_Long_Float (Int_Value); - if Uval'Valid then - Uval := Uval * Powten (Scale); - end if; + -- Update pointer and scan exponent. + Ptr.all := Index; - elsif Scale < 0 then - while (-Scale) > Maxpow and then Uval'Valid loop - Uval := Uval / Powten (Maxpow); - Scale := Scale + Maxpow; - end loop; + Int_Scale := Int_Scale + Scan_Exponent (Str, + Ptr, + Max, + Real => True); - -- Note that we still know that Scale < 0, since the loop - -- above leaves Scale in the range -Maxpow .. -1. - if Uval'Valid then - Uval := Uval / Powten (-Scale); - end if; - end if; + Uval := Uval * Long_Long_Float (Base) ** Int_Scale; -- Here is where we check for a bad based number - - if Bad_Base then + if Base_Violation then Bad_Value (Str); -- If OK, then deal with initial minus sign, note that this processing -- is done even if Uval is zero, so that -0.0 is correctly interpreted. - else if Minus then return -Uval; @@ -376,6 +499,7 @@ package body System.Val_Real is return Uval; end if; end if; + end Scan_Real; ---------------- diff --git a/gcc/ada/libgnat/s-win32.ads b/gcc/ada/libgnat/s-win32.ads index ab832cd..853cef0 100644 --- a/gcc/ada/libgnat/s-win32.ads +++ b/gcc/ada/libgnat/s-win32.ads @@ -57,15 +57,16 @@ package System.Win32 is INVALID_HANDLE_VALUE : constant HANDLE := -1; INVALID_FILE_SIZE : constant := 16#FFFFFFFF#; - type ULONG is new Interfaces.C.unsigned_long; - type DWORD is new Interfaces.C.unsigned_long; - type WORD is new Interfaces.C.unsigned_short; - type BYTE is new Interfaces.C.unsigned_char; - type LONG is new Interfaces.C.long; - type CHAR is new Interfaces.C.char; - type SIZE_T is new Interfaces.C.size_t; - - type BOOL is new Interfaces.C.int; + type ULONG is new Interfaces.C.unsigned_long; + type DWORD is new Interfaces.C.unsigned_long; + type WORD is new Interfaces.C.unsigned_short; + type BYTE is new Interfaces.C.unsigned_char; + type LONG is new Interfaces.C.long; + type CHAR is new Interfaces.C.char; + type SIZE_T is new Interfaces.C.size_t; + type DWORD_PTR is mod 2 ** Standard'Address_Size; + + type BOOL is new Interfaces.C.int; for BOOL'Size use Interfaces.C.int'Size; type Bits1 is range 0 .. 2 ** 1 - 1; @@ -265,7 +266,7 @@ package System.Win32 is dwPageSize : DWORD; lpMinimumApplicationAddress : PVOID; lpMaximumApplicationAddress : PVOID; - dwActiveProcessorMask : DWORD; + dwActiveProcessorMask : DWORD_PTR; dwNumberOfProcessors : DWORD; dwProcessorType : DWORD; dwAllocationGranularity : DWORD; diff --git a/gcc/ada/make.adb b/gcc/ada/make.adb index 805addb..377072c 100644 --- a/gcc/ada/make.adb +++ b/gcc/ada/make.adb @@ -3789,7 +3789,7 @@ package body Make is if Gprbuild = null then Fail_Program - ("project files are no longer supported by gnamake;" & + ("project files are no longer supported by gnatmake;" & " use gprbuild instead"); end if; @@ -4516,7 +4516,9 @@ package body Make is end; end if; - elsif Argv'Length >= 8 and then Argv (1 .. 8) = "--param=" then + elsif (Argv'Length >= 8 and then Argv (1 .. 8) = "--param=") + or else (Argv'Length >= 10 and then Argv (1 .. 10) = "--sysroot=") + then Add_Switch (Argv, Compiler); Add_Switch (Argv, Linker); diff --git a/gcc/ada/make_util.ads b/gcc/ada/make_util.ads index c9be894..9bd576a 100644 --- a/gcc/ada/make_util.ads +++ b/gcc/ada/make_util.ads @@ -50,7 +50,7 @@ package Make_Util is -- Name of the configuration file used by gprbuild and generated by -- gprconfig by default. - On_Windows : constant Boolean := Directory_Separator = '\'; + On_Windows : Boolean renames Osint.On_Windows; -- True when on Windows Source_Info_Option : constant String := "--source-info="; diff --git a/gcc/ada/osint.adb b/gcc/ada/osint.adb index d9d72d0..973f463 100644 --- a/gcc/ada/osint.adb +++ b/gcc/ada/osint.adb @@ -88,6 +88,10 @@ package body Osint is function OS_Time_To_GNAT_Time (T : OS_Time) return Time_Stamp_Type; -- Convert OS format time to GNAT format time stamp. If T is Invalid_Time, -- then returns Empty_Time_Stamp. + -- Round to even seconds on Windows before conversion. + -- Windows ALI files had timestamps rounded to even seconds historically. + -- The rounding was originally done in GM_Split. Now that GM_Split no + -- longer does it, we are rounding it here only for ALI files. function Executable_Prefix return String_Ptr; -- Returns the name of the root directory where the executable is stored. @@ -2179,6 +2183,7 @@ package body Osint is function OS_Time_To_GNAT_Time (T : OS_Time) return Time_Stamp_Type is GNAT_Time : Time_Stamp_Type; + TI : Long_Integer := To_C (T); Y : Year_Type; Mo : Month_Type; D : Day_Type; @@ -2191,7 +2196,17 @@ package body Osint is return Empty_Time_Stamp; end if; - GM_Split (T, Y, Mo, D, H, Mn, S); + if On_Windows and then TI mod 2 > 0 then + -- Windows ALI files had timestamps rounded to even seconds + -- historically. The rounding was originally done in GM_Split. + -- Now that GM_Split no longer does it, we are rounding it here + -- only for ALI files. + + TI := TI + 1; + end if; + + GM_Split (To_Ada (TI), Y, Mo, D, H, Mn, S); + Make_Time_Stamp (Year => Nat (Y), Month => Nat (Mo), diff --git a/gcc/ada/osint.ads b/gcc/ada/osint.ads index dda44e7..a0b046c 100644 --- a/gcc/ada/osint.ads +++ b/gcc/ada/osint.ads @@ -56,6 +56,9 @@ package Osint is -- File descriptor for current library info, list, tree, C, H, or binder -- output. Only one of these is open at a time, so we need only one FD. + On_Windows : constant Boolean := Directory_Separator = '\'; + -- True when on Windows + procedure Initialize; -- Initialize internal tables diff --git a/gcc/ada/s-oscons-tmplt.c b/gcc/ada/s-oscons-tmplt.c index 655d68a..4c3ecc6 100644 --- a/gcc/ada/s-oscons-tmplt.c +++ b/gcc/ada/s-oscons-tmplt.c @@ -1053,6 +1053,11 @@ CND(AF_INET, "IPv4 address family") #endif CND(AF_INET6, "IPv6 address family") +#ifndef AF_UNIX +# define AF_UNIX -1 +#endif +CND(AF_UNIX, "Local unix family") + #ifndef AF_UNSPEC # define AF_UNSPEC -1 #else @@ -1701,6 +1706,19 @@ CND(SIZEOF_sockaddr_in, "struct sockaddr_in") #endif CND(SIZEOF_sockaddr_in6, "struct sockaddr_in6") +/** + ** The sockaddr_un structure is not defined in MINGW C headers + ** but Windows supports it from build 17063. + **/ +#if defined(__MINGW32__) +struct sockaddr_un { + ADDRESS_FAMILY sun_family; /* AF_UNIX */ + char sun_path[108]; /* Pathname */ +}; +#endif +#define SIZEOF_sockaddr_un (sizeof (struct sockaddr_un)) +CND(SIZEOF_sockaddr_un, "struct sockaddr_un") + #define SIZEOF_fd_set (sizeof (fd_set)) CND(SIZEOF_fd_set, "fd_set") CND(FD_SETSIZE, "Max fd value") diff --git a/gcc/ada/sem.adb b/gcc/ada/sem.adb index 2e99531..2967a18 100644 --- a/gcc/ada/sem.adb +++ b/gcc/ada/sem.adb @@ -1360,7 +1360,8 @@ package body Sem is -- unconditionally, and has no restore mechanism, because it is -- intended as a lowest-level Pure package. - Saved_ML : constant Int := Style_Max_Line_Length; + Saved_ML : constant Int := Style_Max_Line_Length; + Saved_CML : constant Boolean := Style_Check_Max_Line_Length; List : Elist_Id; @@ -1395,7 +1396,7 @@ package body Sem is Restore_Scope_Stack (List); Restore_Ghost_Region (Saved_GM, Saved_IGR); Style_Max_Line_Length := Saved_ML; - Style_Check_Max_Line_Length := Style_Max_Line_Length /= 0; + Style_Check_Max_Line_Length := Saved_CML; end Do_Analyze; -- Local variables diff --git a/gcc/ada/sem_aggr.adb b/gcc/ada/sem_aggr.adb index bc80121..87fe050 100644 --- a/gcc/ada/sem_aggr.adb +++ b/gcc/ada/sem_aggr.adb @@ -3158,6 +3158,9 @@ package body Sem_Aggr is elsif Nkind (Anc) = N_Qualified_Expression then return Valid_Limited_Ancestor (Expression (Anc)); + elsif Nkind (Anc) = N_Raise_Expression then + return True; + else return False; end if; @@ -3199,6 +3202,13 @@ package body Sem_Aggr is then return True; + -- The parent type may be a raise expression (which is legal in + -- any expression context). + + elsif A_Type = Raise_Type then + A_Type := Etype (Imm_Type); + return True; + else Imm_Type := Etype (Base_Type (Imm_Type)); end if; diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index 2538c1d..ef9f965 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -9383,7 +9383,7 @@ package body Sem_Ch13 is or else A_Id = Aspect_Priority then Push_Type (Ent); - Preanalyze (Freeze_Expr); + Preanalyze_Spec_Expression (Freeze_Expr, T); Pop_Type (Ent); else Preanalyze (Freeze_Expr); diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index 6af9419..35be35a 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -2047,10 +2047,23 @@ package body Sem_Ch3 is end if; end if; + -- Avoid reporting spurious errors if the component is initialized with + -- a raise expression (which is legal in any expression context) + + if Present (E) + and then + (Nkind (E) = N_Raise_Expression + or else (Nkind (E) = N_Qualified_Expression + and then Nkind (Expression (E)) = N_Raise_Expression)) + then + null; + -- The parent type may be a private view with unknown discriminants, -- and thus unconstrained. Regular components must be constrained. - if not Is_Definite_Subtype (T) and then Chars (Id) /= Name_uParent then + elsif not Is_Definite_Subtype (T) + and then Chars (Id) /= Name_uParent + then if Is_Class_Wide_Type (T) then Error_Msg_N ("class-wide subtype with unknown discriminants" & @@ -12496,6 +12509,18 @@ package body Sem_Ch3 is -- Show Full is simply a renaming of Full_Base Set_Cloned_Subtype (Full, Full_Base); + + -- Propagate predicates + + if Has_Predicates (Full_Base) then + Set_Has_Predicates (Full); + + if Present (Predicate_Function (Full_Base)) + and then No (Predicate_Function (Full)) + then + Set_Predicate_Function (Full, Predicate_Function (Full_Base)); + end if; + end if; end if; -- It is unsafe to share the bounds of a scalar type, because the Itype @@ -13233,7 +13258,9 @@ package body Sem_Ch3 is function Build_Constrained_Discriminated_Type (Old_Type : Entity_Id) return Entity_Id; - -- Ditto for record components + -- Ditto for record components. Handle the case where the constraint + -- is a conversion of the discriminant value, introduced during + -- expansion. function Build_Constrained_Access_Type (Old_Type : Entity_Id) return Entity_Id; @@ -13418,6 +13445,17 @@ package body Sem_Ch3 is if Is_Discriminant (Expr) then Need_To_Create_Itype := True; + + -- After expansion of discriminated task types, the value + -- of the discriminant may be converted to a run-time type + -- for restricted run-times. Propagate the value of the + -- discriminant ss well, so that e.g. the secondary stack + -- component has a static constraint. Necessry for LLVM. + + elsif Nkind (Expr) = N_Type_Conversion + and then Is_Discriminant (Expression (Expr)) + then + Need_To_Create_Itype := True; end if; Next_Elmt (Old_Constraint); @@ -13432,6 +13470,12 @@ package body Sem_Ch3 is if Is_Discriminant (Expr) then Expr := Get_Discr_Value (Expr); + + elsif Nkind (Expr) = N_Type_Conversion + and then Is_Discriminant (Expression (Expr)) + then + Expr := New_Copy_Tree (Expr); + Set_Expression (Expr, Get_Discr_Value (Expression (Expr))); end if; Append (New_Copy_Tree (Expr), To => Constr_List); @@ -13737,6 +13781,7 @@ package body Sem_Ch3 is begin Set_Etype (T_Sub, Corr_Rec); Set_Has_Discriminants (T_Sub, Has_Discriminants (Prot_Subt)); + Set_Is_Tagged_Type (T_Sub, Is_Tagged_Type (Corr_Rec)); Set_Is_Constrained (T_Sub, True); Set_First_Entity (T_Sub, First_Entity (Corr_Rec)); Set_Last_Entity (T_Sub, Last_Entity (Corr_Rec)); diff --git a/gcc/ada/sem_ch4.adb b/gcc/ada/sem_ch4.adb index 0dccd33..313398a 100644 --- a/gcc/ada/sem_ch4.adb +++ b/gcc/ada/sem_ch4.adb @@ -4001,7 +4001,9 @@ package body Sem_Ch4 is if Is_Class_Wide_Type (T) then if not Is_Overloaded (Expr) then - if Base_Type (Etype (Expr)) /= Base_Type (T) then + if Base_Type (Etype (Expr)) /= Base_Type (T) + and then Etype (Expr) /= Raise_Type + then if Nkind (Expr) = N_Aggregate then Error_Msg_N ("type of aggregate cannot be class-wide", Expr); else diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index fb50ec7..eb6768d 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -3376,6 +3376,9 @@ package body Sem_Ch6 is -- Local variables + Body_Nod : Node_Id := Empty; + Minimum_Acc_Objs : List_Id := No_List; + Saved_GM : constant Ghost_Mode_Type := Ghost_Mode; Saved_IGR : constant Node_Id := Ignored_Ghost_Region; Saved_EA : constant Boolean := Expander_Active; @@ -4254,6 +4257,110 @@ package body Sem_Ch6 is end; end if; + -- Generate minimum accessibility local objects to correspond with + -- any extra formal added for anonymous access types. This new local + -- object can then be used instead of the formal in case it is used + -- in an actual to a call to a nested subprogram. + + -- This method is used to suppliment our "small integer model" for + -- accessibility check generation (for more information see + -- Dynamic_Accessibility_Level). + + -- Because we allow accesibility values greater than our expected value + -- passing along the same extra accessibility formal as an actual + -- to a nested subprogram becomes a problem because high values mean + -- different things to the callee even though they are the same to the + -- caller. So, as described in the first section, we create a local + -- object representing the minimum of the accessibility level value that + -- is passed in and the accessibility level of the callee's parameter + -- and locals and use it in the case of a call to a nested subprogram. + -- This generated object is refered to as a "minimum accessiblity + -- level." + + if Present (Spec_Id) or else Present (Body_Id) then + Body_Nod := Unit_Declaration_Node (Body_Id); + + declare + Form : Entity_Id; + begin + -- Grab the appropriate formal depending on whether there exists + -- an actual spec for the subprogram or whether we are dealing + -- with a protected subprogram. + + if Present (Spec_Id) then + if Present (Protected_Body_Subprogram (Spec_Id)) then + Form := First_Formal (Protected_Body_Subprogram (Spec_Id)); + else + Form := First_Formal (Spec_Id); + end if; + else + Form := First_Formal (Body_Id); + end if; + + -- Loop through formals if the subprogram is capable of accepting + -- a generated local object. If it is not then it is also not + -- capable of having local subprograms meaning it would not need + -- a minimum accessibility level object anyway. + + if Present (Body_Nod) + and then Has_Declarations (Body_Nod) + and then Nkind (Body_Nod) /= N_Package_Specification + then + while Present (Form) loop + + if Present (Extra_Accessibility (Form)) + and then No (Minimum_Accessibility (Form)) + then + -- Generate the minimum accessibility level object + + -- A60b : integer := integer'min(2, paramL); + + declare + Loc : constant Source_Ptr := Sloc (Body_Nod); + Obj_Node : constant Node_Id := + Make_Object_Declaration (Loc, + Defining_Identifier => + Make_Temporary + (Loc, 'A', Extra_Accessibility (Form)), + Object_Definition => New_Occurrence_Of + (Standard_Integer, Loc), + Expression => + Make_Attribute_Reference (Loc, + Prefix => New_Occurrence_Of + (Standard_Integer, Loc), + Attribute_Name => Name_Min, + Expressions => New_List ( + Make_Integer_Literal (Loc, + Object_Access_Level (Form)), + New_Occurrence_Of + (Extra_Accessibility (Form), Loc)))); + begin + -- Add the new local object to the Minimum_Acc_Obj to + -- be later prepended to the subprogram's list of + -- declarations after we are sure all expansion is + -- done. + + if Present (Minimum_Acc_Objs) then + Prepend (Obj_Node, Minimum_Acc_Objs); + else + Minimum_Acc_Objs := New_List (Obj_Node); + end if; + + -- Register the object and analyze it + + Set_Minimum_Accessibility + (Form, Defining_Identifier (Obj_Node)); + + Analyze (Obj_Node); + end; + end if; + + Next_Formal (Form); + end loop; + end if; + end; + end if; + -- Now we can go on to analyze the body HSS := Handled_Statement_Sequence (N); @@ -4358,6 +4465,19 @@ package body Sem_Ch6 is Inspect_Deferred_Constant_Completion (Declarations (N)); Analyze (HSS); + -- Add the generated minimum accessibility objects to the subprogram + -- body's list of declarations after analysis of the statements and + -- contracts. + + while Is_Non_Empty_List (Minimum_Acc_Objs) loop + if Present (Declarations (Body_Nod)) then + Prepend (Remove_Head (Minimum_Acc_Objs), Declarations (Body_Nod)); + else + Set_Declarations + (Body_Nod, New_List (Remove_Head (Minimum_Acc_Objs))); + end if; + end loop; + -- Deal with end of scope processing for the body Process_End_Label (HSS, 't', Current_Scope); @@ -8080,7 +8200,6 @@ package body Sem_Ch6 is if Is_Build_In_Place_Function (E) then declare Result_Subt : constant Entity_Id := Etype (E); - Full_Subt : constant Entity_Id := Available_View (Result_Subt); Formal_Typ : Entity_Id; Subp_Decl : Node_Id; Discard : Entity_Id; @@ -8130,7 +8249,7 @@ package body Sem_Ch6 is -- master of the tasks to be created, and the caller's activation -- chain. - if Has_Task (Full_Subt) then + if Needs_BIP_Task_Actuals (E) then Discard := Add_Extra_Formal (E, RTE (RE_Master_Id), diff --git a/gcc/ada/sem_ch8.adb b/gcc/ada/sem_ch8.adb index a7918da..5d03f835 100644 --- a/gcc/ada/sem_ch8.adb +++ b/gcc/ada/sem_ch8.adb @@ -10337,11 +10337,18 @@ package body Sem_Ch8 is -- The package where T is declared is already used elsif In_Use (Scope (T)) then - Error_Msg_Sloc := - Sloc (Find_Most_Prev (Current_Use_Clause (Scope (T)))); - Error_Msg_NE -- CODEFIX - ("& is already use-visible through package use clause #??", - Id, T); + -- Due to expansion of contracts we could be attempting to issue + -- a spurious warning - so verify there is a previous use clause. + + if Current_Use_Clause (Scope (T)) /= + Find_Most_Prev (Current_Use_Clause (Scope (T))) + then + Error_Msg_Sloc := + Sloc (Find_Most_Prev (Current_Use_Clause (Scope (T)))); + Error_Msg_NE -- CODEFIX + ("& is already use-visible through package use clause #??", + Id, T); + end if; -- The current scope is the package where T is declared diff --git a/gcc/ada/sem_eval.adb b/gcc/ada/sem_eval.adb index 5c41642..5f26ecd 100644 --- a/gcc/ada/sem_eval.adb +++ b/gcc/ada/sem_eval.adb @@ -4278,7 +4278,8 @@ package body Sem_Eval is -- The NULL access value elsif Kind = N_Null then - pragma Assert (Is_Access_Type (Underlying_Type (Etype (N)))); + pragma Assert (Is_Access_Type (Underlying_Type (Etype (N))) + or else Error_Posted (N)); Val := Uint_0; -- Character literal diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 7a52b90..38de57d 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -5674,13 +5674,21 @@ package body Sem_Res is -- A universal real conditional expression can appear in a fixed-type -- context and must be resolved with that context to facilitate the - -- code generation in the back end. + -- code generation in the back end. However, If the context is + -- Universal_fixed (i.e. as an operand of a multiplication/division + -- involving a fixed-point operand) the conditional expression must + -- resolve to a unique visible fixed_point type, normally Duration. elsif Nkind_In (N, N_Case_Expression, N_If_Expression) and then Etype (N) = Universal_Real and then Is_Fixed_Point_Type (B_Typ) then - Resolve (N, B_Typ); + if B_Typ = Universal_Fixed then + Resolve (N, Unique_Fixed_Point_Type (N)); + + else + Resolve (N, B_Typ); + end if; else Resolve (N); diff --git a/gcc/ada/sem_spark.adb b/gcc/ada/sem_spark.adb index 038c7cd..e4a8b3e 100644 --- a/gcc/ada/sem_spark.adb +++ b/gcc/ada/sem_spark.adb @@ -708,8 +708,8 @@ package body Sem_SPARK is function Get_Observed_Or_Borrowed_Expr (Expr : Node_Id) return Node_Id; pragma Precondition (Is_Path_Expression (Expr)); -- Return the expression being borrowed/observed when borrowing or - -- observing Expr. If Expr is a call to a traversal function, this is - -- the first actual, otherwise it is Expr. + -- observing Expr. If Expr contains a call to traversal function, this is + -- the first actual of the first such call, otherwise it is Expr. function Get_Perm (N : Node_Or_Entity_Id) return Perm_Kind; -- The function that takes a name as input and returns a permission @@ -1419,12 +1419,12 @@ package body Sem_SPARK is Target : constant Entity_Id := Defining_Identifier (Decl); Target_Typ : constant Node_Id := Etype (Target); Expr : Node_Id; - Dummy : Boolean := True; + Legal : Boolean := True; begin -- Start with legality rules not related to permissions - Check_Declaration_Legality (Decl, Force => True, Legal => Dummy); + Check_Declaration_Legality (Decl, Force => True, Legal => Legal); -- Now check permission-related legality rules @@ -1432,7 +1432,7 @@ package body Sem_SPARK is when N_Full_Type_Declaration => null; - -- ??? What about component declarations with defaults. + -- ??? What about component declarations with defaults. when N_Subtype_Declaration => Check_Expression (Subtype_Indication (Decl), Read); @@ -1440,11 +1440,15 @@ package body Sem_SPARK is when N_Object_Declaration => Expr := Expression (Decl); - if Present (Expr) then + if Legal and then Present (Expr) then Check_Assignment (Target => Target, Expr => Expr); end if; + -- Always add variable to the current permission environment, + -- even in the illegal case, as the rest of the analysis expects + -- to find it. + if Is_Deep (Target_Typ) then declare Tree : constant Perm_Tree_Access := @@ -3772,12 +3776,61 @@ package body Sem_SPARK is ----------------------------------- function Get_Observed_Or_Borrowed_Expr (Expr : Node_Id) return Node_Id is + + function Find_Func_Call (Expr : Node_Id) return Node_Id; + -- Search for function calls in the prefixes of Expr + + -------------------- + -- Find_Func_Call -- + -------------------- + + function Find_Func_Call (Expr : Node_Id) return Node_Id is + begin + case Nkind (Expr) is + when N_Expanded_Name + | N_Identifier + => + return Empty; + + when N_Explicit_Dereference + | N_Indexed_Component + | N_Selected_Component + | N_Slice + => + return Find_Func_Call (Prefix (Expr)); + + when N_Qualified_Expression + | N_Type_Conversion + | N_Unchecked_Type_Conversion + => + return Find_Func_Call (Expression (Expr)); + + when N_Function_Call => + return Expr; + + when others => + raise Program_Error; + end case; + end Find_Func_Call; + + B_Expr : Node_Id := Expr; + begin - if Is_Traversal_Function_Call (Expr) then - return First_Actual (Expr); - else - return Expr; - end if; + -- Search for the first call to a traversal function in Expr. If there + -- is one, its first parameter is the borrowed expression. Otherwise, + -- it is Expr. + + loop + declare + Call : constant Node_Id := Find_Func_Call (B_Expr); + begin + exit when No (Call); + pragma Assert (Is_Traversal_Function_Call (Call)); + B_Expr := First_Actual (Call); + end; + end loop; + + return B_Expr; end Get_Observed_Or_Borrowed_Expr; -------------- diff --git a/gcc/ada/sem_type.adb b/gcc/ada/sem_type.adb index fee9c5e..fc50524 100644 --- a/gcc/ada/sem_type.adb +++ b/gcc/ada/sem_type.adb @@ -2849,7 +2849,7 @@ package body Sem_Type is return False; else - return In_Generic_Actual (Parent (Par)); + return In_Generic_Actual (Par); end if; end In_Generic_Actual; diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index 86ae740..1bcda5f 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -33,6 +33,7 @@ with Elists; use Elists; with Errout; use Errout; with Erroutc; use Erroutc; with Exp_Ch11; use Exp_Ch11; +with Exp_Dbug; use Exp_Dbug; with Exp_Util; use Exp_Util; with Fname; use Fname; with Freeze; use Freeze; @@ -67,6 +68,7 @@ with Tbuild; use Tbuild; with Ttypes; use Ttypes; with Uname; use Uname; +with GNAT.Heap_Sort_G; with GNAT.HTable; use GNAT.HTable; package body Sem_Util is @@ -6529,10 +6531,11 @@ package body Sem_Util is return Dynamic_Accessibility_Level (Renamed_Object (E)); end if; - if Is_Formal (E) or else Ekind_In (E, E_Variable, E_Constant) then - if Present (Extra_Accessibility (E)) then - return New_Occurrence_Of (Extra_Accessibility (E), Loc); - end if; + if (Is_Formal (E) + or else Ekind_In (E, E_Variable, E_Constant)) + and then Present (Get_Accessibility (E)) + then + return New_Occurrence_Of (Get_Accessibility (E), Loc); end if; end if; @@ -8884,11 +8887,17 @@ package body Sem_Util is Variant : Node_Id; Discrete_Choice : Node_Id; Comp_Item : Node_Id; + Discrim : Entity_Id; + Discrim_Name : Node_Id; - Discrim : Entity_Id; - Discrim_Name : Node_Id; - Discrim_Value : Node_Id; + type Discriminant_Value_Status is + (Static_Expr, Static_Subtype, Bad); + subtype Good_Discrim_Value_Status is Discriminant_Value_Status + range Static_Expr .. Static_Subtype; -- range excludes Bad + Discrim_Value : Node_Id; + Discrim_Value_Subtype : Node_Id; + Discrim_Value_Status : Discriminant_Value_Status := Bad; begin Report_Errors := False; @@ -9021,26 +9030,73 @@ package body Sem_Util is end loop Find_Constraint; Discrim_Value := Expression (Assoc); + if Is_OK_Static_Expression (Discrim_Value) then + Discrim_Value_Status := Static_Expr; + else + if Ada_Version >= Ada_2020 then + if Original_Node (Discrim_Value) /= Discrim_Value + and then Nkind (Discrim_Value) = N_Type_Conversion + and then Etype (Original_Node (Discrim_Value)) + = Etype (Expression (Discrim_Value)) + then + Discrim_Value_Subtype := Etype (Original_Node (Discrim_Value)); + -- An unhelpful (for this code) type conversion may be + -- introduced in some cases; deal with it. + else + Discrim_Value_Subtype := Etype (Discrim_Value); + end if; - if not Is_OK_Static_Expression (Discrim_Value) then + if Is_OK_Static_Subtype (Discrim_Value_Subtype) and then + not Is_Null_Range (Type_Low_Bound (Discrim_Value_Subtype), + Type_High_Bound (Discrim_Value_Subtype)) + then + -- Is_Null_Range test doesn't account for predicates, as in + -- subtype Null_By_Predicate is Natural + -- with Static_Predicate => Null_By_Predicate < 0; + -- so test for that null case separately. + + if (not Has_Static_Predicate (Discrim_Value_Subtype)) + or else Present (First (Static_Discrete_Predicate + (Discrim_Value_Subtype))) + then + Discrim_Value_Status := Static_Subtype; + end if; + end if; + end if; - -- If the variant part is governed by a discriminant of the type - -- this is an error. If the variant part and the discriminant are - -- inherited from an ancestor this is legal (AI05-120) unless the - -- components are being gathered for an aggregate, in which case - -- the caller must check Report_Errors. + if Discrim_Value_Status = Bad then - if Scope (Original_Record_Component - ((Entity (First (Choices (Assoc)))))) = Typ - then - Error_Msg_FE - ("value for discriminant & must be static!", - Discrim_Value, Discrim); - Why_Not_Static (Discrim_Value); - end if; + -- If the variant part is governed by a discriminant of the type + -- this is an error. If the variant part and the discriminant are + -- inherited from an ancestor this is legal (AI05-220) unless the + -- components are being gathered for an aggregate, in which case + -- the caller must check Report_Errors. + -- + -- In Ada2020 the above rules are relaxed. A non-static governing + -- discriminant is ok as long as it has a static subtype and + -- every value of that subtype (and there must be at least one) + -- selects the same variant. - Report_Errors := True; - return; + if Scope (Original_Record_Component + ((Entity (First (Choices (Assoc)))))) = Typ + then + if Ada_Version >= Ada_2020 then + Error_Msg_FE + ("value for discriminant & must be static or " & + "discriminant's nominal subtype must be static " & + "and non-null!", + Discrim_Value, Discrim); + else + Error_Msg_FE + ("value for discriminant & must be static!", + Discrim_Value, Discrim); + end if; + Why_Not_Static (Discrim_Value); + end if; + + Report_Errors := True; + return; + end if; end if; Search_For_Discriminant_Value : declare @@ -9049,9 +9105,36 @@ package body Sem_Util is UI_High : Uint; UI_Low : Uint; - UI_Discrim_Value : constant Uint := Expr_Value (Discrim_Value); + UI_Discrim_Value : Uint; begin + case Good_Discrim_Value_Status'(Discrim_Value_Status) is + when Static_Expr => + UI_Discrim_Value := Expr_Value (Discrim_Value); + when Static_Subtype => + -- Arbitrarily pick one value of the subtype and look + -- for the variant associated with that value; we will + -- check later that the same variant is associated with + -- all of the other values of the subtype. + if Has_Static_Predicate (Discrim_Value_Subtype) then + declare + Range_Or_Expr : constant Node_Id := + First (Static_Discrete_Predicate + (Discrim_Value_Subtype)); + begin + if Nkind (Range_Or_Expr) = N_Range then + UI_Discrim_Value := + Expr_Value (Low_Bound (Range_Or_Expr)); + else + UI_Discrim_Value := Expr_Value (Range_Or_Expr); + end if; + end; + else + UI_Discrim_Value + := Expr_Value (Type_Low_Bound (Discrim_Value_Subtype)); + end if; + end case; + Find_Discrete_Value : while Present (Variant) loop -- If a choice is a subtype with a static predicate, it must @@ -9084,7 +9167,7 @@ package body Sem_Util is -- The case statement must include a variant that corresponds to the -- value of the discriminant, unless the discriminant type has a -- static predicate. In that case the absence of an others_choice that - -- would cover this value becomes a run-time error (3.8,1 (21.1/2)). + -- would cover this value becomes a run-time error (3.8.1 (21.1/2)). if No (Variant) and then not Has_Static_Predicate (Etype (Discrim_Name)) @@ -9100,11 +9183,60 @@ package body Sem_Util is -- the same record type. if Present (Variant) then + if Discrim_Value_Status = Static_Subtype then + declare + Discrim_Value_Subtype_Intervals + : constant Interval_Lists.Discrete_Interval_List + := Interval_Lists.Type_Intervals (Discrim_Value_Subtype); + + Variant_Intervals + : constant Interval_Lists.Discrete_Interval_List + := Interval_Lists.Choice_List_Intervals + (Discrete_Choices => Discrete_Choices (Variant)); + begin + if not Interval_Lists.Is_Subset + (Subset => Discrim_Value_Subtype_Intervals, + Of_Set => Variant_Intervals) + then + Error_Msg_NE + ("no single variant is associated with all values of " & + "the subtype of discriminant value &", + Discrim_Value, Discrim); + Report_Errors := True; + return; + end if; + end; + end if; + Gather_Components (Typ, Component_List (Variant), Governed_By, Into, Report_Errors); end if; end Gather_Components; + ----------------------- + -- Get_Accessibility -- + ----------------------- + + function Get_Accessibility (E : Entity_Id) return Node_Id is + begin + -- When minimum accessibility is set for E then we utilize it - except + -- in a few edge cases like the expansion of select statements where + -- generated subprogram may attempt to unnecessarily use a minimum + -- accessibility object declared outside of scope. + + -- To avoid these situations where expansion may get complex we verify + -- that the minimum accessibility object is within scope. + + if Ekind (E) in Formal_Kind + and then Present (Minimum_Accessibility (E)) + and then In_Open_Scopes (Scope (Minimum_Accessibility (E))) + then + return Minimum_Accessibility (E); + end if; + + return Extra_Accessibility (E); + end Get_Accessibility; + ------------------------ -- Get_Actual_Subtype -- ------------------------ @@ -13559,6 +13691,16 @@ package body Sem_Util is Is_Volatile_Full_Access (Etype (Entity (N))))); end Is_Atomic_Or_VFA_Object; + ---------------------- + -- Is_Attribute_Old -- + ---------------------- + + function Is_Attribute_Old (N : Node_Id) return Boolean is + begin + return Nkind (N) = N_Attribute_Reference + and then Attribute_Name (N) = Name_Old; + end Is_Attribute_Old; + ------------------------- -- Is_Attribute_Result -- ------------------------- @@ -26144,24 +26286,59 @@ package body Sem_Util is function Unique_Name (E : Entity_Id) return String is - -- Names in E_Subprogram_Body or E_Package_Body entities are not - -- reliable, as they may not include the overloading suffix. Instead, - -- when looking for the name of E or one of its enclosing scope, we get - -- the name of the corresponding Unique_Entity. + -- Local subprograms - U : constant Entity_Id := Unique_Entity (E); + function Add_Homonym_Suffix (E : Entity_Id) return String; function This_Name return String; + ------------------------ + -- Add_Homonym_Suffix -- + ------------------------ + + function Add_Homonym_Suffix (E : Entity_Id) return String is + + -- Names in E_Subprogram_Body or E_Package_Body entities are not + -- reliable, as they may not include the overloading suffix. + -- Instead, when looking for the name of E or one of its enclosing + -- scope, we get the name of the corresponding Unique_Entity. + + U : constant Entity_Id := Unique_Entity (E); + Nam : constant String := Get_Name_String (Chars (U)); + + begin + -- If E has homonyms but is not fully qualified, as done in + -- GNATprove mode, append the homonym number on the fly. Strip the + -- leading space character in the image of natural numbers. Also do + -- not print the homonym value of 1. + + if Has_Homonym (U) then + declare + N : constant Pos := Get_Homonym_Number (U); + S : constant String := N'Img; + begin + if N > 1 then + return Nam & "__" & S (2 .. S'Last); + end if; + end; + end if; + + return Nam; + end Add_Homonym_Suffix; + --------------- -- This_Name -- --------------- function This_Name return String is begin - return Get_Name_String (Chars (U)); + return Add_Homonym_Suffix (E); end This_Name; + -- Local variables + + U : constant Entity_Id := Unique_Entity (E); + -- Start of processing for Unique_Name begin @@ -26191,16 +26368,17 @@ package body Sem_Util is end if; -- For intances of generic subprograms use the name of the related - -- instace and skip the scope of its wrapper package. + -- instance and skip the scope of its wrapper package. elsif Is_Wrapper_Package (S) then pragma Assert (Scope (S) = Scope (Related_Instance (S))); -- Wrapper package and the instantiation are in the same scope declare + Related_Name : constant String := + Add_Homonym_Suffix (Related_Instance (S)); Enclosing_Name : constant String := - Unique_Name (Scope (S)) & "__" & - Get_Name_String (Chars (Related_Instance (S))); + Unique_Name (Scope (S)) & "__" & Related_Name; begin if Is_Subprogram (U) @@ -26679,7 +26857,7 @@ package body Sem_Util is return; -- In an instance, there is an ongoing problem with completion of - -- type derived from private types. Their structure is what Gigi + -- types derived from private types. Their structure is what Gigi -- expects, but the Etype is the parent type rather than the -- derived private type itself. Do not flag error in this case. The -- private completion is an entity without a parent, like an Itype. @@ -26690,7 +26868,17 @@ package body Sem_Util is -- same reason: inserted body may be outside of the original package -- and only partial views are visible at the point of insertion. - elsif In_Instance or else In_Inlined_Body then + -- If In_Generic_Actual (Expr) is True then we cannot assume that + -- the successful semantic analysis of the generic guarantees anything + -- useful about type checking of this instance, so we ignore + -- In_Instance in that case. There may be cases where this is not + -- right (the symptom would probably be rejecting something + -- that ought to be accepted) but we don't currently have any + -- concrete examples of this. + + elsif (In_Instance and then not In_Generic_Actual (Expr)) + or else In_Inlined_Body + then if Etype (Etype (Expr)) = Etype (Expected_Type) and then (Has_Private_Declaration (Expected_Type) @@ -27060,6 +27248,367 @@ package body Sem_Util is end if; end Yields_Universal_Type; + package body Interval_Lists is + + function In_Interval + (Value : Uint; Interval : Discrete_Interval) return Boolean; + -- Does the given value lie within the given interval? + + ----------------- + -- In_Interval -- + ----------------- + function In_Interval + (Value : Uint; Interval : Discrete_Interval) return Boolean is + begin + return Value >= Interval.Low and then Value <= Interval.High; + end In_Interval; + + procedure Check_Consistency (Intervals : Discrete_Interval_List); + -- Check that list is sorted, lacks null intervals, and has gaps + -- between intervals. + + ------------------------ + -- Check_Consistency -- + ------------------------ + procedure Check_Consistency (Intervals : Discrete_Interval_List) is + begin + if Serious_Errors_Detected > 0 then + return; + end if; + + -- low bound is 1 and high bound equals length + pragma Assert (Intervals'First = 1 and Intervals'Last >= 0); + for Idx in Intervals'Range loop + -- each interval is non-null + pragma Assert (Intervals (Idx).Low <= Intervals (Idx).High); + if Idx /= Intervals'First then + -- intervals are sorted with non-empty gaps between them + pragma Assert + (Intervals (Idx - 1).High < (Intervals (Idx).Low - 1)); + null; + end if; + end loop; + end Check_Consistency; + + function Chosen_Interval (Choice : Node_Id) return Discrete_Interval; + -- Given an element of a Discrete_Choices list, a + -- Static_Discrete_Predicate list, or an Others_Discrete_Choices + -- list (but not an N_Others_Choice node) return the corresponding + -- interval. If an element that does not represent a single + -- contiguous interval due to a static predicate (or which + -- represents a single contiguous interval whose bounds depend on + -- a static predicate) is encountered, then that is an error on the + -- part of whoever built the list in question. + + --------------------- + -- Chosen_Interval -- + --------------------- + function Chosen_Interval (Choice : Node_Id) return Discrete_Interval is + begin + case Nkind (Choice) is + when N_Range => + return (Low => Expr_Value (Low_Bound (Choice)), + High => Expr_Value (High_Bound (Choice))); + + when N_Subtype_Indication => + declare + Range_Exp : constant Node_Id + := Range_Expression (Constraint (Choice)); + begin + return (Low => Expr_Value (Low_Bound (Range_Exp)), + High => Expr_Value (High_Bound (Range_Exp))); + end; + + when N_Others_Choice => + raise Program_Error; + + when others => + if Is_Entity_Name (Choice) and then Is_Type (Entity (Choice)) + then + return + (Low => Expr_Value (Type_Low_Bound (Entity (Choice))), + High => Expr_Value (Type_High_Bound (Entity (Choice)))); + else + -- an expression + return (Low | High => Expr_Value (Choice)); + end if; + end case; + end Chosen_Interval; + + -------------------- + -- Type_Intervals -- + -------------------- + function Type_Intervals + (Typ : Entity_Id) return Discrete_Interval_List + is + begin + if Has_Static_Predicate (Typ) then + declare + -- No sorting or merging needed + SDP_List : constant List_Id := Static_Discrete_Predicate (Typ); + Range_Or_Expr : Node_Id := First (SDP_List); + Result : + Discrete_Interval_List (1 .. List_Length (SDP_List)); + begin + for Idx in Result'Range loop + Result (Idx) := Chosen_Interval (Range_Or_Expr); + Range_Or_Expr := Next (Range_Or_Expr); + end loop; + pragma Assert (not Present (Range_Or_Expr)); + Check_Consistency (Result); + return Result; + end; + else + declare + Low : constant Uint := Expr_Value (Type_Low_Bound (Typ)); + High : constant Uint := Expr_Value (Type_High_Bound (Typ)); + begin + if Low > High then + declare + Null_Array : Discrete_Interval_List (1 .. 0); + begin + return Null_Array; + end; + else + return (1 => (Low => Low, High => High)); + end if; + end; + end if; + end Type_Intervals; + + procedure Normalize_Interval_List + (List : in out Discrete_Interval_List; Last : out Nat); + -- Perform sorting and merging as required by Check_Consistency. + + ----------------------------- + -- Normalize_Interval_List -- + ----------------------------- + procedure Normalize_Interval_List + (List : in out Discrete_Interval_List; Last : out Nat) is + + procedure Move_Interval (From, To : Natural); + -- Copy interval from one location to another + + function Lt_Interval (Idx1, Idx2 : Natural) return Boolean; + -- Compare two list elements + + Temp_0 : Discrete_Interval := (others => Uint_0); + -- cope with Heap_Sort_G idiosyncrasies. + + function Read_Interval (From : Natural) return Discrete_Interval; + -- Normal array indexing unless From = 0 + + ------------------- + -- Read_Interval -- + ------------------- + function Read_Interval (From : Natural) return Discrete_Interval is + begin + if From = 0 then + return Temp_0; + else + return List (Pos (From)); + end if; + end Read_Interval; + + ------------------- + -- Move_Interval -- + ------------------- + procedure Move_Interval (From, To : Natural) is + Rhs : constant Discrete_Interval := Read_Interval (From); + begin + if To = 0 then + Temp_0 := Rhs; + else + List (Pos (To)) := Rhs; + end if; + end Move_Interval; + + ----------------- + -- Lt_Interval -- + ----------------- + function Lt_Interval (Idx1, Idx2 : Natural) return Boolean is + Elem1 : constant Discrete_Interval := Read_Interval (Idx1); + Elem2 : constant Discrete_Interval := Read_Interval (Idx2); + Null_1 : constant Boolean := Elem1.Low > Elem1.High; + Null_2 : constant Boolean := Elem2.Low > Elem2.High; + begin + if Null_1 /= Null_2 then + -- So that sorting moves null intervals to high end + return Null_2; + elsif Elem1.Low /= Elem2.Low then + return Elem1.Low < Elem2.Low; + else + return Elem1.High < Elem2.High; + end if; + end Lt_Interval; + + package Interval_Sorting is + new Gnat.Heap_Sort_G (Move_Interval, Lt_Interval); + + function Is_Null (Idx : Pos) return Boolean; + -- True iff List (Idx) defines a null range + + function Is_Null (Idx : Pos) return Boolean is + begin + return List (Idx).Low > List (Idx).High; + end Is_Null; + + procedure Merge_Intervals (Null_Interval_Count : out Nat); + -- Merge contiguous ranges by replacing one with merged range + -- and the other with a null value. Return a count of the + -- null intervals, both preexisting and those introduced by + -- merging. + + --------------------- + -- Merge_Intervals -- + --------------------- + procedure Merge_Intervals (Null_Interval_Count : out Nat) is + Not_Null : Pos range List'Range; + -- Index of the most recently examined non-null interval + + Null_Interval : constant Discrete_Interval + := (Low => Uint_1, High => Uint_0); -- any null range ok here + begin + if List'Length = 0 or else Is_Null (List'First) then + Null_Interval_Count := List'Length; + -- no non-null elements, so no merge candidates + return; + end if; + + Null_Interval_Count := 0; + Not_Null := List'First; + for Idx in List'First + 1 .. List'Last loop + if Is_Null (Idx) then + -- all remaining elements are null + Null_Interval_Count := + Null_Interval_Count + List (Idx .. List'Last)'Length; + return; + elsif List (Idx).Low = List (Not_Null).High + 1 then + -- Merge the two intervals into one; discard the other + List (Not_Null).High := List (Idx).High; + List (Idx) := Null_Interval; + Null_Interval_Count := Null_Interval_Count + 1; + else + pragma Assert (List (Idx).Low > List (Not_Null).High); + Not_Null := Idx; + end if; + end loop; + end Merge_Intervals; + begin + Interval_Sorting.Sort (Natural (List'Last)); + declare + Null_Interval_Count : Nat; + begin + Merge_Intervals (Null_Interval_Count); + Last := List'Last - Null_Interval_Count; + if Null_Interval_Count /= 0 then + -- Move null intervals introduced during merging to high end + Interval_Sorting.Sort (Natural (List'Last)); + end if; + end; + end Normalize_Interval_List; + + --------------------------- + -- Choice_List_Intervals -- + --------------------------- + function Choice_List_Intervals + (Discrete_Choices : List_Id) return Discrete_Interval_List + is + function Unmerged_Choice_Count return Nat; + -- The number of intervals before adjacent intervals are merged. + + --------------------------- + -- Unmerged_Choice_Count -- + --------------------------- + function Unmerged_Choice_Count return Nat is + Choice : Node_Id := First (Discrete_Choices); + Count : Nat := 0; + begin + while Present (Choice) loop + -- Non-contiguous choices involving static predicates + -- have already been normalized away. + + if Nkind (Choice) = N_Others_Choice then + Count := + Count + List_Length (Others_Discrete_Choices (Choice)); + else + Count := Count + 1; -- an ordinary expression or range + end if; + + Choice := Next (Choice); + end loop; + return Count; + end Unmerged_Choice_Count; + + Choice : Node_Id := First (Discrete_Choices); + Result : Discrete_Interval_List (1 .. Unmerged_Choice_Count); + Count : Nat := 0; + begin + while Present (Choice) loop + if Nkind (Choice) = N_Others_Choice then + declare + Others_Choice : Node_Id + := First (Others_Discrete_Choices (Choice)); + begin + while Present (Others_Choice) loop + Count := Count + 1; + Result (Count) := Chosen_Interval (Others_Choice); + Others_Choice := Next (Others_Choice); + end loop; + end; + else + Count := Count + 1; + Result (Count) := Chosen_Interval (Choice); + end if; + Choice := Next (Choice); + end loop; + pragma Assert (Count = Result'Last); + Normalize_Interval_List (Result, Count); + Check_Consistency (Result (1 .. Count)); + return Result (1 .. Count); + end Choice_List_Intervals; + + --------------- + -- Is_Subset -- + --------------- + function Is_Subset + (Subset, Of_Set : Discrete_Interval_List) return Boolean + is + -- Returns True iff for each interval of Subset we can find + -- a single interval of Of_Set which contains the Subset interval. + begin + if Of_Set'Length = 0 then + return Subset'Length = 0; + end if; + + declare + Set_Index : Pos range Of_Set'Range := Of_Set'First; + begin + for Ss_Idx in Subset'Range loop + while not In_Interval + (Value => Subset (Ss_Idx).Low, + Interval => Of_Set (Set_Index)) + loop + if Set_Index = Of_Set'Last then + return False; + end if; + Set_Index := Set_Index + 1; + end loop; + + if not In_Interval + (Value => Subset (Ss_Idx).High, + Interval => Of_Set (Set_Index)) + then + return False; + end if; + end loop; + end; + + return True; + end Is_Subset; + + end Interval_Lists; + begin Erroutc.Subprogram_Name_Ptr := Subprogram_Name'Access; end Sem_Util; diff --git a/gcc/ada/sem_util.ads b/gcc/ada/sem_util.ads index c9065e5..b41b875 100644 --- a/gcc/ada/sem_util.ads +++ b/gcc/ada/sem_util.ads @@ -983,6 +983,10 @@ package Sem_Util is -- discriminants. Otherwise all components of the parent must be included -- in the subtype for semantic analysis. + function Get_Accessibility (E : Entity_Id) return Node_Id; + -- Obtain the accessibility level for a given entity formal taking into + -- account both extra and minimum accessibility. + function Get_Actual_Subtype (N : Node_Id) return Entity_Id; -- Given a node for an expression, obtain the actual subtype of the -- expression. In the case of a parameter where the formal is an @@ -1549,6 +1553,9 @@ package Sem_Util is -- Determine whether arbitrary node N denotes a reference to an object -- which is either atomic or Volatile_Full_Access. + function Is_Attribute_Old (N : Node_Id) return Boolean; + -- Determine whether node N denotes attribute 'Old + function Is_Attribute_Result (N : Node_Id) return Boolean; -- Determine whether node N denotes attribute 'Result @@ -2962,4 +2969,40 @@ package Sem_Util is function Yields_Universal_Type (N : Node_Id) return Boolean; -- Determine whether unanalyzed node N yields a universal type + package Interval_Lists is + type Discrete_Interval is + record + Low, High : Uint; + end record; + + type Discrete_Interval_List is + array (Pos range <>) of Discrete_Interval; + -- A sorted (in ascending order) list of non-empty pairwise-disjoint + -- intervals, always with a gap of at least one value between + -- successive intervals (i.e., mergeable intervals are merged). + -- Low bound is one; high bound is nonnegative. + + function Type_Intervals (Typ : Entity_Id) return Discrete_Interval_List; + -- Given a static discrete type or subtype, returns the (unique) + -- interval list representing the values of the type/subtype. + -- If no static predicates are involved, the length of the result + -- will be at most one. + + function Choice_List_Intervals (Discrete_Choices : List_Id) + return Discrete_Interval_List; + -- Given a discrete choice list, returns the (unique) interval + -- list representing the chosen values.. + + function Is_Subset (Subset, Of_Set : Discrete_Interval_List) + return Boolean; + -- Returns True iff every value belonging to some interval of + -- Subset also belongs to some interval of Of_Set. + + -- TBD: When we get around to implementing "is statically compatible" + -- correctly for real types with static predicates, we may need + -- an analogous Real_Interval_List type. Most of the language + -- rules that reference "is statically compatible" pertain to + -- discriminants and therefore do require support for real types; + -- the exception is 12.5.1(8). + end Interval_Lists; end Sem_Util; diff --git a/gcc/ada/terminals.c b/gcc/ada/terminals.c index 320ad28..0ce3fb7 100644 --- a/gcc/ada/terminals.c +++ b/gcc/ada/terminals.c @@ -1648,8 +1648,8 @@ __gnat_new_tty (void) */ void __gnat_close_tty (pty_desc* desc) { - if (desc->master_fd >= 0) close (desc->master_fd); - if (desc->slave_fd >= 0) close (desc->slave_fd); + if (desc->master_fd >= 0) { close (desc->master_fd); desc->master_fd = -1; } + if (desc->slave_fd >= 0) { close (desc->slave_fd); desc->slave_fd = -1; } } /* __gnat_tty_name - return slave side device name |