2003-11-13 Vincent Celier <celier@gnat.com>

	* 5bml-tgt.adb (Build_Dynamic_Library): Use
	Osint.Include_Dir_Default_Prefix instead of
	Sdefault.Include_Dir_Default_Name.

	* gnatlbr.adb: Update Copyright notice
	(Gnatlbr): : Use Osint.Include_Dir_Default_Prefix instead of
	Sdefault.Include_Dir_Default_Name and Osint.Object_Dir_Default_Prefix
	instead of Sdefault.Object_Dir_Default_Name

	* gnatlink.adb:
	(Process_Binder_File): Never suppress the option following -Xlinker

	* mdll-utl.adb:
	(Gcc): Use Osint.Object_Dir_Default_Prefix instead of
	Sdefault.Object_Dir_Default_Name.

	* osint.ads, osint.adb:
	(Include_Dir_Default_Prefix, Object_Dir_Default_Prefix): New functions
	Minor reformatting.

	* vms_conv.ads: Minor reformating
	Remove GNAT STANDARD and GNAT PSTA

	* vms_conv.adb:
	Allow GNAT MAKE to have several files on the command line.
	(Init_Object_Dirs): Use Osint.Object_Dir_Default_Prefix instead of
	Sdefault.Object_Dir_Default_Name.
	Minor Reformating
	Remove data for GNAT STANDARD

	* vms_data.ads:
	Add new compiler qualifier /PRINT_STANDARD (-gnatS)
	Remove data for GNAT STANDARD
	Remove options and documentation for -gnatwb/-gnatwB: these warning
	options no longer exist.

2003-11-13  Ed Falis  <falis@gnat.com>

	* 5zthrini.adb: (Init_RTS): Made visible

	* 5zthrini.adb:
	(Register): Removed unnecessary call to taskVarGet that checked whether
	 an ATSD was already set as a task var for the argument thread.

	* s-thread.adb:
	Updated comment to reflect that this is a VxWorks version
	Added context clause for System.Threads.Initialization
	Added call to System.Threads.Initialization.Init_RTS

2003-11-13  Jerome Guitton  <guitton@act-europe.fr>

	* 5zthrini.adb:
	(Init_RTS): New procedure, for the initialization of the run-time lib.

	* s-thread.adb:
	Remove dependancy on System.Init, so that this file can be used in the
	AE653 sequential run-time lib.

2003-11-13  Robert Dewar  <dewar@gnat.com>

	* bindgen.adb: Minor reformatting

2003-11-13  Ed Schonberg  <schonberg@gnat.com>

	* checks.adb:
	(Apply_Discriminant_Check): Do no apply check if target type is derived
	from source type with no applicable constraint.

	* lib-writ.adb:
	(Ensure_System_Dependency): Do not apply the style checks that may have
	been specified for the main unit.

	* sem_ch8.adb:
	(Find_Selected_Component): Further improvement in error message, with
	RM reference.

	* sem_res.adb:
	(Resolve): Handle properly the case of an illegal overloaded protected
	procedure.

2003-11-13  Javier Miranda  <miranda@gnat.com>

	* exp_aggr.adb:
	(Has_Default_Init_Comps): New function to check the presence of
	default initialization in an aggregate.
	(Build_Record_Aggr_Code): Recursively expand the ancestor in case of
	extension aggregate of a limited record. In addition, a new formal
	was added to do not initialize the record controller (if any) during
	this recursive expansion of ancestors.
	(Init_Controller): Add support for limited record components.
	(Expand_Record_Aggregate): In case of default initialized components
	convert the aggregate into a set of assignments.

	* par-ch4.adb (P_Aggregate_Or_Paren_Expr): Update the comment
	describing the new syntax.
	Nothing else needed to be done because this subprogram delegates part of
	its work to P_Precord_Or_Array_Component_Association.
	(P_Record_Or_Array_Component_Association): Give support to the new
	syntax for default initialization of components.

	* sem_aggr.adb:
	(Resolve_Aggregate): Relax the strictness of the frontend in case of
	limited aggregates.
	(Resolve_Record_Aggregate): Give support to default initialized
	components.
	(Get_Value): In case of default initialized components, duplicate
	the corresponding default expression (from the record type
	declaration). In case of default initialization in the *others*
	choice, do not check that all components have the same type.
	(Resolve_Extension_Aggregate): Give support to limited extension
	aggregates.

	* sem_ch3.adb:
	(Check_Initialization): Relax the strictness of the front-end in case
	of aggregate and extension aggregates. This test is now done in
	Get_Value in a per-component manner.

	* sem_ch4.adb (Analyze_Allocator): Don't post an error if the
	expression corresponds to a limited aggregate. This test is now done
	in Get_Value.

	* sinfo.ads, sinfo.adb (N_Component_Association): Addition of
	Box_Present flag.

	* sprint.adb (Sprint_Node_Actual): Modified to print an mbox if
	present in an N_Component_Association node

2003-11-13  Thomas Quinot  <quinot@act-europe.fr>

	* sem_ch9.adb (Analyze_Accept_Statement): A procedure hides a
	type-conformant entry only if they are homographs.

2003-11-13  GNAT Script  <nobody@gnat.com>

	* Make-lang.in: Makefile automatically updated


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

1 files changed, 655 insertions, 666 deletions

diff --git a/gcc/ada/vms_conv.adb b/gcc/ada/vms_conv.adb
index f028b3084a9..479ecde92ee 100644
--- a/gcc/ada/vms_conv.adb
+++ b/gcc/ada/vms_conv.adb
@@ -25,8 +25,7 @@
 ------------------------------------------------------------------------------
 
 with Hostparm;
-with Osint;    use Osint;
-with Sdefault; use Sdefault;
+with Osint; use Osint;
 
 with Ada.Characters.Handling; use Ada.Characters.Handling;
 with Ada.Command_Line;        use Ada.Command_Line;
@@ -141,7 +140,7 @@ package body VMS_Conv is
 
    begin
       Object_Dirs := 0;
-      Object_Dir_Name := String_Access (Object_Dir_Default_Name);
+      Object_Dir_Name := new String'(Object_Dir_Default_Prefix);
       Get_Next_Dir_In_Path_Init (Object_Dir_Name);
 
       loop
@@ -287,13 +286,13 @@ package body VMS_Conv is
 
          Make =>
            (Cname    => new S'("MAKE"),
-            Usage    => new S'("GNAT MAKE file /qualifiers (includes "
+            Usage    => new S'("GNAT MAKE file(s) /qualifiers (includes "
                                & "COMPILE /qualifiers)"),
             VMS_Only => False,
             Unixcmd  => new S'("gnatmake"),
             Unixsws  => null,
             Switches => Make_Switches'Access,
-            Params   => new Parameter_Array'(1 => File),
+            Params   => new Parameter_Array'(1 => Unlimited_Files),
             Defext   => "   "),
 
          Name =>
@@ -340,16 +339,6 @@ package body VMS_Conv is
             Params   => new Parameter_Array'(1 => Unlimited_Files),
             Defext   => "   "),
 
-         Standard =>
-           (Cname    => new S'("STANDARD"),
-            Usage    => new S'("GNAT STANDARD"),
-            VMS_Only => False,
-            Unixcmd  => new S'("gnatpsta"),
-            Unixsws  => null,
-            Switches => Standard_Switches'Access,
-            Params   => new Parameter_Array'(1 .. 0 => File),
-            Defext   => "   "),
-
          Stub =>
            (Cname    => new S'("STUB"),
             Usage    => new S'("GNAT STUB file [directory]/qualifiers"),
@@ -1092,231 +1081,270 @@ package body VMS_Conv is
             Arg_Idx := Argv'First;
 
             <<Tryagain_After_Coalesce>>
-               loop
-                  declare
-                     Next_Arg_Idx : Integer;
-                     Arg          : String_Access;
-
-                  begin
-                     Next_Arg_Idx := Get_Arg_End (Argv.all, Arg_Idx);
-                     Arg := new String'(Argv (Arg_Idx .. Next_Arg_Idx));
+            loop
+               declare
+                  Next_Arg_Idx : Integer;
+                  Arg          : String_Access;
 
-                     --  The first one must be a command name
+               begin
+                  Next_Arg_Idx := Get_Arg_End (Argv.all, Arg_Idx);
+                  Arg := new String'(Argv (Arg_Idx .. Next_Arg_Idx));
 
-                     if Arg_Num = 1 and then Arg_Idx = Argv'First then
+                  --  The first one must be a command name
 
-                        Command := Matching_Name (Arg.all, Commands);
+                  if Arg_Num = 1 and then Arg_Idx = Argv'First then
 
-                        if Command = null then
-                           raise Error_Exit;
-                        end if;
+                     Command := Matching_Name (Arg.all, Commands);
 
-                        The_Command := Command.Command;
+                     if Command = null then
+                        raise Error_Exit;
+                     end if;
 
-                        --  Give usage information if only command given
+                     The_Command := Command.Command;
 
-                        if Argument_Count = 1 and then Next_Arg_Idx = Argv'Last
-                          and then Command.Command /= VMS_Conv.Standard
-                        then
-                           Output_Version;
-                           New_Line;
-                           Put_Line
-                             ("List of available qualifiers and options");
-                           New_Line;
+                     --  Give usage information if only command given
 
-                           Put (Command.Usage.all);
-                           Set_Col (53);
-                           Put_Line (Command.Unix_String.all);
+                     if Argument_Count = 1
+                       and then Next_Arg_Idx = Argv'Last
+                     then
+                        Output_Version;
+                        New_Line;
+                        Put_Line
+                          ("List of available qualifiers and options");
+                        New_Line;
 
-                           declare
-                              Sw : Item_Ptr := Command.Switches;
+                        Put (Command.Usage.all);
+                        Set_Col (53);
+                        Put_Line (Command.Unix_String.all);
 
-                           begin
-                              while Sw /= null loop
-                                 Put ("   ");
-                                 Put (Sw.Name.all);
+                        declare
+                           Sw : Item_Ptr := Command.Switches;
 
-                                 case Sw.Translation is
+                        begin
+                           while Sw /= null loop
+                              Put ("   ");
+                              Put (Sw.Name.all);
 
-                                    when T_Other =>
-                                       Set_Col (53);
-                                       Put_Line (Sw.Unix_String.all &
-                                                 "/<other>");
+                              case Sw.Translation is
 
-                                    when T_Direct =>
-                                       Set_Col (53);
-                                       Put_Line (Sw.Unix_String.all);
+                                 when T_Other =>
+                                    Set_Col (53);
+                                    Put_Line (Sw.Unix_String.all &
+                                              "/<other>");
 
-                                    when T_Directories =>
-                                       Put ("=(direc,direc,..direc)");
-                                       Set_Col (53);
-                                       Put (Sw.Unix_String.all);
-                                       Put (" direc ");
-                                       Put (Sw.Unix_String.all);
-                                       Put_Line (" direc ...");
+                                 when T_Direct =>
+                                    Set_Col (53);
+                                    Put_Line (Sw.Unix_String.all);
 
-                                    when T_Directory =>
-                                       Put ("=directory");
-                                       Set_Col (53);
-                                       Put (Sw.Unix_String.all);
+                                 when T_Directories =>
+                                    Put ("=(direc,direc,..direc)");
+                                    Set_Col (53);
+                                    Put (Sw.Unix_String.all);
+                                    Put (" direc ");
+                                    Put (Sw.Unix_String.all);
+                                    Put_Line (" direc ...");
 
-                                       if Sw.Unix_String (Sw.Unix_String'Last)
-                                         /= '='
-                                       then
-                                          Put (' ');
-                                       end if;
+                                 when T_Directory =>
+                                    Put ("=directory");
+                                    Set_Col (53);
+                                    Put (Sw.Unix_String.all);
 
-                                       Put_Line ("directory ");
+                                    if Sw.Unix_String (Sw.Unix_String'Last)
+                                    /= '='
+                                    then
+                                       Put (' ');
+                                    end if;
 
-                                    when T_File | T_No_Space_File =>
-                                       Put ("=file");
-                                       Set_Col (53);
-                                       Put (Sw.Unix_String.all);
+                                    Put_Line ("directory ");
 
-                                       if Sw.Translation = T_File
-                                         and then Sw.Unix_String
-                                                   (Sw.Unix_String'Last)
-                                                     /= '='
-                                       then
-                                          Put (' ');
-                                       end if;
+                                 when T_File | T_No_Space_File =>
+                                    Put ("=file");
+                                    Set_Col (53);
+                                    Put (Sw.Unix_String.all);
+
+                                    if Sw.Translation = T_File
+                                      and then Sw.Unix_String
+                                        (Sw.Unix_String'Last)
+                                    /= '='
+                                    then
+                                       Put (' ');
+                                    end if;
 
-                                       Put_Line ("file ");
+                                    Put_Line ("file ");
 
-                                    when T_Numeric =>
-                                       Put ("=nnn");
-                                       Set_Col (53);
+                                 when T_Numeric =>
+                                    Put ("=nnn");
+                                    Set_Col (53);
 
-                                       if Sw.Unix_String (Sw.Unix_String'First)
-                                         = '`'
-                                       then
-                                          Put (Sw.Unix_String
-                                               (Sw.Unix_String'First + 1
-                                                .. Sw.Unix_String'Last));
-                                       else
-                                          Put (Sw.Unix_String.all);
-                                       end if;
+                                    if Sw.Unix_String (Sw.Unix_String'First)
+                                    = '`'
+                                    then
+                                       Put (Sw.Unix_String
+                                              (Sw.Unix_String'First + 1
+                                               .. Sw.Unix_String'Last));
+                                    else
+                                       Put (Sw.Unix_String.all);
+                                    end if;
 
-                                       Put_Line ("nnn");
+                                    Put_Line ("nnn");
 
-                                    when T_Alphanumplus =>
-                                       Put ("=xyz");
-                                       Set_Col (53);
+                                 when T_Alphanumplus =>
+                                    Put ("=xyz");
+                                    Set_Col (53);
 
-                                       if Sw.Unix_String (Sw.Unix_String'First)
-                                         = '`'
-                                       then
-                                          Put (Sw.Unix_String
-                                               (Sw.Unix_String'First + 1
-                                                .. Sw.Unix_String'Last));
-                                       else
-                                          Put (Sw.Unix_String.all);
-                                       end if;
+                                    if Sw.Unix_String (Sw.Unix_String'First)
+                                    = '`'
+                                    then
+                                       Put (Sw.Unix_String
+                                              (Sw.Unix_String'First + 1
+                                               .. Sw.Unix_String'Last));
+                                    else
+                                       Put (Sw.Unix_String.all);
+                                    end if;
 
-                                       Put_Line ("xyz");
+                                    Put_Line ("xyz");
 
-                                    when T_String =>
-                                       Put ("=");
-                                       Put ('"');
-                                       Put ("<string>");
-                                       Put ('"');
-                                       Set_Col (53);
+                                 when T_String =>
+                                    Put ("=");
+                                    Put ('"');
+                                    Put ("<string>");
+                                    Put ('"');
+                                    Set_Col (53);
 
-                                       Put (Sw.Unix_String.all);
+                                    Put (Sw.Unix_String.all);
 
-                                       if Sw.Unix_String (Sw.Unix_String'Last)
-                                         /= '='
-                                       then
-                                          Put (' ');
-                                       end if;
+                                    if Sw.Unix_String (Sw.Unix_String'Last)
+                                    /= '='
+                                    then
+                                       Put (' ');
+                                    end if;
 
-                                       Put ("<string>");
-                                       New_Line;
+                                    Put ("<string>");
+                                    New_Line;
 
-                                    when T_Commands =>
-                                       Put (" (switches for ");
-                                       Put (Sw.Unix_String
-                                            (Sw.Unix_String'First + 7
-                                             .. Sw.Unix_String'Last));
-                                       Put (')');
-                                       Set_Col (53);
-                                       Put (Sw.Unix_String
-                                            (Sw.Unix_String'First
-                                             .. Sw.Unix_String'First + 5));
-                                       Put_Line (" switches");
+                                 when T_Commands =>
+                                    Put (" (switches for ");
+                                    Put (Sw.Unix_String
+                                           (Sw.Unix_String'First + 7
+                                            .. Sw.Unix_String'Last));
+                                    Put (')');
+                                    Set_Col (53);
+                                    Put (Sw.Unix_String
+                                           (Sw.Unix_String'First
+                                            .. Sw.Unix_String'First + 5));
+                                    Put_Line (" switches");
 
-                                    when T_Options =>
-                                       declare
-                                          Opt : Item_Ptr := Sw.Options;
+                                 when T_Options =>
+                                    declare
+                                       Opt : Item_Ptr := Sw.Options;
 
-                                       begin
-                                          Put_Line ("=(option,option..)");
+                                    begin
+                                       Put_Line ("=(option,option..)");
 
-                                          while Opt /= null loop
-                                             Put ("      ");
-                                             Put (Opt.Name.all);
+                                       while Opt /= null loop
+                                          Put ("      ");
+                                          Put (Opt.Name.all);
 
-                                             if Opt = Sw.Options then
-                                                Put (" (D)");
-                                             end if;
+                                          if Opt = Sw.Options then
+                                             Put (" (D)");
+                                          end if;
 
-                                             Set_Col (53);
-                                             Put_Line (Opt.Unix_String.all);
-                                             Opt := Opt.Next;
-                                          end loop;
-                                       end;
+                                          Set_Col (53);
+                                          Put_Line (Opt.Unix_String.all);
+                                          Opt := Opt.Next;
+                                       end loop;
+                                    end;
 
-                                 end case;
+                              end case;
 
-                                 Sw := Sw.Next;
-                              end loop;
-                           end;
+                              Sw := Sw.Next;
+                           end loop;
+                        end;
 
-                           raise Normal_Exit;
-                        end if;
+                        raise Normal_Exit;
+                     end if;
 
                      --  Special handling for internal debugging switch /?
 
-                     elsif Arg.all = "/?" then
-                        Display_Command := True;
+                  elsif Arg.all = "/?" then
+                     Display_Command := True;
 
                      --  Copy -switch unchanged
 
-                     elsif Arg (Arg'First) = '-' then
-                        Place (' ');
-                        Place (Arg.all);
+                  elsif Arg (Arg'First) = '-' then
+                     Place (' ');
+                     Place (Arg.all);
 
                      --  Copy quoted switch with quotes stripped
 
-                     elsif Arg (Arg'First) = '"' then
-                        if Arg (Arg'Last) /= '"' then
-                           Put (Standard_Error, "misquoted argument: ");
-                           Put_Line (Standard_Error, Arg.all);
-                           Errors := Errors + 1;
+                  elsif Arg (Arg'First) = '"' then
+                     if Arg (Arg'Last) /= '"' then
+                        Put (Standard_Error, "misquoted argument: ");
+                        Put_Line (Standard_Error, Arg.all);
+                        Errors := Errors + 1;
 
-                        else
-                           Place (' ');
-                           Place (Arg (Arg'First + 1 .. Arg'Last - 1));
-                        end if;
+                     else
+                        Place (' ');
+                        Place (Arg (Arg'First + 1 .. Arg'Last - 1));
+                     end if;
 
                      --  Parameter Argument
 
-                     elsif Arg (Arg'First) /= '/'
-                       and then Make_Commands_Active = null
-                     then
-                        Param_Count := Param_Count + 1;
+                  elsif Arg (Arg'First) /= '/'
+                    and then Make_Commands_Active = null
+                  then
+                     Param_Count := Param_Count + 1;
 
-                        if Param_Count <= Command.Params'Length then
+                     if Param_Count <= Command.Params'Length then
 
-                           case Command.Params (Param_Count) is
+                        case Command.Params (Param_Count) is
 
-                              when File | Optional_File =>
-                                 declare
-                                    Normal_File : constant String_Access :=
-                                                    To_Canonical_File_Spec
-                                                      (Arg.all);
+                           when File | Optional_File =>
+                              declare
+                                 Normal_File : constant String_Access :=
+                                   To_Canonical_File_Spec
+                                     (Arg.all);
 
-                                 begin
+                              begin
+                                 Place (' ');
+                                 Place_Lower (Normal_File.all);
+
+                                 if Is_Extensionless (Normal_File.all)
+                                   and then Command.Defext /= "   "
+                                 then
+                                    Place ('.');
+                                    Place (Command.Defext);
+                                 end if;
+                              end;
+
+                           when Unlimited_Files =>
+                              declare
+                                 Normal_File :
+                                 constant String_Access :=
+                                   To_Canonical_File_Spec (Arg.all);
+
+                                 File_Is_Wild  : Boolean := False;
+                                 File_List     : String_Access_List_Access;
+
+                              begin
+                                 for J in Arg'Range loop
+                                    if Arg (J) = '*'
+                                      or else Arg (J) = '%'
+                                    then
+                                       File_Is_Wild := True;
+                                    end if;
+                                 end loop;
+
+                                 if File_Is_Wild then
+                                    File_List := To_Canonical_File_List
+                                      (Arg.all, False);
+
+                                    for J in File_List.all'Range loop
+                                       Place (' ');
+                                       Place_Lower (File_List.all (J).all);
+                                    end loop;
+
+                                 else
                                     Place (' ');
                                     Place_Lower (Normal_File.all);
 
@@ -1326,36 +1354,92 @@ package body VMS_Conv is
                                        Place ('.');
                                        Place (Command.Defext);
                                     end if;
-                                 end;
+                                 end if;
 
-                              when Unlimited_Files =>
-                                 declare
-                                    Normal_File :
-                                      constant String_Access :=
-                                        To_Canonical_File_Spec (Arg.all);
+                                 Param_Count := Param_Count - 1;
+                              end;
+
+                           when Other_As_Is =>
+                              Place (' ');
+                              Place (Arg.all);
+
+                           when Unlimited_As_Is =>
+                              Place (' ');
+                              Place (Arg.all);
+                              Param_Count := Param_Count - 1;
+
+                           when Files_Or_Wildcard =>
+
+                              --  Remove spaces from a comma separated list
+                              --  of file names and adjust control variables
+                              --  accordingly.
+
+                              while Arg_Num < Argument_Count and then
+                                (Argv (Argv'Last) = ',' xor
+                                   Argument (Arg_Num + 1)
+                                   (Argument (Arg_Num + 1)'First) = ',')
+                              loop
+                                 Argv := new String'
+                                   (Argv.all & Argument (Arg_Num + 1));
+                                 Arg_Num := Arg_Num + 1;
+                                 Arg_Idx := Argv'First;
+                                 Next_Arg_Idx :=
+                                   Get_Arg_End (Argv.all, Arg_Idx);
+                                 Arg := new String'
+                                   (Argv (Arg_Idx .. Next_Arg_Idx));
+                              end loop;
+
+                              --  Parse the comma separated list of VMS
+                              --  filenames and place them on the command
+                              --  line as space separated Unix style
+                              --  filenames. Lower case and add default
+                              --  extension as appropriate.
 
-                                    File_Is_Wild  : Boolean := False;
-                                    File_List     : String_Access_List_Access;
+                              declare
+                                 Arg1_Idx : Integer := Arg'First;
+
+                                 function Get_Arg1_End
+                                   (Arg  : String; Arg_Idx : Integer)
+                                       return Integer;
+                                 --  Begins looking at Arg_Idx + 1 and
+                                 --  returns the index of the last character
+                                 --  before a comma or else the index of the
+                                 --  last character in the string Arg.
 
+                                 ------------------
+                                 -- Get_Arg1_End --
+                                 ------------------
+
+                                 function Get_Arg1_End
+                                   (Arg  : String; Arg_Idx : Integer)
+                                       return Integer
+                                 is
                                  begin
-                                    for J in Arg'Range loop
-                                       if Arg (J) = '*'
-                                         or else Arg (J) = '%'
-                                       then
-                                          File_Is_Wild := True;
+                                    for J in Arg_Idx + 1 .. Arg'Last loop
+                                       if Arg (J) = ',' then
+                                          return J - 1;
                                        end if;
                                     end loop;
 
-                                    if File_Is_Wild then
-                                       File_List := To_Canonical_File_List
-                                         (Arg.all, False);
+                                    return Arg'Last;
+                                 end Get_Arg1_End;
 
-                                       for J in File_List.all'Range loop
-                                          Place (' ');
-                                          Place_Lower (File_List.all (J).all);
-                                       end loop;
+                              begin
+                                 loop
+                                    declare
+                                       Next_Arg1_Idx :
+                                       constant Integer :=
+                                         Get_Arg1_End (Arg.all, Arg1_Idx);
 
-                                    else
+                                       Arg1 :
+                                       constant String :=
+                                         Arg (Arg1_Idx .. Next_Arg1_Idx);
+
+                                       Normal_File :
+                                       constant String_Access :=
+                                         To_Canonical_File_Spec (Arg1);
+
+                                    begin
                                        Place (' ');
                                        Place_Lower (Normal_File.all);
 
@@ -1365,542 +1449,447 @@ package body VMS_Conv is
                                           Place ('.');
                                           Place (Command.Defext);
                                        end if;
-                                    end if;
-
-                                    Param_Count := Param_Count - 1;
-                                 end;
-
-                              when Other_As_Is =>
-                                 Place (' ');
-                                 Place (Arg.all);
-
-                              when Unlimited_As_Is =>
-                                 Place (' ');
-                                 Place (Arg.all);
-                                 Param_Count := Param_Count - 1;
-
-                              when Files_Or_Wildcard =>
-
-                                 --  Remove spaces from a comma separated list
-                                 --  of file names and adjust control variables
-                                 --  accordingly.
-
-                                 while Arg_Num < Argument_Count and then
-                                   (Argv (Argv'Last) = ',' xor
-                                    Argument (Arg_Num + 1)
-                                      (Argument (Arg_Num + 1)'First) = ',')
-                                 loop
-                                    Argv := new String'
-                                           (Argv.all & Argument (Arg_Num + 1));
-                                    Arg_Num := Arg_Num + 1;
-                                    Arg_Idx := Argv'First;
-                                    Next_Arg_Idx :=
-                                      Get_Arg_End (Argv.all, Arg_Idx);
-                                    Arg := new String'
-                                            (Argv (Arg_Idx .. Next_Arg_Idx));
-                                 end loop;
-
-                                 --  Parse the comma separated list of VMS
-                                 --  filenames and place them on the command
-                                 --  line as space separated Unix style
-                                 --  filenames. Lower case and add default
-                                 --  extension as appropriate.
-
-                                 declare
-                                    Arg1_Idx : Integer := Arg'First;
-
-                                    function Get_Arg1_End
-                                      (Arg  : String; Arg_Idx : Integer)
-                                       return Integer;
-                                    --  Begins looking at Arg_Idx + 1 and
-                                    --  returns the index of the last character
-                                    --  before a comma or else the index of the
-                                    --  last character in the string Arg.
 
-                                    ------------------
-                                    -- Get_Arg1_End --
-                                    ------------------
+                                       Arg1_Idx := Next_Arg1_Idx + 1;
+                                    end;
 
-                                    function Get_Arg1_End
-                                      (Arg  : String; Arg_Idx : Integer)
-                                       return Integer
-                                    is
-                                    begin
-                                       for J in Arg_Idx + 1 .. Arg'Last loop
-                                          if Arg (J) = ',' then
-                                             return J - 1;
-                                          end if;
-                                       end loop;
+                                    exit when Arg1_Idx > Arg'Last;
 
-                                       return Arg'Last;
-                                    end Get_Arg1_End;
+                                    --  Don't allow two or more commas in
+                                    --  a row
 
-                                 begin
-                                    loop
-                                       declare
-                                          Next_Arg1_Idx :
-                                            constant Integer :=
-                                              Get_Arg1_End (Arg.all, Arg1_Idx);
-
-                                          Arg1 :
-                                            constant String :=
-                                              Arg (Arg1_Idx .. Next_Arg1_Idx);
-
-                                          Normal_File :
-                                            constant String_Access :=
-                                              To_Canonical_File_Spec (Arg1);
-
-                                       begin
-                                          Place (' ');
-                                          Place_Lower (Normal_File.all);
-
-                                          if Is_Extensionless (Normal_File.all)
-                                            and then Command.Defext /= "   "
-                                          then
-                                             Place ('.');
-                                             Place (Command.Defext);
-                                          end if;
-
-                                          Arg1_Idx := Next_Arg1_Idx + 1;
-                                       end;
-
-                                       exit when Arg1_Idx > Arg'Last;
-
-                                       --  Don't allow two or more commas in
-                                       --  a row
-
-                                       if Arg (Arg1_Idx) = ',' then
-                                          Arg1_Idx := Arg1_Idx + 1;
-                                          if Arg1_Idx > Arg'Last or else
-                                            Arg (Arg1_Idx) = ','
-                                          then
-                                             Put_Line
-                                               (Standard_Error,
-                                                "Malformed Parameter: " &
-                                                Arg.all);
-                                             Put (Standard_Error, "usage: ");
-                                             Put_Line (Standard_Error,
-                                                       Command.Usage.all);
-                                             raise Error_Exit;
-                                          end if;
+                                    if Arg (Arg1_Idx) = ',' then
+                                       Arg1_Idx := Arg1_Idx + 1;
+                                       if Arg1_Idx > Arg'Last or else
+                                         Arg (Arg1_Idx) = ','
+                                       then
+                                          Put_Line
+                                            (Standard_Error,
+                                             "Malformed Parameter: " &
+                                             Arg.all);
+                                          Put (Standard_Error, "usage: ");
+                                          Put_Line (Standard_Error,
+                                                    Command.Usage.all);
+                                          raise Error_Exit;
                                        end if;
+                                    end if;
 
-                                    end loop;
-                                 end;
-                           end case;
-                        end if;
-
-                        --  Qualifier argument
-
-                     else
-                        --  This code is too heavily nested, should be
-                        --  separated out as separate subprogram ???
-
-                        declare
-                           Sw   : Item_Ptr;
-                           SwP  : Natural;
-                           P2   : Natural;
-                           Endp : Natural := 0; -- avoid warning!
-                           Opt  : Item_Ptr;
-
-                        begin
-                           SwP := Arg'First;
-                           while SwP < Arg'Last
-                             and then Arg (SwP + 1) /= '='
-                           loop
-                              SwP := SwP + 1;
-                           end loop;
+                                 end loop;
+                              end;
+                        end case;
+                     end if;
 
-                           --  At this point, the switch name is in
-                           --  Arg (Arg'First..SwP) and if that is not the
-                           --  whole switch, then there is an equal sign at
-                           --  Arg (SwP + 1) and the rest of Arg is what comes
-                           --  after the equal sign.
+                     --  Qualifier argument
 
-                           --  If make commands are active, see if we have
-                           --  another COMMANDS_TRANSLATION switch belonging
-                           --  to gnatmake.
+                  else
+                     --  This code is too heavily nested, should be
+                     --  separated out as separate subprogram ???
+
+                     declare
+                        Sw   : Item_Ptr;
+                        SwP  : Natural;
+                        P2   : Natural;
+                        Endp : Natural := 0; -- avoid warning!
+                        Opt  : Item_Ptr;
+
+                     begin
+                        SwP := Arg'First;
+                        while SwP < Arg'Last
+                          and then Arg (SwP + 1) /= '='
+                        loop
+                           SwP := SwP + 1;
+                        end loop;
+
+                        --  At this point, the switch name is in
+                        --  Arg (Arg'First..SwP) and if that is not the
+                        --  whole switch, then there is an equal sign at
+                        --  Arg (SwP + 1) and the rest of Arg is what comes
+                        --  after the equal sign.
+
+                        --  If make commands are active, see if we have
+                        --  another COMMANDS_TRANSLATION switch belonging
+                        --  to gnatmake.
+
+                        if Make_Commands_Active /= null then
+                           Sw :=
+                             Matching_Name
+                               (Arg (Arg'First .. SwP),
+                                Command.Switches,
+                                Quiet => True);
+
+                           if Sw /= null
+                             and then Sw.Translation = T_Commands
+                           then
+                              null;
 
-                           if Make_Commands_Active /= null then
+                           else
                               Sw :=
                                 Matching_Name
-                                (Arg (Arg'First .. SwP),
-                                 Command.Switches,
-                                 Quiet => True);
-
-                              if Sw /= null
-                                and then Sw.Translation = T_Commands
-                              then
-                                 null;
-
-                              else
-                                 Sw :=
-                                   Matching_Name
-                                   (Arg (Arg'First .. SwP),
-                                    Make_Commands_Active.Switches,
-                                    Quiet => False);
-                              end if;
+                                  (Arg (Arg'First .. SwP),
+                                   Make_Commands_Active.Switches,
+                                   Quiet => False);
+                           end if;
 
                            --  For case of GNAT MAKE or CHOP, if we cannot
                            --  find the switch, then see if it is a
                            --  recognized compiler switch instead, and if
                            --  so process the compiler switch.
 
-                           elsif Command.Name.all = "MAKE"
-                             or else Command.Name.all = "CHOP" then
+                        elsif Command.Name.all = "MAKE"
+                          or else Command.Name.all = "CHOP" then
+                           Sw :=
+                             Matching_Name
+                               (Arg (Arg'First .. SwP),
+                                Command.Switches,
+                                Quiet => True);
+
+                           if Sw = null then
                               Sw :=
                                 Matching_Name
-                                (Arg (Arg'First .. SwP),
-                                 Command.Switches,
-                                 Quiet => True);
-
-                              if Sw = null then
-                                 Sw :=
+                                  (Arg (Arg'First .. SwP),
                                    Matching_Name
-                                   (Arg (Arg'First .. SwP),
-                                    Matching_Name
-                                      ("COMPILE", Commands).Switches,
-                                    Quiet => False);
-                              end if;
+                                     ("COMPILE", Commands).Switches,
+                                   Quiet => False);
+                           end if;
 
                            --  For all other cases, just search the relevant
                            --  command.
 
-                           else
-                              Sw :=
-                                Matching_Name
-                                (Arg (Arg'First .. SwP),
-                                 Command.Switches,
-                                 Quiet => False);
-                           end if;
-
-                           if Sw /= null then
-                              case Sw.Translation is
+                        else
+                           Sw :=
+                             Matching_Name
+                               (Arg (Arg'First .. SwP),
+                                Command.Switches,
+                                Quiet => False);
+                        end if;
 
-                                 when T_Direct =>
-                                    Place_Unix_Switches (Sw.Unix_String);
-                                    if SwP < Arg'Last
-                                      and then Arg (SwP + 1) = '='
+                        if Sw /= null then
+                           case Sw.Translation is
+
+                              when T_Direct =>
+                                 Place_Unix_Switches (Sw.Unix_String);
+                                 if SwP < Arg'Last
+                                   and then Arg (SwP + 1) = '='
+                                 then
+                                    Put (Standard_Error,
+                                         "qualifier options ignored: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                 end if;
+
+                              when T_Directories =>
+                                 if SwP + 1 > Arg'Last then
+                                    Put (Standard_Error,
+                                         "missing directories for: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                    Errors := Errors + 1;
+
+                                 elsif Arg (SwP + 2) /= '(' then
+                                    SwP := SwP + 2;
+                                    Endp := Arg'Last;
+
+                                 elsif Arg (Arg'Last) /= ')' then
+
+                                    --  Remove spaces from a comma separated
+                                    --  list of file names and adjust
+                                    --  control variables accordingly.
+
+                                    if Arg_Num < Argument_Count and then
+                                      (Argv (Argv'Last) = ',' xor
+                                         Argument (Arg_Num + 1)
+                                         (Argument (Arg_Num + 1)'First) = ',')
                                     then
-                                       Put (Standard_Error,
-                                            "qualifier options ignored: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                    end if;
-
-                                 when T_Directories =>
-                                    if SwP + 1 > Arg'Last then
-                                       Put (Standard_Error,
-                                            "missing directories for: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                       Errors := Errors + 1;
-
-                                    elsif Arg (SwP + 2) /= '(' then
-                                       SwP := SwP + 2;
-                                       Endp := Arg'Last;
-
-                                    elsif Arg (Arg'Last) /= ')' then
-
-                                       --  Remove spaces from a comma separated
-                                       --  list of file names and adjust
-                                       --  control variables accordingly.
-
-                                       if Arg_Num < Argument_Count and then
-                                         (Argv (Argv'Last) = ',' xor
-                                          Argument (Arg_Num + 1)
-                                          (Argument (Arg_Num + 1)'First) = ',')
-                                       then
-                                          Argv :=
-                                            new String'(Argv.all
-                                                        & Argument
-                                                           (Arg_Num + 1));
-                                          Arg_Num := Arg_Num + 1;
-                                          Arg_Idx := Argv'First;
-                                          Next_Arg_Idx
-                                            := Get_Arg_End (Argv.all, Arg_Idx);
-                                          Arg := new String'
-                                            (Argv (Arg_Idx .. Next_Arg_Idx));
-                                          goto Tryagain_After_Coalesce;
-                                       end if;
-
-                                       Put (Standard_Error,
-                                            "incorrectly parenthesized " &
-                                            "or malformed argument: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                       Errors := Errors + 1;
-
-                                    else
-                                       SwP := SwP + 3;
-                                       Endp := Arg'Last - 1;
+                                       Argv :=
+                                         new String'(Argv.all
+                                                     & Argument
+                                                       (Arg_Num + 1));
+                                       Arg_Num := Arg_Num + 1;
+                                       Arg_Idx := Argv'First;
+                                       Next_Arg_Idx
+                                       := Get_Arg_End (Argv.all, Arg_Idx);
+                                       Arg := new String'
+                                         (Argv (Arg_Idx .. Next_Arg_Idx));
+                                       goto Tryagain_After_Coalesce;
                                     end if;
 
-                                    while SwP <= Endp loop
-                                       declare
-                                          Dir_Is_Wild       : Boolean := False;
-                                          Dir_Maybe_Is_Wild : Boolean := False;
-                                          Dir_List : String_Access_List_Access;
-                                       begin
-                                          P2 := SwP;
-
-                                          while P2 < Endp
-                                            and then Arg (P2 + 1) /= ','
-                                          loop
+                                    Put (Standard_Error,
+                                         "incorrectly parenthesized " &
+                                         "or malformed argument: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                    Errors := Errors + 1;
+
+                                 else
+                                    SwP := SwP + 3;
+                                    Endp := Arg'Last - 1;
+                                 end if;
+
+                                 while SwP <= Endp loop
+                                    declare
+                                       Dir_Is_Wild       : Boolean := False;
+                                       Dir_Maybe_Is_Wild : Boolean := False;
+                                       Dir_List : String_Access_List_Access;
+                                    begin
+                                       P2 := SwP;
 
-                                             --  A wildcard directory spec on
-                                             --  VMS will contain either * or
-                                             --  % or ...
+                                       while P2 < Endp
+                                         and then Arg (P2 + 1) /= ','
+                                       loop
 
-                                             if Arg (P2) = '*' then
-                                                Dir_Is_Wild := True;
+                                          --  A wildcard directory spec on
+                                          --  VMS will contain either * or
+                                          --  % or ...
 
-                                             elsif Arg (P2) = '%' then
-                                                Dir_Is_Wild := True;
+                                          if Arg (P2) = '*' then
+                                             Dir_Is_Wild := True;
 
-                                             elsif Dir_Maybe_Is_Wild
-                                               and then Arg (P2) = '.'
-                                               and then Arg (P2 + 1) = '.'
-                                             then
-                                                Dir_Is_Wild := True;
-                                                Dir_Maybe_Is_Wild := False;
+                                          elsif Arg (P2) = '%' then
+                                             Dir_Is_Wild := True;
 
-                                             elsif Dir_Maybe_Is_Wild then
-                                                Dir_Maybe_Is_Wild := False;
+                                          elsif Dir_Maybe_Is_Wild
+                                            and then Arg (P2) = '.'
+                                            and then Arg (P2 + 1) = '.'
+                                          then
+                                             Dir_Is_Wild := True;
+                                             Dir_Maybe_Is_Wild := False;
 
-                                             elsif Arg (P2) = '.'
-                                               and then Arg (P2 + 1) = '.'
-                                             then
-                                                Dir_Maybe_Is_Wild := True;
+                                          elsif Dir_Maybe_Is_Wild then
+                                             Dir_Maybe_Is_Wild := False;
 
-                                             end if;
+                                          elsif Arg (P2) = '.'
+                                            and then Arg (P2 + 1) = '.'
+                                          then
+                                             Dir_Maybe_Is_Wild := True;
 
-                                             P2 := P2 + 1;
-                                          end loop;
+                                          end if;
 
-                                          if Dir_Is_Wild then
-                                             Dir_List := To_Canonical_File_List
-                                               (Arg (SwP .. P2), True);
+                                          P2 := P2 + 1;
+                                       end loop;
 
-                                             for J in Dir_List.all'Range loop
-                                                Place_Unix_Switches
-                                                  (Sw.Unix_String);
-                                                Place_Lower
-                                                  (Dir_List.all (J).all);
-                                             end loop;
+                                       if Dir_Is_Wild then
+                                          Dir_List := To_Canonical_File_List
+                                            (Arg (SwP .. P2), True);
 
-                                          else
+                                          for J in Dir_List.all'Range loop
                                              Place_Unix_Switches
                                                (Sw.Unix_String);
                                              Place_Lower
-                                               (To_Canonical_Dir_Spec
-                                                (Arg (SwP .. P2), False).all);
-                                          end if;
+                                               (Dir_List.all (J).all);
+                                          end loop;
 
-                                          SwP := P2 + 2;
-                                       end;
-                                    end loop;
+                                       else
+                                          Place_Unix_Switches
+                                            (Sw.Unix_String);
+                                          Place_Lower
+                                            (To_Canonical_Dir_Spec
+                                               (Arg (SwP .. P2), False).all);
+                                       end if;
 
-                                 when T_Directory =>
-                                    if SwP + 1 > Arg'Last then
-                                       Put (Standard_Error,
-                                            "missing directory for: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                       Errors := Errors + 1;
+                                       SwP := P2 + 2;
+                                    end;
+                                 end loop;
 
-                                    else
-                                       Place_Unix_Switches (Sw.Unix_String);
+                              when T_Directory =>
+                                 if SwP + 1 > Arg'Last then
+                                    Put (Standard_Error,
+                                         "missing directory for: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                    Errors := Errors + 1;
 
-                                       --  Some switches end in "=". No space
-                                       --  here
+                                 else
+                                    Place_Unix_Switches (Sw.Unix_String);
 
-                                       if Sw.Unix_String
-                                         (Sw.Unix_String'Last) /= '='
-                                       then
-                                          Place (' ');
-                                       end if;
+                                    --  Some switches end in "=". No space
+                                    --  here
 
-                                       Place_Lower
-                                         (To_Canonical_Dir_Spec
-                                          (Arg (SwP + 2 .. Arg'Last),
-                                           False).all);
+                                    if Sw.Unix_String
+                                      (Sw.Unix_String'Last) /= '='
+                                    then
+                                       Place (' ');
                                     end if;
 
-                                 when T_File | T_No_Space_File =>
-                                    if SwP + 1 > Arg'Last then
-                                       Put (Standard_Error,
-                                            "missing file for: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                       Errors := Errors + 1;
+                                    Place_Lower
+                                      (To_Canonical_Dir_Spec
+                                         (Arg (SwP + 2 .. Arg'Last),
+                                          False).all);
+                                 end if;
 
-                                    else
-                                       Place_Unix_Switches (Sw.Unix_String);
-
-                                       --  Some switches end in "=". No space
-                                       --  here.
-
-                                       if Sw.Translation = T_File
-                                         and then Sw.Unix_String
-                                                   (Sw.Unix_String'Last) /= '='
-                                       then
-                                          Place (' ');
-                                       end if;
+                              when T_File | T_No_Space_File =>
+                                 if SwP + 1 > Arg'Last then
+                                    Put (Standard_Error,
+                                         "missing file for: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                    Errors := Errors + 1;
 
-                                       Place_Lower
-                                         (To_Canonical_File_Spec
-                                          (Arg (SwP + 2 .. Arg'Last)).all);
-                                    end if;
-
-                                 when T_Numeric =>
-                                    if
-                                      OK_Integer (Arg (SwP + 2 .. Arg'Last))
-                                    then
-                                       Place_Unix_Switches (Sw.Unix_String);
-                                       Place (Arg (SwP + 2 .. Arg'Last));
+                                 else
+                                    Place_Unix_Switches (Sw.Unix_String);
 
-                                    else
-                                       Put (Standard_Error, "argument for ");
-                                       Put (Standard_Error, Sw.Name.all);
-                                       Put_Line
-                                         (Standard_Error, " must be numeric");
-                                       Errors := Errors + 1;
-                                    end if;
+                                    --  Some switches end in "=". No space
+                                    --  here.
 
-                                 when T_Alphanumplus =>
-                                    if
-                                      OK_Alphanumerplus
-                                        (Arg (SwP + 2 .. Arg'Last))
+                                    if Sw.Translation = T_File
+                                      and then Sw.Unix_String
+                                        (Sw.Unix_String'Last) /= '='
                                     then
-                                       Place_Unix_Switches (Sw.Unix_String);
-                                       Place (Arg (SwP + 2 .. Arg'Last));
-
-                                    else
-                                       Put (Standard_Error, "argument for ");
-                                       Put (Standard_Error, Sw.Name.all);
-                                       Put_Line (Standard_Error,
-                                                 " must be alphanumeric");
-                                       Errors := Errors + 1;
+                                       Place (' ');
                                     end if;
 
-                                 when T_String =>
-
-                                    --  A String value must be extended to the
-                                    --  end of the Argv, otherwise strings like
-                                    --  "foo/bar" get split at the slash.
-                                    --
-                                    --  The begining and ending of the string
-                                    --  are flagged with embedded nulls which
-                                    --  are removed when building the Spawn
-                                    --  call. Nulls are use because they won't
-                                    --  show up in a /? output. Quotes aren't
-                                    --  used because that would make it
-                                    --  difficult to embed them.
+                                    Place_Lower
+                                      (To_Canonical_File_Spec
+                                         (Arg (SwP + 2 .. Arg'Last)).all);
+                                 end if;
 
+                              when T_Numeric =>
+                                 if
+                                   OK_Integer (Arg (SwP + 2 .. Arg'Last))
+                                 then
                                     Place_Unix_Switches (Sw.Unix_String);
-                                    if Next_Arg_Idx /= Argv'Last then
-                                       Next_Arg_Idx := Argv'Last;
-                                       Arg := new String'
-                                         (Argv (Arg_Idx .. Next_Arg_Idx));
-
-                                       SwP := Arg'First;
-                                       while SwP < Arg'Last and then
-                                         Arg (SwP + 1) /= '=' loop
-                                          SwP := SwP + 1;
-                                       end loop;
-                                    end if;
-                                    Place (ASCII.NUL);
                                     Place (Arg (SwP + 2 .. Arg'Last));
-                                    Place (ASCII.NUL);
 
-                                 when T_Commands =>
-
-                                    --  Output -largs/-bargs/-cargs
-
-                                    Place (' ');
-                                    Place (Sw.Unix_String
-                                           (Sw.Unix_String'First ..
-                                            Sw.Unix_String'First + 5));
-
-                                    if Sw.Unix_String
-                                         (Sw.Unix_String'First + 7 ..
-                                          Sw.Unix_String'Last) =
-                                       "MAKE"
-                                    then
-                                       Make_Commands_Active := null;
+                                 else
+                                    Put (Standard_Error, "argument for ");
+                                    Put (Standard_Error, Sw.Name.all);
+                                    Put_Line
+                                      (Standard_Error, " must be numeric");
+                                    Errors := Errors + 1;
+                                 end if;
+
+                              when T_Alphanumplus =>
+                                 if
+                                   OK_Alphanumerplus
+                                     (Arg (SwP + 2 .. Arg'Last))
+                                 then
+                                    Place_Unix_Switches (Sw.Unix_String);
+                                    Place (Arg (SwP + 2 .. Arg'Last));
 
-                                    else
-                                       --  Set source of new commands, also
-                                       --  setting this non-null indicates that
-                                       --  we are in the special commands mode
-                                       --  for processing the -xargs case.
-
-                                       Make_Commands_Active :=
-                                         Matching_Name
-                                         (Sw.Unix_String
-                                            (Sw.Unix_String'First + 7 ..
-                                               Sw.Unix_String'Last),
-                                          Commands);
-                                    end if;
+                                 else
+                                    Put (Standard_Error, "argument for ");
+                                    Put (Standard_Error, Sw.Name.all);
+                                    Put_Line (Standard_Error,
+                                              " must be alphanumeric");
+                                    Errors := Errors + 1;
+                                 end if;
+
+                              when T_String =>
+
+                                 --  A String value must be extended to the
+                                 --  end of the Argv, otherwise strings like
+                                 --  "foo/bar" get split at the slash.
+                                 --
+                                 --  The begining and ending of the string
+                                 --  are flagged with embedded nulls which
+                                 --  are removed when building the Spawn
+                                 --  call. Nulls are use because they won't
+                                 --  show up in a /? output. Quotes aren't
+                                 --  used because that would make it
+                                 --  difficult to embed them.
+
+                                 Place_Unix_Switches (Sw.Unix_String);
+                                 if Next_Arg_Idx /= Argv'Last then
+                                    Next_Arg_Idx := Argv'Last;
+                                    Arg := new String'
+                                      (Argv (Arg_Idx .. Next_Arg_Idx));
 
-                                 when T_Options =>
-                                    if SwP + 1 > Arg'Last then
-                                       Place_Unix_Switches
-                                         (Sw.Options.Unix_String);
-                                       SwP := Endp + 1;
-
-                                    elsif Arg (SwP + 2) /= '(' then
-                                       SwP := SwP + 2;
-                                       Endp := Arg'Last;
-
-                                    elsif Arg (Arg'Last) /= ')' then
-                                       Put
-                                         (Standard_Error,
-                                          "incorrectly parenthesized " &
-                                          "argument: ");
-                                       Put_Line (Standard_Error, Arg.all);
-                                       Errors := Errors + 1;
-                                       SwP := Endp + 1;
+                                    SwP := Arg'First;
+                                    while SwP < Arg'Last and then
+                                    Arg (SwP + 1) /= '=' loop
+                                       SwP := SwP + 1;
+                                    end loop;
+                                 end if;
+                                 Place (ASCII.NUL);
+                                 Place (Arg (SwP + 2 .. Arg'Last));
+                                 Place (ASCII.NUL);
 
-                                    else
-                                       SwP := SwP + 3;
-                                       Endp := Arg'Last - 1;
-                                    end if;
+                              when T_Commands =>
 
-                                    while SwP <= Endp loop
-                                       P2 := SwP;
+                                 --  Output -largs/-bargs/-cargs
 
-                                       while P2 < Endp
-                                         and then Arg (P2 + 1) /= ','
-                                       loop
-                                          P2 := P2 + 1;
-                                       end loop;
+                                 Place (' ');
+                                 Place (Sw.Unix_String
+                                          (Sw.Unix_String'First ..
+                                             Sw.Unix_String'First + 5));
+
+                                 if Sw.Unix_String
+                                   (Sw.Unix_String'First + 7 ..
+                                      Sw.Unix_String'Last) =
+                                     "MAKE"
+                                 then
+                                    Make_Commands_Active := null;
+
+                                 else
+                                    --  Set source of new commands, also
+                                    --  setting this non-null indicates that
+                                    --  we are in the special commands mode
+                                    --  for processing the -xargs case.
+
+                                    Make_Commands_Active :=
+                                      Matching_Name
+                                        (Sw.Unix_String
+                                             (Sw.Unix_String'First + 7 ..
+                                                  Sw.Unix_String'Last),
+                                         Commands);
+                                 end if;
+
+                              when T_Options =>
+                                 if SwP + 1 > Arg'Last then
+                                    Place_Unix_Switches
+                                      (Sw.Options.Unix_String);
+                                    SwP := Endp + 1;
+
+                                 elsif Arg (SwP + 2) /= '(' then
+                                    SwP := SwP + 2;
+                                    Endp := Arg'Last;
+
+                                 elsif Arg (Arg'Last) /= ')' then
+                                    Put
+                                      (Standard_Error,
+                                       "incorrectly parenthesized " &
+                                       "argument: ");
+                                    Put_Line (Standard_Error, Arg.all);
+                                    Errors := Errors + 1;
+                                    SwP := Endp + 1;
+
+                                 else
+                                    SwP := SwP + 3;
+                                    Endp := Arg'Last - 1;
+                                 end if;
+
+                                 while SwP <= Endp loop
+                                    P2 := SwP;
+
+                                    while P2 < Endp
+                                      and then Arg (P2 + 1) /= ','
+                                    loop
+                                       P2 := P2 + 1;
+                                    end loop;
 
-                                       --  Option name is in Arg (SwP .. P2)
+                                    --  Option name is in Arg (SwP .. P2)
 
-                                       Opt := Matching_Name (Arg (SwP .. P2),
-                                                             Sw.Options);
+                                    Opt := Matching_Name (Arg (SwP .. P2),
+                                                          Sw.Options);
 
-                                       if Opt /= null then
-                                          Place_Unix_Switches
-                                            (Opt.Unix_String);
-                                       end if;
+                                    if Opt /= null then
+                                       Place_Unix_Switches
+                                         (Opt.Unix_String);
+                                    end if;
 
-                                       SwP := P2 + 2;
-                                    end loop;
+                                    SwP := P2 + 2;
+                                 end loop;
 
-                                 when T_Other =>
-                                    Place_Unix_Switches
-                                      (new String'(Sw.Unix_String.all &
-                                                   Arg.all));
+                              when T_Other =>
+                                 Place_Unix_Switches
+                                   (new String'(Sw.Unix_String.all &
+                                                Arg.all));
 
-                              end case;
-                           end if;
-                        end;
-                     end if;
+                           end case;
+                        end if;
+                     end;
+                  end if;
 
-                     Arg_Idx := Next_Arg_Idx + 1;
-                  end;
+                  Arg_Idx := Next_Arg_Idx + 1;
+               end;
 
-                  exit when Arg_Idx > Argv'Last;
+               exit when Arg_Idx > Argv'Last;
 
-               end loop;
+            end loop;
          end Process_Argument;
 
          Arg_Num := Arg_Num + 1;