[multiple changes]

2010-06-23  Thomas Quinot  <quinot@adacore.com>

	* exp_attr.adb (Expand_Access_To_Protected_Op): When rewriting a
	reference to a protected subprogram outside of the protected's scope,
	ensure the corresponding external subprogram is frozen before the
	reference.

2010-06-23  Ed Schonberg  <schonberg@adacore.com>

	* sem_prag.adb: Fix typo in error message.
	* sem.adb: Refine previous change.

2010-06-23  Robert Dewar  <dewar@adacore.com>

	* impunit.adb, a-suewen.adb, a-suewen.ads, a-suenco.adb, a-suenco.ads,
	a-suezen.adb, a-suezen.ads, a-stuten.adb, a-stuten.ads, Makefile.rtl:
	Implement Ada 2012 string encoding packages.

2010-06-23  Arnaud Charlet  <charlet@adacore.com>

	* a-stwiun-shared.adb, a-stwiun-shared.ads, a-stzunb-shared.adb,
	a-stzunb-shared.ads, a-swunau-shared.adb, a-swuwti-shared.adb,
	a-szunau-shared.adb, a-szuzti-shared.adb: New files.
	* gcc-interface/Makefile.in: Enable use of above files.

From-SVN: r161277

gcc/ada/Makefile.rtl

@@ -226,6 +226,9 @@ GNATRTL_NONTASKING_OBJS= \
   a-stzsea$(objext) \
   a-stzsup$(objext) \
   a-stzunb$(objext) \
+  a-suenco$(objext) \
+  a-suewen$(objext) \
+  a-suezen$(objext) \
   a-suteio$(objext) \
   a-swbwha$(objext) \
   a-swfwha$(objext) \

gcc/ada/a-suenco.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                   ADA.STRINGS.UTF_ENCODING.CONVERSIONS                   --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This is an Ada 2012 package defined in AI05-0137-1. It provides conversions
+--  from one UTF encoding method to another. Note: this package is consistent
+--  with Ada 95, and may be used in Ada 95 or Ada 2005 mode.
+
+package Ada.Strings.UTF_Encoding.Conversions is
+   pragma Pure (Conversions);
+
+   --  In the following conversion routines, a BOM in the input that matches
+   --  the encoding scheme is ignored, an incorrect BOM causes Encoding_Error
+   --  to be raised. A BOM is present in the output if the Output_BOM parameter
+   --  is set to True.
+
+   function Convert
+     (Item          : UTF_String;
+      Input_Scheme  : Encoding_Scheme;
+      Output_Scheme : Encoding_Scheme;
+      Output_BOM    : Boolean := False) return UTF_String;
+   --  Convert from input encoded in UTF-8, UTF-16LE, or UTF-16BE as specified
+   --  by the Input_Scheme argument, and generate an output encoded in one of
+   --  these three schemes as specified by the Output_Scheme argument.
+
+   function Convert
+     (Item          : UTF_String;
+      Input_Scheme  : Encoding_Scheme;
+      Output_BOM    : Boolean := False) return UTF_16_Wide_String;
+   --  Convert from input encoded in UTF-8, UTF-16LE, or UTF-16BE as specified
+   --  by the Input_Scheme argument, and generate an output encoded in UTF-16.
+
+   function Convert
+     (Item          : UTF_8_String;
+      Output_BOM    : Boolean := False) return UTF_16_Wide_String;
+   --  Convert from UTF-8 to UTF-16
+
+   function Convert
+     (Item          : UTF_16_Wide_String;
+      Output_Scheme : Encoding_Scheme;
+      Output_BOM    : Boolean := False) return UTF_String;
+   --  Convert from UTF-16 to UTF-8, UTF-16LE, or UTF-16BE as specified by
+   --  the Output_Scheme argument.
+
+   function Convert
+     (Item          : UTF_16_Wide_String;
+      Output_BOM    : Boolean := False) return UTF_8_String;
+   --  Convert from UTF-16 to UTF-8
+
+end Ada.Strings.UTF_Encoding.Conversions;

gcc/ada/a-suewen.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                  ADA.STRINGS.UTF_ENCODING.WIDE_ENCODING                  --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This is an Ada 2012 package defined in AI05-0137-1. It is used for encoding
+--  and decoding Wide_String values using UTF encodings. Note: this package is
+--  consistent with Ada 95, and may be included in Ada 95 implementations.
+
+package Ada.Strings.UTF_Encoding.Wide_Encoding is
+   pragma Pure (Wide_Encoding);
+
+   --  The encoding routines take a Wide_String as input and encode the result
+   --  using the specified UTF encoding method. The result includes a BOM if
+   --  the Output_BOM argument is set to True. Encoding_Error is raised if an
+   --  invalid character appears in the input. In particular the characters
+   --  in the range 16#D800# .. 16#DFFF# are invalid because they conflict
+   --  with UTF-16 surrogate encodings, and the characters 16#FFFE# and
+   --  16#FFFF# are also invalid because they conflict with BOM codes.
+
+   function Encode
+     (Item          : Wide_String;
+      Output_Scheme : Encoding_Scheme;
+      Output_BOM    : Boolean  := False) return UTF_String;
+   --  Encode Wide_String using UTF-8, UTF-16LE or UTF-16BE encoding as
+   --  specified by the Output_Scheme parameter.
+
+   function Encode
+     (Item       : Wide_String;
+      Output_BOM : Boolean  := False) return UTF_8_String;
+   --  Encode Wide_String using UTF-8 encoding
+
+   function Encode
+     (Item       : Wide_String;
+      Output_BOM : Boolean  := False) return UTF_16_Wide_String;
+   --  Encode Wide_String using UTF_16 encoding
+
+   --  The decoding routines take a UTF String as input, and return a decoded
+   --  Wide_String. If the UTF String starts with a BOM that matches the
+   --  encoding method, it is ignored. An incorrect BOM raises Encoding_Error.
+
+   function Decode
+     (Item         : UTF_String;
+      Input_Scheme : Encoding_Scheme) return Wide_String;
+   --  The input is encoded in UTF_8, UTF_16LE or UTF_16BE as specified by the
+   --  Input_Scheme parameter. It is decoded and returned as a Wide_String
+   --  value. Note: a convenient form for scheme may be Encoding (UTF_String).
+
+   function Decode
+     (Item : UTF_8_String) return Wide_String;
+   --  The input is encoded in UTF-8 and returned as a Wide_String value
+
+   function Decode
+     (Item : UTF_16_Wide_String) return Wide_String;
+   --  The input is encoded in UTF-16 and returned as a Wide_String value
+
+end Ada.Strings.UTF_Encoding.Wide_Encoding;

gcc/ada/a-suezen.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                ADA.STRINGS.UTF_ENCODING.WIDE_WIDE_ENCODING               --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This is an Ada 2012 package defined in AI05-0137-1. It is used for encoding
+--  and decoding Wide_String values using UTF encodings. Note: this package is
+--  consistent with Ada 2005, and may be used in Ada 2005 mode, but cannot be
+--  used in Ada 95 mode, since Wide_Wide_Character is an Ada 2005 feature.
+
+package Ada.Strings.UTF_Encoding.Wide_Wide_Encoding is
+   pragma Pure (Wide_Wide_Encoding);
+
+   --  The encoding routines take a Wide_Wide_String as input and encode the
+   --  result using the specified UTF encoding method. The result includes a
+   --  BOM if the Output_BOM parameter is set to True.
+
+   function Encode
+     (Item          : Wide_Wide_String;
+      Output_Scheme : Encoding_Scheme;
+      Output_BOM    : Boolean  := False) return UTF_String;
+   --  Encode Wide_Wide_String using UTF-8, UTF-16LE or UTF-16BE encoding as
+   --  specified by the Output_Scheme parameter.
+
+   function Encode
+     (Item       : Wide_Wide_String;
+      Output_BOM : Boolean  := False) return UTF_8_String;
+   --  Encode Wide_Wide_String using UTF-8 encoding
+
+   function Encode
+     (Item       : Wide_Wide_String;
+      Output_BOM : Boolean  := False) return UTF_16_Wide_String;
+   --  Encode Wide_Wide_String using UTF_16 encoding
+
+   --  The decoding routines take a UTF String as input, and return a decoded
+   --  Wide_String. If the UTF String starts with a BOM that matches the
+   --  encoding method, it is ignored. An incorrect BOM raises Encoding_Error.
+
+   function Decode
+     (Item         : UTF_String;
+      Input_Scheme : Encoding_Scheme) return Wide_Wide_String;
+   --  The input is encoded in UTF_8, UTF_16LE or UTF_16BE as specified by the
+   --  Input_Scheme parameter. It is decoded and returned as a Wide_Wide_String
+   --  value. Note: a convenient form for Scheme may be Encoding (UTF_String).
+
+   function Decode
+     (Item : UTF_8_String) return Wide_Wide_String;
+   --  The input is encoded in UTF-8 and returned as a Wide_Wide_String value
+
+   function Decode
+     (Item : UTF_16_Wide_String) return Wide_Wide_String;
+   --  The input is encoded in UTF-16 and returned as a Wide_String value
+
+end Ada.Strings.UTF_Encoding.Wide_Wide_Encoding;

gcc/ada/a-swunau-shared.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                          GNAT RUN-TIME COMPONENTS                        --
+--                                                                          --
+--        A D A . S T R I N G S . W I D E _ U N B O U N D E D . A U X       --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--          Copyright (C) 1992-2009, 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, USA.                                              --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+package body Ada.Strings.Wide_Unbounded.Aux is
+
+   ---------------------
+   -- Get_Wide_String --
+   ---------------------
+
+   procedure Get_Wide_String
+     (U : Unbounded_Wide_String;
+      S : out Big_Wide_String_Access;
+      L : out Natural)
+   is
+      X : aliased Big_Wide_String;
+      for X'Address use U.Reference.Data'Address;
+   begin
+      S := X'Unchecked_Access;
+      L := U.Reference.Last;
+   end Get_Wide_String;
+
+   ---------------------
+   -- Set_Wide_String --
+   ---------------------
+
+   procedure Set_Wide_String
+     (UP : in out Unbounded_Wide_String;
+      S  : Wide_String_Access)
+   is
+      X : Wide_String_Access := S;
+
+   begin
+      Set_Unbounded_Wide_String (UP, S.all);
+      Free (X);
+   end Set_Wide_String;
+
+end Ada.Strings.Wide_Unbounded.Aux;

gcc/ada/a-swuwti-shared.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                  ADA.STRINGS.WIDE_UNBOUNDED.WIDE_TEXT_IO                 --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--          Copyright (C) 1997-2009, 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, USA.                                              --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Text_IO; use Ada.Wide_Text_IO;
+
+package body Ada.Strings.Wide_Unbounded.Wide_Text_IO is
+
+   --------------
+   -- Get_Line --
+   --------------
+
+   function Get_Line return Unbounded_Wide_String is
+      Buffer : Wide_String (1 .. 1000);
+      Last   : Natural;
+      Result : Unbounded_Wide_String;
+
+   begin
+      Get_Line (Buffer, Last);
+      Set_Unbounded_Wide_String (Result, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (Buffer, Last);
+         Append (Result, Buffer (1 .. Last));
+      end loop;
+
+      return Result;
+   end Get_Line;
+
+   function Get_Line
+     (File : Ada.Wide_Text_IO.File_Type) return Unbounded_Wide_String
+   is
+      Buffer : Wide_String (1 .. 1000);
+      Last   : Natural;
+      Result : Unbounded_Wide_String;
+
+   begin
+      Get_Line (File, Buffer, Last);
+      Set_Unbounded_Wide_String (Result, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (File, Buffer, Last);
+         Append (Result, Buffer (1 .. Last));
+      end loop;
+
+      return Result;
+   end Get_Line;
+
+   procedure Get_Line (Item : out Unbounded_Wide_String) is
+   begin
+      Get_Line (Current_Input, Item);
+   end Get_Line;
+
+   procedure Get_Line
+     (File : Ada.Wide_Text_IO.File_Type;
+      Item : out Unbounded_Wide_String)
+   is
+      Buffer : Wide_String (1 .. 1000);
+      Last   : Natural;
+
+   begin
+      Get_Line (File, Buffer, Last);
+      Set_Unbounded_Wide_String (Item, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (File, Buffer, Last);
+         Append (Item, Buffer (1 .. Last));
+      end loop;
+   end Get_Line;
+
+   ---------
+   -- Put --
+   ---------
+
+   procedure Put (U : Unbounded_Wide_String) is
+      UR : constant Shared_Wide_String_Access := U.Reference;
+
+   begin
+      Put (UR.Data (1 .. UR.Last));
+   end Put;
+
+   procedure Put (File : File_Type; U : Unbounded_Wide_String) is
+      UR : constant Shared_Wide_String_Access := U.Reference;
+
+   begin
+      Put (File, UR.Data (1 .. UR.Last));
+   end Put;
+
+   --------------
+   -- Put_Line --
+   --------------
+
+   procedure Put_Line (U : Unbounded_Wide_String) is
+      UR : constant Shared_Wide_String_Access := U.Reference;
+
+   begin
+      Put_Line (UR.Data (1 .. UR.Last));
+   end Put_Line;
+
+   procedure Put_Line (File : File_Type; U : Unbounded_Wide_String) is
+      UR : constant Shared_Wide_String_Access := U.Reference;
+
+   begin
+      Put_Line (File, UR.Data (1 .. UR.Last));
+   end Put_Line;
+
+end Ada.Strings.Wide_Unbounded.Wide_Text_IO;

gcc/ada/a-szunau-shared.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                          GNAT RUN-TIME COMPONENTS                        --
+--                                                                          --
+--   A D A . S T R I N G S . W I D E _ W I D E _ U N B O U N D E D . A U X  --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--          Copyright (C) 1992-2009, 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, USA.                                              --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+package body Ada.Strings.Wide_Wide_Unbounded.Aux is
+
+   --------------------------
+   -- Get_Wide_Wide_String --
+   --------------------------
+
+   procedure Get_Wide_Wide_String
+     (U : Unbounded_Wide_Wide_String;
+      S : out Big_Wide_Wide_String_Access;
+      L : out Natural)
+   is
+      X : aliased Big_Wide_Wide_String;
+      for X'Address use U.Reference.Data'Address;
+   begin
+      S := X'Unchecked_Access;
+      L := U.Reference.Last;
+   end Get_Wide_Wide_String;
+
+   --------------------------
+   -- Set_Wide_Wide_String --
+   --------------------------
+
+   procedure Set_Wide_Wide_String
+     (UP : in out Unbounded_Wide_Wide_String;
+      S  : Wide_Wide_String_Access)
+   is
+      X : Wide_Wide_String_Access := S;
+
+   begin
+      Set_Unbounded_Wide_Wide_String (UP, S.all);
+      Free (X);
+   end Set_Wide_Wide_String;
+
+end Ada.Strings.Wide_Wide_Unbounded.Aux;

gcc/ada/a-szuzti-shared.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUN-TIME COMPONENTS                         --
+--                                                                          --
+--                  ADA.STRINGS.WIDE_UNBOUNDED.WIDE_TEXT_IO                 --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--          Copyright (C) 1997-2009, 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, USA.                                              --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- GNAT was originally developed  by the GNAT team at  New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO; use Ada.Wide_Wide_Text_IO;
+
+package body Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO is
+
+   --------------
+   -- Get_Line --
+   --------------
+
+   function Get_Line return Unbounded_Wide_Wide_String is
+      Buffer : Wide_Wide_String (1 .. 1000);
+      Last   : Natural;
+      Result : Unbounded_Wide_Wide_String;
+
+   begin
+      Get_Line (Buffer, Last);
+      Set_Unbounded_Wide_Wide_String (Result, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (Buffer, Last);
+         Append (Result, Buffer (1 .. Last));
+      end loop;
+
+      return Result;
+   end Get_Line;
+
+   function Get_Line
+     (File : Ada.Wide_Wide_Text_IO.File_Type)
+      return Unbounded_Wide_Wide_String
+   is
+      Buffer : Wide_Wide_String (1 .. 1000);
+      Last   : Natural;
+      Result : Unbounded_Wide_Wide_String;
+
+   begin
+      Get_Line (File, Buffer, Last);
+      Set_Unbounded_Wide_Wide_String (Result, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (File, Buffer, Last);
+         Append (Result, Buffer (1 .. Last));
+      end loop;
+
+      return Result;
+   end Get_Line;
+
+   procedure Get_Line (Item : out Unbounded_Wide_Wide_String) is
+   begin
+      Get_Line (Current_Input, Item);
+   end Get_Line;
+
+   procedure Get_Line
+     (File : Ada.Wide_Wide_Text_IO.File_Type;
+      Item : out Unbounded_Wide_Wide_String)
+   is
+      Buffer : Wide_Wide_String (1 .. 1000);
+      Last   : Natural;
+
+   begin
+      Get_Line (File, Buffer, Last);
+      Set_Unbounded_Wide_Wide_String (Item, Buffer (1 .. Last));
+
+      while Last = Buffer'Last loop
+         Get_Line (File, Buffer, Last);
+         Append (Item, Buffer (1 .. Last));
+      end loop;
+   end Get_Line;
+
+   ---------
+   -- Put --
+   ---------
+
+   procedure Put (U : Unbounded_Wide_Wide_String) is
+      UR : constant Shared_Wide_Wide_String_Access := U.Reference;
+
+   begin
+      Put (UR.Data (1 .. UR.Last));
+   end Put;
+
+   procedure Put (File : File_Type; U : Unbounded_Wide_Wide_String) is
+      UR : constant Shared_Wide_Wide_String_Access := U.Reference;
+
+   begin
+      Put (File, UR.Data (1 .. UR.Last));
+   end Put;
+
+   --------------
+   -- Put_Line --
+   --------------
+
+   procedure Put_Line (U : Unbounded_Wide_Wide_String) is
+      UR : constant Shared_Wide_Wide_String_Access := U.Reference;
+
+   begin
+      Put_Line (UR.Data (1 .. UR.Last));
+   end Put_Line;
+
+   procedure Put_Line (File : File_Type; U : Unbounded_Wide_Wide_String) is
+      UR : constant Shared_Wide_Wide_String_Access := U.Reference;
+
+   begin
+      Put_Line (File, UR.Data (1 .. UR.Last));
+   end Put_Line;
+
+end Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO;

gcc/ada/exp_attr.adb

@@ -280,16 +280,14 @@ package body Exp_Attr is
    --  Start of processing for Expand_Access_To_Protected_Op
 
    begin
-      --  Within the body of the protected type, the prefix
-      --  designates a local operation, and the object is the first
-      --  parameter of the corresponding protected body of the
-      --  current enclosing operation.
+      --  Within the body of the protected type, the prefix designates a local
+      --  operation, and the object is the first parameter of the corresponding
+      --  protected body of the current enclosing operation.
 
       if Is_Entity_Name (Pref) then
          if May_Be_External_Call then
             Sub :=
-              New_Occurrence_Of
-                (External_Subprogram (Entity (Pref)), Loc);
+              New_Occurrence_Of (External_Subprogram (Entity (Pref)), Loc);
          else
             Sub :=
               New_Occurrence_Of
@@ -372,6 +370,7 @@ package body Exp_Attr is
         Make_Aggregate (Loc,
           Expressions => New_List (Obj_Ref, Sub_Ref));
 
+      Freeze_Before (N, Entity (Sub));
       Rewrite (N, Agg);
       Analyze_And_Resolve (N, E_T);
 

gcc/ada/gcc-interface/Makefile.in

@@ -407,9 +407,6 @@ ATOMICS_TARGET_PAIRS += \
   a-szunau.adb<a-szunau-shared.adb \
   a-szuzti.adb<a-szuzti-shared.adb
 
-# Reset setting for now
-ATOMICS_TARGET_PAIRS =
-
 LIB_VERSION = $(strip $(shell grep ' Library_Version :' $(fsrcpfx)ada/gnatvsn.ads | sed -e 's/.*"\(.*\)".*/\1/'))
 
 # $(filter-out PATTERN...,TEXT) removes all PATTERN words from TEXT.

gcc/ada/impunit.adb

@@ -173,6 +173,14 @@ package body Impunit is
      "a-wichun",    -- Ada.Wide_Characters.Unicode
      "a-widcha",    -- Ada.Wide_Characters
 
+      --  Note: strictly the next two should be Ada 2012 units, but it seems
+      --  harmless (and useful) to make then available in Ada 95 mode, since
+      --  they only deal with Wide_Character, not Wide_Wide_Character.
+
+     "a-stuten",    -- Ada.Strings.UTF_Encoding
+     "a-suenco",    -- Ada.Strings.UTF_Encoding.Conversions
+     "a-suewen",    -- Ada.Strings.UTF_Encoding.Wide_Encoding
+
    ---------------------------
    -- GNAT Special IO Units --
    ---------------------------
@@ -459,10 +467,10 @@ package body Impunit is
      "a-szuzti",    -- Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO
      "a-zchuni",    -- Ada.Wide_Wide_Characters.Unicode
 
-      --  Note: strictly the next one should be an Ada 2012 unit, but it seems
-      --  harmless (and useful) to make it available in Ada 2005 mode.
+      --  Note: strictly the following should be Ada 2012 units, but it seems
+      --  harmless (and useful) to make then available in Ada 2005 mode.
 
-     "a-stuten",    -- Ada.Strings.UTF_Encoding
+     "a-suezen",    -- Ada.Strings.UTF_Encoding.Wide_Wide_Encoding
 
    ---------------------------
    -- GNAT Special IO Units --

gcc/ada/sem_prag.adb

@@ -12284,7 +12284,7 @@ package body Sem_Prag is
                   elsif not Is_Static_String_Expression (Arg1) then
                      Error_Pragma_Arg
                        ("argument of pragma% must be On/Off or " &
-                        "static string expression", Arg2);
+                        "static string expression", Arg1);
 
                   --  One argument string expression case
 
@@ -12504,6 +12504,11 @@ package body Sem_Prag is
             raise Program_Error;
       end case;
 
+      --  AI05-0144: detect dangerous order dependence. Disabled for now,
+      --  until AI is formally approved.
+
+      --  Check_Order_Dependence;
+
    exception
       when Pragma_Exit => null;
    end Analyze_Pragma;