[multiple changes]

2012-03-07  Gary Dismukes  <dismukes@adacore.com>

	* exp_ch4.adb (Apply_Accessibility_Check): Call
	Remove_Side_Effects in the build-in-place case, to ensure that
	we capture the call and don't end up with two calls.

2012-03-07  Javier Miranda  <miranda@adacore.com>

	* exp_ch6.adb (Expand_Inlined_Call): Skip inlining of functions
	that return unconstrained types using an extended return statement
	since the support for inlining these functions has not been yet
	added to the frontend.
	* s-vaflop.adb, s-vaflop-vms-alpha.adb: Code reorganization.
	* a-ngrear.ads: Replace all the Inline_Always pragmas by pragma
	Inline.
	* a-ngrear.adb (Eigenvalues, Transpose): Restructured to use
	extended return statement.
	* a-strsup.adb, a-stzsup.adb, a-stwisu.adb (Concat, Super_Slice,
	Super_To_String): Restructured to use extended return statement.
	* a-chahan.adb (To_Basic, To_Lower, To_Upper): Restructured to
	use extended return statement.
	* s-gearop.adb (Diagonal, Matrix_Elementwise_Operation,
	Vector_Elementwise_Operation, Matrix_Elementwise_Operation,
	Matrix_Matrix_Scalar_Elementwise_Operation,
	Vector_Vector_Elementwise_Operation,
	Vector_Vector_Scalar_Elementwise_Operation,
	Matrix_Scalar_Elementwise_Operation,
	Vector_Scalar_Elementwise_Operation,
	Scalar_Matrix_Elementwise_Operation,
	Scalar_Vector_Elementwise_Operation, Matrix_Matrix_Product,
	Matrix_Vector_Product, Outer_Product, Unit_Matrix, Unit_Vector,
	Vector_Matrix_Product): Restructured to use extended return
	statement.

2012-03-07  Vincent Pucci  <pucci@adacore.com>

	* sem_ch5.adb (One_Bound): Minor reformatting.

2012-03-07  Tristan Gingold  <gingold@adacore.com>

	* s-osinte-vms-ia64.adb, s-osinte-vms-ia64.ads, s-osinte-vms.adb,
	s-osinte-vms.ads, gcc-interface/Makefile.in: Merge s-osinte-vms and
	s-osinte-vms-ia64.

From-SVN: r185051

1 files changed, 96 insertions, 82 deletions

diff --git a/gcc/ada/a-stzsup.adb b/gcc/ada/a-stzsup.adb
index efad7b0..a79dfa0 100644
--- a/gcc/ada/a-stzsup.adb
+++ b/gcc/ada/a-stzsup.adb
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 B o d y                                  --
 --                                                                          --
---          Copyright (C) 2003-2010, Free Software Foundation, Inc.         --
+--          Copyright (C) 2003-2012, 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- --
@@ -42,100 +42,111 @@ package body Ada.Strings.Wide_Wide_Superbounded is
      (Left  : Super_String;
       Right : Super_String) return Super_String
    is
-      Result : Super_String (Left.Max_Length);
-      Llen   : constant Natural := Left.Current_Length;
-      Rlen   : constant Natural := Right.Current_Length;
-      Nlen   : constant Natural := Llen + Rlen;
-
    begin
-      if Nlen > Left.Max_Length then
-         raise Ada.Strings.Length_Error;
-      else
-         Result.Current_Length := Nlen;
-         Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
-         Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
-      end if;
+      return Result : Super_String (Left.Max_Length) do
+         declare
+            Llen : constant Natural := Left.Current_Length;
+            Rlen : constant Natural := Right.Current_Length;
+            Nlen : constant Natural := Llen + Rlen;
 
-      return Result;
+         begin
+            if Nlen > Left.Max_Length then
+               raise Ada.Strings.Length_Error;
+            else
+               Result.Current_Length := Nlen;
+               Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
+               Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
+            end if;
+         end;
+      end return;
    end Concat;
 
    function Concat
      (Left  : Super_String;
       Right : Wide_Wide_String) return Super_String
    is
-      Result : Super_String (Left.Max_Length);
-      Llen   : constant Natural := Left.Current_Length;
-
-      Nlen   : constant Natural := Llen + Right'Length;
-
    begin
-      if Nlen > Left.Max_Length then
-         raise Ada.Strings.Length_Error;
-      else
-         Result.Current_Length := Nlen;
-         Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
-         Result.Data (Llen + 1 .. Nlen) := Right;
-      end if;
-      return Result;
+      return Result : Super_String (Left.Max_Length) do
+         declare
+            Llen : constant Natural := Left.Current_Length;
+            Nlen : constant Natural := Llen + Right'Length;
+
+         begin
+            if Nlen > Left.Max_Length then
+               raise Ada.Strings.Length_Error;
+            else
+               Result.Current_Length := Nlen;
+               Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
+               Result.Data (Llen + 1 .. Nlen) := Right;
+            end if;
+         end;
+      end return;
    end Concat;
 
    function Concat
      (Left  : Wide_Wide_String;
       Right : Super_String) return Super_String
    is
-      Result : Super_String (Right.Max_Length);
-      Llen   : constant Natural := Left'Length;
-      Rlen   : constant Natural := Right.Current_Length;
-      Nlen   : constant Natural := Llen + Rlen;
-
    begin
-      if Nlen > Right.Max_Length then
-         raise Ada.Strings.Length_Error;
-      else
-         Result.Current_Length := Nlen;
-         Result.Data (1 .. Llen) := Left;
-         Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
-      end if;
+      return Result : Super_String (Right.Max_Length) do
+         declare
+            Llen : constant Natural := Left'Length;
+            Rlen : constant Natural := Right.Current_Length;
+            Nlen : constant Natural := Llen + Rlen;
 
-      return Result;
+         begin
+            if Nlen > Right.Max_Length then
+               raise Ada.Strings.Length_Error;
+            else
+               Result.Current_Length := Nlen;
+               Result.Data (1 .. Llen) := Left;
+               Result.Data (Llen + 1 .. Nlen) := Right.Data (1 .. Rlen);
+            end if;
+         end;
+      end return;
    end Concat;
 
    function Concat
      (Left  : Super_String;
       Right : Wide_Wide_Character) return Super_String
    is
-      Result : Super_String (Left.Max_Length);
-      Llen   : constant Natural := Left.Current_Length;
-
    begin
-      if Llen = Left.Max_Length then
-         raise Ada.Strings.Length_Error;
-      else
-         Result.Current_Length := Llen + 1;
-         Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
-         Result.Data (Result.Current_Length) := Right;
-      end if;
+      return Result : Super_String (Left.Max_Length) do
+         declare
+            Llen : constant Natural := Left.Current_Length;
 
-      return Result;
+         begin
+            if Llen = Left.Max_Length then
+               raise Ada.Strings.Length_Error;
+            else
+               Result.Current_Length := Llen + 1;
+               Result.Data (1 .. Llen) := Left.Data (1 .. Llen);
+               Result.Data (Result.Current_Length) := Right;
+            end if;
+         end;
+      end return;
    end Concat;
 
    function Concat
      (Left  : Wide_Wide_Character;
       Right : Super_String) return Super_String
    is
-      Result : Super_String (Right.Max_Length);
-      Rlen   : constant Natural := Right.Current_Length;
-
    begin
-      if Rlen = Right.Max_Length then
-         raise Ada.Strings.Length_Error;
-      else
-         Result.Current_Length := Rlen + 1;
-         Result.Data (1) := Left;
-         Result.Data (2 .. Result.Current_Length) := Right.Data (1 .. Rlen);
-      end if;
+      return Result : Super_String (Right.Max_Length) do
+         declare
+            Rlen : constant Natural := Right.Current_Length;
 
-      return Result;
+         begin
+            if Rlen = Right.Max_Length then
+               raise Ada.Strings.Length_Error;
+            else
+               Result.Current_Length := Rlen + 1;
+               Result.Data (1) := Left;
+               Result.Data (2 .. Result.Current_Length) :=
+                 Right.Data (1 .. Rlen);
+            end if;
+         end;
+      end return;
    end Concat;
 
    -----------
@@ -1469,13 +1480,15 @@ package body Ada.Strings.Wide_Wide_Superbounded is
    begin
       --  Note: test of High > Length is in accordance with AI95-00128
 
-      if Low > Source.Current_Length + 1
-        or else High > Source.Current_Length
-      then
-         raise Index_Error;
-      else
-         return Source.Data (Low .. High);
-      end if;
+      return R : Wide_Wide_String (Low .. High) do
+         if Low > Source.Current_Length + 1
+           or else High > Source.Current_Length
+         then
+            raise Index_Error;
+         end if;
+
+         R := Source.Data (Low .. High);
+      end return;
    end Super_Slice;
 
    function Super_Slice
@@ -1483,19 +1496,18 @@ package body Ada.Strings.Wide_Wide_Superbounded is
       Low    : Positive;
       High   : Natural) return Super_String
    is
-      Result : Super_String (Source.Max_Length);
-
    begin
-      if Low > Source.Current_Length + 1
-        or else High > Source.Current_Length
-      then
-         raise Index_Error;
-      else
-         Result.Current_Length := High - Low + 1;
-         Result.Data (1 .. Result.Current_Length) := Source.Data (Low .. High);
-      end if;
-
-      return Result;
+      return Result : Super_String (Source.Max_Length) do
+         if Low > Source.Current_Length + 1
+           or else High > Source.Current_Length
+         then
+            raise Index_Error;
+         else
+            Result.Current_Length := High - Low + 1;
+            Result.Data (1 .. Result.Current_Length) :=
+              Source.Data (Low .. High);
+         end if;
+      end return;
    end Super_Slice;
 
    procedure Super_Slice
@@ -1627,7 +1639,9 @@ package body Ada.Strings.Wide_Wide_Superbounded is
      (Source : Super_String) return Wide_Wide_String
    is
    begin
-      return Source.Data (1 .. Source.Current_Length);
+      return R : Wide_Wide_String (1 .. Source.Current_Length) do
+         R := Source.Data (1 .. Source.Current_Length);
+      end return;
    end Super_To_String;
 
    ---------------------