2005-02-09 Robert Dewar <dewar@adacore.com>

	    Thomas Quinot  <quinot@adacore.com>
	    Javier Miranda  <miranda@adacore.com>
	    Pascal Obry  <obry@adacore.com>
	    Ed Schonberg  <schonberg@adacore.com>
	    Doug Rupp  <rupp@adacore.com>
	    Gary Dismukes  <dismukes@adacore.com>
	    Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>

	* g-zstspl.ads: New file.

	* a-chahan.ads, a-chahan.adb: Add declarations from AI-285

	* a-string.ads: Add pragma Ada_05 for wide_wide_space to get warning in
	Ada 95 mode
	Add definition of Wide_Wide_Space for AI-285

	* impunit.ads, impunit.adb, sem_ch10.adb: Complete rewrite and new
	interface (to support Ada 95 and Ada 2005 units).
	Add Unbounded_IO files
	Add entries for Wide_Wide packages for AI-285
	Add list of containers packages to Ada 2005 unit list

	* a-swuwti.ads, a-swuwti.adb, a-suteio.ads, a-suteio.adb: Updates to
	support new Unbounded_IO package cleanly.

	* g-utf_32.ads, g-utf_32.adb: New files.

	* Makefile.rtl: Add entry for g-utf_32
	Add new files for Unbounded_IO
	Adjust make file for new AI-285 wide wide packages
	Add AI-302 containers to the run time.

	* a-stwibo.adb, a-stwibo.ads, a-stwisu.adb, a-stwisu.ads,
	a-strbou.ads, a-strbou.adb, a-strsup.ads, a-strsup.adb: New
	subprograms for AI-301.

	* a-stwiun.adb, a-stwiun.ads: Minor reformatting.

	* a-stunau.ads: Minor comment correction

	* rtsfind.ads, rtsfind.adb: Add definitions for Wide_Wide attributes
	etc.
	Also extend Text_IO_Kludge to support Wide_Wide_Text_IO
	(Check_RPC): Update to match changes in expanded code.
	Clean up unused entity.

	* exp_ch3.ads, exp_ch3.adb: Fix various places where Wide_Wide_String
	was not taken into account.
	This includes proper initialization with Normalize_Scalars.
	(Get_Simple_Init_Val): Major rewrite for initialize scalars and
	normalize scalars cases (particularly the latter) to do a better job
	of finding invalid representations.

	* s-scaval.ads, s-scaval.adb: Add values for zero invalid values

	* s-strops.ads, s-strops.adb: Remove string normalize routines, never
	used

	* exp_dist.adb: Add support for wide wide character type
	(Expand_Receiving_Stubs_Bodies): For a package declaration that has a
	private part, generate stub bodies at the end of the private part,
	not the visible part.
	(Add_RACW_Primitive_Operations_And_Bodies): Add last missing code for
	PolyORB support.
	(Add_Obj_RPC_Receiver_Completion): Add PCS-specific subprograms and
	generic wrapper to execute final processing after completing the
	expansion of the RPC receiver for an RACW.

	* snames.h, snames.ads, snames.adb: Add definitions for wide_wide
	packages and attributes.
	(Preset_Names): Addition of the new reserved words of Ada 2005,
	that is interface, overriding and synchronized.
	(Get_Pragma_Id): Give support to the use of the new reserved word
	"interface" as a pragma name.
	(Is_Pragma_Name): Give support to the use of the new reserved word
	"interface" as a pragma name.
	(Preset_Names): Add stream_size string for the Stream_Size Ada2005
	attribute implementation.

	* exp_attr.adb (Expand_Attribute_Reference): Do not apply validity
	checks to entities that are output parameters of Asm operations.
	Handle the Stream_Size attribute.
	Add implementation of Wide_Wide_Value, Wide_Wide_Image, Wide_Wide_Width

	* exp_imgv.ads, exp_imgv.adb: Add support for wide wide character type

	* sem_attr.adb (Eval_Attribute): Raise compile-time constraint error
	for second parameter being 0.0.
	Add support for wide wide character type.
	(Analyze_Attribute, Eval_Attribute): Handle the Stream_Size attribute.

	* s-valwch.adb, s-valwch.ads, s-imgwch.ads, s-imgwch.adb,
	s-wchstw.ads, s-wchstw.adb, s-wchwts.adb, s-wchwts.ads,
	s-widwch.adb, s-widwch.ads, s-wwdcha.adb, s-wwdcha.ads,
	s-wwdenu.adb, s-wwdenu.ads, s-wwdwch.adb, s-wwdwch.ads: Add support
	for wide wide character cases.

	* cstand.adb: Create entities for Wide_Wide_Character and
	Wide_Wide_String.

	* i-c.ads, i-c.adb: Fix not raising CE for null wide strings in
	accordance with AI-258.
	Add new declarations for 16/32 bit C character types (Part of AI285)

	* einfo.ads, einfo.adb (Is_Obsolescent, Is_Ada_2005): New flag
	(Obsolescent_Warning): New field
	(Rep_Clause): New local subprogram used to share code. Returns the rep
	clause for which the name is given in parameter.
	(Has_Stream_Size_Clause): New routine.
	(Stream_Size_Clause): Idem. Implementation is based on Rep_Clause.
	(Address_Clause): Implementation is now using Rep_Clause.
	(Alignment_Clause): Idem.
	(Size_Clause): Idem.

	* lib-xref.adb (Generate_Reference): Test for reference to Ada 2005
	entity in non-Ada 2005 mode and generate warning.

	* par-prag.adb: Add handling of one argument form for pragma Ada_05.
	(Prag): Code cleanup. Remove old gnat pragma "overriding"

	* sem_prag.adb: Add handling of one argument form for pragma Ada_05
	(Analyze_Pragma, case Elaborate, Elaborate_All): Do not disable warnings
	on the named unit if the pragma is not in the current compilation unit,
	so that elaboration calls in the current unit can set up an elaboration
	dependency on the named unit, as needed.
	(Analyze_Pragma, case Obsolescent): Allow pragma to be used for library
	subprogram as well as for subprograms declared within a package.
	(Analyze_Pragma, Sig_Flags): Code cleanup. Remove support for the GNAT
	pragma overriding.

	* krunch.ads, krunch.adb: Add special handling of Wide_Wide (krunched
	to z) to avoid some instances of duplication for Wide_Wide packages.

	* namet.ads, namet.adb: Implement encoding (WWhhhhhhhh) for wide wide
	characters.

	* scn.adb: Char_Literal_Value field is now a Uint

	* scng.adb: Significant rewrite to handle new Ada 2005 features
	allowing wide and wide wide characters in program text, e.g. for
	identifiers, as described in AI-285.
	(Set_Reserved): New procedure, makes setting up keywords cleaner.
	(Initialize_Scanner): Register the new reserved words of Ada 2005.
	(Scan): Give support to the new reserved words.

	* par-ch2.adb (P_Identifier): Compiling in Ada95 mode, generate a
	warning notifying that interface, overriding, and synchronized are
	new reserved words.
	(P_Pragma): Allow the use of the new reserved word "interface" as
	a pragma name.

	* gnatls.adb, gnatbind.adb,
	ali-util.adb, binde.adb, ali.ads, ali.adb: Code cleanup. Rename
	identifiers named "interface" to "SAL_Interface".

	* bindgen.adb (Gen_Main_Ada): Add support for the new SEH
	(Structured Exception handling).
	(Gen_Main_C): Idem.

	* bindgen.adb:
	(Gen_Main_Ada): Set the default exit code if specified.
	(Gen_Main_C): Likewise.
	Part of *DC20-006.
	(Gen_Output_File_C): Remove redundant output of gnat_exit_status.
	Code cleanup. Rename identifiers named "interface" to "SAL_Interface"

	* switch-b.adb, bindusg.adb, opt.ads, vms_data.ads: Add handling of
	new -Xnnn switch.

	* mlib-prj.adb, mlib.adb: Code cleanup. Rename one identifier that
	has a collision with the new Ada 2005 "interface" reserved word.

	* par-ch3.adb (P_Defining_Identifier): Compiling in Ada95 mode,
	generate a warning notifying that interface, overriding, and
	synchronized are new reserved words.

	* scans.ads (Token_Type): Addition of the tokens corresponding to the
	new reserved words of Ada 2005: Tok_Interface, Tok_Overriding
	and Tok_Synchronized.

	* sem_res.adb (Resolve_Actuals): Change error messages to refer to
	"dispatching" rather than "primitive" operations, since dispatching
	calls are now allowed to abstract formal subprograms (which are not
	primitive).
	Char_Literal_Value field is now a Uint
	(Resolve_Slice): If the prefix is an access to an unconstrained array,
	compute the actual subtype of the designated object to impose the proper
	index constraints.
	(Resolve_Selected_Component): Do not insert an access check if the
	prefix is an access type: such a node is expanded into an explicit
	dereference, on which the access check is performed anyway. Removes
	expensive duplicate checks.
	(Resolve_Call): Use new flag Is_Obsolescent and field
	Obsolescent_Warning so that pragma Obsolescent works on library
	subprograms.
	Add support for wide wide character type
	(Resolve_Allocator): Replace the error message on wrong null-exclusion
	value by a warning message.
	(Resolve_Type_Conversion): If the mixed-mode expression is interpreted
	as fixed-point, and one of the operands is non-static and universal, it
	can only be an illegal exponentiation operation, in which case there is
	no real value to retrieve.

	* exp_strm.adb: Add support for wide wide character type
	(Build_Elementary_Input_Call): Compute the size of the stream element by
	querying the rep chain to find the Stream_Attribute attribute value.
	(Build_Elementary_Write_Call): Ditto.

	* sem_aggr.adb: Char_Literal_Value field is now a Uint
	Add support for wide wide character type
	Replace the error messages on wrong null-exclusion value by warnings
	as described in Ada 2005.
	(Resolve_Extension_Aggregate): Document the fact that the error
	message on class-wide expressions in extensions aggregates.

	* sem_case.adb: Add support for wide wide character type

	* sem_ch13.adb: Add support for wide wide character type
	(Analyze_Attribute_Definition_Clause): Handle the Stream_Size attribute.

	* sem_ch3.adb: Add support for wide wide character type
	(Process_Subtype): If constraint is illegal for the type, set Ekind of
	now-useless Itype, to prevent cascaded errors on a compiler built
	without -gnatp.

	* sem_ch8.adb: Add with and use of Sem_Disp.
	(Analyze_Subprogram_Renaming): Replace unclean uses of
	Corresponding_Spec with Corresponding_Formal_Spec (and delete setting
	of Corresponding_Spec to Empty).
	(Attribute_Renaming): Replace use of Corresponding_Spec with
	Corresponding_ Formal_Spec and simplify condition.
	(Use_One_Package): Check that scope of homonym of identifier is defined,
	before checking whether it is a wrapper package.
	Add support for wide wide character type

	* sem_eval.adb: Add support for wide wide character type.
	(Eval_Arithmetic_Op): Check for compile time known signed integer
	overflow in the non-static case.
	(Subtypes_Statically_Match): A formal scalar type and its base type do
	not statically match.

	* sem_util.adb (Collect_Primitive_Operations): Minor change of "/=" to
	"not in" for test of N_Formal_Subprogram_Declaration (which is now a
	subtype).
	(Unit_Declaration_Node): Ditto.
	(Is_Variable_Prefix):  For the case of an indexed component whose prefix
	has a packed array type, the prefix has been rewritten into a type
	conversion. Determine variable-ness from the converted expression.
	Handle wide wide character cases.

	* stand.ads: Add types Wide_Wide_Character and Wide_Wide_String

	* stringt.ads, stringt.adb: Handle full UTF-32 range.
	Remove ["0A"] from comment, since it can look like a line terminator.
	Currently we don't permit this, but this is under discussion by the
	ARG, and it is easy enough to use a different example.

	* s-wchcon.ads, s-wchcnv.ads, s-wchcnv.adb: Add new subprograms for
	handling UTF-32 encoding for wide wide character.
	Implement new brackets coding ["hhhhhhhh"]
	Add UTF-8 encodings for full UTF-32 range

	* ttypes.ads: Add definition of Standard_Wide_Wide_Character_Size

	* types.h, types.ads, types.adb: Wide_Wide_Character now has full 31
	bit range Add full UTF-32 support.
	(RT_Exception_Code): Addition of CE_Null_Not_Allowed; used to
	notify that constraint error will be raised at run-time
	because a null value is assigned to a null-excluding object.
	Remove some obsolete declarations and make Char_Code
	unsigned.

	* a-except.adb (Rcheck_30): New subprogram. Addition of the message
	corresponding to CE_Null_Not_Allowed, and adjust the output of all the
	Rcheck subprograms.

	* checks.adb (Check_Null_Not_Allowed): Replace the error message on
	wrong null-exclusion value by a warning message.
	(Enable_Range_Check): Do range check if the prefix is an
	explicit dereference whose designated object is an unconstrained array.
	Current algorithm for removing duplicate checks is over-eager in this
	case.

	* sem_ch5.adb (Analyze_Assignment): Replace the error messages on wrong
	null-exclusion value by a warning message

	* atree.h, atree.ads, atree.adb: Remove Char_Code field support
	completely. Add support for Uint2 field

	sem_ch2.adb, exp_ch11.adb, exp_dbug.adb,
	exp_prag.adb: Char_Literal_Value field is now a Uint.

	* exp_util.adb (Insert_Actions): Replace
	N_Formal_Subprogram_Declaration by
	N_Formal_{Abstract|Concrete}_Subprogram_Declaration.
	Char_Literal_Value field is now a Uint.

	* sinfo.ads, sinfo.adb (Corresponding_Formal_Spec): New function
	defined for subprogram renaming declarations. When set, the field
	indicates the defining entity of a corresponding formal subprogram
	when the renaming corresponds to a formal subprogram association in an
	instantiation.
	(Set_Corresponding_Formal_Spec): New procedure to return
	Corresponding_Formal_Spec field.
	Minor changes of "=" to "in" in tests of N_Formal_Subprogram_Declaration
	(which is now a subtype).
	Char_Literal_Value field is now a Uint

	* exp_disp.ads, exp_disp.adb (Make_DT): Generate code that moves the
	pointer to the base of the dispatch table.
	Minor changes to comments.
	(Controlling_Type): New function for determining the tagged type
	associated with a tagged primitive subprogram.
	(Expand_Dispatching_Call): Add support for a controlling actual that is
	directly a value of type Ada.Tag rather than a tagged object.

	* i-cpp.ads, i-cpp.adb, a-tags.ads, a-tags.adb: Update documentation
	describing the new layout.
	(Dispatch_Table): The expander computes the actual array size, allocates
	the Dispatch_Table record accordingly, and generates code that displaces
	the base of the record after the Typeinfo_Ptr component. The access to
	these components is done by means of local functions.
	(Offset_To_Top): New function.
	(Typeinfo_Ptr): New function.
	(Get_TSD): Modified to access the new position of the TSD.
	(Set_TSD): Modified to save the TSD in its new position.

	* par-ch12.adb (P_Formal_Subprogram_Declaration): Add parsing for the
	case of formal abstract subprograms. Add check and message for -gnat05.
	Update comments.

	* sem_ch12.adb: Add with and use for Sem_Disp.
	(Analyze_Associations): Minor change from "=" to "in" for use of
	N_Formal_Subtype_Declaration (which is now a subtype).
	(Set_Analyzed_Formal): Minor changes from "=" to "in" for uses of
	N_Formal_Subtype_Declaration (which is now a subtype).
	(Analyze_Formal_Subprogram): Add handling for
	N_Formal_Abstract_Subprogram, marking the formal as abstract and
	dispatching, setting the controlling status of the formal parameters
	and result, and issuing an error if there is no controlling type for
	the formal subprogram.
	(Instantiate_Formal_Subprogram): Rather than setting Corresponding_Spec,
	which is an unclean use of that field, we set the new field
	Corresponding_Formal_Spec to make the formal subprogram available to
	processing in Analyze_Subprogram_Declaration.
	(Analyze_Formal_{Discrete, Decimal_Fixed_Point, Fixed_Point,
	Floating_Point, Modular_Integer, Signed_Integer}_Type: Make formal type
	Constrained, so that it is is does not statically match its anonymous
	base type.

	* sem_ch6.adb (Analyze_Subprogram_Specification): Include test for
	abstract formal subprograms in error check for functions returning
	abstract types. Set scope of new designator for
	a parameterless subprogram, so that it is available when checking the
	body for nested subprograms, before full analysis of said body.
	(Analyze_Subprogram_Body): Warn on inlining bodies with nested
	subprogram only if inner one comes from source.
	(Analyze_Function_Call): If the call is given in object notation, the
	analysis of the name rewrites the node and analyzes it with the proper
	argument list. After analyzing the name, if the call has been rewritten
	and the result type is set, no further analysis is needed.
	(Analyze_Return_Type): Subsidiary to Process_Formals: analyze subtype
	mark in function specification, in a context where the formals are
	visible and hide outer homographs.

	* sem_disp.adb (Check_Controlling_Type): Relax the check for same scope
	as the tagged type for the cases of abstract formal subprograms and
	renamings of those.  Clean up spec comments.
	(Check_Dispatching_Context): Add error message to indicate "abstract
	procedure", covering the case of a call to a formal abstract procedure
	that has statically tagged operands.
	(Check_Dispatching_Call): Check for the case of an actual given by
	a tag-indeterminate function call whose type is an ancestor of the
	containing call's associated tagged type. This situation can occur
	for inherited primitives with function defaults. In this case we
	use the tagged type's tag directly as the controlling argument for
	the calls.
	(Expand_Call): Name change on call to Expand_Dispatch_Call.

	* sprint.adb (Sprint_Node_Actual): Split
	N_Formal_Subprogram_Declaration into two alternatives for the new
	cases N_Formal_Abstract_Subprogram_Declaration and
	N_Formal_Concrete_Subprogram_Declaration.
	Char_Literal_Value field is now a Uint.

	* trans.c: Get rid of junk Uint2 reference.
	Char_Literal_Value field is now a Uint.
	(gnat_to_gnu, case N_Aggregate): Check TYPE_UNCHECKED_UNION_P.
	(gigi): Correct third arg to gimplify_body.

	* ada-tree.h: (TYPE_UNCHECKED_UNION_P): New flag.
	(TYPE_LANG_FLAG_0): Check for record or union.

	* treepr.adb: Char_Literal_Value field is now a Uint

	* uintp.h, uintp.ads, uintp.adb: Add new routines UI_To_CC and
	UI_From_CC.

	* widechar.ads, widechar.adb (Is_UTF_32_Non_Graphic): New function
	Add full UTF-32 support
	Char_Code is now 32 bits

	* sinput.ads, sinput.adb (Skip_Line_Terminators): Extend to deal with
	wide character UTF_32 line terminators.
	Initialize Main_Source_File to avoid error when no main
	source is loaded.

	* errout.adb (Finalize): Do not check Num_SRef_Pragmas
	(Main_Source_File) when no main source has been loaded, to avoid
	potential crash.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@94809 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 518 insertions, 468 deletions

diff --git a/gcc/ada/a-strbou.ads b/gcc/ada/a-strbou.ads
index 7e9f54f1b0a..5b8346ad102 100644
--- a/gcc/ada/a-strbou.ads
+++ b/gcc/ada/a-strbou.ads
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---          Copyright (C) 1992-2003 Free Software Foundation, Inc.          --
+--          Copyright (C) 1992-2005 Free Software Foundation, Inc.          --
 --                                                                          --
 -- This specification is derived from the Ada Reference Manual for use with --
 -- GNAT. The copyright notice above, and the license provisions that follow --
@@ -55,214 +55,245 @@ pragma Preelaborate (Bounded);
 
       subtype Length_Range is Natural range 0 .. Max_Length;
 
-      function Length (Source : in Bounded_String) return Length_Range;
+      function Length (Source : Bounded_String) return Length_Range;
 
       --------------------------------------------------------
       -- Conversion, Concatenation, and Selection Functions --
       --------------------------------------------------------
 
       function To_Bounded_String
-        (Source : in String;
-         Drop   : in Truncation := Error)
-         return   Bounded_String;
+        (Source : String;
+         Drop   : Truncation := Error) return Bounded_String;
 
-      function To_String (Source : in Bounded_String) return String;
+      function To_String (Source : Bounded_String) return String;
+
+      procedure Set_Bounded_String
+        (Target : out Bounded_String;
+         Source : String;
+         Drop   : Truncation := Error);
+      pragma Ada_05 (Set_Bounded_String);
 
       function Append
-        (Left, Right : in Bounded_String;
-         Drop        : in Truncation  := Error)
-         return        Bounded_String;
+        (Left  : Bounded_String;
+         Right : Bounded_String;
+         Drop  : Truncation  := Error) return Bounded_String;
 
       function Append
-        (Left  : in Bounded_String;
-         Right : in String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Left  : Bounded_String;
+         Right : String;
+         Drop  : Truncation := Error) return Bounded_String;
 
       function Append
-        (Left  : in String;
-         Right : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Left  : String;
+         Right : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String;
 
       function Append
-        (Left  : in Bounded_String;
-         Right : in Character;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Left  : Bounded_String;
+         Right : Character;
+         Drop  : Truncation := Error) return Bounded_String;
 
       function Append
-        (Left  : in Character;
-         Right : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Left  : Character;
+         Right : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String;
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in Bounded_String;
-         Drop     : in Truncation  := Error);
+         New_Item : Bounded_String;
+         Drop     : Truncation  := Error);
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in String;
-         Drop     : in Truncation  := Error);
+         New_Item : String;
+         Drop     : Truncation  := Error);
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in Character;
-         Drop     : in Truncation  := Error);
+         New_Item : Character;
+         Drop     : Truncation  := Error);
 
       function "&"
-        (Left, Right : in Bounded_String)
-         return        Bounded_String;
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Bounded_String;
 
       function "&"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Bounded_String;
+        (Left  : Bounded_String;
+         Right : String) return Bounded_String;
 
       function "&"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Bounded_String;
+        (Left  : String;
+         Right : Bounded_String) return Bounded_String;
 
       function "&"
-        (Left  : in Bounded_String;
-         Right : in Character)
-         return  Bounded_String;
+        (Left  : Bounded_String;
+         Right : Character) return Bounded_String;
 
       function "&"
-        (Left  : in Character;
-         Right : in Bounded_String)
-         return  Bounded_String;
+        (Left  : Character;
+         Right : Bounded_String) return Bounded_String;
 
       function Element
-        (Source : in Bounded_String;
-         Index  : in Positive)
-         return   Character;
+        (Source : Bounded_String;
+         Index  : Positive) return Character;
 
       procedure Replace_Element
         (Source : in out Bounded_String;
-         Index  : in Positive;
-         By     : in Character);
+         Index  : Positive;
+         By     : Character);
 
       function Slice
-        (Source : in Bounded_String;
-         Low    : in Positive;
-         High   : in Natural)
-         return   String;
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural) return String;
+
+      function Bounded_Slice
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural) return Bounded_String;
+      pragma Ada_05 (Bounded_Slice);
+
+      procedure Bounded_Slice
+        (Source : Bounded_String;
+         Target : out Bounded_String;
+         Low    : Positive;
+         High   : Natural);
+      pragma Ada_05 (Bounded_Slice);
 
-      function "="  (Left, Right : in Bounded_String) return Boolean;
+      function "="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean;
 
       function "="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean;
+        (Left  : Bounded_String;
+         Right : String) return Boolean;
 
       function "="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean;
+        (Left  : String;
+         Right : Bounded_String) return Boolean;
 
-      function "<"  (Left, Right : in Bounded_String) return Boolean;
+      function "<"
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean;
 
       function "<"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean;
+        (Left  : Bounded_String;
+         Right : String) return Boolean;
 
       function "<"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean;
+        (Left  : String;
+         Right : Bounded_String) return Boolean;
 
-      function "<=" (Left, Right : in Bounded_String) return Boolean;
+      function "<="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean;
 
       function "<="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean;
+        (Left  : Bounded_String;
+         Right : String) return Boolean;
 
       function "<="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean;
+        (Left  : String;
+         Right : Bounded_String) return Boolean;
 
-      function ">"  (Left, Right : in Bounded_String) return Boolean;
+      function ">"
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean;
 
       function ">"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean;
+        (Left  : Bounded_String;
+         Right : String) return Boolean;
 
       function ">"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean;
+        (Left  : String;
+         Right : Bounded_String) return Boolean;
 
-      function ">=" (Left, Right : in Bounded_String) return Boolean;
+      function ">="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean;
 
       function ">="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean;
+        (Left  : Bounded_String;
+         Right : String) return Boolean;
 
       function ">="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean;
+        (Left  : String;
+         Right : Bounded_String) return Boolean;
 
       ----------------------
       -- Search Functions --
       ----------------------
 
       function Index
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Going   : in Direction := Forward;
-         Mapping : in Maps.Character_Mapping := Maps.Identity)
-         return    Natural;
+        (Source  : Bounded_String;
+         Pattern : String;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
+
+      function Index
+        (Source  : Bounded_String;
+         Pattern : String;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping_Function) return Natural;
 
       function Index
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Going   : in Direction := Forward;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Natural;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set;
+         Test   : Membership := Inside;
+         Going  : Direction  := Forward) return Natural;
 
       function Index
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set;
-         Test   : in Membership := Inside;
-         Going  : in Direction  := Forward)
-         return   Natural;
+        (Source  : Bounded_String;
+         Pattern : String;
+         From    : Positive;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
+      pragma Ada_05 (Index);
+
+      function Index
+        (Source  : Bounded_String;
+         Pattern : String;
+         From    : Positive;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping_Function) return Natural;
+      pragma Ada_05 (Index);
+
+      function Index
+        (Source  : Bounded_String;
+         Set     : Maps.Character_Set;
+         From    : Positive;
+         Test    : Membership := Inside;
+         Going   : Direction := Forward) return Natural;
+      pragma Ada_05 (Index);
 
       function Index_Non_Blank
-        (Source : in Bounded_String;
-         Going  : in Direction := Forward)
-         return   Natural;
+        (Source : Bounded_String;
+         Going  : Direction := Forward) return Natural;
+
+      function Index_Non_Blank
+        (Source : Bounded_String;
+         From   : Positive;
+         Going  : Direction := Forward) return Natural;
+      pragma Ada_05 (Index_Non_Blank);
 
       function Count
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Mapping : in Maps.Character_Mapping := Maps.Identity)
-         return    Natural;
+        (Source  : Bounded_String;
+         Pattern : String;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural;
 
       function Count
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Natural;
+        (Source  : Bounded_String;
+         Pattern : String;
+         Mapping : Maps.Character_Mapping_Function) return Natural;
 
       function Count
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set)
-         return   Natural;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set) return Natural;
 
       procedure Find_Token
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set;
-         Test   : in Membership;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set;
+         Test   : Membership;
          First  : out Positive;
          Last   : out Natural);
 
@@ -271,569 +302,588 @@ pragma Preelaborate (Bounded);
       ------------------------------------
 
       function Translate
-        (Source   : in Bounded_String;
-         Mapping  : in Maps.Character_Mapping)
-         return     Bounded_String;
+        (Source  : Bounded_String;
+         Mapping : Maps.Character_Mapping) return Bounded_String;
 
       procedure Translate
         (Source   : in out Bounded_String;
-         Mapping  : in Maps.Character_Mapping);
+         Mapping  : Maps.Character_Mapping);
 
       function Translate
-        (Source  : in Bounded_String;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Bounded_String;
+        (Source  : Bounded_String;
+         Mapping : Maps.Character_Mapping_Function) return Bounded_String;
 
       procedure Translate
         (Source  : in out Bounded_String;
-         Mapping : in Maps.Character_Mapping_Function);
+         Mapping : Maps.Character_Mapping_Function);
 
       ---------------------------------------
       -- String Transformation Subprograms --
       ---------------------------------------
 
       function Replace_Slice
-        (Source   : in Bounded_String;
-         Low      : in Positive;
-         High     : in Natural;
-         By       : in String;
-         Drop     : in Truncation := Error)
-         return     Bounded_String;
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural;
+         By     : String;
+         Drop   : Truncation := Error) return Bounded_String;
 
       procedure Replace_Slice
         (Source   : in out Bounded_String;
-         Low      : in Positive;
-         High     : in Natural;
-         By       : in String;
-         Drop     : in Truncation := Error);
+         Low      : Positive;
+         High     : Natural;
+         By       : String;
+         Drop     : Truncation := Error);
 
       function Insert
-        (Source   : in Bounded_String;
-         Before   : in Positive;
-         New_Item : in String;
-         Drop     : in Truncation := Error)
-         return     Bounded_String;
+        (Source   : Bounded_String;
+         Before   : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error) return Bounded_String;
 
       procedure Insert
         (Source   : in out Bounded_String;
-         Before   : in Positive;
-         New_Item : in String;
-         Drop     : in Truncation := Error);
+         Before   : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error);
 
       function Overwrite
-        (Source    : in Bounded_String;
-         Position  : in Positive;
-         New_Item  : in String;
-         Drop      : in Truncation := Error)
-         return      Bounded_String;
+        (Source   : Bounded_String;
+         Position : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error) return Bounded_String;
 
       procedure Overwrite
         (Source    : in out Bounded_String;
-         Position  : in Positive;
-         New_Item  : in String;
-         Drop      : in Truncation := Error);
+         Position  : Positive;
+         New_Item  : String;
+         Drop      : Truncation := Error);
 
       function Delete
-        (Source  : in Bounded_String;
-         From    : in Positive;
-         Through : in Natural)
-         return    Bounded_String;
+        (Source  : Bounded_String;
+         From    : Positive;
+         Through : Natural) return Bounded_String;
 
       procedure Delete
         (Source  : in out Bounded_String;
-         From    : in Positive;
-         Through : in Natural);
+         From    : Positive;
+         Through : Natural);
 
       ---------------------------------
       -- String Selector Subprograms --
       ---------------------------------
 
       function Trim
-        (Source : in Bounded_String;
-         Side   : in Trim_End)
-         return   Bounded_String;
+        (Source : Bounded_String;
+         Side   : Trim_End) return Bounded_String;
 
       procedure Trim
         (Source : in out Bounded_String;
-         Side   : in Trim_End);
+         Side   : Trim_End);
 
       function Trim
-        (Source  : in Bounded_String;
-          Left   : in Maps.Character_Set;
-          Right  : in Maps.Character_Set)
-          return   Bounded_String;
+        (Source : Bounded_String;
+          Left  : Maps.Character_Set;
+          Right : Maps.Character_Set) return Bounded_String;
 
       procedure Trim
         (Source : in out Bounded_String;
-         Left   : in Maps.Character_Set;
-         Right  : in Maps.Character_Set);
+         Left   : Maps.Character_Set;
+         Right  : Maps.Character_Set);
 
       function Head
-        (Source : in Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character := Space;
-         Drop   : in Truncation := Error)
-         return   Bounded_String;
+        (Source : Bounded_String;
+         Count  : Natural;
+         Pad    : Character := Space;
+         Drop   : Truncation := Error) return Bounded_String;
 
       procedure Head
         (Source : in out Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error);
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error);
 
       function Tail
-        (Source : in Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error)
-         return Bounded_String;
+        (Source : Bounded_String;
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error) return Bounded_String;
 
       procedure Tail
         (Source : in out Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error);
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error);
 
       ------------------------------------
       -- String Constructor Subprograms --
       ------------------------------------
 
       function "*"
-        (Left  : in Natural;
-         Right : in Character)
-         return  Bounded_String;
+        (Left  : Natural;
+         Right : Character) return Bounded_String;
 
       function "*"
-        (Left  : in Natural;
-         Right : in String)
-         return  Bounded_String;
+        (Left  : Natural;
+         Right : String) return Bounded_String;
 
       function "*"
-        (Left  : in Natural;
-         Right : in Bounded_String)
-         return  Bounded_String;
+        (Left  : Natural;
+         Right : Bounded_String) return Bounded_String;
 
       function Replicate
-        (Count : in Natural;
-         Item  : in Character;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Count : Natural;
+         Item  : Character;
+         Drop  : Truncation := Error) return Bounded_String;
 
       function Replicate
-        (Count : in Natural;
-         Item  : in String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Count : Natural;
+         Item  : String;
+         Drop  : Truncation := Error) return Bounded_String;
 
       function Replicate
-        (Count : in Natural;
-         Item  : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String;
+        (Count : Natural;
+         Item  : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String;
 
    private
-
-      --  Most of the implementation is in the non generic package
+      --  Most of the implementation is in the separate non generic package
       --  Ada.Strings.Superbounded. Type Bounded_String is derived from type
-      --  Superbounded.Super_String with the maximum length constraint.
-      --  Except for five, all subprograms are renames of subprograms that
-      --  are inherited from Superbounded.Super_String.
+      --  Superbounded.Super_String with the maximum length constraint. In
+      --  almost all cases, the routines in Superbounded can be called with
+      --  no requirement to pass the maximum length explicitly, since there
+      --  is at least one Bounded_String argument from which the maximum
+      --  length can be obtained. For all such routines, the implementation
+      --  in this private part is simply a renaming of the corresponding
+      --  routine in the super bouded package.
+
+      --  The five exceptions are the * and Replicate routines operating on
+      --  character values. For these cases, we have a routine in the body
+      --  that calls the superbounded routine passing the maximum length
+      --  explicitly as an extra parameter.
 
       type Bounded_String is new Superbounded.Super_String (Max_Length);
+      --  Deriving Bounded_String from Superbounded.Super_String is the
+      --  real trick, it ensures that the type Bounded_String declared in
+      --  the generic instantiation is compatible with the Super_String
+      --  type declared in the Superbounded package.
 
       Null_Bounded_String : constant Bounded_String :=
-        (Max_Length     => Max_Length,
-         Current_Length => 0,
-         Data           => (1 .. Max_Length => ASCII.NUL));
+                              (Max_Length     => Max_Length,
+                               Current_Length => 0,
+                               Data           =>
+                                 (1 .. Max_Length => ASCII.NUL));
 
       pragma Inline (To_Bounded_String);
 
-      function Length (Source : in Bounded_String) return Length_Range
-        renames Super_Length;
+      procedure Set_Bounded_String
+        (Target : out Bounded_String;
+         Source : String;
+         Drop   : Truncation := Error)
+         renames Set_Super_String;
 
-      function To_String (Source : in Bounded_String) return String
-        renames Super_To_String;
+      function Length
+        (Source : Bounded_String) return Length_Range
+         renames Super_Length;
+
+      function To_String
+        (Source : Bounded_String) return String
+         renames Super_To_String;
 
       function Append
-        (Left, Right : in Bounded_String;
-         Drop        : in Truncation  := Error)
-         return        Bounded_String
-        renames Super_Append;
+        (Left  : Bounded_String;
+         Right : Bounded_String;
+         Drop  : Truncation  := Error) return Bounded_String
+         renames Super_Append;
 
       function Append
-        (Left  : in Bounded_String;
-         Right : in String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String
-        renames Super_Append;
+        (Left  : Bounded_String;
+         Right : String;
+         Drop  : Truncation := Error) return Bounded_String
+         renames Super_Append;
 
       function Append
-        (Left  : in String;
-         Right : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String
-        renames Super_Append;
+        (Left  : String;
+         Right : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String
+         renames Super_Append;
 
       function Append
-        (Left  : in Bounded_String;
-         Right : in Character;
-         Drop  : in Truncation := Error)
-         return  Bounded_String
-        renames Super_Append;
+        (Left  : Bounded_String;
+         Right : Character;
+         Drop  : Truncation := Error) return Bounded_String
+         renames Super_Append;
 
       function Append
-        (Left  : in Character;
-         Right : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String
-        renames Super_Append;
+        (Left  : Character;
+         Right : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String
+         renames Super_Append;
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in Bounded_String;
-         Drop     : in Truncation  := Error)
-        renames Super_Append;
+         New_Item : Bounded_String;
+         Drop     : Truncation  := Error)
+         renames Super_Append;
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in String;
-         Drop     : in Truncation  := Error)
-        renames Super_Append;
+         New_Item : String;
+         Drop     : Truncation  := Error)
+         renames Super_Append;
 
       procedure Append
         (Source   : in out Bounded_String;
-         New_Item : in Character;
-         Drop     : in Truncation  := Error)
-        renames Super_Append;
+         New_Item : Character;
+         Drop     : Truncation  := Error)
+         renames Super_Append;
 
       function "&"
-        (Left, Right : in Bounded_String)
-         return        Bounded_String
-        renames Concat;
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Bounded_String
+         renames Concat;
 
       function "&"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Bounded_String
-        renames Concat;
+        (Left  : Bounded_String;
+         Right : String) return Bounded_String
+         renames Concat;
 
       function "&"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Bounded_String
-        renames Concat;
+        (Left  : String;
+         Right : Bounded_String) return Bounded_String
+         renames Concat;
 
       function "&"
-        (Left  : in Bounded_String;
-         Right : in Character)
-         return  Bounded_String
-        renames Concat;
+        (Left  : Bounded_String;
+         Right : Character) return Bounded_String
+         renames Concat;
 
       function "&"
-        (Left  : in Character;
-         Right : in Bounded_String)
-         return  Bounded_String
-        renames Concat;
+        (Left  : Character;
+         Right : Bounded_String) return Bounded_String
+         renames Concat;
 
       function Element
-        (Source : in Bounded_String;
-         Index  : in Positive)
-         return   Character
-        renames Super_Element;
+        (Source : Bounded_String;
+         Index  : Positive) return Character
+         renames Super_Element;
 
       procedure Replace_Element
         (Source : in out Bounded_String;
-         Index  : in Positive;
-         By     : in Character)
-        renames Super_Replace_Element;
+         Index  : Positive;
+         By     : Character)
+         renames Super_Replace_Element;
 
       function Slice
-        (Source : in Bounded_String;
-         Low    : in Positive;
-         High   : in Natural)
-         return   String
-        renames Super_Slice;
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural) return String
+         renames Super_Slice;
+
+      function Bounded_Slice
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural) return Bounded_String
+         renames Super_Slice;
+
+      procedure Bounded_Slice
+        (Source : Bounded_String;
+         Target : out Bounded_String;
+         Low    : Positive;
+         High   : Natural)
+         renames Super_Slice;
 
-      function "="  (Left, Right : in Bounded_String) return Boolean
-        renames Equal;
+      function "="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean
+         renames Equal;
 
       function "="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean
-        renames Equal;
+        (Left  : Bounded_String;
+         Right : String) return Boolean
+         renames Equal;
 
       function "="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean
-        renames Equal;
+        (Left  : String;
+         Right : Bounded_String) return Boolean
+         renames Equal;
 
-      function "<"  (Left, Right : in Bounded_String) return Boolean
-        renames Less;
+      function "<"
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean
+         renames Less;
 
       function "<"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean
-        renames Less;
+        (Left  : Bounded_String;
+         Right : String) return Boolean
+         renames Less;
 
       function "<"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean
-        renames Less;
+        (Left  : String;
+         Right : Bounded_String) return Boolean
+         renames Less;
 
-      function "<=" (Left, Right : in Bounded_String) return Boolean
-        renames Less_Or_Equal;
+      function "<="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean
+         renames Less_Or_Equal;
 
       function "<="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean
-        renames Less_Or_Equal;
+        (Left  : Bounded_String;
+         Right : String) return Boolean
+         renames Less_Or_Equal;
 
       function "<="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean
-        renames Less_Or_Equal;
+        (Left  : String;
+         Right : Bounded_String) return Boolean
+         renames Less_Or_Equal;
 
-      function ">"  (Left, Right : in Bounded_String) return Boolean
-        renames Greater;
+      function ">"
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean
+         renames Greater;
 
       function ">"
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean
-        renames Greater;
+        (Left  : Bounded_String;
+         Right : String) return Boolean
+         renames Greater;
 
       function ">"
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean
-        renames Greater;
+        (Left  : String;
+         Right : Bounded_String) return Boolean
+         renames Greater;
 
-      function ">=" (Left, Right : in Bounded_String) return Boolean
-        renames Greater_Or_Equal;
+      function ">="
+        (Left  : Bounded_String;
+         Right : Bounded_String) return Boolean
+         renames Greater_Or_Equal;
 
       function ">="
-        (Left  : in Bounded_String;
-         Right : in String)
-         return  Boolean
-        renames Greater_Or_Equal;
+        (Left  : Bounded_String;
+         Right : String) return Boolean
+         renames Greater_Or_Equal;
 
       function ">="
-        (Left  : in String;
-         Right : in Bounded_String)
-         return  Boolean
-        renames Greater_Or_Equal;
+        (Left  : String;
+         Right : Bounded_String) return Boolean
+         renames Greater_Or_Equal;
+
+      function Index
+        (Source  : Bounded_String;
+         Pattern : String;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
+         renames Super_Index;
+
+      function Index
+        (Source  : Bounded_String;
+         Pattern : String;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping_Function) return Natural
+         renames Super_Index;
 
       function Index
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Going   : in Direction := Forward;
-         Mapping : in Maps.Character_Mapping := Maps.Identity)
-         return    Natural
-        renames Super_Index;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set;
+         Test   : Membership := Inside;
+         Going  : Direction  := Forward) return Natural
+         renames Super_Index;
 
       function Index
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Going   : in Direction := Forward;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Natural
-        renames Super_Index;
+        (Source  : Bounded_String;
+         Pattern : String;
+         From    : Positive;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
+         renames Super_Index;
 
       function Index
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set;
-         Test   : in Membership := Inside;
-         Going  : in Direction  := Forward)
-         return   Natural
-        renames Super_Index;
+        (Source  : Bounded_String;
+         Pattern : String;
+         From    : Positive;
+         Going   : Direction := Forward;
+         Mapping : Maps.Character_Mapping_Function) return Natural
+      renames Super_Index;
+
+      function Index
+        (Source  : Bounded_String;
+         Set     : Maps.Character_Set;
+         From    : Positive;
+         Test    : Membership := Inside;
+         Going   : Direction := Forward) return Natural
+      renames Super_Index;
+
+      function Index_Non_Blank
+        (Source : Bounded_String;
+         Going  : Direction := Forward) return Natural
+         renames Super_Index_Non_Blank;
 
       function Index_Non_Blank
-        (Source : in Bounded_String;
-         Going  : in Direction := Forward)
-         return   Natural
-        renames Super_Index_Non_Blank;
+        (Source : Bounded_String;
+         From   : Positive;
+         Going  : Direction := Forward) return Natural
+         renames Super_Index_Non_Blank;
 
       function Count
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Mapping : in Maps.Character_Mapping := Maps.Identity)
-         return    Natural
-        renames Super_Count;
+        (Source  : Bounded_String;
+         Pattern : String;
+         Mapping : Maps.Character_Mapping := Maps.Identity) return Natural
+         renames Super_Count;
 
       function Count
-        (Source  : in Bounded_String;
-         Pattern : in String;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Natural
-        renames Super_Count;
+        (Source  : Bounded_String;
+         Pattern : String;
+         Mapping : Maps.Character_Mapping_Function) return Natural
+         renames Super_Count;
 
       function Count
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set)
-         return   Natural
-        renames Super_Count;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set) return Natural
+         renames Super_Count;
 
       procedure Find_Token
-        (Source : in Bounded_String;
-         Set    : in Maps.Character_Set;
-         Test   : in Membership;
+        (Source : Bounded_String;
+         Set    : Maps.Character_Set;
+         Test   : Membership;
          First  : out Positive;
          Last   : out Natural)
-        renames Super_Find_Token;
+         renames Super_Find_Token;
 
       function Translate
-        (Source   : in Bounded_String;
-         Mapping  : in Maps.Character_Mapping)
-         return     Bounded_String
-        renames Super_Translate;
+        (Source  : Bounded_String;
+         Mapping : Maps.Character_Mapping) return Bounded_String
+         renames Super_Translate;
 
       procedure Translate
         (Source   : in out Bounded_String;
-         Mapping  : in Maps.Character_Mapping)
-        renames Super_Translate;
+         Mapping  : Maps.Character_Mapping)
+         renames Super_Translate;
 
       function Translate
-        (Source  : in Bounded_String;
-         Mapping : in Maps.Character_Mapping_Function)
-         return    Bounded_String
-        renames Super_Translate;
+        (Source  : Bounded_String;
+         Mapping : Maps.Character_Mapping_Function) return Bounded_String
+         renames Super_Translate;
 
       procedure Translate
         (Source  : in out Bounded_String;
-         Mapping : in Maps.Character_Mapping_Function)
-        renames Super_Translate;
+         Mapping : Maps.Character_Mapping_Function)
+         renames Super_Translate;
 
       function Replace_Slice
-        (Source   : in Bounded_String;
-         Low      : in Positive;
-         High     : in Natural;
-         By       : in String;
-         Drop     : in Truncation := Error)
-         return     Bounded_String
-        renames Super_Replace_Slice;
+        (Source : Bounded_String;
+         Low    : Positive;
+         High   : Natural;
+         By     : String;
+         Drop   : Truncation := Error) return Bounded_String
+         renames Super_Replace_Slice;
 
       procedure Replace_Slice
         (Source   : in out Bounded_String;
-         Low      : in Positive;
-         High     : in Natural;
-         By       : in String;
-         Drop     : in Truncation := Error)
-        renames Super_Replace_Slice;
+         Low      : Positive;
+         High     : Natural;
+         By       : String;
+         Drop     : Truncation := Error)
+         renames Super_Replace_Slice;
 
       function Insert
-        (Source   : in Bounded_String;
-         Before   : in Positive;
-         New_Item : in String;
-         Drop     : in Truncation := Error)
-         return     Bounded_String
-        renames Super_Insert;
+        (Source   : Bounded_String;
+         Before   : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error) return Bounded_String
+         renames Super_Insert;
 
       procedure Insert
         (Source   : in out Bounded_String;
-         Before   : in Positive;
-         New_Item : in String;
-         Drop     : in Truncation := Error)
-        renames Super_Insert;
+         Before   : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error)
+         renames Super_Insert;
 
       function Overwrite
-        (Source    : in Bounded_String;
-         Position  : in Positive;
-         New_Item  : in String;
-         Drop      : in Truncation := Error)
-         return      Bounded_String
-        renames Super_Overwrite;
+        (Source   : Bounded_String;
+         Position : Positive;
+         New_Item : String;
+         Drop     : Truncation := Error) return Bounded_String
+         renames Super_Overwrite;
 
       procedure Overwrite
         (Source    : in out Bounded_String;
-         Position  : in Positive;
-         New_Item  : in String;
-         Drop      : in Truncation := Error)
-        renames Super_Overwrite;
+         Position  : Positive;
+         New_Item  : String;
+         Drop      : Truncation := Error)
+         renames Super_Overwrite;
 
       function Delete
-        (Source  : in Bounded_String;
-         From    : in Positive;
-         Through : in Natural)
-         return    Bounded_String
-        renames Super_Delete;
+        (Source  : Bounded_String;
+         From    : Positive;
+         Through : Natural) return Bounded_String
+         renames Super_Delete;
 
       procedure Delete
         (Source  : in out Bounded_String;
-         From    : in Positive;
-         Through : in Natural)
-        renames Super_Delete;
+         From    : Positive;
+         Through : Natural)
+         renames Super_Delete;
 
       function Trim
-        (Source : in Bounded_String;
-         Side   : in Trim_End)
-         return   Bounded_String
-        renames Super_Trim;
+        (Source : Bounded_String;
+         Side   : Trim_End) return Bounded_String
+         renames Super_Trim;
 
       procedure Trim
         (Source : in out Bounded_String;
-         Side   : in Trim_End)
-        renames Super_Trim;
+         Side   : Trim_End)
+         renames Super_Trim;
 
       function Trim
-        (Source  : in Bounded_String;
-          Left   : in Maps.Character_Set;
-          Right  : in Maps.Character_Set)
-          return   Bounded_String
-        renames Super_Trim;
+        (Source : Bounded_String;
+         Left   : Maps.Character_Set;
+         Right  : Maps.Character_Set) return Bounded_String
+         renames Super_Trim;
 
       procedure Trim
         (Source : in out Bounded_String;
-         Left   : in Maps.Character_Set;
-         Right  : in Maps.Character_Set)
-        renames Super_Trim;
+         Left   : Maps.Character_Set;
+         Right  : Maps.Character_Set)
+         renames Super_Trim;
 
       function Head
-        (Source : in Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character := Space;
-         Drop   : in Truncation := Error)
-         return   Bounded_String
-        renames Super_Head;
+        (Source : Bounded_String;
+         Count  : Natural;
+         Pad    : Character := Space;
+         Drop   : Truncation := Error) return Bounded_String
+         renames Super_Head;
 
       procedure Head
         (Source : in out Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error)
-        renames Super_Head;
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error)
+         renames Super_Head;
 
       function Tail
-        (Source : in Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error)
-         return Bounded_String
-        renames Super_Tail;
+        (Source : Bounded_String;
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error) return Bounded_String
+         renames Super_Tail;
 
       procedure Tail
         (Source : in out Bounded_String;
-         Count  : in Natural;
-         Pad    : in Character  := Space;
-         Drop   : in Truncation := Error)
-        renames Super_Tail;
+         Count  : Natural;
+         Pad    : Character  := Space;
+         Drop   : Truncation := Error)
+         renames Super_Tail;
 
       function "*"
-        (Left  : in Natural;
-         Right : in Bounded_String)
-         return  Bounded_String
-        renames Times;
+        (Left  : Natural;
+         Right : Bounded_String) return Bounded_String
+         renames Times;
 
       function Replicate
-        (Count : in Natural;
-         Item  : in Bounded_String;
-         Drop  : in Truncation := Error)
-         return  Bounded_String
+        (Count : Natural;
+         Item  : Bounded_String;
+         Drop  : Truncation := Error) return Bounded_String
          renames Super_Replicate;
 
    end Generic_Bounded_Length;