--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gcc/ada/libgnat/g-rewdat.ads	Fri Oct 27 22:46:09 2017 +0900
@@ -0,0 +1,152 @@
+------------------------------------------------------------------------------
+--                         GNAT COMPILER COMPONENTS                         --
+--                                                                          --
+--                     G N A T . R E W R I T E _ D A T A                    --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--           Copyright (C) 2014-2017, 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- --
+-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
+-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
+-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
+-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
+--                                                                          --
+-- As a special exception under Section 7 of GPL version 3, you are granted --
+-- additional permissions described in the GCC Runtime Library Exception,   --
+-- version 3.1, as published by the Free Software Foundation.               --
+--                                                                          --
+-- You should have received a copy of the GNU General Public License and    --
+-- a copy of the GCC Runtime Library Exception along with this program;     --
+-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
+-- <http://www.gnu.org/licenses/>.                                          --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This package can be used to rewrite data on the fly. All occurrences of a
+--  string (named pattern) will be replaced by another string.
+
+--  It is not necessary to load all data in memory and so this package can be
+--  used for large data chunks like disk files for example. The pattern is
+--  a standard string and not a regular expression.
+
+--  There is no dynamic allocation in the implementation.
+
+--  For example, to replace all occurrences of "Gnat" with "GNAT":
+
+--    Rewriter : Buffer := Create (Pattern => "Gnat", Value => "GNAT");
+
+--  The output procedure that will receive the rewritten data:
+
+--    procedure Do (Data : Stream_Element_Array) is
+--    begin
+--       <implementation to handle Data>
+--    end Do;
+
+--  Then:
+
+--    Write (Rewriter, "Let's talk about Gnat compiler", Do'Access);
+--    Write (Rewriter, "Gnat is an Ada compiler", Do'Access);
+--    Flush (Rewriter, Do'Access);
+
+--  Another possible usage is to specify a method to get the input data:
+
+--    procedure Get
+--      (Buffer : out Stream_Element_Array;
+--       Last   : out Stream_Element_Offset)
+--    is
+--    begin
+--       <get some data from a file, a socket, etc...>
+--       Last := ...
+--       Buffer := ...
+--    end Get;
+
+--  Then we can rewrite the whole file with:
+
+--    Rewrite (Rewriter, Input => Get'Access, Output => Do'Access);
+
+with Ada.Streams; use Ada.Streams;
+
+package GNAT.Rewrite_Data is
+
+   type Buffer (<>) is limited private;
+   type Buffer_Ref is access all Buffer;
+
+   function Create
+     (Pattern, Value : String;
+      Size           : Stream_Element_Offset := 1_024) return Buffer;
+   --  Create a rewrite buffer. Pattern is the string to be rewritten as Value.
+   --  Size represents the size of the internal buffer used to store the data
+   --  ready to be output. A larger buffer may improve the performance, as the
+   --  Output routine (see Write, Rewrite below) will be called only when this
+   --  buffer is full. Note that Size cannot be lower than Pattern'Length, and
+   --  if this is the case, then Size value is set to Pattern'Length.
+
+   function Size (B : Buffer) return Natural;
+   --  Returns the current size of the buffer (count of Stream_Array_Element)
+
+   procedure Flush
+     (B      : in out Buffer;
+      Output : not null access procedure (Data : Stream_Element_Array));
+   --  Call Output for all remaining data in the buffer. The buffer is
+   --  reset and ready for another use after this call.
+
+   procedure Reset (B : in out Buffer);
+   pragma Inline (Reset);
+   --  Clear all data in buffer, B is ready for another use. Note that this is
+   --  not needed after a Flush. Note: all data remaining in Buffer is lost.
+
+   procedure Write
+     (B      : in out Buffer;
+      Data   : Stream_Element_Array;
+      Output : not null access procedure (Data : Stream_Element_Array));
+   --  Write Data into the buffer, call Output for any prepared data. Flush
+   --  must be called when the last piece of Data as been sent in the Buffer.
+
+   procedure Rewrite
+     (B      : in out Buffer;
+      Input  : not null access procedure
+                          (Buffer : out Stream_Element_Array;
+                           Last   : out Stream_Element_Offset);
+      Output : not null access procedure (Data : Stream_Element_Array));
+   --  Read data from Input, rewrite it, and then call Output. When there is
+   --  no more data to be read from Input, Last must be set to 0. Before
+   --  leaving this routine, call Flush above to send all remaining data to
+   --  Output.
+
+   procedure Link (From : in out Buffer; To : Buffer_Ref);
+   --  Link two rewrite buffers. That is, all data sent to From buffer will be
+   --  rewritten and then passed to the To rewrite buffer.
+
+private
+
+   type Buffer
+     (Size, Size_Pattern, Size_Value : Stream_Element_Offset) is
+   limited record
+      Pos_C : Stream_Element_Offset; -- last valid element in Current
+      Pos_B : Stream_Element_Offset; -- last valid element in Buffer
+
+      Next  : Buffer_Ref;
+      --  A link to another rewriter if any
+
+      Buffer : Stream_Element_Array (1 .. Size);
+      --  Fully prepared/rewritten data waiting to be output
+
+      Current : Stream_Element_Array (1 .. Size_Pattern);
+      --  Current data checked, this buffer contains every piece of data
+      --  starting with the pattern. It means that at any point:
+      --  Current (1 .. Pos_C) = Pattern (1 .. Pos_C).
+
+      Pattern : Stream_Element_Array (1 .. Size_Pattern);
+      --  The pattern to look for
+
+      Value : Stream_Element_Array (1 .. Size_Value);
+      --  The value the pattern is replaced by
+   end record;
+
+end GNAT.Rewrite_Data;