ada: INOX: prototype RFC on String Interpolation

This patch incorporates a prototype for a new string literal syntax
which supports the use of "string interpolation," where the names
of variables or expressions can be used directly within the string
literal, such that the value of the variable or the expression is
"interpolated" directly into the value of the enclosing string
upon use at run-time.

gcc/ada/

	* scans.ads (Tok_Left_Curly_Bracket, Tok_Right_Curly_Bracket)
	(Tok_Left_Interpolated_String): Placed in no category since they
	don't fit well in the existing categories. Fix typo in comment.
	(Inside_Interpolated_String_Literal): New scan state variable.
	* scng.adb (Slit): Scan interpolated string literals,
	continuations of interpolated string literals and escaped
	characters found in interpolated string literals.
	(Scan): Handle consecutive interpolated expressions. Handle ending
	delimiter placed immediately after an interpolated expression.
	Handle string literal placed after interpolated expression. Handle
	left and right curly brackets; when extensions are not allowed
	they are treated as left and right paren; when extensions are
	allowed they are handled as delimiters of interpolated string
	literals.
	* sinfo.ads (N_Interpolated_String_Literal): New node.
	* gen_il-gen-gen_nodes.adb (N_Interpolated_String_Literal): Define
	N_String_Literal node.
	* gen_il-types.ads (Opt_Type_Enum): Define N_String_Literal as
	concrete node type.
	* par-ch2.adb (P_Interpolated_String_Literal): New subprogram.
	* par-ch4.adb (P_Simple_Expression): Handle '}' as expression
	terminator when scanning an interpolated expression; disable error
	recovery machinery for binary operator when we are processing an
	interpolated string literal and reach the expression terminator
	'}'.
	(P_Primary): Call P_Interpolated_String_Literal when the opening
	interpolated-string-literal delimiter is found (that is, the left
	curly bracket '{').
	* par-tchk.adb (T_Right_Curly_Bracket): New subprogram.
	* par.adb (P_Interpolated_String_Literal): New declaration.
	(T_Right_Curly_Bracket): New declaration.
	* sem.adb (Analyze): Call Analyze_Interpolated_String_Literal.
	* sem_ch2.ads (Analyze_Interpolated_String_Literal): New
	subprogram
	* sem_ch2.adb (Analyze_Interpolated_String_Literal): Likewise.
	* sem_util.adb (Is_User_Defined_Literal): Complete mapping of
	literal aspects adding that interpolated string literals have no
	correspondence with any aspect.
	* sem_res.adb (Resolve_Interpolated_String_Literal): New
	subprogram.
	(Has_Applicable_User_Defined_Literal): Complete mapping of literal
	aspects adding that interpolated string literals have no
	correspondency with any aspect.
	* expander.adb (Expand): Add call to
	Expand_N_Interpolated_String_Literal.
	* exp_util.adb (Insert_Actions): Handle
	N_Interpolated_String_Literal nodes; that is, continue climbing.
	* exp_ch2.ads (Expand_N_Interpolated_String_Literal): New
	subprogram.
	* exp_ch2.adb (Expand_N_Interpolated_String_Literal): Likewise.
	* exp_put_image.adb (Build_Elementary_Put_Image_Call): Add missing
	conversion to force dispatching call. Required to handle calls to
	descendants.
	(Build_String_Put_Image_Call): Do not output string delimiters
	when the put_image call is part of an interpolated string literal.
	* rtsfind.ads (RTU_Id): Add RE_Set_Trim_Leading_Spaces.
	* sprint.adb (Sprint_Node): Output interpolated string contents.
	* libgnat/a-stbubo.adb (Get_UTF_8): Add default value for
	Trim_Leading_White_Spaces component in aggregate.
	(Buffer_Type_Implementation): Update Trim_Leading_White_Spaces.
	* libgnat/a-stbuun.adb (Get_UTF_8): Likewise.
	(Buffer_Type_Implementation): Likewise.
	* libgnat/a-sttebu.ads (Set_Trim_Leading_Spaces): New subprogram.
	(Trim_Leading_Spaces): New subprogram.
	(Root_Buffer_Type): Adding Trim_Leading_While_Spaces component.
	* libgnat/a-sttebu.adb (procedure Set_Trim_Leading_Spaces): New
	subprogram.
	(Trim_Leading_Space): New subprogram.
	(Put_UTF_8): Handle Trim_Leading_White_Spaces.
	(New_Line): Likewise.
	* libgnat/s-putima.ads (Put_Image_String): Adding formal
	(with_delimiters).
	(Put_Image_Wide_String): Likewise.
	(Put_Image_Wide_Wide_String): Likewise.
	* libgnat/s-putima.adb (Put_Image_String): Adding support for new
	formal.
	(Put_Image_Wide_String): Likewise.
	(Put_Image_Wide_Wide_String): Likewise.

1 files changed, 44 insertions, 24 deletions

diff --git a/gcc/ada/libgnat/a-stbuun.adb b/gcc/ada/libgnat/a-stbuun.adb
index eabcad1..54449fb 100644
--- a/gcc/ada/libgnat/a-stbuun.adb
+++ b/gcc/ada/libgnat/a-stbuun.adb
@@ -29,6 +29,7 @@
 --                                                                          --
 ------------------------------------------------------------------------------
 
+with Ada.Characters.Handling;
 with Ada.Unchecked_Deallocation;
 with Ada.Strings.UTF_Encoding.Conversions;
 with Ada.Strings.UTF_Encoding.Strings;
@@ -104,9 +105,15 @@ package body Ada.Strings.Text_Buffers.Unbounded is
             --  forget to add corresponding assignment statement below.
             Dummy : array (1 .. 0) of Buffer_Type :=
               [others =>
-                 (Indentation  => <>, Indent_Pending => <>, UTF_8_Length => <>,
-                  UTF_8_Column => <>, All_7_Bits => <>, All_8_Bits => <>,
-                  List         => <>, Last_Used => <>)];
+                 (Indentation               => <>,
+                  Indent_Pending            => <>,
+                  UTF_8_Length              => <>,
+                  UTF_8_Column              => <>,
+                  All_7_Bits                => <>,
+                  All_8_Bits                => <>,
+                  Trim_Leading_White_Spaces => <>,
+                  List                      => <>,
+                  Last_Used                 => <>)];
          begin
             Buffer.Indentation    := Defaulted.Indentation;
             Buffer.Indent_Pending := Defaulted.Indent_Pending;
@@ -140,28 +147,41 @@ package body Ada.Strings.Text_Buffers.Unbounded is
       procedure Buffer_Type_Implementation (Buffer : in out Buffer_Type) is
       begin
          for Char of Item loop
-            Buffer.All_7_Bits := @ and then Character'Pos (Char) < 128;
-
-            if Buffer.Last_Used = Buffer.List.Current_Chunk.Length then
-               --  Current chunk is full; allocate a new one with doubled size
-
-               declare
-                  Cc     : Chunk renames Buffer.List.Current_Chunk.all;
-                  Max    : constant Positive := Integer'Last / 2;
-                  Length : constant Natural  :=
-                    Integer'Min (Max, 2 * Cc.Length);
-               begin
-                  pragma Assert (Cc.Next = null);
-                  Cc.Next                   := new Chunk (Length => Length);
-                  Buffer.List.Current_Chunk := Cc.Next;
-                  Buffer.Last_Used          := 0;
-               end;
-            end if;
 
-            Buffer.UTF_8_Length                                := @ + 1;
-            Buffer.UTF_8_Column                                := @ + 1;
-            Buffer.Last_Used                                   := @ + 1;
-            Buffer.List.Current_Chunk.Chars (Buffer.Last_Used) := Char;
+            --  The Trim_Leading_Space flag, which can be set prior to calling
+            --  any of the Put operations, which will cause white space
+            --  characters to be discarded by any Put operation until a
+            --  non-white-space character is encountered, at which point
+            --  the flag will be reset.
+
+            if not Buffer.Trim_Leading_White_Spaces
+              or else not Characters.Handling.Is_Space (Char)
+            then
+               Buffer.All_7_Bits := @ and then Character'Pos (Char) < 128;
+               Buffer.Trim_Leading_White_Spaces := False;
+
+               if Buffer.Last_Used = Buffer.List.Current_Chunk.Length then
+                  --  Current chunk is full; allocate a new one with doubled
+                  --  size
+
+                  declare
+                     Cc     : Chunk renames Buffer.List.Current_Chunk.all;
+                     Max    : constant Positive := Integer'Last / 2;
+                     Length : constant Natural  :=
+                                Integer'Min (Max, 2 * Cc.Length);
+                  begin
+                     pragma Assert (Cc.Next = null);
+                     Cc.Next                   := new Chunk (Length => Length);
+                     Buffer.List.Current_Chunk := Cc.Next;
+                     Buffer.Last_Used          := 0;
+                  end;
+               end if;
+
+               Buffer.UTF_8_Length                                := @ + 1;
+               Buffer.UTF_8_Column                                := @ + 1;
+               Buffer.Last_Used                                   := @ + 1;
+               Buffer.List.Current_Chunk.Chars (Buffer.Last_Used) := Char;
+            end if;
          end loop;
       end Buffer_Type_Implementation;
    begin