Subversion Repositories openrisc_2011-10-31

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                    G N A T . C O M M A N D _ L I N E                     --

--                                                                          --

--                                 S p e c                                  --

--                                                                          --

--                     Copyright (C) 1999-2009, AdaCore                     --

--                                                                          --

-- 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.      --

--                                                                          --

------------------------------------------------------------------------------

--  High level package for command line parsing and manipulation

--  Parsing the command line

--  ========================

--  This package provides an interface for parsing command line arguments,

--  when they are either read from Ada.Command_Line or read from a string list.

--  As shown in the example below, one should first retrieve the switches

--  (special command line arguments starting with '-' by default) and their

--  parameters, and then the rest of the command line arguments.

--  This package is flexible enough to accommodate various needs: optional

--  switch parameters, various characters to separate a switch and its

--  parameter, whether to stop the parsing at the first non-switch argument

--  encountered, etc.

--  begin

--     loop

--        case Getopt ("a b: ad") is  -- Accepts '-a', '-ad', or '-b argument'

--           when ASCII.NUL => exit;

--           when 'a' =>

--                 if Full_Switch = "a" then

--                    Put_Line ("Got a");

--                 else

--                    Put_Line ("Got ad");

--                 end if;

--           when 'b' =>

--              Put_Line ("Got b + " & Parameter);

--           when others =>

--              raise Program_Error;         -- cannot occur!

--        end case;

--     end loop;

--     loop

--        declare

--           S : constant String := Get_Argument (Do_Expansion => True);

--        begin

--           exit when S'Length = 0;

--           Put_Line ("Got " & S);

--        end;

--     end loop;

--  exception

--     when Invalid_Switch    => Put_Line ("Invalid Switch " & Full_Switch);

--     when Invalid_Parameter => Put_Line ("No parameter for " & Full_Switch);

--  end;

--  A more complicated example would involve the use of sections for the

--  switches, as for instance in gnatmake. The same command line is used to

--  provide switches for several tools. Each tool recognizes its switches by

--  separating them with special switches that act as section separators.

--  Each section acts as a command line of its own.

--  begin

--     Initialize_Option_Scan ('-', False, "largs bargs cargs");

--     loop

--        --  Same loop as above to get switches and arguments

--     end loop;

--     Goto_Section ("bargs");

--     loop

--        --  Same loop as above to get switches and arguments

--        --  The supported switches in Getopt might be different

--     end loop;

--     Goto_Section ("cargs");

--     loop

--        --  Same loop as above to get switches and arguments

--        --  The supported switches in Getopt might be different

--     end loop;

--  end;

--  The example above have shown how to parse the command line when the

--  arguments are read directly from Ada.Command_Line. However, these arguments

--  can also be read from a list of strings. This can be useful in several

--  contexts, either because your system does not support Ada.Command_Line, or

--  because you are manipulating other tools and creating their command line by

--  hand, or for any other reason.

--  To create the list of strings, it is recommended to use

--  GNAT.OS_Lib.Argument_String_To_List.

--  The example below shows how to get the parameters from such a list. Note

--  also the use of '*' to get all the switches, and not report errors when an

--  unexpected switch was used by the user

--  declare

--     Parser : Opt_Parser;

--     Args : constant Argument_List_Access :=

--        GNAT.OS_Lib.Argument_String_To_List ("-g -O1 -Ipath");

--  begin

--     Initialize_Option_Scan (Parser, Args);

--     while Getopt ("* g O! I=", Parser) /= ASCII.NUL loop

--        Put_Line ("Switch " & Full_Switch (Parser)

--                  & " param=" & Parameter (Parser));

--     end loop;

--     Free (Parser);

--  end;

--

--  Creating and manipulating the command line

--  ===========================================

--  This package provides mechanisms to create and modify command lines by

--  adding or removing arguments from them. The resulting command line is kept

--  as short as possible by coalescing arguments whenever possible.

--  Complex command lines can thus be constructed, for example from an GUI

--  (although this package does not by itself depend upon any specific GUI

--  toolkit). For instance, if you are configuring the command line to use

--  when spawning a tool with the following characteristics:

--    * Specifying -gnatwa is the same as specifying -gnatwu -gnatwv, but

--      shorter and more readable

--    * All switches starting with -gnatw can be grouped, for instance one

--      can write -gnatwcd instead of -gnatwc -gnatwd.

--      Of course, this can be combined with the above and -gnatwacd is the

--      same as -gnatwc -gnatwd -gnatwu -gnatwv

--    * The switch -T is the same as -gnatwAB

--    * A switch -foo takes one mandatory parameter

--  These properties can be configured through this package with the following

--  calls:

--     Config : Command_Line_Configuration;

--     Define_Prefix (Config, "-gnatw");

--     Define_Alias  (Config, "-gnatwa", "-gnatwuv");

--     Define_Alias  (Config, "-T",      "-gnatwAB");

--  Using this configuration, one can then construct a command line for the

--  tool with:

--     Cmd : Command_Line;

--     Set_Configuration (Cmd, Config);

--     Add_Switch (Cmd, "-bar");

--     Add_Switch (Cmd, "-gnatwu");

--     Add_Switch (Cmd, "-gnatwv");  --  will be grouped with the above

--     Add_Switch (Cmd, "-T");

--  The resulting command line can be iterated over to get all its switches,

--  There are two modes for this iteration: either you want to get the

--  shortest possible command line, which would be:

--      -bar -gnatwaAB

--  or on the other hand you want each individual switch (so that your own

--  tool does not have to do further complex processing), which would be:

--      -bar -gnatwu -gnatwv -gnatwA -gnatwB

--  Of course, we can assume that the tool you want to spawn would understand

--  both of these, since they are both compatible with the description we gave

--  above. However, the first result is useful if you want to show the user

--  what you are spawning (since that keeps the output shorter), and the second

--  output is more useful for a tool that would check whether -gnatwu was

--  passed (which isn't obvious in the first output). Likewise, the second

--  output is more useful if you have a graphical interface since each switch

--  can be associated with a widget, and you immediately know whether -gnatwu

--  was selected.

--

--  Some command line arguments can have parameters, which on a command line

--  appear as a separate argument that must immediately follow the switch.

--  Since the subprograms in this package will reorganize the switches to group

--  them, you need to indicate what is a command line

--  parameter, and what is a switch argument.

--  This is done by passing an extra argument to Add_Switch, as in:

--     Add_Switch (Cmd, "-foo", "arg1");

--  This ensures that "arg1" will always be treated as the argument to -foo,

--  and will not be grouped with other parts of the command line.

--  Parsing the command line with grouped arguments

--  ===============================================

--  The command line construction facility can also be used in conjunction with

--  Getopt to interpret a command line. For example when implementing the tool

--  described above, you would do a first loop with Getopt to pass the switches

--  and their arguments, and create a temporary representation of the command

--  line as a Command_Line object. Finally, you can query each individual

--  switch from that object. For instance:

--    declare

--      Cmd  : Command_Line;

--      Iter : Command_Line_Iterator;

--    begin

--      while Getopt ("foo: gnatw! T bar") /= ASCII.NUL loop

--         Add_Switch (Cmd, Full_Switch, Parameter);

--      end loop;

--      Start (Cmd, Iter, Expanded => True);

--      while Has_More (Iter) loop

--        if Current_Switch (Iter) = "-gnatwu" then ..

--        elsif Current_Switch (Iter) = "-gnatwv" then ...

--        end if;

--        Next (Iter);

--      end loop;

--  The above means that your tool does not have to handle on its own whether

--  the user passed -gnatwa (in which case -gnatwu was indeed selected), or

--  just -gnatwu, or a combination of -gnatw switches as in -gnatwuv.

with Ada.Command_Line;

with GNAT.Directory_Operations;

with GNAT.OS_Lib;

with GNAT.Regexp;

package GNAT.Command_Line is

   -------------

   -- Parsing --

   -------------

   type Opt_Parser is private;

   Command_Line_Parser : constant Opt_Parser;

   --  This object is responsible for parsing a list of arguments, which by

   --  default are the standard command line arguments from Ada.Command_Line.

   --  This is really a pointer to actual data, which must therefore be

   --  initialized through a call to Initialize_Option_Scan, and must be freed

   --  with a call to Free.

   --

   --  As a special case, Command_Line_Parser does not need to be either

   --  initialized or free-ed.

   procedure Initialize_Option_Scan

     (Switch_Char              : Character := '-';

      Stop_At_First_Non_Switch : Boolean := False;

      Section_Delimiters       : String := "");

   procedure Initialize_Option_Scan

     (Parser                   : out Opt_Parser;

      Command_Line             : GNAT.OS_Lib.Argument_List_Access;

      Switch_Char              : Character := '-';

      Stop_At_First_Non_Switch : Boolean := False;

      Section_Delimiters       : String := "");

   --  The first procedure resets the internal state of the package to prepare

   --  to rescan the parameters. It does not need to be called before the first

   --  use of Getopt (but it could be), but it must be called if you want to

   --  start rescanning the command line parameters from the start. The

   --  optional parameter Switch_Char can be used to reset the switch

   --  character, e.g. to '/' for use in DOS-like systems.

   --

   --  The second subprogram initializes a parser that takes its arguments from

   --  an array of strings rather than directly from the command line. In this

   --  case, the parser is responsible for freeing the strings stored in

   --  Command_Line. If you pass null to Command_Line, this will in fact create

   --  a second parser for Ada.Command_Line, which doesn't share any data with

   --  the default parser. This parser must be free-ed.

   --

   --  The optional parameter Stop_At_First_Non_Switch indicates if Getopt is

   --  to look for switches on the whole command line, or if it has to stop as

   --  soon as a non-switch argument is found.

   --

   --  Example:

   --

   --      Arguments: my_application file1 -c

   --

   --      If Stop_At_First_Non_Switch is False, then -c will be considered

   --      as a switch (returned by getopt), otherwise it will be considered

   --      as a normal argument (returned by Get_Argument).

   --

   --  If SECTION_DELIMITERS is set, then every following subprogram

   --  (Getopt and Get_Argument) will only operate within a section, which

   --  is delimited by any of these delimiters or the end of the command line.

   --

   --  Example:

   --      Initialize_Option_Scan (Section_Delimiters => "largs bargs cargs");

   --

   --      Arguments on command line : my_application -c -bargs -d -e -largs -f

   --      This line is made of three section, the first one is the default one

   --      and includes only the '-c' switch, the second one is between -bargs

   --      and -largs and includes '-d -e' and the last one includes '-f'

   procedure Free (Parser : in out Opt_Parser);

   --  Free the memory used by the parser. Calling this is not mandatory for

   --  the Command_Line_Parser

   procedure Goto_Section

     (Name   : String := "";

      Parser : Opt_Parser := Command_Line_Parser);

   --  Change the current section. The next Getopt of Get_Argument will start

   --  looking at the beginning of the section. An empty name ("") refers to

   --  the first section between the program name and the first section

   --  delimiter. If the section does not exist, then Invalid_Section is

   --  raised.

   function Full_Switch

     (Parser : Opt_Parser := Command_Line_Parser) return String;

   --  Returns the full name of the last switch found (Getopt only returns

   --  the first character)

   function Getopt

     (Switches    : String;

      Concatenate : Boolean := True;

      Parser      : Opt_Parser := Command_Line_Parser) return Character;

   --  This function moves to the next switch on the command line (defined as

   --  switch character followed by a character within Switches, casing being

   --  significant). The result returned is the first character of the switch

   --  that is located. If there are no more switches in the current section,

   --  returns ASCII.NUL. If Concatenate is True (by default), the switches

   --  does not need to be separated by spaces (they can be concatenated if

   --  they do not require an argument, e.g. -ab is the same as two separate

   --  arguments -a -b).

   --

   --  Switches is a string of all the possible switches, separated by a

   --  space. A switch can be followed by one of the following characters:

   --

   --   ':'  The switch requires a parameter. There can optionally be a space

   --        on the command line between the switch and its parameter.

   --

   --   '='  The switch requires a parameter. There can either be a '=' or a

   --        space on the command line between the switch and its parameter.

   --

   --   '!'  The switch requires a parameter, but there can be no space on the

   --        command line between the switch and its parameter.

   --

   --   '?'  The switch may have an optional parameter. There can be no space

   --        between the switch and its argument.

   --

   --        e.g. if Switches has the following value : "a? b",

   --        The command line can be:

   --

   --             -afoo    :  -a switch with 'foo' parameter

   --             -a foo   :  -a switch and another element on the

   --                           command line 'foo', returned by Get_Argument

   --

   --     Example: if Switches is "-a: -aO:", you can have the following

   --              command lines:

   --

   --                -aarg    :  'a' switch with 'arg' parameter

   --                -a arg   :  'a' switch with 'arg' parameter

   --                -aOarg   :  'aO' switch with 'arg' parameter

   --                -aO arg  :  'aO' switch with 'arg' parameter

   --

   --    Example:

   --

   --       Getopt ("a b: ac ad?")

   --

   --         accept either 'a' or 'ac' with no argument,

   --         accept 'b' with a required argument

   --         accept 'ad' with an optional argument

   --

   --  If the first item in switches is '*', then Getopt will catch

   --  every element on the command line that was not caught by any other

   --  switch. The character returned by GetOpt is '*', but Full_Switch

   --  contains the full command line argument, including leading '-' if there

   --  is one. If this character was not returned, there would be no way of

   --  knowing whether it is there or not.

   --

   --    Example

   --       Getopt ("* a b")

   --       If the command line is '-a -c toto.o -b', Getopt will return

   --       successively 'a', '*', '*' and 'b'. When '*' is returned,

   --       Full_Switch returns the corresponding item on the command line.

   --

   --  When Getopt encounters an invalid switch, it raises the exception

   --  Invalid_Switch and sets Full_Switch to return the invalid switch.

   --  When Getopt cannot find the parameter associated with a switch, it

   --  raises Invalid_Parameter, and sets Full_Switch to return the invalid

   --  switch character.

   --

   --  Note: in case of ambiguity, e.g. switches a ab abc, then the longest

   --  matching switch is returned.

   --

   --  Arbitrary characters are allowed for switches, although it is

   --  strongly recommended to use only letters and digits for portability

   --  reasons.

   --

   --  When Concatenate is False, individual switches need to be separated by

   --  spaces.

   --

   --    Example

   --       Getopt ("a b", Concatenate => False)

   --       If the command line is '-ab', exception Invalid_Switch will be

   --       raised and Full_Switch will return "ab".

   function Get_Argument

     (Do_Expansion : Boolean := False;

      Parser       : Opt_Parser := Command_Line_Parser) return String;

   --  Returns the next element on the command line which is not a switch.

   --  This function should not be called before Getopt has returned

   --  ASCII.NUL.

   --

   --  If Expansion is True, then the parameter on the command line will be

   --  considered as a filename with wild cards, and will be expanded. The

   --  matching file names will be returned one at a time. When there are no

   --  more arguments on the command line, this function returns an empty

   --  string. This is useful in non-Unix systems for obtaining normal

   --  expansion of wild card references.

   function Parameter

     (Parser : Opt_Parser := Command_Line_Parser) return String;

   --  Returns the parameter associated with the last switch returned by

   --  Getopt. If no parameter was associated with the last switch, or no

   --  previous call has been made to Get_Argument, raises Invalid_Parameter.

   --  If the last switch was associated with an optional argument and this

   --  argument was not found on the command line, Parameter returns an empty

   --  string.

   function Separator

     (Parser : Opt_Parser := Command_Line_Parser) return Character;

   --  The separator that was between the switch and its parameter. This is

   --  of little use in general, only if you want to know exactly what was on

   --  the command line. This is in general a single character, set to

   --  ASCII.NUL if the switch and the parameter were concatenated. A space is

   --  returned if the switch and its argument were in two separate arguments.

   type Expansion_Iterator is limited private;

   --  Type used during expansion of file names

   procedure Start_Expansion

     (Iterator     : out Expansion_Iterator;

      Pattern      : String;

      Directory    : String := "";

      Basic_Regexp : Boolean := True);

   --  Initialize a wild card expansion. The next calls to Expansion will

   --  return the next file name in Directory which match Pattern (Pattern

   --  is a regular expression, using only the Unix shell and DOS syntax if

   --  Basic_Regexp is True). When Directory is an empty string, the current

   --  directory is searched.

   --

   --  Pattern may contain directory separators (as in "src/*/*.ada").

   --  Subdirectories of Directory will also be searched, up to one

   --  hundred levels deep.

   --

   --  When Start_Expansion has been called, function Expansion should be

   --  called repeatedly until it returns an empty string, before

   --  Start_Expansion can be called again with the same Expansion_Iterator

   --  variable.

   function Expansion (Iterator : Expansion_Iterator) return String;

   --  Returns the next file in the directory matching the parameters given

   --  to Start_Expansion and updates Iterator to point to the next entry.

   --  Returns an empty string when there is no more file in the directory

   --  and its subdirectories.

   --

   --  If Expansion is called again after an empty string has been returned,

   --  then the exception GNAT.Directory_Operations.Directory_Error is raised.

   Invalid_Section : exception;

   --  Raised when an invalid section is selected by Goto_Section

   Invalid_Switch : exception;

   --  Raised when an invalid switch is detected in the command line

   Invalid_Parameter : exception;

   --  Raised when a parameter is missing, or an attempt is made to obtain a

   --  parameter for a switch that does not allow a parameter

   -----------------

   -- Configuring --

   -----------------

   type Command_Line_Configuration is private;

   procedure Define_Alias

     (Config   : in out Command_Line_Configuration;

      Switch   : String;

      Expanded : String);

   --  Indicates that whenever Switch appears on the command line, it should

   --  be expanded as Expanded. For instance, for the GNAT compiler switches,

   --  we would define "-gnatwa" as an alias for "-gnatwcfijkmopruvz", ie some

   --  default warnings to be activated.

   --

   --  Likewise, in some context you could define "--verbose" as an alias for

   --  ("-v", "--full"), ie two switches.

   procedure Define_Prefix

     (Config   : in out Command_Line_Configuration;

      Prefix   : String);

   --  Indicates that all switches starting with the given prefix should be

   --  grouped. For instance, for the GNAT compiler we would define "-gnatw"

   --  as a prefix, so that "-gnatwu -gnatwv" can be grouped into "-gnatwuv"

   --  It is assume that the remaining of the switch ("uv") is a set of

   --  characters whose order is irrelevant. In fact, this package will sort

   --  them alphabetically.

   procedure Define_Switch

     (Config : in out Command_Line_Configuration;

      Switch : String);

   --  Indicates a new switch. The format of this switch follows the getopt

   --  format (trailing ':', '?', etc for defining a switch with parameters).

   --  The switches defined in the command_line_configuration object are used

   --  when ungrouping switches with more that one character after the prefix.

   procedure Define_Section

     (Config  : in out Command_Line_Configuration;

      Section : String);

   --  Indicates a new switch section. Every switch belonging to the same

   --  section are ordered together, preceded by the section. They are placed

   --  at the end of the command line (as in 'gnatmake somefile.adb -cargs -g')

   function Get_Switches

     (Config      : Command_Line_Configuration;

      Switch_Char : Character) return String;

   --  Get the switches list as expected by getopt. This list is built using

   --  all switches defined previously via Define_Switch above.

   procedure Free (Config : in out Command_Line_Configuration);

   --  Free the memory used by Config

   -------------

   -- Editing --

   -------------

   type Command_Line is private;

   procedure Set_Configuration

     (Cmd    : in out Command_Line;

      Config : Command_Line_Configuration);

   --  Set the configuration for this command line

   function Get_Configuration

     (Cmd : Command_Line) return Command_Line_Configuration;

   --  Return the configuration used for that command line

   procedure Set_Command_Line

     (Cmd                : in out Command_Line;

      Switches           : String;

      Getopt_Description : String    := "";

      Switch_Char        : Character := '-');

   --  Set the new content of the command line, by replacing the current

   --  version with Switches.

   --

   --  The parsing of Switches is done through calls to Getopt, by passing

   --  Getopt_Description as an argument. (a "*" is automatically prepended so

   --  that all switches and command line arguments are accepted).

   --

   --  To properly handle switches that take parameters, you should document

   --  them in Getopt_Description. Otherwise, the switch and its parameter will

   --  be recorded as two separate command line arguments as returned by a

   --  Command_Line_Iterator (which might be fine depending on your

   --  application).

   --

   --  If the command line has sections (such as -bargs -largs -cargs), then

   --  they should be listed in the Sections parameter (as "-bargs -cargs")

   --

   --  This function can be used to reset Cmd by passing an empty string.

   procedure Add_Switch

     (Cmd        : in out Command_Line;

      Switch     : String;

      Parameter  : String    := "";

      Separator  : Character := ' ';

      Section    : String    := "";

      Add_Before : Boolean   := False);

   --  Add a new switch to the command line, and combine/group it with existing

   --  switches if possible. Nothing is done if the switch already exists with

   --  the same parameter.

   --

   --  If the Switch takes a parameter, the latter should be specified

   --  separately, so that the association between the two is always correctly

   --  recognized even if the order of switches on the command line changes.

   --  For instance, you should pass "--check=full" as ("--check", "full") so

   --  that Remove_Switch below can simply take "--check" in parameter. That

   --  will automatically remove "full" as well. The value of the parameter is

   --  never modified by this package.

   --

   --  On the other hand, you could decide to simply pass "--check=full" as

   --  the Switch above, and then pass no parameter. This means that you need

   --  to pass "--check=full" to Remove_Switch as well.

   --

   --  A Switch with a parameter will never be grouped with another switch to

   --  avoid ambiguities as to who the parameter applies to.

   --

   --  Separator is the character that goes between the switches and its

   --  parameter on the command line. If it is set to ASCII.NUL, then no

   --  separator is applied, and they are concatenated

   --

   --  If the switch is part of a section, then it should be specified so that

   --  the switch is correctly placed in the command line, and the section

   --  added if not already present. For example, to add the -g switch into the

   --  -cargs section, you need to call (Cmd, "-g", Section => "-cargs")

   --

   --  Add_Before allows insertion of the switch at the beginning of the

   --  command line.

   procedure Add_Switch

     (Cmd        : in out Command_Line;

      Switch     : String;

      Parameter  : String    := "";

      Separator  : Character := ' ';

      Section    : String    := "";

      Add_Before : Boolean   := False;

      Success    : out Boolean);

   --  Same as above, returning the status of the operation

   procedure Remove_Switch

     (Cmd           : in out Command_Line;

      Switch        : String;

      Remove_All    : Boolean := False;

      Has_Parameter : Boolean := False;

      Section       : String := "");

   --  Remove Switch from the command line, and ungroup existing switches if

   --  necessary.

   --

   --  The actual parameter to the switches are ignored. If for instance

   --  you are removing "-foo", then "-foo param1" and "-foo param2" can

   --  be removed.

   --

   --  If Remove_All is True, then all matching switches are removed, otherwise

   --  only the first matching one is removed.

   --

   --  If Has_Parameter is set to True, then only switches having a parameter

   --  are removed.

   --

   --  If the switch belongs to a section, then this section should be

   --  specified: Remove_Switch (Cmd_Line, "-g", Section => "-cargs") called

   --  on the command line "-g -cargs -g" will result in "-g", while if

   --  called with (Cmd_Line, "-g") this will result in "-cargs -g".

   --  If Remove_All is set, then both "-g" will be removed.

   procedure Remove_Switch

     (Cmd           : in out Command_Line;

      Switch        : String;

      Remove_All    : Boolean := False;

      Has_Parameter : Boolean := False;

      Section       : String  := "";

      Success       : out Boolean);

   --  Same as above, reporting the success of the operation (Success is False

   --  if no switch was removed).

   procedure Remove_Switch

     (Cmd       : in out Command_Line;

      Switch    : String;

      Parameter : String;

      Section   : String := "");

   --  Remove a switch with a specific parameter. If Parameter is the empty

   --  string, then only a switch with no parameter will be removed.

   ---------------

   -- Iteration --

   ---------------

   type Command_Line_Iterator is private;

   procedure Start

     (Cmd      : in out Command_Line;

      Iter     : in out Command_Line_Iterator;

      Expanded : Boolean);

   --  Start iterating over the command line arguments. If Expanded is true,

   --  then the arguments are not grouped and no alias is used. For instance,

   --  "-gnatwv" and "-gnatwu" would be returned instead of "-gnatwuv".

   --

   --  The iterator becomes invalid if the command line is changed through a

   --  call to Add_Switch, Remove_Switch or Set_Command_Line.

   function Current_Switch    (Iter : Command_Line_Iterator) return String;

   function Is_New_Section    (Iter : Command_Line_Iterator) return Boolean;

   function Current_Section   (Iter : Command_Line_Iterator) return String;

   function Current_Separator (Iter : Command_Line_Iterator) return String;

   function Current_Parameter (Iter : Command_Line_Iterator) return String;

   --  Return the current switch and its parameter (or the empty string if

   --  there is no parameter or the switch was added through Add_Switch

   --  without specifying the parameter.

   --

   --  Separator is the string that goes between the switch and its separator.

   --  It could be the empty string if they should be concatenated, or a space

   --  for instance. When printing, you should not add any other character.

   function Has_More (Iter : Command_Line_Iterator) return Boolean;

   --  Return True if there are more switches to be returned

   procedure Next (Iter : in out Command_Line_Iterator);

   --  Move to the next switch

   procedure Free (Cmd : in out Command_Line);

   --  Free the memory used by Cmd

private

   Max_Depth : constant := 100;

   --  Maximum depth of subdirectories

   Max_Path_Length : constant := 1024;

   --  Maximum length of relative path

   type Depth is range 1 .. Max_Depth;

   type Level is record

      Name_Last : Natural := 0;

      Dir       : GNAT.Directory_Operations.Dir_Type;

   end record;

   type Level_Array is array (Depth) of Level;

   type Section_Number is new Natural range 0 .. 65534;

   for Section_Number'Size use 16;

   type Parameter_Type is record

      Arg_Num : Positive;

      First   : Positive;

      Last    : Positive;

      Extra   : Character;

   end record;

   type Is_Switch_Type is array (Natural range <>) of Boolean;

   pragma Pack (Is_Switch_Type);

   type Section_Type is array (Natural range <>) of Section_Number;

   pragma Pack (Section_Type);

   type Expansion_Iterator is limited record

      Start : Positive := 1;

      --  Position of the first character of the relative path to check against

      --  the pattern.

      Dir_Name : String (1 .. Max_Path_Length);

      Current_Depth : Depth := 1;

      Levels : Level_Array;

      Regexp : GNAT.Regexp.Regexp;

      --  Regular expression built with the pattern

      Maximum_Depth : Depth := 1;

      --  The maximum depth of directories, reflecting the number of directory

      --  separators in the pattern.

   end record;

   type Opt_Parser_Data (Arg_Count : Natural) is record

      Arguments : GNAT.OS_Lib.Argument_List_Access;

      --  null if reading from the command line

      The_Parameter : Parameter_Type;

      The_Separator : Character;

      The_Switch    : Parameter_Type;

      --  This type and this variable are provided to store the current switch

      --  and parameter.

      Is_Switch : Is_Switch_Type (1 .. Arg_Count) := (others => False);

      --  Indicates wich arguments on the command line are considered not be

      --  switches or parameters to switches (leaving e.g. filenames,...)

      Section : Section_Type (1 .. Arg_Count) := (others => 1);

      --  Contains the number of the section associated with the current

      --  switch. If this number is 0, then it is a section delimiter, which is

      --  never returned by GetOpt.

      Current_Argument : Natural := 1;

      --  Number of the current argument parsed on the command line

      Current_Index : Natural := 1;

      --  Index in the current argument of the character to be processed

      Current_Section : Section_Number := 1;

      Expansion_It : aliased Expansion_Iterator;

      --  When Get_Argument is expanding a file name, this is the iterator used

      In_Expansion : Boolean := False;

      --  True if we are expanding a file

      Switch_Character : Character := '-';

      --  The character at the beginning of the command line arguments,

      --  indicating the beginning of a switch.

      Stop_At_First : Boolean := False;

      --  If it is True then Getopt stops at the first non-switch argument

   end record;

   Command_Line_Parser_Data : aliased Opt_Parser_Data

     (Ada.Command_Line.Argument_Count);

   --  The internal data used when parsing the command line

   type Opt_Parser is access all Opt_Parser_Data;

   Command_Line_Parser : constant Opt_Parser :=

                           Command_Line_Parser_Data'Access;

   type Command_Line_Configuration_Record is record

      Prefixes : GNAT.OS_Lib.Argument_List_Access;

      --  The list of prefixes

      Sections : GNAT.OS_Lib.Argument_List_Access;

      --  The list of sections

      Aliases    : GNAT.OS_Lib.Argument_List_Access;

      Expansions : GNAT.OS_Lib.Argument_List_Access;